arbiter-dev 0.2.0__py3-none-any.whl

arbiter/store.py

@@ -0,0 +1,249 @@
+"""Store — SQLite persistence for quality metrics, trends, and agent scores."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Generator
+
+from arbiter.scoring import AgentScore, RepoScore
+
+
+_DEFAULT_DB = Path("arbiter_data.db")
+
+
+@dataclass(frozen=True, slots=True)
+class FileScore:
+    """Quality info for a single file."""
+
+    file_path: str
+    finding_count: int
+    worst_severity: str
+    last_agent: str
+
+
+class Store:
+    """SQLite store for Arbiter quality data."""
+
+    def __init__(self, db_path: Path | str = _DEFAULT_DB):
+        self._db_path = Path(db_path)
+        self._init_db()
+
+    @contextmanager
+    def _conn(self) -> Generator[sqlite3.Connection, None, None]:
+        conn = sqlite3.connect(str(self._db_path))
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+            conn.commit()
+        finally:
+            conn.close()
+
+    def _init_db(self) -> None:
+        with self._conn() as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS commit_quality (
+                    commit_hash TEXT,
+                    repo_name TEXT NOT NULL DEFAULT '',
+                    timestamp TEXT NOT NULL,
+                    agent TEXT NOT NULL,
+                    files_changed INTEGER DEFAULT 0,
+                    loc_added INTEGER DEFAULT 0,
+                    loc_removed INTEGER DEFAULT 0,
+                    overall_score REAL,
+                    lint_score REAL,
+                    security_score REAL,
+                    complexity_score REAL,
+                    total_findings INTEGER DEFAULT 0,
+                    findings_json TEXT,
+                    created_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS file_quality (
+                    file_path TEXT,
+                    repo_name TEXT NOT NULL DEFAULT '',
+                    finding_count INTEGER DEFAULT 0,
+                    worst_severity TEXT,
+                    last_agent TEXT,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS repo_snapshots (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    repo_name TEXT NOT NULL DEFAULT '',
+                    timestamp TEXT NOT NULL,
+                    overall_score REAL,
+                    lint_score REAL,
+                    security_score REAL,
+                    complexity_score REAL,
+                    total_findings INTEGER,
+                    total_loc INTEGER,
+                    findings_json TEXT
+                );
+
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_commit_repo ON commit_quality(commit_hash, repo_name);
+                CREATE INDEX IF NOT EXISTS idx_commit_agent ON commit_quality(agent);
+                CREATE INDEX IF NOT EXISTS idx_commit_repo_name ON commit_quality(repo_name);
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_file_repo ON file_quality(file_path, repo_name);
+                CREATE INDEX IF NOT EXISTS idx_snapshot_repo ON repo_snapshots(repo_name);
+                CREATE INDEX IF NOT EXISTS idx_commit_timestamp ON commit_quality(timestamp);
+                CREATE INDEX IF NOT EXISTS idx_snapshot_timestamp ON repo_snapshots(timestamp);
+            """)
+
+    def record_commit(
+        self,
+        commit_hash: str,
+        timestamp: str,
+        agent: str,
+        files_changed: int,
+        loc_added: int,
+        loc_removed: int,
+        score: RepoScore,
+        repo_name: str = "",
+    ) -> None:
+        """Record quality data for a single commit."""
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with self._conn() as conn:
+            conn.execute(
+                """INSERT OR REPLACE INTO commit_quality
+                   (commit_hash, repo_name, timestamp, agent, files_changed, loc_added, loc_removed,
+                    overall_score, lint_score, security_score, complexity_score,
+                    total_findings, findings_json, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (commit_hash, repo_name, timestamp, agent, files_changed, loc_added, loc_removed,
+                 score.overall, score.lint_score, score.security_score, score.complexity_score,
+                 score.total_findings, json.dumps(score.findings_by_severity), now),
+            )
+
+    def record_snapshot(self, score: RepoScore, total_loc: int, repo_name: str = "") -> None:
+        """Record a point-in-time repo quality snapshot."""
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with self._conn() as conn:
+            conn.execute(
+                """INSERT INTO repo_snapshots
+                   (repo_name, timestamp, overall_score, lint_score, security_score, complexity_score,
+                    total_findings, total_loc, findings_json)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (repo_name, now, score.overall, score.lint_score, score.security_score,
+                 score.complexity_score, score.total_findings, total_loc,
+                 json.dumps(score.findings_by_tool)),
+            )
+
+    def update_file_quality(self, file_path: str, finding_count: int, worst_severity: str, agent: str, repo_name: str = "") -> None:
+        """Update quality record for a single file."""
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with self._conn() as conn:
+            conn.execute(
+                """INSERT OR REPLACE INTO file_quality
+                   (file_path, repo_name, finding_count, worst_severity, last_agent, updated_at)
+                   VALUES (?, ?, ?, ?, ?, ?)""",
+                (file_path, repo_name, finding_count, worst_severity, agent, now),
+            )
+
+    def get_agent_leaderboard(self) -> list[AgentScore]:
+        """Get quality scores aggregated by agent."""
+        with self._conn() as conn:
+            rows = conn.execute("""
+                SELECT agent,
+                       COUNT(*) as commit_count,
+                       AVG(overall_score) as avg_score,
+                       SUM(loc_added) as total_loc
+                FROM commit_quality
+                GROUP BY agent
+                ORDER BY avg_score DESC
+            """).fetchall()
+
+        return [
+            AgentScore(
+                agent_name=row["agent"],
+                commit_count=row["commit_count"],
+                avg_score=round(row["avg_score"] or 0, 1),
+                total_loc=row["total_loc"] or 0,
+            )
+            for row in rows
+        ]
+
+    def get_trend(self, days: int = 30) -> list[dict[str, Any]]:
+        """Get repo quality snapshots over time."""
+        with self._conn() as conn:
+            rows = conn.execute("""
+                SELECT timestamp, overall_score, lint_score, security_score,
+                       complexity_score, total_findings, total_loc
+                FROM repo_snapshots
+                ORDER BY timestamp DESC
+                LIMIT ?
+            """, (days,)).fetchall()
+        return [dict(row) for row in reversed(rows)]
+
+    def get_worst_files(self, limit: int = 20) -> list[FileScore]:
+        """Get files ranked by worst quality."""
+        with self._conn() as conn:
+            rows = conn.execute("""
+                SELECT file_path, finding_count, worst_severity, last_agent
+                FROM file_quality
+                WHERE finding_count > 0
+                ORDER BY finding_count DESC
+                LIMIT ?
+            """, (limit,)).fetchall()
+        return [
+            FileScore(
+                file_path=row["file_path"],
+                finding_count=row["finding_count"],
+                worst_severity=row["worst_severity"] or "LOW",
+                last_agent=row["last_agent"] or "unknown",
+            )
+            for row in rows
+        ]
+
+    def get_agent_trend(self, agent: str, days: int = 30) -> list[dict[str, Any]]:
+        """Get quality trend for a specific agent over time."""
+        with self._conn() as conn:
+            rows = conn.execute("""
+                SELECT timestamp, overall_score, lint_score, security_score,
+                       complexity_score, total_findings, loc_added, commit_hash
+                FROM commit_quality
+                WHERE agent = ?
+                ORDER BY timestamp DESC
+                LIMIT ?
+            """, (agent, days)).fetchall()
+        return [dict(row) for row in reversed(rows)]
+
+    def get_recent_commits(self, agent: str | None = None, limit: int = 50) -> list[dict[str, Any]]:
+        """Get recent commits with quality data."""
+        with self._conn() as conn:
+            if agent:
+                rows = conn.execute("""
+                    SELECT * FROM commit_quality
+                    WHERE agent = ?
+                    ORDER BY timestamp DESC LIMIT ?
+                """, (agent, limit)).fetchall()
+            else:
+                rows = conn.execute("""
+                    SELECT * FROM commit_quality
+                    ORDER BY timestamp DESC LIMIT ?
+                """, (limit,)).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_fleet_report(self) -> list[dict[str, Any]]:
+        """Get quality summary per repo — the fleet-wide view."""
+        with self._conn() as conn:
+            rows = conn.execute("""
+                SELECT repo_name,
+                       overall_score,
+                       lint_score,
+                       security_score,
+                       complexity_score,
+                       total_findings,
+                       total_loc,
+                       timestamp
+                FROM repo_snapshots
+                WHERE id IN (
+                    SELECT MAX(id) FROM repo_snapshots GROUP BY repo_name
+                )
+                ORDER BY overall_score DESC
+            """).fetchall()
+        return [dict(row) for row in rows]

arbiter_dev-0.2.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: arbiter-dev
+Version: 0.2.0
+Summary: Agent-aware code quality system for multi-agent codebases
+Author: Reuben Bowlby, Daniel Matha
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: analyzers
+Requires-Dist: ruff>=0.4.0; extra == "analyzers"
+Requires-Dist: radon>=6.0; extra == "analyzers"
+Requires-Dist: vulture>=2.10; extra == "analyzers"
+Requires-Dist: bandit>=1.7.0; extra == "analyzers"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: all
+Requires-Dist: arbiter[analyzers,test]; extra == "all"
+Dynamic: license-file
+
+# Arbiter
+
+**Agent-aware code quality system for multi-agent codebases.**
+
+In 2026, code is written by fleets of AI agents. Arbiter knows *who* wrote each line — human or AI — and scores quality accordingly.
+
+## What Makes Arbiter Different
+
+| Feature | Traditional Tools | Arbiter |
+|---------|------------------|---------|
+| Agent attribution | None | First-class: tracks Claude, Codex, Gemini, Copilot, humans |
+| Per-commit scoring | Repo-wide only | Scores each commit's changed files individually |
+| Diff analysis | N/A | Score only what changed in a PR/branch |
+| Transparency | Opaque score | Every score decomposes into lint + security + complexity |
+| Agent-specific gates | N/A | Different quality thresholds per agent trust tier |
+| Tool integration | Proprietary | Wraps tools you already trust: ruff, Bandit, radon, vulture |
+| Dashboard | SaaS login | Single HTML file with per-agent timelines, commit feed, fleet view |
+| Dependencies | Heavy | Analysis tools only; core is stdlib Python |
+
+## Quick Start
+
+```bash
+git clone https://github.com/hummbl-dev/arbiter.git
+cd arbiter
+
+# Install (makes `arbiter` command available)
+pip install ".[analyzers]"
+
+# Quick score (no persistence)
+arbiter score /path/to/your/repo
+
+# Full analysis with per-commit agent attribution
+arbiter analyze /path/to/your/repo
+
+# Score only files changed since main
+arbiter diff /path/to/your/repo --base main
+
+# Agent leaderboard
+arbiter agents
+
+# Start dashboard
+arbiter serve --port 8080
+# Open http://localhost:8080
+```
+
+### Without install (PYTHONPATH)
+
+```bash
+PYTHONPATH=src python -m arbiter score /path/to/your/repo
+```
+
+### With Docker
+
+```bash
+docker build -t arbiter .
+docker run -p 8080:8080 -v /path/to/repo:/repo:ro arbiter
+```
+
+## Architecture
+
+```
+Git Repo ──→ [Git Historian] ──→ [Analyzer Runner] ──→ [Scoring Engine] ──→ [SQLite Store]
+                  │                      │                     │                    │
+           agent attribution      tool invocation        weighted rubric       trend data
+           (Co-Authored-By,       (ruff, radon,          (lint 35%,             │
+            email matching)        vulture, bandit)        security 30%,        ├──→ REST API
+                                                           complexity 35%)     └──→ Dashboard
+             ┌────────────┐
+             │Diff Analyzer│ ←── v0.2: scores only changed files per commit/branch
+             └────────────┘
+```
+
+### Per-Commit Scoring (v0.2)
+
+Every commit is scored against only the files it changed, not the entire repo. This makes the agent leaderboard meaningful — a commit that touches 1 clean file scores differently than one that touches 10 messy files.
+
+### Diff Mode (v0.2)
+
+`arbiter diff` scores only files changed since a base branch. Ideal for CI/PR quality gates — fast, scoped, actionable.
+
+### Agent Attribution
+
+Arbiter identifies which agent authored each commit:
+
+1. **Co-Authored-By trailer** — `Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>`
+2. **Author email** — maps `noreply@anthropic.com` → claude, `codex@openai.com` → codex
+3. **Default** — "human" if no agent pattern matches
+
+Configure in `agents.yml`:
+```yaml
+agents:
+  - name: claude
+    emails: [noreply@anthropic.com]
+    co_author_patterns: ["Claude\\s+(Opus|Sonnet|Haiku)"]
+    trust_tier: verified
+    quality_threshold: 70.0
+  - name: gemini
+    trust_tier: probation
+    quality_threshold: 80.0  # Higher bar for probationary agents
+```
+
+### Analyzers (pluggable)
+
+| Analyzer | Tool | What It Finds |
+|----------|------|--------------|
+| Lint | ruff | Style violations, import errors, bugbear patterns |
+| Complexity | radon | Cyclomatic complexity (grade A-F per function) |
+| Security | bandit | Hardcoded secrets, shell injection, dangerous patterns |
+| Dead Code | vulture | Unused functions, imports, variables |
+| Duplication | AST hash | Near-duplicate function bodies |
+
+### Scoring
+
+Deterministic. Same code → same score. Always.
+
+```
+Overall = Lint (35%) + Security (30%) + Complexity (35%)
+
+Penalty points by severity:
+  CRITICAL: 50 | HIGH: 20 | MEDIUM: 5 | LOW: 1
+
+Score = 100 - (total_penalty / LOC) * normalization_factor
+```
+
+Grades: A (90+) | B (80+) | C (70+) | D (60+) | F (<60)
+
+### Dashboard (v2)
+
+Single HTML file with Chart.js. No build step, no React, no npm.
+
+- **Score Card** — Big number + breakdown bars
+- **Agent Leaderboard** — Who writes the best code? Color-coded by agent
+- **Per-Agent Quality Timeline** — Score over time per agent (not just repo-wide)
+- **Commit Feed** — Recent commits with agent, score, changes, timestamp
+- **Hotspot Files** — Ranked by finding count
+- **Fleet View** — Multi-repo quality grid with color-coded scores
+- **Tabbed UI** — Overview, Commits, Fleet tabs
+
+### API
+
+```
+GET /api/score                  Current repo score
+GET /api/agents                 Agent leaderboard
+GET /api/agents/{name}/trend    Per-agent quality over time
+GET /api/trend?days=30          Quality over time
+GET /api/worst?limit=20         Worst files
+GET /api/commits                Recent commits with scores
+GET /api/commits/{hash}         Detail for one commit
+GET /api/fleet                  Fleet report (multi-repo)
+GET /api/health                 System health
+```
+
+## CLI Commands
+
+```bash
+arbiter analyze <repo>                     # Full analysis + per-commit scoring + persist
+arbiter score <repo> [--json] [--exclude]  # Quick score (no persist)
+arbiter diff <repo> [--base main] [--json] # Score only changed files vs base branch
+arbiter agents                             # Agent leaderboard
+arbiter trend [--days 30]                  # Quality trend
+arbiter worst [--limit 20]                 # Worst files
+arbiter commits [--agent claude]           # Recent commits
+arbiter audit-fleet <directory>            # Audit all repos in a directory
+arbiter fleet-report                       # Fleet quality summary
+arbiter triage                             # Auto-classify repos: green/yellow/red/archive
+arbiter fix <repo> [--dry-run]             # Auto-fix ruff findings + before/after score
+arbiter serve [--port 8080]                # API + dashboard
+```
+
+## Tests
+
+```bash
+pip install ".[test]"
+PYTHONPATH=src python -m pytest tests/ -v
+# 78 tests, <7 seconds
+```
+
+## Requirements
+
+- Python 3.11+
+- git (for historian)
+- Optional: ruff, radon, vulture, bandit (for full analysis)
+- Docker (for containerized deployment)
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+---
+
+Built by [HUMMBL LLC](https://hummbl.io) from production experience coordinating Claude, Codex, Gemini, and human engineers on a 6,000+ test codebase.

arbiter_dev-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+arbiter/__init__.py,sha256=lSICWpF66jOKqVJoxYj0vZledRMNPty4ea779jJfU1M,74
+arbiter/__main__.py,sha256=KUJxV2q_wgm7TFqX9je6IU4E9lAvxR_nU_XGU0GY80Q,23171
+arbiter/agent_registry.py,sha256=IpEPKCUwlUuJA1GkIK6qsUnNSF9K48wLcm0697mh_GY,3777
+arbiter/api.py,sha256=z0jannzi2DFrjo33cwu8Sleueweqzsbb4pkqhq0vcOA,6240
+arbiter/bus_bridge.py,sha256=us_NNncATORbLYJya8k1g3hGw33CDX306xyyJleamJg,2496
+arbiter/diff_analyzer.py,sha256=qkyuPHDC2Ck2ne9qbUPoh-37qNkG5TNp0NCKPbKV1Ts,4873
+arbiter/git_historian.py,sha256=Gd9JWoYKt__sKpaI90uZxR5ILRb5tY_ujCngFc_CK6U,6411
+arbiter/scoring.py,sha256=3RU_fvC3JWTuyf5_llkEuFe9tzlrfwjLjPB7Gz4vc60,3742
+arbiter/store.py,sha256=tut9zJtONxrG0xHThDd9XSigkpqLfTTpPxuThyGNCd4,10072
+arbiter/analyzers/__init__.py,sha256=0uuTqh9PRPE43SYBYoN2y2YXcLkROW6gBjfiqqgpE0g,67
+arbiter/analyzers/base.py,sha256=hNrZTG4YQsXLfxbbhgrBtmal8HP_8KK33fALFoamxXI,1185
+arbiter/analyzers/complexity_analyzer.py,sha256=oe-oq22L-h1GAhxdvTWq1QywrS-yPh2BbpA2ZwOujzE,2144
+arbiter/analyzers/dead_code_analyzer.py,sha256=QIwnrdMdF3H3PiU3A0HSj_UM4y3_iviYkb7xgU4Uwu0,1704
+arbiter/analyzers/duplication_analyzer.py,sha256=F2pcmFNnkJ5CGukMjuMI4uTGsPNUyQl1LRL2xpD4uFI,3553
+arbiter/analyzers/ruff_analyzer.py,sha256=tANAuRri1X3jW6RdRjl9zaFplY7ufD2Alv_Wx5SQJdI,2449
+arbiter/analyzers/security_analyzer.py,sha256=5qtbOMn-lAegvh9cZcf8kysbW3S5EBuoqTTjmPiO3-g,1910
+arbiter_dev-0.2.0.dist-info/licenses/LICENSE,sha256=x6CmZmL3qaXphWZWt02ZP2p_BcsoaSQxLj_R9IyalcM,1097
+arbiter_dev-0.2.0.dist-info/METADATA,sha256=FVND_2CIzLrIpx74dv66AQhgnrkpl74gQ9TnUO_V8-U,7647
+arbiter_dev-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+arbiter_dev-0.2.0.dist-info/entry_points.txt,sha256=5UnDdGkHgctdc9b73lvcfv3lh8tUVaq2uc8HoleTy2I,50
+arbiter_dev-0.2.0.dist-info/top_level.txt,sha256=6xckoxU5fjdxvk-5J6uCv2PcPz11wqzqL1DXldzj8ZQ,8
+arbiter_dev-0.2.0.dist-info/RECORD,,

arbiter_dev-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arbiter_dev-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arbiter = arbiter.__main__:main

arbiter_dev-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Reuben Bowlby, Daniel Matha / HUMMBL LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arbiter_dev-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+arbiter