#!/usr/bin/env bash # shellcheck disable=SC2016 # the embedded `node -e` programs use JS template literals on purpose # audit-worktree.sh — read-only "trust but verify" pass over a worker's worktree. # # scripts/dev/audit-worktree.sh [--base ] [--repo ] # # Prints, in order: dirty files; commits since the merge-base with the base; `git diff --stat`; # protected-surface hits; assertion / test lines removed under tests/; per-file # eslint-suppressions.json counts that went UP versus the base; new keys in # test-masking-allowlist.json; leftover tsconfig.*tmp*.json / scratch files; and, when an open # PR exists for the branch, whether its head on GitHub equals the local HEAD. # # --base defaults to origin/ as listed by `git ls-remote --heads origin`. # Every comparison is working tree versus merge-base, so uncommitted edits count too. # # Final line: audit-worktree: dirty= protected= removed_asserts= suppressions_up= # allowlist_new= tmp_files= pr=<#N|none> head= # Exit 1 when protected > 0, tmp_files > 0 or the PR head does not match (2 on usage errors). # The script never writes to the worktree; the only `gh` call is `pr list`. GH_BIN overrides # the `gh` binary (tests point it at a stub). set -euo pipefail usage() { cat >&2 <<'EOF' usage: audit-worktree.sh [--base ] [--repo ] --base ref to diff against (default origin/ on origin) --repo GitHub repository for the PR lookup (default: origin URL, else cheaper-inference/OmniRoute) env: GH_BIN (gh binary) EOF } die() { echo "audit-worktree: $*" >&2 exit 2 } GH="${GH_BIN:-gh}" WT="" BASE="" REPO="" while [ $# -gt 0 ]; do case "$1" in --base | --repo) [ $# -ge 2 ] || die "missing value for $1" if [ "$1" = --base ]; then BASE="$2"; else REPO="$2"; fi shift 2 ;; -h | --help) usage exit 0 ;; -*) usage die "unknown option: $1" ;; *) [ -z "$WT" ] || { usage die "unexpected argument: $1" } WT="$1" shift ;; esac done [ -n "$WT" ] || { usage exit 2 } [ -d "$WT" ] || die "$WT is not a directory" cd "$WT" [ "$(git rev-parse --is-inside-work-tree 2>/dev/null || true)" = "true" ] || die "$WT is not a git work tree" cd "$(git rev-parse --show-toplevel)" PROTECTED_RE='(^|/)(AGENTS\.md|CLAUDE\.md|GEMINI\.md|llm\.txt|SKILL\.md)$|^\.agents/|^\.claude/|^config/quality/skill-templates/' TMP_RE='(^|/)tsconfig\.[^/]*tmp[^/]*\.json$|\.(orig|rej|tmp)$' count_lines() { printf '%s' "$1" | grep -c . || true } # $1 label, $2 body → "label (n):" + indented body or "(none)". section() { local n n=$(count_lines "$2") printf '%s (%s):\n' "$1" "$n" if [ "$n" -gt 0 ]; then printf '%s\n' "$2" | sed 's/^/ /'; else echo " (none)"; fi echo } # ---- base ---------------------------------------------------------------------------------- if [ -z "$BASE" ]; then latest=$(git ls-remote --heads origin 'release/v*' 2>/dev/null | sed 's#.*refs/heads/##' | sort -V | tail -n 1 || true) [ -n "$latest" ] || die "origin has no release/v* branch; pass --base " BASE="origin/$latest" fi git rev-parse -q --verify "$BASE^{commit}" >/dev/null || die "base $BASE not found locally (fetch it first)" MB=$(git merge-base "$BASE" HEAD) HEAD_SHA=$(git rev-parse HEAD) BRANCH=$(git rev-parse --abbrev-ref HEAD) echo "audit-worktree: $PWD" echo "branch: $BRANCH @ ${HEAD_SHA:0:12} — base: $BASE (merge-base ${MB:0:12})" echo # ---- 1. dirty ------------------------------------------------------------------------------ DIRTY=$(git status --short --untracked-files=all) section "dirty" "$DIRTY" # ---- 2. commits ---------------------------------------------------------------------------- section "commits $(printf '%s' "$MB" | cut -c1-12)..HEAD" "$(git log --oneline "$MB..HEAD")" # ---- 3. diff --stat (working tree vs merge-base) ------------------------------------------ echo "diff --stat vs merge-base:" STAT=$(git diff --stat "$MB") if [ -n "$STAT" ]; then printf '%s\n' "$STAT" | sed 's/^/ /'; else echo " (none)"; fi echo # Changed files = tracked changes versus the merge-base plus untracked files. CHANGED=$({ git diff --name-only "$MB" git ls-files --others --exclude-standard } | sort -u) # ---- 4. protected surfaces ----------------------------------------------------------------- PROTECTED=$(printf '%s\n' "$CHANGED" | { grep -E "$PROTECTED_RE" || true; }) section "protected surfaces" "$PROTECTED" # ---- 5. removed assertion / test lines under tests/ --------------------------------------- REMOVED="" while IFS= read -r f; do [ -n "$f" ] || continue hits=$(git diff "$MB" -- "$f" | { grep -E '^-' || true; } | { grep -vE '^---' || true; } | { grep -E 'assert|test\(|it\(' || true; }) [ -z "$hits" ] || REMOVED+="$(printf '%s\n' "$hits" | sed "s#^#$f: #")"$'\n' done < <(printf '%s\n' "$CHANGED" | { grep -E '^tests/' || true; }) section "removed assert/test lines under tests/" "$REMOVED" # ---- 6. eslint-suppressions.json counts that went up -------------------------------------- # Both versions are parsed with node: base from `git show :` on stdin, head # from the working tree. A file or rule missing on one side counts as 0. SUPP_PATH="config/quality/eslint-suppressions.json" SUPP_UP=$({ git show "$MB:$SUPP_PATH" 2>/dev/null || echo '{}'; } | node -e ' const fs = require("fs"); const base = JSON.parse(fs.readFileSync(0, "utf8") || "{}"); const head = fs.existsSync(process.argv[1]) ? JSON.parse(fs.readFileSync(process.argv[1], "utf8")) : {}; for (const [file, rules] of Object.entries(head)) { if (file.startsWith("_") || typeof rules !== "object" || rules === null) continue; const up = []; for (const [rule, v] of Object.entries(rules)) { const h = Number((v && v.count) || 0); const b = Number(((base[file] || {})[rule] || {}).count || 0); if (h > b) up.push(`${rule} ${b} → ${h}`); } if (up.length) process.stdout.write(`${file}: ${up.join(", ")}\n`); }' "$SUPP_PATH") section "eslint-suppressions.json counts UP vs base (only DOWN is allowed)" "$SUPP_UP" # ---- 7. new test-masking-allowlist.json keys ---------------------------------------------- ALLOW_PATH="config/quality/test-masking-allowlist.json" ALLOW_NEW=$({ git show "$MB:$ALLOW_PATH" 2>/dev/null || echo '{}'; } | node -e ' const fs = require("fs"); const base = JSON.parse(fs.readFileSync(0, "utf8") || "{}"); const head = fs.existsSync(process.argv[1]) ? JSON.parse(fs.readFileSync(process.argv[1], "utf8")) : {}; for (const [key, reason] of Object.entries(head)) { if (key.startsWith("_") || key in base) continue; const text = String(reason).replace(/\s+/g, " "); process.stdout.write(`${key}: ${text.length > 120 ? text.slice(0, 117) + "..." : text}\n`); }' "$ALLOW_PATH") section "new test-masking-allowlist.json keys (each needs a concrete justification)" "$ALLOW_NEW" # ---- 8. leftover tsconfig.*tmp*.json / scratch files -------------------------------------- TMP_FILES=$({ git ls-files --cached --others --exclude-standard | { grep -E "$TMP_RE" || true; } find . -maxdepth 1 -name 'tsconfig.*tmp*.json' | sed 's#^\./##' } | sort -u) section "leftover tsconfig.*tmp*.json / scratch files" "$TMP_FILES" # ---- 9. PR head vs local HEAD -------------------------------------------------------------- PR_NUM="none" HEAD_STATE="none" if [ -z "$REPO" ]; then REPO=$(git remote get-url origin 2>/dev/null | sed -nE 's#.*github\.com[:/]([^/]+/[^/.]+)(\.git)?/?$#\1#p' || true) [ -n "$REPO" ] || REPO="cheaper-inference/OmniRoute" fi echo "pull request:" if [ "$BRANCH" = "HEAD" ]; then echo " detached HEAD — no branch to look up" elif ! command -v "$GH" >/dev/null 2>&1; then echo " gh not available ($GH) — PR lookup skipped" else PR_JSON=$("$GH" pr list --repo "$REPO" --head "$BRANCH" --state open --json number,headRefOid,url 2>/dev/null || echo '[]') PR_LINE=$(printf '%s' "$PR_JSON" | node -e ' let s = ""; process.stdin.on("data", (d) => (s += d)).on("end", () => { let rows = []; try { rows = JSON.parse(s || "[]"); } catch { rows = []; } const p = Array.isArray(rows) ? rows[0] : undefined; process.stdout.write(p ? `${p.number} ${p.headRefOid || "-"} ${p.url || "-"}` : "none - -"); });') read -r PR_NUM PR_OID PR_URL <<<"$PR_LINE" if [ "$PR_NUM" = "none" ]; then echo " no open PR for $BRANCH in $REPO" else PR_NUM="#$PR_NUM" if [ "$PR_OID" = "$HEAD_SHA" ]; then HEAD_STATE="ok" echo " PUSH LANDED — PR $PR_NUM head ${PR_OID:0:12} == local HEAD ($PR_URL)" else HEAD_STATE="mismatch" echo " HEAD NOT PUSHED — PR $PR_NUM head ${PR_OID:0:12} != local HEAD ${HEAD_SHA:0:12} ($PR_URL)" fi fi fi if [ "$BRANCH" != "HEAD" ] && REMOTE_SHA=$(git rev-parse -q --verify "refs/remotes/origin/$BRANCH" 2>/dev/null); then if [ "$REMOTE_SHA" = "$HEAD_SHA" ]; then echo " origin/$BRANCH == HEAD" else echo " origin/$BRANCH at ${REMOTE_SHA:0:12} differs from HEAD ${HEAD_SHA:0:12} (last fetch/push)" fi fi echo # ---- summary ------------------------------------------------------------------------------- N_DIRTY=$(count_lines "$DIRTY") N_PROTECTED=$(count_lines "$PROTECTED") N_REMOVED=$(count_lines "$REMOVED") N_SUPP=$(count_lines "$SUPP_UP") N_ALLOW=$(count_lines "$ALLOW_NEW") N_TMP=$(count_lines "$TMP_FILES") echo "audit-worktree: dirty=$N_DIRTY protected=$N_PROTECTED removed_asserts=$N_REMOVED suppressions_up=$N_SUPP allowlist_new=$N_ALLOW tmp_files=$N_TMP pr=$PR_NUM head=$HEAD_STATE" [ "$N_PROTECTED" -eq 0 ] && [ "$N_TMP" -eq 0 ] && [ "$HEAD_STATE" != "mismatch" ]