arbiter-dev 0.2.0__py3-none-any.whl

arbiter/__init__.py

@@ -0,0 +1,3 @@
+"""Arbiter — Agent-aware code quality system."""
+
+__version__ = "0.1.0"

arbiter/__main__.py

@@ -0,0 +1,570 @@
+"""Arbiter CLI entry point.
+
+Usage:
+    python -m arbiter analyze /path/to/repo     Full analysis with persistence
+    python -m arbiter score /path/to/repo        Quick score (no persistence)
+    python -m arbiter agents                     Agent leaderboard
+    python -m arbiter trend [--days 30]          Quality trend over time
+    python -m arbiter worst [--limit 20]         Worst files by quality
+    python -m arbiter commits [--agent NAME]     Recent commits with scores
+    python -m arbiter serve [--port 8080]        Start API + dashboard
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from arbiter.agent_registry import AgentRegistry
+from arbiter.analyzers.base import Analyzer, Finding
+from arbiter.analyzers.ruff_analyzer import RuffAnalyzer
+from arbiter.analyzers.complexity_analyzer import ComplexityAnalyzer
+from arbiter.analyzers.security_analyzer import SecurityAnalyzer
+from arbiter.analyzers.dead_code_analyzer import DeadCodeAnalyzer
+from arbiter.analyzers.duplication_analyzer import DuplicationAnalyzer
+from arbiter.diff_analyzer import score_commit, score_diff
+from arbiter.git_historian import count_loc, walk_commits
+from arbiter.scoring import score_findings
+from arbiter.store import Store
+
+
+def _get_analyzers() -> list[Analyzer]:
+    """Get all available analyzers."""
+    all_analyzers = [
+        RuffAnalyzer(),
+        ComplexityAnalyzer(),
+        SecurityAnalyzer(),
+        DeadCodeAnalyzer(),
+        DuplicationAnalyzer(),
+    ]
+    available = []
+    for a in all_analyzers:
+        if a.is_available():
+            available.append(a)
+        else:
+            print(f"  [skip] {a.name} not installed", file=sys.stderr)
+    return available
+
+
+def _run_analysis(repo_path: Path, analyzers: list[Analyzer], exclude_paths: list[str] | None = None) -> list[Finding]:
+    """Run all analyzers against a repo."""
+    all_findings: list[Finding] = []
+    for analyzer in analyzers:
+        try:
+            findings = analyzer.analyze_repo(repo_path, exclude_paths=exclude_paths)
+            all_findings.extend(findings)
+            print(f"  [{analyzer.name}] {len(findings)} findings", file=sys.stderr)
+        except Exception as e:
+            print(f"  [{analyzer.name}] ERROR: {e}", file=sys.stderr)
+    return all_findings
+
+
+def _find_git_root(path: Path) -> Path | None:
+    """Walk up from path to find the nearest .git directory."""
+    current = path
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return None
+
+
+def cmd_analyze(args: argparse.Namespace) -> None:
+    """Full analysis: run analyzers, score, persist to store."""
+    repo_path = Path(args.repo).resolve()
+    git_root = _find_git_root(repo_path)
+    if not git_root:
+        print(f"Warning: {repo_path} is not inside a git repository. Skipping commit analysis.", file=sys.stderr)
+
+    db_path = Path(args.db) if args.db else Path("arbiter_data.db")
+    store = Store(db_path)
+    registry = AgentRegistry()
+
+    exclude_paths = [p.strip() for p in args.exclude.split(",") if p.strip()] if args.exclude else None
+    if exclude_paths:
+        print(f"Analyzing {repo_path} (excluding: {', '.join(exclude_paths)})...", file=sys.stderr)
+    else:
+        print(f"Analyzing {repo_path}...", file=sys.stderr)
+
+    # Run analyzers
+    analyzers = _get_analyzers()
+    findings = _run_analysis(repo_path, analyzers, exclude_paths=exclude_paths)
+    loc = count_loc(repo_path)
+
+    repo_name = repo_path.name
+
+    # Score
+    score = score_findings(findings, loc)
+    store.record_snapshot(score, loc, repo_name=repo_name)
+
+    # Update file-level quality
+    file_findings: dict[str, list[Finding]] = {}
+    for f in findings:
+        file_findings.setdefault(f.file_path, []).append(f)
+    for fp, ff in file_findings.items():
+        worst = max((f.severity for f in ff), key=lambda s: {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1}.get(s, 0))
+        store.update_file_quality(fp, len(ff), worst, "analysis", repo_name=repo_name)
+
+    # Walk recent commits and score per-agent (requires git root)
+    commits = []
+    if git_root:
+        commits = walk_commits(git_root, max_count=args.commits, registry=registry)
+        for commit in commits:
+            # Per-commit scoring: score only the files this commit touched
+            commit_score = score_commit(git_root, commit, analyzers, exclude_paths=exclude_paths)
+            store.record_commit(
+                commit.hash, commit.timestamp, commit.agent,
+                commit.files_changed, commit.loc_added, commit.loc_removed, commit_score,
+                repo_name=repo_name,
+            )
+
+    # Print summary
+    print(f"\n{'='*60}")
+    print(f"  Arbiter Score: {score.overall} ({score.grade})")
+    print(f"{'='*60}")
+    print(f"  Lint:       {score.lint_score:5.1f}")
+    print(f"  Security:   {score.security_score:5.1f}")
+    print(f"  Complexity: {score.complexity_score:5.1f}")
+    print(f"  Findings:   {score.total_findings} ({', '.join(f'{k}:{v}' for k, v in sorted(score.findings_by_severity.items()))})")
+    print(f"  LOC:        {loc:,}")
+    print(f"  Commits:    {len(commits)} analyzed")
+    print(f"  Tools:      {', '.join(score.findings_by_tool.keys()) or 'none'}")
+
+    # Agent leaderboard
+    board = store.get_agent_leaderboard()
+    if board:
+        print("\n  Agent Leaderboard:")
+        for agent in board:
+            print(f"    {agent.agent_name:12s}  avg={agent.avg_score:5.1f}  commits={agent.commit_count}  loc={agent.total_loc:,}")
+
+    print(f"\n  Data stored in {db_path}")
+
+
+def cmd_score(args: argparse.Namespace) -> None:
+    """Quick score without persistence."""
+    repo_path = Path(args.repo).resolve()
+    exclude_paths = [p.strip() for p in args.exclude.split(",") if p.strip()] if args.exclude else None
+    analyzers = _get_analyzers()
+    findings = _run_analysis(repo_path, analyzers, exclude_paths=exclude_paths)
+    loc = count_loc(repo_path)
+    score = score_findings(findings, loc)
+
+    if args.json:
+        print(json.dumps({
+            "overall": score.overall,
+            "grade": score.grade,
+            "lint": score.lint_score,
+            "security": score.security_score,
+            "complexity": score.complexity_score,
+            "findings": score.total_findings,
+            "loc": loc,
+            "by_severity": score.findings_by_severity,
+            "by_tool": score.findings_by_tool,
+        }, indent=2))
+    else:
+        print(f"Score: {score.overall} ({score.grade}) | Lint: {score.lint_score} | Security: {score.security_score} | Complexity: {score.complexity_score} | Findings: {score.total_findings} | LOC: {loc:,}")
+
+
+def cmd_agents(args: argparse.Namespace) -> None:
+    """Print agent leaderboard."""
+    db_path = Path(args.db) if args.db else Path("arbiter_data.db")
+    store = Store(db_path)
+    board = store.get_agent_leaderboard()
+    if not board:
+        print("No data. Run 'arbiter analyze' first.")
+        return
+    print(f"{'Agent':15s} {'Avg Score':>10s} {'Commits':>8s} {'LOC':>10s}")
+    print("-" * 47)
+    for agent in board:
+        print(f"{agent.agent_name:15s} {agent.avg_score:10.1f} {agent.commit_count:8d} {agent.total_loc:10,}")
+
+
+def cmd_trend(args: argparse.Namespace) -> None:
+    """Print quality trend."""
+    db_path = Path(args.db) if args.db else Path("arbiter_data.db")
+    store = Store(db_path)
+    trend = store.get_trend(days=args.days)
+    if not trend:
+        print("No trend data. Run 'arbiter analyze' first.")
+        return
+    for point in trend:
+        print(f"{point['timestamp']}  score={point['overall_score']:5.1f}  "
+              f"lint={point['lint_score']:5.1f}  sec={point['security_score']:5.1f}  "
+              f"cx={point['complexity_score']:5.1f}  findings={point['total_findings']}")
+
+
+def cmd_worst(args: argparse.Namespace) -> None:
+    """Print worst files by quality."""
+    db_path = Path(args.db) if args.db else Path("arbiter_data.db")
+    store = Store(db_path)
+    worst = store.get_worst_files(limit=args.limit)
+    if not worst:
+        print("No file data. Run 'arbiter analyze' first.")
+        return
+    print(f"{'File':60s} {'Findings':>8s} {'Severity':>10s} {'Agent':>10s}")
+    print("-" * 92)
+    for f in worst:
+        print(f"{f.file_path:60s} {f.finding_count:8d} {f.worst_severity:>10s} {f.last_agent:>10s}")
+
+
+def cmd_audit_fleet(args: argparse.Namespace) -> None:
+    """Audit all repos in a directory."""
+    fleet_dir = Path(args.directory).resolve()
+    if not fleet_dir.is_dir():
+        print(f"Error: {fleet_dir} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    db_path = Path(args.db) if args.db else Path("arbiter_fleet.db")
+    store = Store(db_path)
+    registry = AgentRegistry()
+    analyzers = _get_analyzers()
+
+    repos = sorted([d for d in fleet_dir.iterdir() if d.is_dir() and (d / ".git").exists()])
+    print(f"Found {len(repos)} git repos in {fleet_dir}", file=sys.stderr)
+
+    for i, repo_path in enumerate(repos, 1):
+        repo_name = repo_path.name
+        print(f"\n[{i}/{len(repos)}] {repo_name}", file=sys.stderr)
+
+        findings = _run_analysis(repo_path, analyzers)
+        loc = count_loc(repo_path)
+        score = score_findings(findings, loc)
+        store.record_snapshot(score, loc, repo_name=repo_name)
+
+        # File-level quality
+        file_findings: dict[str, list[Finding]] = {}
+        for f in findings:
+            file_findings.setdefault(f.file_path, []).append(f)
+        for fp, ff in file_findings.items():
+            worst = max((f.severity for f in ff), key=lambda s: {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1}.get(s, 0))
+            store.update_file_quality(fp, len(ff), worst, "analysis", repo_name=repo_name)
+
+        # Commits
+        commits = walk_commits(repo_path, max_count=args.commits, registry=registry)
+        for commit in commits:
+            store.record_commit(
+                commit.hash, commit.timestamp, commit.agent,
+                commit.files_changed, commit.loc_added, commit.loc_removed, score,
+                repo_name=repo_name,
+            )
+
+        grade = score.grade
+        print(f"  Score: {score.overall} ({grade}) | {score.total_findings} findings | {loc:,} LOC", file=sys.stderr)
+
+    # Print fleet summary
+    print(f"\n{'='*70}", file=sys.stderr)
+    report = store.get_fleet_report()
+    _print_fleet_report(report)
+    print(f"\nData stored in {db_path}")
+
+
+def cmd_fleet_report(args: argparse.Namespace) -> None:
+    """Print fleet quality report from existing data."""
+    db_path = Path(args.db) if args.db else Path("arbiter_fleet.db")
+    store = Store(db_path)
+    report = store.get_fleet_report()
+    if not report:
+        print("No fleet data. Run 'arbiter audit-fleet <dir>' first.")
+        return
+    _print_fleet_report(report)
+
+
+def _print_fleet_report(report: list[dict]) -> None:
+    """Format and print the fleet report."""
+    def _grade(score: float) -> str:
+        if score >= 90: return "A"
+        if score >= 80: return "B"
+        if score >= 70: return "C"
+        if score >= 60: return "D"
+        return "F"
+
+    print(f"\n{'Repo':30s} {'Score':>6s} {'Grade':>6s} {'Findings':>9s} {'LOC':>8s}")
+    print("-" * 63)
+    grades = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0}
+    for r in report:
+        score = r.get("overall_score", 0) or 0
+        g = _grade(score)
+        grades[g] += 1
+        loc = r.get("total_loc", 0) or 0
+        findings = r.get("total_findings", 0) or 0
+        name = (r.get("repo_name") or "?")[:30]
+        print(f"{name:30s} {score:6.1f} {g:>6s} {findings:9d} {loc:8,}")
+
+    print(f"\nFleet: {len(report)} repos | ", end="")
+    print(" | ".join(f"{g}:{c}" for g, c in sorted(grades.items()) if c > 0))
+
+
+def cmd_triage(args: argparse.Namespace) -> None:
+    """Auto-classify repos and output actionable recommendations."""
+    db_path = Path(args.db) if args.db else Path("arbiter_fleet.db")
+    store = Store(db_path)
+    report = store.get_fleet_report()
+    if not report:
+        print("No fleet data. Run 'arbiter audit-fleet <dir>' first.")
+        return
+
+    green, yellow, red, archive = [], [], [], []
+
+    for r in report:
+        score = r.get("overall_score", 0) or 0
+        loc = r.get("total_loc", 0) or 0
+        findings = r.get("total_findings", 0) or 0
+        name = r.get("repo_name", "?")
+
+        entry = {"name": name, "score": score, "loc": loc, "findings": findings}
+
+        if loc == 0 and findings == 0:
+            archive.append(entry)
+        elif score >= 80:
+            green.append(entry)
+        elif score >= 60:
+            if findings > 100:
+                red.append(entry)
+            else:
+                yellow.append(entry)
+        else:
+            red.append(entry)
+
+    print("=" * 70)
+    print("  ARBITER FLEET TRIAGE")
+    print("=" * 70)
+
+    print(f"\n  GREEN ({len(green)} repos) — no action needed")
+    for r in sorted(green, key=lambda x: -x["score"]):
+        print(f"    {r['name']:30s}  {r['score']:5.1f}  {r['loc']:>8,} LOC")
+
+    print(f"\n  YELLOW ({len(yellow)} repos) — minor cleanup")
+    for r in sorted(yellow, key=lambda x: x["score"]):
+        print(f"    {r['name']:30s}  {r['score']:5.1f}  {r['findings']:>5d} findings  {r['loc']:>8,} LOC")
+        print(f"      ACTION: ruff check --fix {r['name']}/")
+
+    print(f"\n  RED ({len(red)} repos) — needs remediation or archival decision")
+    for r in sorted(red, key=lambda x: x["score"]):
+        print(f"    {r['name']:30s}  {r['score']:5.1f}  {r['findings']:>5d} findings  {r['loc']:>8,} LOC")
+        if r["findings"] > 500:
+            print(f"      ACTION: ruff check --fix + manual review (high finding count)")
+        else:
+            print(f"      ACTION: ruff check --fix, then re-score")
+
+    print(f"\n  ARCHIVE CANDIDATES ({len(archive)} repos) — 0 LOC, no Python code")
+    for r in sorted(archive, key=lambda x: x["name"]):
+        print(f"    {r['name']}")
+    print(f"      ACTION: review for archival → gh repo archive hummbl-dev/<name>")
+
+    print(f"\n{'='*70}")
+    print(f"  Summary: {len(green)} green | {len(yellow)} yellow | {len(red)} red | {len(archive)} archive candidates")
+    print(f"{'='*70}")
+
+
+def cmd_fix(args: argparse.Namespace) -> None:
+    """Run ruff --fix on a repo and show before/after score."""
+    repo_path = Path(args.repo).resolve()
+    if not (repo_path / ".git").exists():
+        print(f"Error: {repo_path} is not a git repository", file=sys.stderr)
+        sys.exit(1)
+
+    analyzers = _get_analyzers()
+    ruff_only = [a for a in analyzers if a.name == "ruff"]
+    if not ruff_only:
+        print("Error: ruff not available", file=sys.stderr)
+        sys.exit(1)
+
+    # Before score
+    findings_before = _run_analysis(repo_path, ruff_only)
+    loc = count_loc(repo_path)
+    score_before = score_findings(findings_before, loc)
+
+    print(f"\nBEFORE: {score_before.overall} ({score_before.grade}) | {score_before.total_findings} findings")
+
+    if args.dry_run:
+        # Show what would be fixed
+        import subprocess
+        result = subprocess.run(
+            ["ruff", "check", "--fix", "--diff", str(repo_path)],
+            capture_output=True, text=True, timeout=120,
+        )
+        if result.stdout:
+            lines = result.stdout.strip().split("\n")
+            print(f"\nWould fix {len([l for l in lines if l.startswith('---')])} files")
+            print("(use without --dry-run to apply)")
+        else:
+            print("\nNothing to fix automatically.")
+        return
+
+    # Apply fixes
+    import subprocess
+    result = subprocess.run(
+        ["ruff", "check", "--fix", "--unsafe-fixes", str(repo_path)],
+        capture_output=True, text=True, timeout=120,
+    )
+    print(f"\nruff --fix output: {result.stdout.strip()}" if result.stdout.strip() else "")
+
+    # After score
+    findings_after = _run_analysis(repo_path, ruff_only)
+    score_after = score_findings(findings_after, loc)
+
+    delta = score_after.overall - score_before.overall
+    print(f"AFTER:  {score_after.overall} ({score_after.grade}) | {score_after.total_findings} findings")
+    print(f"DELTA:  {'+' if delta >= 0 else ''}{delta:.1f} points | "
+          f"{score_before.total_findings - score_after.total_findings} findings fixed")
+
+    if score_after.total_findings > 0:
+        print(f"\nRemaining findings ({score_after.total_findings}):")
+        for f in findings_after[:10]:
+            print(f"  {f.file_path}:{f.line} [{f.rule_id}] {f.message[:60]}")
+        if len(findings_after) > 10:
+            print(f"  ... and {len(findings_after) - 10} more")
+
+    if not args.no_commit and delta > 0:
+        print(f"\nTo commit: cd {repo_path} && git add -A && git commit -m 'fix: auto-remediate ruff findings (Arbiter)'")
+
+
+def cmd_diff(args: argparse.Namespace) -> None:
+    """Score only files changed since base branch."""
+    repo_path = Path(args.repo).resolve()
+    exclude_paths = [p.strip() for p in args.exclude.split(",") if p.strip()] if args.exclude else None
+    analyzers = _get_analyzers()
+
+    base = args.base
+    print(f"Analyzing diff against {base}...", file=sys.stderr)
+
+    diff_score, findings, changed_files = score_diff(
+        repo_path, analyzers, base_branch=base, exclude_paths=exclude_paths,
+    )
+
+    python_changed = [f for f in changed_files if f.endswith(".py")]
+
+    if args.json:
+        print(json.dumps({
+            "overall": diff_score.overall,
+            "grade": diff_score.grade,
+            "lint": diff_score.lint_score,
+            "security": diff_score.security_score,
+            "complexity": diff_score.complexity_score,
+            "findings": diff_score.total_findings,
+            "files_changed": len(changed_files),
+            "python_files_changed": len(python_changed),
+            "by_severity": diff_score.findings_by_severity,
+            "by_tool": diff_score.findings_by_tool,
+            "changed_files": changed_files,
+        }, indent=2))
+    else:
+        print(f"\nDiff vs {base}: {len(changed_files)} files changed ({len(python_changed)} Python)")
+        print(f"Score: {diff_score.overall} ({diff_score.grade}) | "
+              f"Lint: {diff_score.lint_score} | Security: {diff_score.security_score} | "
+              f"Complexity: {diff_score.complexity_score} | "
+              f"Findings: {diff_score.total_findings}")
+
+        if findings:
+            print(f"\nTop findings ({min(len(findings), 10)} of {len(findings)}):")
+            for f in findings[:10]:
+                print(f"  {f.file_path}:{f.line} [{f.severity}] {f.rule_id}: {f.message[:60]}")
+            if len(findings) > 10:
+                print(f"  ... and {len(findings) - 10} more")
+
+
+def cmd_commits(args: argparse.Namespace) -> None:
+    """Print recent commits with scores."""
+    db_path = Path(args.db) if args.db else Path("arbiter_data.db")
+    store = Store(db_path)
+    commits = store.get_recent_commits(agent=args.agent, limit=args.limit)
+    if not commits:
+        print("No commit data. Run 'arbiter analyze' first.")
+        return
+    for c in commits:
+        print(f"{c['commit_hash'][:8]}  {c['agent']:12s}  score={c['overall_score']:5.1f}  "
+              f"+{c['loc_added']}/-{c['loc_removed']}  {c['timestamp'][:16]}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Arbiter — Agent-aware code quality system")
+    parser.add_argument("--db", help="Path to SQLite database (default: arbiter_data.db)")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # analyze
+    p_analyze = subparsers.add_parser("analyze", help="Full analysis with persistence")
+    p_analyze.add_argument("repo", help="Path to git repository")
+    p_analyze.add_argument("--commits", type=int, default=100, help="Max commits to analyze")
+    p_analyze.add_argument("--exclude", type=str, default="", help="Comma-separated paths to exclude (e.g. dashboard,agents/factorio_system)")
+
+    # score
+    p_score = subparsers.add_parser("score", help="Quick score (no persistence)")
+    p_score.add_argument("repo", help="Path to directory or git repository")
+    p_score.add_argument("--json", action="store_true", help="JSON output")
+    p_score.add_argument("--exclude", type=str, default="", help="Comma-separated paths to exclude")
+
+    # diff
+    p_diff = subparsers.add_parser("diff", help="Score only files changed since base branch")
+    p_diff.add_argument("repo", help="Path to git repository")
+    p_diff.add_argument("--base", default="main", help="Base branch (default: main)")
+    p_diff.add_argument("--json", action="store_true", help="JSON output")
+    p_diff.add_argument("--exclude", type=str, default="", help="Comma-separated paths to exclude")
+
+    # agents
+    subparsers.add_parser("agents", help="Agent leaderboard")
+
+    # trend
+    p_trend = subparsers.add_parser("trend", help="Quality trend")
+    p_trend.add_argument("--days", type=int, default=30, help="Days of history")
+
+    # worst
+    p_worst = subparsers.add_parser("worst", help="Worst files")
+    p_worst.add_argument("--limit", type=int, default=20, help="Number of files")
+
+    # commits
+    p_commits = subparsers.add_parser("commits", help="Recent commits with scores")
+    p_commits.add_argument("--agent", help="Filter by agent")
+    p_commits.add_argument("--limit", type=int, default=50, help="Number of commits")
+
+    # audit-fleet
+    p_fleet = subparsers.add_parser("audit-fleet", help="Audit all repos in a directory")
+    p_fleet.add_argument("directory", help="Directory containing git repos")
+    p_fleet.add_argument("--commits", type=int, default=20, help="Max commits per repo")
+
+    # triage
+    subparsers.add_parser("triage", help="Auto-classify repos with actionable recommendations")
+
+    # fix
+    p_fix = subparsers.add_parser("fix", help="Auto-fix ruff findings and show before/after")
+    p_fix.add_argument("repo", help="Path to git repository")
+    p_fix.add_argument("--dry-run", action="store_true", help="Show what would be fixed without applying")
+    p_fix.add_argument("--no-commit", action="store_true", help="Don't suggest commit command")
+
+    # fleet-report
+    subparsers.add_parser("fleet-report", help="Print fleet quality report")
+
+    # serve
+    p_serve = subparsers.add_parser("serve", help="Start API + dashboard")
+    p_serve.add_argument("--port", type=int, default=8080, help="Port")
+    p_serve.add_argument("--host", default="0.0.0.0", help="Host")
+
+    args = parser.parse_args()
+
+    commands = {
+        "analyze": cmd_analyze,
+        "score": cmd_score,
+        "diff": cmd_diff,
+        "agents": cmd_agents,
+        "trend": cmd_trend,
+        "worst": cmd_worst,
+        "commits": cmd_commits,
+        "audit-fleet": cmd_audit_fleet,
+        "fleet-report": cmd_fleet_report,
+        "triage": cmd_triage,
+        "fix": cmd_fix,
+    }
+
+    handler = commands.get(args.command)
+    if handler:
+        handler(args)
+    elif args.command == "serve":
+        from arbiter.api import run_server
+        run_server(host=args.host, port=args.port, db_path=args.db)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

arbiter/agent_registry.py

@@ -0,0 +1,120 @@
+"""Agent Registry — Maps commit authors to AI agent identities.
+
+Provides agent attribution for commits based on author email,
+Co-Authored-By trailers, and configurable patterns.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class AgentProfile:
+    """Profile for a known agent or human contributor."""
+
+    name: str
+    emails: list[str] = field(default_factory=list)
+    co_author_patterns: list[str] = field(default_factory=list)
+    trust_tier: str = "verified"  # verified, probation, unknown
+    quality_threshold: float = 70.0  # minimum passing score
+
+
+# Default registry covering common AI agent signatures
+_DEFAULT_AGENTS = [
+    AgentProfile(
+        name="claude",
+        emails=["noreply@anthropic.com"],
+        co_author_patterns=[r"Claude\s+(Opus|Sonnet|Haiku|Code)"],
+        trust_tier="verified",
+        quality_threshold=70.0,
+    ),
+    AgentProfile(
+        name="codex",
+        emails=["codex@openai.com", "noreply@github.com"],
+        co_author_patterns=[r"Codex"],
+        trust_tier="verified",
+        quality_threshold=70.0,
+    ),
+    AgentProfile(
+        name="gemini",
+        emails=["gemini@google.com"],
+        co_author_patterns=[r"Gemini"],
+        trust_tier="probation",
+        quality_threshold=80.0,
+    ),
+    AgentProfile(
+        name="copilot",
+        emails=[],
+        co_author_patterns=[r"GitHub\s+Copilot"],
+        trust_tier="verified",
+        quality_threshold=70.0,
+    ),
+]
+
+
+class AgentRegistry:
+    """Registry of known agents and human contributors."""
+
+    def __init__(self, agents: list[AgentProfile] | None = None):
+        self._agents = agents if agents is not None else list(_DEFAULT_AGENTS)
+        self._email_index: dict[str, str] = {}
+        self._rebuild_index()
+
+    def _rebuild_index(self) -> None:
+        self._email_index.clear()
+        for agent in self._agents:
+            for email in agent.emails:
+                self._email_index[email.lower()] = agent.name
+
+    def add_agent(self, agent: AgentProfile) -> None:
+        self._agents.append(agent)
+        self._rebuild_index()
+
+    def identify(self, author_email: str, commit_message: str = "") -> str:
+        """Identify the agent from commit metadata.
+
+        Checks in order:
+        1. Co-Authored-By trailer in commit message
+        2. Author email match
+        3. Default: "human"
+        """
+        # Check Co-Authored-By patterns
+        for agent in self._agents:
+            for pattern in agent.co_author_patterns:
+                if re.search(pattern, commit_message, re.IGNORECASE):
+                    return agent.name
+
+        # Check email
+        email_lower = author_email.lower()
+        if email_lower in self._email_index:
+            return self._email_index[email_lower]
+
+        return "human"
+
+    def get_profile(self, agent_name: str) -> AgentProfile | None:
+        for agent in self._agents:
+            if agent.name == agent_name:
+                return agent
+        return None
+
+    def all_agents(self) -> list[AgentProfile]:
+        return list(self._agents)
+
+    @classmethod
+    def from_json(cls, path: Path) -> "AgentRegistry":
+        """Load registry from a JSON config file."""
+        data = json.loads(path.read_text())
+        agents = []
+        for entry in data.get("agents", []):
+            agents.append(AgentProfile(
+                name=entry["name"],
+                emails=entry.get("emails", []),
+                co_author_patterns=entry.get("co_author_patterns", []),
+                trust_tier=entry.get("trust_tier", "unknown"),
+                quality_threshold=entry.get("quality_threshold", 70.0),
+            ))
+        return cls(agents)