code-yeongyu/oh-my-openagent / packages/shared-skills/skills/programming
programming
FlaggedApplies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, JavaScript, and Go. Use for work on .py, .rs, .ts, .js, or .go files, and whenever a test or spec file is written, reshaped, reviewed, or deleted: the four-question test authoring gate and the junk-test classes live here.
scripts/rust/check-no-excuse-rules.sh
View on GitHub#!/usr/bin/env bash
# No-excuse rule checker for Rust files.
# Only rules that can be enforced via pure text matching live here.
# Everything semantic is on clippy + miri + nextest.
#
# Rules:
# unwrap / expect outside tests, unless the previous line carries
# #[expect(clippy::unwrap_used|expect_used, reason = "...")]
# placeholder-macro todo!/unimplemented!/unreachable! in committed code
# box-dyn-error Box<dyn Error> in non-test code
# lib-panic panic!() in library code
# discarded-result `let _ = call(...)`, unless the previous line carries
# #[expect(clippy::let_underscore_must_use, reason = "...")]
# blocking-in-async std::thread::sleep / std::fs / reqwest::blocking /
# .blocking_*() inside an async fn or async block
# unsafe-no-safety unsafe { without // SAFETY: in the preceding 5 lines
# allow-attribute #[allow(...)] - silence lints with #[expect(lint, reason)]
# expect-without-reason #[expect(...)] with no `reason = "..."`
# narrowing-as-cast possible narrowing numeric `as` cast
set -euo pipefail
if [ $# -eq 0 ]; then
echo "Usage: $0 <file.rs> [file.rs ...]" >&2
exit 2
fi
violations=0
report() {
echo "::error file=$1,line=$2::[$3] $4" >&2
violations=$((violations + 1))
}
is_test_path() {
case "$1" in
*/tests/*|*/benches/*|*/examples/*|*/build.rs|*_test.rs|tests/*|benches/*|examples/*) return 0 ;;
esac
return 1
}
count_char() {
local only="${1//[^$2]/}"
echo "${#only}"
}
for file in "$@"; do
[ -f "$file" ] || continue
case "$file" in
*.rs) ;;
*) continue ;;
esac
in_test_file=0
is_test_path "$file" && in_test_file=1
lines=()
while IFS= read -r raw || [ -n "$raw" ]; do lines+=("$raw"); done < "$file"
total=${#lines[@]}
# Brace-tracked regions: a region starts at its marker line and ends when the
# braces opened after the marker are closed again.
in_cfg_test=0; cfg_depth=0; cfg_opened=0
in_async=0; async_depth=0; async_opened=0
for ((i = 0; i < total; i++)); do
line_no=$((i + 1))
line="${lines[$i]}"
prev=""
[ "$i" -gt 0 ] && prev="${lines[$((i - 1))]}"
code_only="${line%%//*}"
opens=$(count_char "$code_only" "{")
closes=$(count_char "$code_only" "}")
if [[ "$line" =~ \#\[cfg\(test\)\] ]]; then
in_cfg_test=1; cfg_depth=0; cfg_opened=0
fi
if [ "$in_cfg_test" -eq 1 ]; then
cfg_depth=$((cfg_depth + opens - closes))
[ "$opens" -gt 0 ] && cfg_opened=1
if [ "$cfg_opened" -eq 1 ] && [ "$cfg_depth" -le 0 ]; then in_cfg_test=0; fi
fi
if [ "$in_async" -eq 0 ] && [[ "$code_only" =~ (^|[^[:alnum:]_])async([[:space:]]+(move[[:space:]]*)?\{|[[:space:]]+(unsafe[[:space:]]+)?fn[[:space:]]) ]]; then
in_async=1; async_depth=0; async_opened=0
fi
async_line=$in_async
if [ "$in_async" -eq 1 ]; then
async_depth=$((async_depth + opens - closes))
[ "$opens" -gt 0 ] && async_opened=1
if [ "$async_opened" -eq 1 ] && [ "$async_depth" -le 0 ]; then in_async=0; fi
fi
exempt=0
[ "$in_test_file" -eq 1 ] && exempt=1
[ "$in_cfg_test" -eq 1 ] && exempt=1
if [ "$exempt" -eq 0 ]; then
if [[ "$code_only" =~ \.unwrap\(\) ]] && [[ ! "$prev" =~ \#\[expect\(clippy::unwrap_used,.*reason ]]; then
report "$file" "$line_no" "unwrap" ".unwrap() outside tests - use ? / ok_or / let-else, or for a proven invariant use .expect() behind #[expect(clippy::expect_used, reason = \"...\")]"
fi
if [[ "$code_only" =~ \.expect\( ]] && [[ ! "$prev" =~ \#\[expect\(clippy::expect_used,.*reason ]]; then
report "$file" "$line_no" "expect" ".expect() outside tests - use ?, or for a proven invariant annotate the previous line with #[expect(clippy::expect_used, reason = \"...\")]"
fi
if [[ "$code_only" =~ (todo!|unimplemented!|unreachable!|unreachable_unchecked!) ]]; then
report "$file" "$line_no" "placeholder-macro" "todo!/unimplemented!/unreachable! in committed code"
fi
if [[ "$code_only" =~ Box\<dyn[[:space:]]+Error ]]; then
report "$file" "$line_no" "box-dyn-error" "Box<dyn Error> in non-test code - use anyhow::Error (apps) or thiserror enum (libs)"
fi
if [[ "$file" == */src/lib.rs || "$file" == */src/*/mod.rs || ( "$file" == */src/*.rs && "$file" != */src/main.rs && "$file" != */src/bin/* ) ]]; then
if [[ "$code_only" =~ panic!\( ]]; then
report "$file" "$line_no" "lib-panic" "panic!() in library code - return Result"
fi
fi
if [[ "$code_only" =~ let[[:space:]]+_[[:space:]]*=[[:space:]]*[^\;]*\( ]] && [[ ! "$prev" =~ \#\[expect\(clippy::let_underscore_must_use,.*reason ]]; then
report "$file" "$line_no" "discarded-result" "let _ = call() drops its result - propagate or handle the error; log it on a best-effort path"
fi
if [ "$async_line" -eq 1 ] && [[ "$code_only" =~ (thread::sleep\(|std::fs::|reqwest::blocking::|\.blocking_(recv|send|lock|read|write)\() ]]; then
report "$file" "$line_no" "blocking-in-async" "blocking call inside async code - use tokio::time::sleep / tokio::fs / the async client, or move it into spawn_blocking"
fi
fi
if [[ "$code_only" =~ unsafe[[:space:]]*\{ ]]; then
start=$((i > 5 ? i - 5 : 0))
window=$(printf '%s\n' "${lines[@]:$start:$((i - start + 1))}")
if [[ ! "$window" =~ //[[:space:]]*SAFETY: ]]; then
report "$file" "$line_no" "unsafe-no-safety-comment" "unsafe block without // SAFETY: comment in preceding 5 lines"
fi
fi
if [[ "$code_only" =~ \#!?\[allow\( ]]; then
report "$file" "$line_no" "allow-attribute" "#[allow(...)] - use #[expect(lint, reason = \"...\")] so the exception fails once the lint stops firing"
fi
if [[ "$code_only" =~ \#!?\[expect\( ]]; then
attr=$(printf '%s\n' "${lines[@]:$i:4}")
if [[ ! "$attr" =~ reason[[:space:]]*= ]]; then
report "$file" "$line_no" "expect-without-reason" "#[expect(...)] needs reason = \"...\" naming why the lint does not apply"
fi
fi
# Heuristic flag for human review; exact analysis belongs to clippy::cast_possible_truncation.
if [[ "$code_only" =~ (u16|u32|u64|u128|usize|i16|i32|i64|i128|isize)[[:space:]]+as[[:space:]]+(u8|u16|u32|i8|i16|i32)([^[:alnum:]_]|$) ]]; then
report "$file" "$line_no" "narrowing-as-cast" "possible narrowing 'as' cast - use TryFrom / try_into() for fallible conversion"
fi
done
done
if [ "$violations" -gt 0 ]; then
echo "" >&2
echo "rust-programmer: ${violations} violation(s). Fix before declaring work done." >&2
echo "" >&2
echo "Then run the full toolchain gate:" >&2
echo " cargo fmt --all -- --check" >&2
echo " cargo clippy --all-targets --all-features -- -D warnings" >&2
echo " cargo nextest run --all-targets --all-features && cargo test --doc" >&2
echo " cargo +nightly miri nextest run --all-features # if unsafe touched" >&2
echo " cargo machete" >&2
echo " cargo deny check" >&2
exit 1
fi
echo "rust-programmer: no-excuse rules passed for $# file(s)."
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |