arbiter-dev 0.2.0__py3-none-any.whl

arbiter/diff_analyzer.py

@@ -0,0 +1,161 @@
+"""Diff Analyzer — Per-commit and per-branch quality scoring.
+
+Scores only the files that changed, not the entire repo.
+This makes agent leaderboard scores meaningful.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from arbiter.analyzers.base import Analyzer, Finding
+from arbiter.git_historian import (
+    CommitInfo,
+    count_loc_for_files,
+    get_changed_files,
+    get_diff_files,
+)
+from arbiter.scoring import RepoScore, score_findings
+
+
+def score_commit(
+    repo_path: Path,
+    commit: CommitInfo,
+    analyzers: list[Analyzer],
+    *,
+    exclude_paths: list[str] | None = None,
+) -> RepoScore:
+    """Score only the files changed in a specific commit.
+
+    Returns a RepoScore scoped to the commit's changed files.
+    Non-Python commits get a perfect score (100).
+    """
+    changed = get_changed_files(repo_path, commit.hash)
+    return _score_file_set(repo_path, changed, analyzers, exclude_paths=exclude_paths)
+
+
+def score_diff(
+    repo_path: Path,
+    analyzers: list[Analyzer],
+    *,
+    base_branch: str = "main",
+    exclude_paths: list[str] | None = None,
+) -> tuple[RepoScore, list[Finding], list[str]]:
+    """Score only the files changed between base branch and HEAD.
+
+    Returns (score, findings, changed_files).
+    """
+    changed = get_diff_files(repo_path, base_branch)
+    python_files = [f for f in changed if f.endswith(".py")]
+
+    if not python_files:
+        empty_score = RepoScore(
+            overall=100.0,
+            lint_score=100.0,
+            security_score=100.0,
+            complexity_score=100.0,
+            total_findings=0,
+        )
+        return empty_score, [], changed
+
+    abs_files = [repo_path / f for f in python_files]
+    existing = [f for f in abs_files if f.exists()]
+    if not existing:
+        empty_score = RepoScore(
+            overall=100.0,
+            lint_score=100.0,
+            security_score=100.0,
+            complexity_score=100.0,
+            total_findings=0,
+        )
+        return empty_score, [], changed
+
+    findings = _run_analyzers_on_files(analyzers, existing, exclude_paths=exclude_paths)
+    loc = count_loc_for_files(existing)
+    score = score_findings(findings, max(loc, 1))
+
+    return score, findings, changed
+
+
+def _score_file_set(
+    repo_path: Path,
+    changed_files: list[str],
+    analyzers: list[Analyzer],
+    *,
+    exclude_paths: list[str] | None = None,
+) -> RepoScore:
+    """Score a set of changed files."""
+    python_files = [f for f in changed_files if f.endswith(".py")]
+
+    if not python_files:
+        return RepoScore(
+            overall=100.0,
+            lint_score=100.0,
+            security_score=100.0,
+            complexity_score=100.0,
+            total_findings=0,
+        )
+
+    abs_files = [repo_path / f for f in python_files]
+    existing = [f for f in abs_files if f.exists()]
+    if not existing:
+        return RepoScore(
+            overall=100.0,
+            lint_score=100.0,
+            security_score=100.0,
+            complexity_score=100.0,
+            total_findings=0,
+        )
+
+    findings = _run_analyzers_on_files(analyzers, existing, exclude_paths=exclude_paths)
+    loc = count_loc_for_files(existing)
+    return score_findings(findings, max(loc, 1))
+
+
+def _run_analyzers_on_files(
+    analyzers: list[Analyzer],
+    files: list[Path],
+    *,
+    exclude_paths: list[str] | None = None,
+) -> list[Finding]:
+    """Run analyzers against specific files (not full repo).
+
+    Creates a temporary analysis by running each analyzer on individual files
+    and filtering findings to only the target files.
+    """
+    all_findings: list[Finding] = []
+    file_set = {str(f) for f in files}
+    # Also index by just the filename for relative path matching
+    rel_set = {str(f.name) for f in files}
+
+    for analyzer in analyzers:
+        if not analyzer.is_available():
+            continue
+        for file_path in files:
+            try:
+                # Run analyzer on the file's parent directory and filter
+                findings = analyzer.analyze_repo(
+                    file_path.parent,
+                    exclude_paths=exclude_paths,
+                )
+                for f in findings:
+                    # Match findings to our target files
+                    if (
+                        f.file_path in file_set
+                        or str(Path(f.file_path).resolve()) in file_set
+                        or Path(f.file_path).name in rel_set
+                    ):
+                        all_findings.append(f)
+            except Exception:
+                continue
+
+    # Deduplicate (same file + line + rule can appear if parent dirs overlap)
+    seen = set()
+    unique: list[Finding] = []
+    for f in all_findings:
+        key = (f.file_path, f.line, f.rule_id)
+        if key not in seen:
+            seen.add(key)
+            unique.append(f)
+
+    return unique

arbiter/git_historian.py

@@ -0,0 +1,209 @@
+"""Git Historian — Walks git log and extracts commit metadata with agent attribution.
+
+Uses subprocess to call git CLI. No git library dependencies.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from arbiter.agent_registry import AgentRegistry
+
+
+@dataclass(frozen=True, slots=True)
+class CommitInfo:
+    """Metadata for a single git commit."""
+
+    hash: str
+    author_name: str
+    author_email: str
+    timestamp: str  # ISO 8601
+    message: str
+    files_changed: int
+    loc_added: int
+    loc_removed: int
+    agent: str  # attributed agent name
+
+
+# Git log format: hash|author_name|author_email|timestamp|subject
+_LOG_FORMAT = "%H|%an|%ae|%aI|%s"
+_LOG_SEP = "|"
+
+
+def walk_commits(
+    repo_path: str | Path,
+    *,
+    since: str | None = None,
+    until: str | None = None,
+    max_count: int = 500,
+    registry: AgentRegistry | None = None,
+) -> list[CommitInfo]:
+    """Walk git log and return commit info with agent attribution.
+
+    Args:
+        repo_path: Path to the git repository.
+        since: ISO date string for start of range.
+        until: ISO date string for end of range.
+        max_count: Maximum commits to return.
+        registry: Agent registry for attribution. Uses default if None.
+
+    Returns:
+        List of CommitInfo, newest first.
+    """
+    if registry is None:
+        registry = AgentRegistry()
+
+    repo = Path(repo_path)
+    cmd = [
+        "git", "-C", str(repo), "log",
+        f"--format={_LOG_FORMAT}",
+        f"--max-count={max_count}",
+    ]
+    if since:
+        cmd.append(f"--since={since}")
+    if until:
+        cmd.append(f"--until={until}")
+
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+    if result.returncode != 0:
+        return []
+
+    commits: list[CommitInfo] = []
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            continue
+        parts = line.split(_LOG_SEP, 4)
+        if len(parts) < 5:
+            continue
+
+        commit_hash, author_name, author_email, timestamp, subject = parts
+
+        # Get full message for Co-Authored-By detection
+        full_msg = _get_full_message(repo, commit_hash)
+
+        # Get diffstat
+        loc_added, loc_removed, files_changed = _get_diffstat(repo, commit_hash)
+
+        # Attribute agent
+        agent = registry.identify(author_email, full_msg)
+
+        commits.append(CommitInfo(
+            hash=commit_hash,
+            author_name=author_name,
+            author_email=author_email,
+            timestamp=timestamp,
+            message=subject,
+            files_changed=files_changed,
+            loc_added=loc_added,
+            loc_removed=loc_removed,
+            agent=agent,
+        ))
+
+    return commits
+
+
+def _get_full_message(repo: Path, commit_hash: str) -> str:
+    """Get the full commit message (for Co-Authored-By trailer parsing)."""
+    result = subprocess.run(
+        ["git", "-C", str(repo), "log", "-1", "--format=%B", commit_hash],
+        capture_output=True, text=True, timeout=10,
+    )
+    return result.stdout if result.returncode == 0 else ""
+
+
+def _get_diffstat(repo: Path, commit_hash: str) -> tuple[int, int, int]:
+    """Get LOC added, removed, and files changed for a commit."""
+    result = subprocess.run(
+        ["git", "-C", str(repo), "diff", "--shortstat", f"{commit_hash}~1", commit_hash],
+        capture_output=True, text=True, timeout=10,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return 0, 0, 0
+
+    text = result.stdout.strip()
+    added = removed = files = 0
+
+    import re
+    files_m = re.search(r"(\d+) files? changed", text)
+    added_m = re.search(r"(\d+) insertions?", text)
+    removed_m = re.search(r"(\d+) deletions?", text)
+
+    if files_m:
+        files = int(files_m.group(1))
+    if added_m:
+        added = int(added_m.group(1))
+    if removed_m:
+        removed = int(removed_m.group(1))
+
+    return added, removed, files
+
+
+def get_changed_files(repo_path: str | Path, commit_hash: str) -> list[str]:
+    """Get list of files changed in a specific commit (relative paths)."""
+    repo = Path(repo_path)
+    result = subprocess.run(
+        ["git", "-C", str(repo), "diff", "--name-only", f"{commit_hash}~1", commit_hash],
+        capture_output=True, text=True, timeout=10,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return []
+    return [f for f in result.stdout.strip().split("\n") if f]
+
+
+def get_diff_files(repo_path: str | Path, base_branch: str = "main") -> list[str]:
+    """Get list of files changed between base branch and HEAD (relative paths)."""
+    repo = Path(repo_path)
+    # Use merge-base to find the common ancestor
+    merge_base = subprocess.run(
+        ["git", "-C", str(repo), "merge-base", base_branch, "HEAD"],
+        capture_output=True, text=True, timeout=10,
+    )
+    if merge_base.returncode != 0:
+        # Fallback: diff directly against branch
+        base_ref = base_branch
+    else:
+        base_ref = merge_base.stdout.strip()
+
+    result = subprocess.run(
+        ["git", "-C", str(repo), "diff", "--name-only", base_ref, "HEAD"],
+        capture_output=True, text=True, timeout=10,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return []
+    return [f for f in result.stdout.strip().split("\n") if f]
+
+
+def get_python_files(repo_path: str | Path) -> list[Path]:
+    """List all tracked Python files in the repo."""
+    repo = Path(repo_path)
+    result = subprocess.run(
+        ["git", "-C", str(repo), "ls-files", "*.py"],
+        capture_output=True, text=True, timeout=10,
+    )
+    if result.returncode != 0:
+        return []
+    return [repo / f for f in result.stdout.strip().split("\n") if f]
+
+
+def count_loc(repo_path: str | Path) -> int:
+    """Count total lines of Python code in the repo."""
+    total = 0
+    for py_file in get_python_files(repo_path):
+        try:
+            total += sum(1 for _ in open(py_file, encoding="utf-8", errors="ignore"))
+        except OSError:
+            continue
+    return total
+
+
+def count_loc_for_files(file_paths: list[Path]) -> int:
+    """Count total lines of code for a specific set of files."""
+    total = 0
+    for py_file in file_paths:
+        try:
+            total += sum(1 for _ in open(py_file, encoding="utf-8", errors="ignore"))
+        except OSError:
+            continue
+    return total

arbiter/scoring.py

@@ -0,0 +1,127 @@
+"""Scoring Engine — Deterministic, transparent, decomposable quality scoring.
+
+Every score breaks down into: lint, security, complexity, duplication, coverage.
+Same code always produces the same score.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from arbiter.analyzers.base import Finding
+
+
+@dataclass(frozen=True, slots=True)
+class RepoScore:
+    """Quality score for a repository or subset of files."""
+
+    overall: float  # 0-100 weighted composite
+    lint_score: float  # 0-100
+    security_score: float  # 0-100
+    complexity_score: float  # 0-100
+    total_findings: int
+    findings_by_severity: dict[str, int] = field(default_factory=dict)
+    findings_by_tool: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def grade(self) -> str:
+        if self.overall >= 90:
+            return "A"
+        if self.overall >= 80:
+            return "B"
+        if self.overall >= 70:
+            return "C"
+        if self.overall >= 60:
+            return "D"
+        return "F"
+
+
+@dataclass(frozen=True, slots=True)
+class AgentScore:
+    """Quality metrics attributed to a specific agent."""
+
+    agent_name: str
+    commit_count: int
+    avg_score: float
+    total_loc: int
+    trend: str = "stable"  # improving, stable, declining
+
+
+# Default weights (must sum to 1.0)
+_DEFAULT_WEIGHTS = {
+    "lint": 0.35,
+    "security": 0.30,
+    "complexity": 0.35,
+}
+
+
+def score_findings(
+    findings: list[Finding],
+    loc: int,
+    *,
+    weights: dict[str, float] | None = None,
+) -> RepoScore:
+    """Score a set of findings against a codebase.
+
+    The scoring is deterministic: same findings + same LOC = same score.
+
+    Scoring formula per dimension:
+      score = 100 - (penalty_points / max(loc, 1)) * normalization_factor
+
+    Penalty points by severity:
+      CRITICAL: 50, HIGH: 20, MEDIUM: 5, LOW: 1
+    """
+    w = weights or _DEFAULT_WEIGHTS
+    if loc < 1:
+        loc = 1
+
+    severity_points = {"CRITICAL": 50, "HIGH": 20, "MEDIUM": 5, "LOW": 1}
+
+    # Categorize findings
+    lint_findings = [f for f in findings if f.tool in ("ruff", "vulture")]
+    security_findings = [f for f in findings if f.tool in ("bandit", "semgrep")]
+    complexity_findings = [f for f in findings if f.tool in ("radon", "complexity")]
+
+    # Score each dimension
+    lint_score = _dimension_score(lint_findings, loc, severity_points, 1000)
+    security_score = _dimension_score(security_findings, loc, severity_points, 500)
+    complexity_score = _dimension_score(complexity_findings, loc, severity_points, 800)
+
+    # Weighted overall
+    overall = (
+        lint_score * w.get("lint", 0.35)
+        + security_score * w.get("security", 0.30)
+        + complexity_score * w.get("complexity", 0.35)
+    )
+
+    # Count by severity and tool
+    by_severity: dict[str, int] = {}
+    by_tool: dict[str, int] = {}
+    for f in findings:
+        by_severity[f.severity] = by_severity.get(f.severity, 0) + 1
+        by_tool[f.tool] = by_tool.get(f.tool, 0) + 1
+
+    return RepoScore(
+        overall=round(overall, 1),
+        lint_score=round(lint_score, 1),
+        security_score=round(security_score, 1),
+        complexity_score=round(complexity_score, 1),
+        total_findings=len(findings),
+        findings_by_severity=by_severity,
+        findings_by_tool=by_tool,
+    )
+
+
+def _dimension_score(
+    findings: list[Finding],
+    loc: int,
+    severity_points: dict[str, int],
+    normalization: int,
+) -> float:
+    """Score a single dimension. Returns 0-100."""
+    if not findings:
+        return 100.0
+
+    total_penalty = sum(severity_points.get(f.severity, 1) for f in findings)
+    score = 100.0 - (total_penalty / max(loc, 1)) * normalization
+    return max(0.0, min(100.0, score))