291 lines
13 KiB
Plaintext
Raw Permalink Normal View History

feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
#!/usr/bin/env python3
"""Run every blocking lint check CI runs, locally, with the same pinned tools: the lint
the workflow's guards, ruff and the code-health ratchet, plus the case-collision, lazy-deps,
profile-archive and blob-size guards that CI runs in workflows of their own.
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
python scripts/check # everything, against the merge-base with origin/main
python scripts/check --only health # just the code-health ratchet
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
python scripts/check --staged # judge the index (the pre-commit hook runs this)
python scripts/check --commit REV # judge one commit (the pre-push hook runs this)
python scripts/check --install-hook [pre-commit|pre-push] # run it automatically
python scripts/check --uninstall-hook
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
CI runs the same command (``.github/workflows/lint.yml``), so a green local run means a green
lint lane. Hooks are skippable (``--no-verify``); CI is not. The code-health part honours the
``ENFORCEMENT`` switch in ``scripts/code_health/config.py`` (blocking / advisory / off).
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
"""
from __future__ import annotations
import argparse
import os
import subprocess
import sys
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
import tempfile
from collections.abc import Iterator
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
from concurrent.futures import ThreadPoolExecutor
fix(code-health): occurrence provenance, alias-aware rules, strict file cap (round 4) Fourth review round (F11-F18, N1-N4, kvnloo, Adolanium): - Hits are old only where the base occurrence survives: a line the comment- and whitespace-blind line diff keeps (blame semantics), or anything inside a unit whose body is unchanged. An identical violation moved past unrelated code is new; removing an allow comment or re-indenting is not. Hit fingerprints exclude comments (N4). - Inline allows cover their own line; only a comment-only line covers the next (N3). - Rules read a copy of the AST with import aliases resolved, so `sp.run`, `from subprocess import run as execute`, aliased threading/asyncio/load_config are seen (F12); deadline helpers must resolve to the real asyncio API, and communicate()/wait() are judged only on receivers holding a spawned process (F13); infinite deadlines are unbounded (F14). - HERMES_* writes introduce a name too (N1); bool(os.environ[...]) is HX010 (N2); HX009 needs the isinstance subject to come from gather(return_exceptions=True). - Recursive self-references are normalised out of body hashes, so a recursive rename keeps its cap, py and ts (F15). Decorators belong to their function's scope and classes are matchable units, so their hits follow proven moves (F16). - An over-cap file may not grow (F17, Teknium: strict improvement-only). - A file the checker cannot parse or measure (ast/ruff/TS parse error) fails. - scripts/check: --staged always lints an index snapshot (ignored files are invisible to git status, not to guards) (F18); create the --prefix dir for Git for Windows (F11); --only builds just the selected jobs, so it needs no ruff for non-ruff checks. - CODEOWNERS covers scripts/check + scripts/code_health; frontend-only PRs skip the Python-only lint jobs again and run only the ratchet.
2026-10-04 12:36:18 -07:00
from contextlib import contextmanager
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
from dataclasses import dataclass
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
from pathlib import Path
# Before the engine imports: they need 3.11 (tomllib), and an older python3 first on PATH would
# otherwise die in a traceback on every hooked commit or push.
if sys.version_info < (3, 11):
print(f"scripts/check needs Python 3.11+, this is {'.'.join(map(str, sys.version_info[:3]))};"
" run it with the repo's virtualenv (.venv/bin/python scripts/check)", file=sys.stderr)
raise SystemExit(2)
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
REPO = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(REPO))
from scripts.code_health import gitio # noqa: E402
from scripts.code_health.ruff_runner import resolve_ruff # noqa: E402
_HOOK_MARK = "# hermes-agent scripts/check hook"
# Hooks are shared by every worktree of the clone, so the checked-out branch decides nothing:
# each candidate (the index being committed, the tip of each pushed branch) is materialized and
# judged by its own scripts/check, and a candidate that predates scripts/check is not judged.
_HOOK_HEAD = f"""#!/usr/bin/env bash
{_HOOK_MARK} (`scripts/check --install-hook`; skip once with --no-verify)
""" + r"""repo="$(git rev-parse --show-toplevel)" || exit 1
git_dir="$(git rev-parse --absolute-git-dir)" || exit 1
# The repo's virtualenv first (this worktree's, then the main checkout's): a bare python3 on
# PATH may predate the 3.11 that scripts/check needs.
common="$(cd "$(git rev-parse --git-common-dir)/.." && pwd)"
py=
for root in "$repo" "$common"; do
for rel in .venv/bin/python venv/bin/python .venv/Scripts/python.exe venv/Scripts/python.exe; do
if [ -z "$py" ] && [ -x "$root/$rel" ]; then py="$root/$rel"; fi
done
done
[ -n "$py" ] || py="$(command -v python3 || command -v python)" || {
echo "scripts/check hook: no python3 or python on PATH" >&2; exit 1; }
judge() { # judge TREE-ISH ARGS...: check out TREE-ISH alone and run its own scripts/check ARGS
local tree=$1 tmp dir rc
shift
tmp="$(mktemp -d)" || return 1
# Git for Windows: native git and python get this path verbatim when MSYS path conversion
# is off (MSYS_NO_PATHCONV=1, as Hermes' terminal sets it), so hand them C:/... spelling.
dir="$tmp"
if command -v cygpath >/dev/null 2>&1; then dir="$(cygpath -m "$tmp")" || dir="$tmp"; fi
GIT_INDEX_FILE="$dir/index" git read-tree "$tree" &&
GIT_INDEX_FILE="$dir/index" git checkout-index -a -f --prefix="$dir/tree/" &&
GIT_DIR="$git_dir" "$py" "$dir/tree/scripts/check" "$@" </dev/null
rc=$?
rm -rf "$tmp"
return $rc
}
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
"""
_HOOKS = {
# git may export a relative GIT_INDEX_FILE, and the checker runs from another directory.
"pre-commit": _HOOK_HEAD + """\
index="$(git rev-parse --path-format=absolute --git-path index)" || exit 1
export GIT_INDEX_FILE="$index"
tree="$(git write-tree)" || exit 1
git cat-file -e "$tree:scripts/check" 2>/dev/null || exit 0
judge "$tree" --staged
""",
# stdin: "<local ref> <local sha> <remote ref> <remote sha>" per pushed ref; an all-zero
# local sha is a deletion. Each pushed branch tip is judged, as CI judges the PR as a whole;
# intermediate commits are not judged one by one.
"pre-push": _HOOK_HEAD + """status=0
while read -r _ local_sha _ _; do
case "$local_sha" in *[!0]*) ;; *) continue ;; esac
git cat-file -e "$local_sha:scripts/check" 2>/dev/null || continue
judge "$local_sha" --commit "$local_sha" </dev/null || status=1
done
exit $status
""",
}
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
# name -> argv (relative to the repo root); mirrors the blocking steps in lint.yml, plus the
# unconditional guards CI runs in their own workflows (case-collision-check.yml,
# lazy-deps-guard.yml, profile-artifact-check.yml, blob-size-check.yml).
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
_GUARDS = {
"footguns": ["scripts/check-windows-footguns.py", "--all"],
"shebangs": ["scripts/check_bash_shebangs.py"],
"no-tmp": ["scripts/check_no_tmp_literals.py"],
ci(process): no new detached spawn outside spawn_owned without a reason A child started in its own session or group (start_new_session, os.setsid / setpgid / setpgrp, windows_detach_popen_kwargs) does not die with a SIGKILLed Hermes: it reparents to init and runs forever. That is how every family this PR migrates leaked. With the families on spawn_owned, this keeps the class closed. scripts/check_detached_spawns.py (AST) flags those shapes in the production trees unless the line, or the line above it, says `detached-spawn: ok — <why>`. It runs in scripts/check ("detached-spawns") and as a blocking lint.yml step. The baseline is empty: every remaining site is on spawn_owned / own_process_groups, or carries its reason. The reasons this commit adds are the census verdicts: - must outlive the starter on purpose: restart watchers, /update and the updater hand-offs, dashboard/desktop/service launches, cron and kanban workers (restart-safe), the update-custody watchdog itself; - awaited with a group kill on timeout: cron scripts, rg search, the Browser Use CLI, update completion (holds the checkout lock fd); - covered by its own parent guard: the compute host (compute_host._parent_guard_loop flushes sessions; a supervisor KILL could cut that short); - not a spawn: the wake-word `start_new_session` config key and event field. tests/scripts/test_check_detached_spawns.py: each shape flagged, non-detached and commented/string shapes not, the marker opts out on its line or the line above and nowhere else, tests and the helper are out of scope, main() fails on a new unmarked spawn, and the repository scan is empty. Teeth: appending an unmarked start_new_session Popen to tools/file_operations_search.py turns `scripts/check --only detached-spawns` red (rc 1); restoring it turns it green.
2026-10-12 17:48:43 +05:30
"detached-spawns": ["scripts/check_detached_spawns.py"],
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
"config-writers": ["scripts/check_config_yaml_writers.py"],
"config-readers": ["scripts/check_config_yaml_readers.py"],
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
"os-marker-fakes": ["scripts/ci/check_os_marker_fakes.py"],
"agents-md": ["scripts/ci/check_agents_md_size.py"],
"case-collisions": ["scripts/check-case-collisions.py"],
"lazy-deps": ["scripts/ci/check_lazy_deps_imports.py"],
"profile-archives": ["scripts/ci/check_profile_archive_boundary.py"],
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
}
# Guards that judge a diff, not a tree: they get the same base/head as the ratchet
# (blob-size-check.yml).
_DIFF_GUARDS = {"blob-size": ["scripts/ci/check_blob_size.py"]}
_CHECKS = (*_GUARDS, *_DIFF_GUARDS, "ruff", "health")
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
@dataclass
class _Job:
argv: list[str]
cwd: Path = REPO
env: dict[str, str] | None = None
def _run(job: _Job) -> tuple[int, str]:
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
proc = subprocess.run(
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
job.argv, cwd=job.cwd, env=job.env, capture_output=True, text=True, encoding="utf-8",
errors="replace", stdin=subprocess.DEVNULL, timeout=900, check=False,
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
)
return proc.returncode, (proc.stdout + proc.stderr).strip()
def _git_in(env: dict[str, str], *args: str) -> None:
proc = subprocess.run(["git", *args], cwd=REPO, env=env, capture_output=True, text=True,
stdin=subprocess.DEVNULL, timeout=300, check=False)
if proc.returncode != 0:
raise RuntimeError(f"git {' '.join(args)} failed: {proc.stderr.strip()}")
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
@contextmanager
def _tree_snapshot(tree: str) -> Iterator[tuple[Path, dict[str, str]]]:
"""``tree`` checked out on its own, plus git env that sees exactly that tree.
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
The user's worktree and index are never touched (no stash, no checkout): the tree is read
into a private index and written to a temp dir. Always a snapshot, even when the worktree
looks clean: ignored files (scratch, build output) are invisible to git status but not to
the guards that walk the disk.
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
"""
git_dir = gitio.git(REPO, "rev-parse", "--absolute-git-dir").strip()
with tempfile.TemporaryDirectory(prefix="hermes-check-tree-") as tmp:
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
root = Path(tmp) / "tree"
root.mkdir()
env = {**os.environ, "GIT_DIR": git_dir, "GIT_WORK_TREE": str(root),
"GIT_INDEX_FILE": str(Path(tmp) / "index")}
_git_in(env, "read-tree", tree)
# -f: on a case-insensitive filesystem paths that differ only by case are one file, and
# without it the second one aborts the snapshot before the case-collision guard runs
# (the guards read the index, which keeps both).
_git_in(env, "checkout-index", "-a", "-f")
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
yield root, env
def _jobs(names: list[str], base: str | None, head: str | None,
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
root: Path = REPO, env: dict[str, str] | None = None) -> dict[str, _Job]:
fix(code-health): occurrence provenance, alias-aware rules, strict file cap (round 4) Fourth review round (F11-F18, N1-N4, kvnloo, Adolanium): - Hits are old only where the base occurrence survives: a line the comment- and whitespace-blind line diff keeps (blame semantics), or anything inside a unit whose body is unchanged. An identical violation moved past unrelated code is new; removing an allow comment or re-indenting is not. Hit fingerprints exclude comments (N4). - Inline allows cover their own line; only a comment-only line covers the next (N3). - Rules read a copy of the AST with import aliases resolved, so `sp.run`, `from subprocess import run as execute`, aliased threading/asyncio/load_config are seen (F12); deadline helpers must resolve to the real asyncio API, and communicate()/wait() are judged only on receivers holding a spawned process (F13); infinite deadlines are unbounded (F14). - HERMES_* writes introduce a name too (N1); bool(os.environ[...]) is HX010 (N2); HX009 needs the isinstance subject to come from gather(return_exceptions=True). - Recursive self-references are normalised out of body hashes, so a recursive rename keeps its cap, py and ts (F15). Decorators belong to their function's scope and classes are matchable units, so their hits follow proven moves (F16). - An over-cap file may not grow (F17, Teknium: strict improvement-only). - A file the checker cannot parse or measure (ast/ruff/TS parse error) fails. - scripts/check: --staged always lints an index snapshot (ignored files are invisible to git status, not to guards) (F18); create the --prefix dir for Git for Windows (F11); --only builds just the selected jobs, so it needs no ruff for non-ruff checks. - CODEOWNERS covers scripts/check + scripts/code_health; frontend-only PRs skip the Python-only lint jobs again and run only the ratchet.
2026-10-04 12:36:18 -07:00
jobs: dict[str, _Job] = {}
for name in names: # built only when selected: `--only shebangs` needs no ruff
if name in _GUARDS:
jobs[name] = _Job([sys.executable, *_GUARDS[name]], root, env)
elif name in _DIFF_GUARDS:
argv = [sys.executable, *_DIFF_GUARDS[name]]
argv += ["--base", base] if base else []
argv += ["--head", head] if head else []
jobs[name] = _Job(argv, root, env)
fix(code-health): occurrence provenance, alias-aware rules, strict file cap (round 4) Fourth review round (F11-F18, N1-N4, kvnloo, Adolanium): - Hits are old only where the base occurrence survives: a line the comment- and whitespace-blind line diff keeps (blame semantics), or anything inside a unit whose body is unchanged. An identical violation moved past unrelated code is new; removing an allow comment or re-indenting is not. Hit fingerprints exclude comments (N4). - Inline allows cover their own line; only a comment-only line covers the next (N3). - Rules read a copy of the AST with import aliases resolved, so `sp.run`, `from subprocess import run as execute`, aliased threading/asyncio/load_config are seen (F12); deadline helpers must resolve to the real asyncio API, and communicate()/wait() are judged only on receivers holding a spawned process (F13); infinite deadlines are unbounded (F14). - HERMES_* writes introduce a name too (N1); bool(os.environ[...]) is HX010 (N2); HX009 needs the isinstance subject to come from gather(return_exceptions=True). - Recursive self-references are normalised out of body hashes, so a recursive rename keeps its cap, py and ts (F15). Decorators belong to their function's scope and classes are matchable units, so their hits follow proven moves (F16). - An over-cap file may not grow (F17, Teknium: strict improvement-only). - A file the checker cannot parse or measure (ast/ruff/TS parse error) fails. - scripts/check: --staged always lints an index snapshot (ignored files are invisible to git status, not to guards) (F18); create the --prefix dir for Git for Windows (F11); --only builds just the selected jobs, so it needs no ruff for non-ruff checks. - CODEOWNERS covers scripts/check + scripts/code_health; frontend-only PRs skip the Python-only lint jobs again and run only the ratchet.
2026-10-04 12:36:18 -07:00
elif name == "ruff":
jobs[name] = _Job([*resolve_ruff(root), "check", "."], root, env)
fix(code-health): occurrence provenance, alias-aware rules, strict file cap (round 4) Fourth review round (F11-F18, N1-N4, kvnloo, Adolanium): - Hits are old only where the base occurrence survives: a line the comment- and whitespace-blind line diff keeps (blame semantics), or anything inside a unit whose body is unchanged. An identical violation moved past unrelated code is new; removing an allow comment or re-indenting is not. Hit fingerprints exclude comments (N4). - Inline allows cover their own line; only a comment-only line covers the next (N3). - Rules read a copy of the AST with import aliases resolved, so `sp.run`, `from subprocess import run as execute`, aliased threading/asyncio/load_config are seen (F12); deadline helpers must resolve to the real asyncio API, and communicate()/wait() are judged only on receivers holding a spawned process (F13); infinite deadlines are unbounded (F14). - HERMES_* writes introduce a name too (N1); bool(os.environ[...]) is HX010 (N2); HX009 needs the isinstance subject to come from gather(return_exceptions=True). - Recursive self-references are normalised out of body hashes, so a recursive rename keeps its cap, py and ts (F15). Decorators belong to their function's scope and classes are matchable units, so their hits follow proven moves (F16). - An over-cap file may not grow (F17, Teknium: strict improvement-only). - A file the checker cannot parse or measure (ast/ruff/TS parse error) fails. - scripts/check: --staged always lints an index snapshot (ignored files are invisible to git status, not to guards) (F18); create the --prefix dir for Git for Windows (F11); --only builds just the selected jobs, so it needs no ruff for non-ruff checks. - CODEOWNERS covers scripts/check + scripts/code_health; frontend-only PRs skip the Python-only lint jobs again and run only the ratchet.
2026-10-04 12:36:18 -07:00
else:
# The ratchet reads both sides from git. It runs from `root` like every other job, so
# in a snapshot its engine, rules and policy files (profile_scope_patterns.json, the
# ruff pin) are the judged artifact's own, never unstaged working-tree bytes.
fix(code-health): occurrence provenance, alias-aware rules, strict file cap (round 4) Fourth review round (F11-F18, N1-N4, kvnloo, Adolanium): - Hits are old only where the base occurrence survives: a line the comment- and whitespace-blind line diff keeps (blame semantics), or anything inside a unit whose body is unchanged. An identical violation moved past unrelated code is new; removing an allow comment or re-indenting is not. Hit fingerprints exclude comments (N4). - Inline allows cover their own line; only a comment-only line covers the next (N3). - Rules read a copy of the AST with import aliases resolved, so `sp.run`, `from subprocess import run as execute`, aliased threading/asyncio/load_config are seen (F12); deadline helpers must resolve to the real asyncio API, and communicate()/wait() are judged only on receivers holding a spawned process (F13); infinite deadlines are unbounded (F14). - HERMES_* writes introduce a name too (N1); bool(os.environ[...]) is HX010 (N2); HX009 needs the isinstance subject to come from gather(return_exceptions=True). - Recursive self-references are normalised out of body hashes, so a recursive rename keeps its cap, py and ts (F15). Decorators belong to their function's scope and classes are matchable units, so their hits follow proven moves (F16). - An over-cap file may not grow (F17, Teknium: strict improvement-only). - A file the checker cannot parse or measure (ast/ruff/TS parse error) fails. - scripts/check: --staged always lints an index snapshot (ignored files are invisible to git status, not to guards) (F18); create the --prefix dir for Git for Windows (F11); --only builds just the selected jobs, so it needs no ruff for non-ruff checks. - CODEOWNERS covers scripts/check + scripts/code_health; frontend-only PRs skip the Python-only lint jobs again and run only the ratchet.
2026-10-04 12:36:18 -07:00
health = [sys.executable, "-m", "scripts.code_health"]
health += ["--base", base] if base else []
health += ["--head", head] if head else []
jobs[name] = _Job(health, root, env)
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
return jobs
def _run_jobs(jobs: dict[str, _Job]) -> dict[str, tuple[int, str]]:
with ThreadPoolExecutor(max_workers=len(jobs) or 1) as pool:
return dict(zip(jobs, pool.map(_run, jobs.values()), strict=True))
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
def _run_all(args: argparse.Namespace) -> dict[str, tuple[int, str]]:
if not (args.staged or args.commit):
return _run_jobs(_jobs(args.only, args.base, None))
# Hooks judge the bytes being committed or pushed, never the working tree. Without --base the
# ratchet derives the base from the head (a commit's own merge-base) and the switch from main.
if args.staged:
tree = head = gitio.git(REPO, "write-tree").strip()
else:
head = gitio.resolve_rev(REPO, args.commit)
tree = gitio.resolve_tree(REPO, head)
with _tree_snapshot(tree) as (root, env):
return _run_jobs(_jobs(args.only, args.base, head, root, env))
def _hooks_dir() -> Path:
return Path(gitio.git(REPO, "rev-parse", "--path-format=absolute", "--git-path", "hooks").strip())
def _ours(target: Path) -> bool:
return _HOOK_MARK in target.read_text(encoding="utf-8-sig", errors="replace")
def install_hook(kind: str) -> int:
hooks = _hooks_dir()
target = hooks / kind
if target.exists() and not _ours(target):
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
print(f"scripts/check: {target} exists and is not ours; add `python scripts/check` to it")
return 1
hooks.mkdir(parents=True, exist_ok=True)
target.write_text(_HOOKS[kind], encoding="utf-8", newline="\n")
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
os.chmod(target, 0o755) # windows-footgun: ok — chmod +x is a no-op on Windows, harmless
print(f"scripts/check: {kind} hook installed at {target} (every worktree of this clone)")
return 0
def uninstall_hooks() -> int:
removed = [t for t in (_hooks_dir() / k for k in _HOOKS) if t.exists() and _ours(t)]
for target in removed:
target.unlink()
print(f"scripts/check: removed {target}")
if not removed:
print("scripts/check: no scripts/check hooks installed")
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
return 0
def _selected(parser: argparse.ArgumentParser, only: str | None) -> list[str]:
"""Every check, or exactly the named ones. A typo must not turn into an empty green run."""
if only is None:
return list(_CHECKS)
wanted = {name.strip() for name in only.split(",")} - {""}
unknown = sorted(wanted - set(_CHECKS))
if not wanted or unknown:
parser.error(f"--only {only!r}: unknown or no check name ({', '.join(unknown) or 'empty'});"
f" valid: {', '.join(_CHECKS)}")
return [name for name in _CHECKS if name in wanted]
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(prog="scripts/check", description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--only", help=f"comma list of: {', '.join(_CHECKS)}")
parser.add_argument("--base", help="base revision for the code-health ratchet and blob-size")
target = parser.add_mutually_exclusive_group()
target.add_argument("--staged", action="store_true",
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
help="check the index (what `git commit` records), not the working tree")
target.add_argument("--commit", metavar="REV", help="check one commit's tree (pre-push)")
parser.add_argument("--install-hook", nargs="?", const="pre-commit", choices=sorted(_HOOKS),
help="run on every commit (default) or every push")
parser.add_argument("--uninstall-hook", action="store_true", help="remove our git hooks")
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
args = parser.parse_args(argv)
args.only = _selected(parser, args.only)
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
if args.install_hook:
return install_hook(args.install_hook)
if args.uninstall_hook:
return uninstall_hooks()
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
try:
fix(code-health): one-to-one move matching, real deadlines, index-exact hook Second-round review on #132646 (F1-F10), each reproduced on 2531fb2 first: - Moves are matched one-to-one: unchanged units are reserved first, then same-file body, then cross-file body only when the origin's name is gone, then same name. A copy of unchanged debt is new debt; a function moved over a same-name stub keeps its own cap (F1, F3). - Every base hit is owned by exactly one head scope, so a file rename no longer counts each old hit twice (F2). - Ruff runs when either side has Python, so a delete-only .py diff with a TS edit no longer crashes on a missing ruff result (F4). - Deadlines must be finite: timeout=None, **{} and asyncio.timeout(None) are no deadline; awaited calls inside `async with asyncio.timeout(x)` are bounded (F5, F8). - HX005 walks only what runs at import: the import-time branch of a `__name__` guard (either operator), loops, match, try*, decorators, class bases; a lambda value is deferred (F9). - `health: allow` counts only in real comment tokens (Python tokenize, TS comment trivia), never in string literals (F7). - TS function lines are owned by the innermost function, so siblings on one line give it up once (F10). - The pre-commit hook runs `scripts/check --staged`: health compares the index tree, and when the working tree differs from the index the other checkers run on a checkout-index copy with a copied index, so commits are judged on the staged bytes and unstaged work is never touched (F6).
2026-10-04 03:53:31 -07:00
results = _run_all(args)
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
except RuntimeError as exc:
print(f"scripts/check: {exc}", file=sys.stderr)
return 2
failed = [name for name, (code, _) in results.items() if code != 0]
# A passing health run still carries advisories and comment-allowed findings that the
# reviewer must see, so its report is always shown.
for name, (code, output) in results.items():
if code != 0 or name == "health":
label = "failed" if code != 0 else "ok"
print(f"\n=== {name} ({label}) ===\n{output.rstrip()}")
feat: code-health ratchet with per-unit caps for Python and TypeScript scripts/code_health measures the files a change touches on both sides (base revision and head) and fails when: - a function or file over target grows past its own value on the base (CC 20, 300 own lines, nesting 6, file 2,000 lines); - a new function or file is over target; - a pattern rule gains a fingerprint (rule + enclosing function + line text), so fixing one violation never buys another. Code that moves keeps its cap: functions match by name-independent body hash, pattern hits by (rule, line text) once their function has left the old place. Nested functions are their own units, so a closure edit never counts against the hook or function around it. Python CC is ruff's C901 minus the direct nested defs; TypeScript is parsed with the lockfile's typescript (no type check). Rules: swallowed exceptions (S110, BLE001, E722), correctness (F821/F823/ F811/F841, RUF006), hangs (ASYNC230/240, S113, subprocess/urlopen without timeout, sync config I/O in async def, get_event_loop, gather results checked against Exception), profile scope (hardcoded ~/.hermes, a new HERMES_* env var, UnscopedSecretError -> os.getenv, import-time capture, raw threading.Thread, P05/P06 from profile_scope_patterns.json), argv process identity, bool() of an env string, and if/elif ladders. Growth of a file already over 2,000 lines is advisory: replaying 300 merged PRs, a blocking file-size ratchet would have stopped 46 of them before the 119 over-target files are split. Everything else blocks; the same replay finds 18 PRs that would have needed a change, every finding a real hit for its rule. No baseline file: base is measured on the fly, so an improvement that lands on main is the new cap at once and parallel PRs never conflict on ratchet state. `# health: allow <RULE> -- <why>` is the reviewed escape.
2026-10-04 00:37:45 -07:00
status = "FAILED: " + ", ".join(failed) if failed else "ok"
print(f"\nscripts/check: {len(results)} checks, {status}")
return 1 if failed else 0
if __name__ == "__main__":
raise SystemExit(main())