pi-dev-team 0.2.0

package/skills/code-review/scripts/change_shape.py

@@ -0,0 +1,372 @@
+#!/usr/bin/env python3
+"""Classify a changeset's shape to gate low-yield review lenses (#1254).
+
+Running the full review panel unconditionally wastes tokens on diffs with no
+runtime/logic surface. The 2026-07-20 audit found `performance-review` fired
+0/10 and `correctness-review` 1/10 — on doc/config-dominated commits most lenses
+no-op. `/code-review` (invoked directly) applies no complexity gate the way
+`/build` and `/plan` do, so every lens runs on every changed file regardless of
+change shape.
+
+This module is the deterministic gate. Given the changed-file list it decides
+whether the changeset has any **runtime surface** — a file that could hold
+executable logic. When it does not (every file is documentation or config),
+the two low-yield code lenses (`performance-review`, `correctness-review`) are
+skipped; the rest of the panel still runs.
+
+**Fail-safe by construction.** A file is "no runtime surface" only when it is
+*provably* documentation or config (matches an explicit allowlist). Anything
+else — an unknown extension, a source file, functional Claude-config markdown —
+counts as runtime surface, so the lenses run. A misclassification can only ever
+*add* a lens, never silently drop one on real code.
+
+Pure policy — no filesystem, no globals. Mirrors the documentation-only
+short-circuit's classification in `code-review/SKILL.md` (this gate is the
+weaker sibling: the short-circuit skips *everything* when every file is
+documentation; this skips only the two low-yield lenses when every file is
+documentation *or* config, which the doc-only short-circuit does not cover).
+
+Test-only classification (#1964)
+--------------------------------
+This module answers a second, independent question: is *every* changed file
+provably a test file (per `knowledge/test-file-indicators.md`)? A diff of that
+shape is structurally incapable of exhibiting what several expensive lenses
+look for — and under `/test-improve`'s default `refactor-mode: no-refactor`,
+Phase 5's diff is *guaranteed* to have it, because `/build` rejects
+production-code changes in that mode.
+
+`testOnly` is reported but currently skips **nothing**: `TEST_ONLY_SKIP_LENSES`
+ships empty on purpose. Which lens is safe to drop on a test-only diff is an
+empirical question, and the evidence (per-lens outcomes split by `diff_shape`
+in `review-value.jsonl`) is still being collected. This mirrors the
+architectural-impact gate's own rule — "widen `GATED_LENSES` from #1624's
+measured per-agent data, not from intuition about which lens probably no-ops."
+Two lenses in particular must NOT be added without data: `security-review`
+(tests embed credentials and injection payloads) and `correctness-review`
+(an inverted assertion is precisely its subject).
+
+Test-only classification is **include-biased in the same direction** as the
+runtime-surface check: a changeset is test-only only when every file is
+*provably* a test. Anything unproven — a fixture, a `conftest.py`, a helper, a
+`.cs` file whose test-ness needs its contents — makes the answer `False`, so
+the full panel runs. Because this module is filesystem-free by contract, the
+content-probing branches of the shared classifier are deliberately starved
+(`content=""`), which can only ever move the answer toward "not test-only".
+
+Scope note: this is a filename-shape gate. Annotation-only edits *inside* a
+source file (e.g. adding a C# attribute) still count as runtime surface — that
+would require diff parsing and is deliberately out of scope for v1.
+
+Shared literal tables (#1477): the documentation-extension, doc-root-word,
+and functional-config-name/segment literals below are byte-identical to
+`hooks/pre_commit_review.py`'s own doc-only classifier and were previously
+hand-duplicated between the two, kept in sync only by comment convention.
+They now live in `hooks/lib/doc_classification.py`, imported here via the
+same `sys.path.insert` cross-boundary pattern `pre_commit_review.py` already
+uses for its own `hooks/lib/` imports — see that module's docstring for why
+this location was chosen and why the *matching logic* (prefix vs. exact
+match) intentionally stays local to each caller rather than being unified
+too.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Iterable
+from pathlib import Path, PurePosixPath
+
+# skills/code-review/scripts -> skills/code-review -> skills -> plugin root
+# -> hooks/lib
+_HOOKS_LIB_DIR = Path(__file__).resolve().parents[3] / "hooks" / "lib"
+if str(_HOOKS_LIB_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_LIB_DIR))
+
+# Both shared modules are imported, never re-implemented. There is deliberately
+# no `except ImportError` fallback (#1968): a hand-written stand-in for a shared
+# classifier is a second copy of the logic that can drift from its source
+# silently, and one already did — the `is_test_file` fallback added in #1964
+# shipped folding all four indicator families into one `re.IGNORECASE` pattern
+# while `test_file_classify` compiles its step-definition regex
+# case-sensitively, so `backsteps.py` read as a step definition and an ordinary
+# source file could pass as a test. The whole suite stayed green, because every
+# other test exercised the import path that succeeds.
+#
+# `hooks/lib/` ships inside this same plugin, so an unreachable one is a broken
+# install or a moved file, not a supported degraded mode. Failing here — loudly,
+# naming the path that was searched — surfaces that immediately instead of
+# silently answering classification questions from a divergent copy.
+def _require_shared(module: str) -> ImportError:
+    """Build the diagnostic for a shared-module import that could not resolve.
+
+    The parent-count in `_HOOKS_LIB_DIR` is the fragile part (a moved file
+    changes it), so the message names the resolved path rather than leaving a
+    bare `No module named ...` to be reverse-engineered.
+    """
+    return ImportError(
+        f"{__name__} requires the shared classifier {module!r} from the "
+        f"dev-team plugin's hooks/lib, which could not be imported.\n"
+        f"  searched: {_HOOKS_LIB_DIR}\n"
+        f"  exists:   {_HOOKS_LIB_DIR.is_dir()}\n"
+        "This module deliberately has no fallback copy of the classifier "
+        "(#1968) — a divergent stand-in silently mis-classifies files. Fix the "
+        "install or the path rather than re-adding a local implementation."
+    )
+
+
+try:
+    from doc_classification import (  # type: ignore[import-not-found]
+        DOC_EXTENSIONS,
+        DOC_ROOT_WORDS,
+        is_functional_config,
+    )
+except ImportError as exc:  # pragma: no cover - broken install, not a supported mode
+    raise _require_shared("doc_classification") from exc
+
+# `knowledge/test-file-indicators.md`'s single encoding, shared with the
+# refactor test-freeze guards (#1964).
+try:
+    from test_file_classify import is_test_file  # type: ignore[import-not-found]
+except ImportError as exc:  # pragma: no cover - broken install, not a supported mode
+    raise _require_shared("test_file_classify") from exc
+
+
+LOW_YIELD_LENSES = ["performance-review", "correctness-review"]
+
+# Lenses to skip when EVERY changed file is provably prose (`.md`/`.mdx`),
+# including functional Claude-config markdown (#2104). `has_runtime_surface`
+# correctly treats agents/skills/knowledge/.claude markdown as runtime
+# surface — it drives agent behavior, so `performance-review` and
+# `correctness-review` still run against it above. But a handful of lenses
+# review a *code-level* property no markdown file, functional or not, can
+# exhibit: an injection/auth/data-exposure vulnerability, a domain-boundary
+# leak, a test-coverage gap, or a resource leak/N+1 query. Dispatching a
+# 9-agent panel (including these four) against a single-file skill-markdown
+# diff produced elaborate findings framed as security/domain/test/performance
+# issues that were really prose/spec-consistency nitpicks belonging to
+# doc-review/spec-compliance-review/correctness-review instead. Each of these
+# four agents' own `## Skip` clause already self-reports skip on a
+# documentation-only target (security-review: "static assets, images, or
+# documentation"; domain-review: "no business logic or domain entities
+# present"; test-review: "no test files in target"; performance-review:
+# "configuration, documentation, or type definitions") — dispatching them
+# anyway just pays for a self-reported skip, or worse, an ungrounded finding
+# stretched to fit the lens.
+#
+# Deliberately NARROWER than `select_lenses.py`'s own
+# `NON_EXECUTABLE_SKIP_ELIGIBLE` allowlist, which considered and REJECTED
+# adding security-review/domain-review/arch-review for its broader
+# "non-executable" category (docs **and** config/lockfiles/assets): that
+# module's own comment documents why — security-review's Skip clause does not
+# cover config/lockfiles (its Scope mandates scanning them for hardcoded
+# credentials) and domain-review's is a content judgment a config file's type
+# alone can't answer. This module's prose-only signal is strictly `.md`/
+# `.mdx` — it never widens to config, so neither rejection applies here.
+# `arch-review` and `correctness-review` are deliberately absent from this
+# list for the same reason `select_lenses.py` keeps `arch-review` unfiltered:
+# a pure-markdown ADR update, or a functional-config skill/agent file, is
+# exactly the content their own `## Detect` sections exist to review.
+PROSE_ONLY_SKIP_LENSES = [
+    "security-review", "domain-review", "test-review", "performance-review",
+]
+
+# Extensions provably incapable of holding anything but prose (lower-cased).
+_PROSE_EXTENSIONS = {".md", ".mdx"}
+
+# Lenses to skip when EVERY changed file is provably a test file (#1964).
+# Deliberately EMPTY until per-lens `diff_shape` outcome data justifies each
+# entry — see this module's docstring. Adding a name here without citing that
+# measurement is the mistake the docstring names; `security-review` and
+# `correctness-review` are explicitly not candidates on intuition.
+TEST_ONLY_SKIP_LENSES: list[str] = []
+
+# Documentation extensions (lower-cased). Mirrors SKILL.md's doc-only rule.
+_DOC_EXTENSIONS = DOC_EXTENSIONS
+
+# Documentation root-file stems (matched case-insensitively on the stem
+# prefix) — same word list `pre_commit_review.py`'s doc-only classifier uses
+# for its own (exact-match) root-doc check.
+_DOC_ROOT_PREFIXES = DOC_ROOT_WORDS
+
+# Config / data extensions with no executable logic surface (lower-cased).
+# Unique to this gate — `pre_commit_review.py` has no equivalent "config"
+# concept, so this stays local (nothing to extract against).
+_CONFIG_EXTENSIONS = {
+    ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf",
+    ".properties", ".lock", ".csv", ".tsv",
+}
+
+# Config dotfiles carry no suffix (``PurePosixPath(".gitignore").suffix == ""``),
+# so they are matched by full name instead (lower-cased).
+_CONFIG_NAMES = {
+    ".gitignore", ".gitattributes", ".editorconfig", ".env", ".dockerignore",
+    ".npmignore", ".prettierignore",
+}
+
+# Functional-config classification (markdown/paths that drive agent/skill/
+# command behavior and always count as runtime surface, same exclusion as
+# SKILL.md) now lives in `is_functional_config` above — shared with
+# `select_lenses.py` (#1923), including the "templates" addition this gate
+# has always applied on top of the shared core set (`pre_commit_review.py`'s
+# doc-only classifier deliberately does not include it; see that module's
+# docstring on staying a strict subset — unaffected by this extraction).
+
+
+def _is_documentation(path: PurePosixPath) -> bool:
+    if path.suffix.lower() in _DOC_EXTENSIONS:
+        return True
+    if "docs" in path.parts:
+        return True
+    stem = path.name.lower()
+    return any(stem.startswith(prefix) for prefix in _DOC_ROOT_PREFIXES)
+
+
+def _is_config(path: PurePosixPath) -> bool:
+    return (
+        path.suffix.lower() in _CONFIG_EXTENSIONS
+        or path.name.lower() in _CONFIG_NAMES
+    )
+
+
+def _has_runtime_surface_file(file: str) -> bool:
+    """True when a single file could hold executable logic (fail-safe default)."""
+    path = PurePosixPath(str(file).strip())
+    if not path.name:
+        return False  # empty entry contributes nothing
+    if is_functional_config(path):
+        return True
+    # Provably non-runtime only when documentation or config; anything else
+    # (source, unknown extension) is treated as runtime surface.
+    return not (_is_documentation(path) or _is_config(path))
+
+
+def has_runtime_surface(files: Iterable[str]) -> bool:
+    """True when *any* changed file could hold executable logic.
+
+    An empty changeset has no runtime surface (returns False).
+    """
+    return any(_has_runtime_surface_file(f) for f in files if str(f).strip())
+
+
+def _is_provably_test_file(file: str) -> bool:
+    """True when a single file is provably a test (fail-safe default: False).
+
+    `content=""` starves the shared classifier's content-probing branches (C#
+    attributes, Java annotations) rather than touching the filesystem, keeping
+    this module's no-I/O contract. That can only ever answer "not a test",
+    which biases the changeset toward "not test-only" — i.e. toward running
+    every lens. Java's class-name convention (`FooTest.java`) still resolves
+    by name and is unaffected.
+    """
+    name = str(file).strip()
+    if not name:
+        return False
+    return bool(is_test_file(name, content=""))
+
+
+def is_test_only(files: Iterable[str]) -> bool:
+    """True when *every* changed file is provably a test file.
+
+    An empty changeset is not test-only (there is nothing to prove), matching
+    `has_runtime_surface`'s treatment of the empty case.
+    """
+    file_list = [f for f in files if str(f).strip()]
+    if not file_list:
+        return False
+    return all(_is_provably_test_file(f) for f in file_list)
+
+
+def _is_prose_file(file: str) -> bool:
+    return PurePosixPath(str(file).strip()).suffix.lower() in _PROSE_EXTENSIONS
+
+
+def is_prose_only(files: Iterable[str]) -> bool:
+    """True when *every* changed file is `.md`/`.mdx` prose (#2104).
+
+    Unlike `has_runtime_surface`, this makes no exception for functional
+    Claude-config markdown: a `.md` file cannot exhibit an injection
+    vulnerability, a domain-boundary leak, a test-coverage gap, or an N+1
+    query regardless of whether it also drives agent behavior. An empty
+    changeset is not prose-only, matching the other predicates' empty-case
+    convention.
+    """
+    file_list = [f for f in files if str(f).strip()]
+    if not file_list:
+        return False
+    return all(_is_prose_file(f) for f in file_list)
+
+
+def lenses_to_skip(files: Iterable[str]) -> list[str]:
+    """Return the low-yield lenses to skip for this changeset.
+
+    Empty when the changeset has any runtime surface and is not prose-only.
+    A doc/config-only changeset (no runtime surface) skips `performance-review`
+    and `correctness-review`; a prose-only changeset (every file `.md`/`.mdx`,
+    including functional Claude-config markdown) additionally skips
+    `security-review`, `domain-review`, and `test-review` (#2104) — the two
+    sets are independent and union together, since a prose-only diff is
+    always also a no-runtime-surface diff unless it is functional config.
+    """
+    file_list = [f for f in files if str(f).strip()]
+    if not file_list:
+        return []  # nothing to review — the caller handles empty scope
+
+    # Ordered, deduplicated union — preserves each source list's own order and
+    # never lists a lens twice (e.g. `performance-review` is in both
+    # LOW_YIELD_LENSES and PROSE_ONLY_SKIP_LENSES for a plain-docs-only diff).
+    skip: list[str] = []
+    seen: set[str] = set()
+
+    def _extend(names: Iterable[str]) -> None:
+        for name in names:
+            if name not in seen:
+                seen.add(name)
+                skip.append(name)
+
+    if not has_runtime_surface(file_list):
+        _extend(LOW_YIELD_LENSES)
+    # Runtime surface present. A test-only changeset may still narrow the
+    # roster once TEST_ONLY_SKIP_LENSES is populated from measured data; it is
+    # empty today, so this contributes nothing (#1964).
+    elif is_test_only(file_list):
+        _extend(TEST_ONLY_SKIP_LENSES)
+    if is_prose_only(file_list):
+        _extend(PROSE_ONLY_SKIP_LENSES)
+    return skip
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--files", nargs="*", default=[],
+        help="changed file paths (space-separated)",
+    )
+    parser.add_argument(
+        "--files-from", default=None,
+        help="read newline-separated file paths from this file ('-' for stdin)",
+    )
+    args = parser.parse_args(argv)
+
+    files = list(args.files)
+    if args.files_from:
+        if args.files_from == "-":
+            text = sys.stdin.read()
+        else:
+            with open(args.files_from) as f:
+                text = f.read()
+        files.extend(line for line in text.splitlines() if line.strip())
+
+    skip = lenses_to_skip(files)
+    result = {
+        "hasRuntimeSurface": has_runtime_surface(files),
+        "isTestOnly": is_test_only(files),
+        "isProseOnly": is_prose_only(files),
+        "skipLenses": skip,
+    }
+    print(json.dumps(result, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/skills/code-review/scripts/change_size.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Classify a changeset's size to gate the /code-review agent panel (#1339).
+
+`/code-review` Step 3 dispatches the full ~17-agent `Scope: always` panel on
+every review regardless of diff size — a 2-line registry-table-row removal
+(issue #1331's fix: 2 files, ~1 added line) pays the same review cost as a
+25-file structural migration (issue #1334's fix: 537 added lines). The
+pre-PR hook (`hooks/pre_pr_review.py`, #1886) has no coupling to which or how
+many agents ran — it only checks that `/code-review` produced a matching
+`.pr-review-passed` hash — so the panel-size decision is entirely Step 3's to
+make, and today it makes no such distinction.
+
+This module is the deterministic gate, sibling to `change_shape.py` (#1254,
+which gates by file *type*). This gate gates by file *size*: given the target
+files' `git diff --numstat` lines, it decides whether the changeset qualifies
+for a narrowed agent panel.
+
+**Added lines only, not deleted.** Added lines are unverified, newly
+introduced content a reviewer must actually check; deleted lines are
+comparatively low-risk (a dangling reference from a large deletion breaks the
+build/tests, not silently). This is what lets issue #1331's fix (97 deleted
+lines, ~1 added) qualify while issue #1334's fix (537 added lines) does not —
+weighting total added+deleted would keep #1331's fix on the slow path,
+defeating this gate's own motivating example.
+
+**Gate-machinery carve-out.** Any file under `hooks/` or `skills/code-review/`
+— the enforcement mechanism and this gate's own review orchestration —
+always disqualifies, at any size. A change to the gate's own logic is exactly
+the case where a cheap, self-certifying review would be a problem, so it is
+excluded from ever qualifying for the shortcut it defines.
+
+**Fail-safe by construction**, mirroring `change_shape.py`'s own philosophy:
+a `git diff --numstat` failure, a binary-file marker (`-\t-\tpath`), or any
+line this module cannot parse disqualifies the gate for that run (full
+panel) — never counts as "small enough" by omission.
+
+**Applicability is Step 3's job, not this module's.** This gate only makes
+sense when there is an actual diff to measure (auto-scoped uncommitted
+changes, or `--since <ref>`) — `--path`, `--all`, and the full-repository
+fallback review complete files, not a diff, so `SKILL.md` never invokes this
+module for those scopes. That decision is documented in `SKILL.md` Step 3's
+"Change-size gate" subsection, not enforced here.
+
+Pure policy — no filesystem, no globals. Stdlib-only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Iterable
+from typing import NamedTuple
+
+# Thresholds calibrated against two real commits cited in spec #1345:
+# issue #1331's fix (2 files, ~1 added line — should qualify) and issue
+# #1334's fix (25 files, 537 added lines — should not). Hardcoded, not a new
+# review-config.json surface — smallest change that solves the stated
+# problem; revisit if real usage shows these miscalibrated.
+MAX_FILES = 3
+MAX_ADDED_LINES = 20
+
+# The agents that stay meaningful at any diff size and survive the fast path:
+# a single line can introduce a vulnerability (security-review), a logic
+# defect (correctness-review), a spec mismatch (spec-compliance-review), or
+# doc drift (doc-review). Every other `Scope: always` agent is primarily a
+# code-quality-at-scale concern a diff this small essentially cannot exhibit
+# meaningfully.
+#
+# KEEP THIS IN SYNC with the identically-named list restated in English in
+# `code-review/SKILL.md`'s "Change-size gate" subsection (Step 3) — same
+# single-source-of-truth risk `change_shape.py`'s `LOW_YIELD_LENSES` already
+# carries against its own `SKILL.md` restatement.
+FAST_PATH_AGENTS = [
+    "security-review",
+    "correctness-review",
+    "spec-compliance-review",
+    "doc-review",
+]
+
+# Path segments marking the review/gate machinery itself. A change here is
+# exactly the case where a cheap, self-certifying review is a safety problem,
+# so it always disqualifies, regardless of size. Narrower than
+# `change_shape.py`'s "functional Claude-config" carve-out (agents/,
+# knowledge/, .claude/, templates/) — those stay eligible for the fast path
+# when small enough, since issue #1331's own motivating example touches
+# `knowledge/agent-registry.md` and an `agents/` file and is exactly the case
+# this gate must unblock.
+_GATE_MACHINERY_PREFIXES = ("hooks/", "skills/code-review/")
+
+
+class NumstatResult(NamedTuple):
+    file_count: int
+    added_lines: int
+    ok: bool
+    files: tuple[str, ...]
+
+
+def parse_numstat(lines: Iterable[str]) -> NumstatResult:
+    """Parse `git diff --numstat` lines into a size signal.
+
+    Each line is `<added>\\t<deleted>\\t<path>`. A binary file reports `-` for
+    both counts; any line that isn't exactly that shape, or whose added/
+    deleted fields aren't parseable as non-negative integers (or `-`), marks
+    the whole result not-ok (fail-safe — a partial read is not "small").
+    """
+    files: list[str] = []
+    added_total = 0
+    ok = True
+    for raw in lines:
+        line = raw.rstrip("\n")
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        if len(parts) != 3:
+            ok = False
+            continue
+        added_field, deleted_field, path = parts
+        if not path.strip():
+            ok = False
+            continue
+        if added_field == "-" and deleted_field == "-":
+            # Binary file — numstat can't report line counts. Fail-safe: we
+            # cannot prove this file is small, so disqualify the whole run.
+            ok = False
+            files.append(path)
+            continue
+        if not added_field.isdigit() or not deleted_field.isdigit():
+            ok = False
+            continue
+        added_total += int(added_field)
+        files.append(path)
+    return NumstatResult(
+        file_count=len(files), added_lines=added_total, ok=ok, files=tuple(files)
+    )
+
+
+def is_gate_machinery(path: str) -> bool:
+    """True when `path` is under the review/gate enforcement machinery."""
+    normalized = str(path).strip().replace("\\", "/")
+    return any(normalized.startswith(prefix) for prefix in _GATE_MACHINERY_PREFIXES)
+
+
+def qualifies_for_fast_path(result: NumstatResult) -> bool:
+    """True when this changeset qualifies for the narrowed fast-path panel.
+
+    Requires: numstat parsed cleanly, file count and added-line count both
+    within threshold, and no file is gate machinery. Any single failing
+    condition disqualifies (fail-safe by construction).
+    """
+    if not result.ok:
+        return False
+    if result.file_count == 0:
+        return False
+    if result.file_count > MAX_FILES:
+        return False
+    if result.added_lines > MAX_ADDED_LINES:
+        return False
+    return not any(is_gate_machinery(f) for f in result.files)
+
+
+def evaluate(lines: Iterable[str]) -> dict:
+    """Evaluate numstat lines and return the full decision as a dict."""
+    result = parse_numstat(lines)
+    qualifies = qualifies_for_fast_path(result)
+    return {
+        "filesChanged": result.file_count,
+        "addedLines": result.added_lines,
+        "qualifiesForFastPath": qualifies,
+        "keepAgents": list(FAST_PATH_AGENTS) if qualifies else [],
+    }
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--numstat", nargs="*", default=[],
+        help="git diff --numstat lines, one per arg (space-separated)",
+    )
+    parser.add_argument(
+        "--numstat-from", default=None,
+        help="read newline-separated numstat lines from this file ('-' for stdin)",
+    )
+    args = parser.parse_args(argv)
+
+    lines = list(args.numstat)
+    if args.numstat_from:
+        if args.numstat_from == "-":
+            text = sys.stdin.read()
+        else:
+            with open(args.numstat_from) as handle:
+                text = handle.read()
+        lines.extend(line for line in text.splitlines() if line.strip())
+
+    print(json.dumps(evaluate(lines), sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
+
+
+__all__ = (
+    "FAST_PATH_AGENTS",
+    "MAX_ADDED_LINES",
+    "MAX_FILES",
+    "NumstatResult",
+    "evaluate",
+    "is_gate_machinery",
+    "parse_numstat",
+    "qualifies_for_fast_path",
+)