Your #1 Arena Model Fails in Real Repositories: The Leaderboard Mirage

#!/usr/bin/env python3
"""
blast_radius_gate.py - Deterministic AST Public-API Gate for Agentic Swarms
Enforces Chesterton's Fence: permits internal function implementation edits,
but strictly blocks altering or deleting exported public type contracts.

Python only: a file that does not parse fails the gate, and so does any git error.
Usage: blast_radius_gate.py [--staged] FILE...   (--staged checks the index, for pre-commit)
"""

import sys
import ast
import subprocess
from pathlib import Path

def git(*args: str) -> str:
    """Runs git and fails closed: a git error raises instead of reading as a pass."""
    res = subprocess.run(["git", "--literal-pathspecs", *args],
                         capture_output=True, encoding="utf-8", timeout=30)
    if res.returncode != 0:
        raise RuntimeError(f"git {args[0]} failed: {res.stderr.strip()}")
    return res.stdout

def _is_public(name: str) -> bool:
    """Public means no leading underscore, plus dunders such as __init__."""
    return not name.startswith("_") or (name.startswith("__") and name.endswith("__"))

def _signature(node, qualname: str) -> str:
    """Renders decorators, async, defaults, annotations and the return type."""
    decorators = "".join(f"@{ast.unparse(d)} " for d in node.decorator_list)
    kind = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
    returns = f" -> {ast.unparse(node.returns)}" if node.returns else ""
    return f"{decorators}{kind} {qualname}({ast.unparse(node.args)}){returns}"

def extract_public_ast_signatures(source_code: str) -> dict[str, str]:
    """Parses AST and extracts public function, class, method and attribute signatures.

    Descends into class bodies. A gate that stops at module level records that a
    class exists but never what it promises, so renaming or re-arging a public
    method reads as clean. Attributes cover module constants and dataclass fields.
    """
    signatures = {}

    def walk(body, prefix: str) -> None:
        for node in body:
            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and _is_public(node.name):
                signatures[prefix + node.name] = _signature(node, prefix + node.name)
            elif isinstance(node, ast.ClassDef) and _is_public(node.name):
                decorators = "".join(f"@{ast.unparse(d)} " for d in node.decorator_list)
                bases = [ast.unparse(b) for b in node.bases] + [ast.unparse(k) for k in node.keywords]
                signatures[prefix + node.name] = f"{decorators}class {prefix}{node.name}({', '.join(bases)})"
                walk(node.body, f"{prefix}{node.name}.")
            elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) \
                    and _is_public(node.target.id):
                name = prefix + node.target.id
                default = " = ..." if node.value else ""
                signatures[name] = f"{name}: {ast.unparse(node.annotation)}{default}"
            elif isinstance(node, ast.Assign):
                if not prefix and any(isinstance(t, ast.Name) and t.id == "__all__" for t in node.targets):
                    try:
                        for exported in ast.literal_eval(node.value):
                            signatures[f"__all__[{exported}]"] = f"exported name {exported}"
                    except (ValueError, TypeError):
                        pass
                for t in node.targets:
                    if isinstance(t, ast.Name) and _is_public(t.id):
                        signatures[prefix + t.id] = f"{prefix}{t.id} = ..."

    walk(ast.parse(source_code.removeprefix("\ufeff")).body, "")  # a UTF-8 BOM is valid source
    return signatures

def verify_ast_blast_radius(file_path: str, staged: bool = False) -> tuple[bool, list[str]]:
    """Asserts zero mutations to existing public API signatures."""
    # Parse the candidate first, so a new file that does not parse (a .ts file included) fails too.
    if staged:
        index_name = git("ls-files", "--full-name", "--", file_path).strip()
        current_code = git("show", f":{index_name}") if index_name else ""
    else:
        path = Path(file_path)
        current_code = path.read_text(encoding="utf-8") if path.exists() else ""
    try:
        current_sigs = extract_public_ast_signatures(current_code)
    except SyntaxError as e:
        return False, [f"UNPARSABLE: line {e.lineno}: {e.msg}. The gate reads Python only."]

    # HEAD:<path> is read from the repo root, so ask git for the root-relative name first.
    has_head = subprocess.run(["git", "rev-parse", "--verify", "--quiet", "HEAD"],
                              capture_output=True).returncode == 0
    name = git("ls-tree", "--full-name", "--name-only", "HEAD", "--", file_path).strip() if has_head else ""
    if not name:
        return True, []  # Brand new file that parses: nothing at HEAD to break
    try:
        head_sigs = extract_public_ast_signatures(git("show", f"HEAD:{name}"))
    except SyntaxError as e:
        return False, [f"UNPARSABLE at HEAD: line {e.lineno}: {e.msg}. The gate reads Python only."]

    violations = []
    for symbol, base_sig in head_sigs.items():
        if symbol not in current_sigs:
            violations.append(f"DELETED: Public contract '{symbol}' was removed by the agent.")
        elif current_sigs[symbol] != base_sig:
            violations.append(f"MUTATED: '{symbol}' changed from `{base_sig}` to `{current_sigs[symbol]}`")

    return len(violations) == 0, violations

if __name__ == "__main__":
    staged = sys.argv[1:2] == ["--staged"]
    targets = sys.argv[2:] if staged else sys.argv[1:]
    has_error = False
    for target in targets:
        passed, violations = verify_ast_blast_radius(target, staged)
        if not passed:
            has_error = True
            for v in violations:
                print(f"[AST GATE BLOCKED] {target}: {v}", file=sys.stderr)

    if has_error:
        print("\nAction: diff rejected. Feeding AST violation to Tier 2 repair loop.", file=sys.stderr)
        sys.exit(1)
    sys.exit(0)