PyPI - code-mower - Versions diffs - 0.5.0b5__py3-none-any.whl - Mend

code-mower 0.5.0b5__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (185) hide show

code_mower/__init__.py +3 -0
code_mower/adapters/__init__.py +39 -0
code_mower/adapters/_base.py +148 -0
code_mower/adapters/cursor_bugbot.py +97 -0
code_mower/adapters/gitar.py +111 -0
code_mower/adapters/greptile.py +191 -0
code_mower/adapters/qodo.py +140 -0
code_mower/antigravity_cli_audit_pr.py +241 -0
code_mower/audit_handoff_log.py +345 -0
code_mower/audit_labeler_lib.py +311 -0
code_mower/audit_progress.py +203 -0
code_mower/blind_review_artifacts.py +562 -0
code_mower/blind_review_coordinator.py +276 -0
code_mower/bootstrap.py +524 -0
code_mower/builder_experiment.py +539 -0
code_mower/calibration/__init__.py +181 -0
code_mower/calibration/arms.py +267 -0
code_mower/calibration/auto_discovery.py +348 -0
code_mower/calibration/commands.py +192 -0
code_mower/calibration/context_inputs.py +199 -0
code_mower/calibration/corpus.py +91 -0
code_mower/calibration/evidence.py +20 -0
code_mower/calibration/evidence_report.py +360 -0
code_mower/calibration/identity.py +27 -0
code_mower/calibration/metrics.py +18 -0
code_mower/calibration/overlap.py +103 -0
code_mower/calibration/planning.py +309 -0
code_mower/calibration/policy.py +207 -0
code_mower/calibration/results.py +315 -0
code_mower/calibration/run_results.py +147 -0
code_mower/calibration/run_status.py +64 -0
code_mower/calibration/runner.py +360 -0
code_mower/calibration/truth.py +188 -0
code_mower/calibration/value_report.py +142 -0
code_mower/checks.py +402 -0
code_mower/claude_audit_pr.py +1126 -0
code_mower/claude_cli_bounce.py +303 -0
code_mower/claude_cli_environment.py +73 -0
code_mower/clear_stale.py +374 -0
code_mower/cli.py +537 -0
code_mower/cloud.py +674 -0
code_mower/cloud_client/__init__.py +173 -0
code_mower/cloud_client/bundle.py +155 -0
code_mower/cloud_client/doctor.py +206 -0
code_mower/cloud_client/dogfood.py +78 -0
code_mower/cloud_client/endpoints.py +114 -0
code_mower/cloud_client/errors.py +7 -0
code_mower/cloud_client/events.py +278 -0
code_mower/cloud_client/export.py +272 -0
code_mower/cloud_client/git_metadata.py +46 -0
code_mower/cloud_client/manifest.py +39 -0
code_mower/cloud_client/operations.py +448 -0
code_mower/cloud_client/reports.py +45 -0
code_mower/cloud_client/setup.py +205 -0
code_mower/cloud_client/upload.py +97 -0
code_mower/code_mower_calibration.py +598 -0
code_mower/code_mower_context_packs.py +591 -0
code_mower/code_mower_merge.py +227 -0
code_mower/code_mower_telemetry.py +561 -0
code_mower/coderabbit_cli_audit_pr.py +526 -0
code_mower/codex_audit_env_preflight.py +220 -0
code_mower/codex_audit_pr.py +1738 -0
code_mower/codex_audit_schema_smoke.py +160 -0
code_mower/codex_audit_verdict.schema.json +44 -0
code_mower/config.py +655 -0
code_mower/doctor.py +161 -0
code_mower/doctor_checks/__init__.py +104 -0
code_mower/doctor_checks/cloud.py +129 -0
code_mower/doctor_checks/common.py +215 -0
code_mower/doctor_checks/github.py +128 -0
code_mower/doctor_checks/github_actions.py +11 -0
code_mower/doctor_checks/github_actions_cost.py +99 -0
code_mower/doctor_checks/github_actions_cost_summary.py +111 -0
code_mower/doctor_checks/github_actions_failure_annotations.py +27 -0
code_mower/doctor_checks/github_actions_failure_models.py +47 -0
code_mower/doctor_checks/github_actions_failure_scan.py +200 -0
code_mower/doctor_checks/github_actions_failure_selection.py +63 -0
code_mower/doctor_checks/github_actions_failures.py +103 -0
code_mower/doctor_checks/github_actions_permissions.py +55 -0
code_mower/doctor_checks/github_api.py +79 -0
code_mower/doctor_checks/github_branch.py +56 -0
code_mower/doctor_checks/github_config.py +25 -0
code_mower/doctor_checks/github_provider.py +61 -0
code_mower/doctor_checks/github_repo.py +120 -0
code_mower/doctor_checks/groups.py +36 -0
code_mower/doctor_checks/models.py +96 -0
code_mower/doctor_checks/output.py +86 -0
code_mower/doctor_checks/presets.py +64 -0
code_mower/doctor_checks/privacy.py +20 -0
code_mower/doctor_checks/provider_api_model.py +138 -0
code_mower/doctor_checks/provider_api_model_openai.py +29 -0
code_mower/doctor_checks/provider_api_model_profiles.py +137 -0
code_mower/doctor_checks/provider_env.py +113 -0
code_mower/doctor_checks/provider_env_required.py +56 -0
code_mower/doctor_checks/provider_env_tokens.py +100 -0
code_mower/doctor_checks/provider_local_cli.py +162 -0
code_mower/doctor_checks/provider_local_cli_commands.py +47 -0
code_mower/doctor_checks/provider_local_cli_probe_config.py +70 -0
code_mower/doctor_checks/provider_probe.py +20 -0
code_mower/doctor_checks/provider_probe_auth.py +52 -0
code_mower/doctor_checks/provider_probe_evaluation.py +109 -0
code_mower/doctor_checks/provider_probe_json.py +45 -0
code_mower/doctor_checks/provider_probe_remediation.py +39 -0
code_mower/doctor_checks/providers.py +159 -0
code_mower/doctor_checks/registry.py +69 -0
code_mower/doctor_checks/runner.py +188 -0
code_mower/doctor_checks/runtime.py +89 -0
code_mower/doctor_checks/runtime_github_auth.py +148 -0
code_mower/gemini_cli_audit_pr.py +897 -0
code_mower/hermes_cli_audit_pr.py +436 -0
code_mower/init.py +888 -0
code_mower/lane_configs/__init__.py +37 -0
code_mower/lane_configs/aider.py +32 -0
code_mower/lane_configs/antigravity_cli.py +35 -0
code_mower/lane_configs/claude.py +35 -0
code_mower/lane_configs/codex.py +32 -0
code_mower/lane_configs/devin.py +33 -0
code_mower/lane_configs/gemini_cli.py +35 -0
code_mower/lane_configs/hermes_cli.py +35 -0
code_mower/lane_configs/local_llm.py +31 -0
code_mower/local_llm_audit_pr.py +1364 -0
code_mower/local_llm_bakeoff.py +458 -0
code_mower/local_llm_calibration.py +441 -0
code_mower/local_llm_profiles.py +66 -0
code_mower/migration.py +508 -0
code_mower/migration_install.py +292 -0
code_mower/migration_mirror.py +392 -0
code_mower/migration_readiness.py +237 -0
code_mower/migration_rehearsal.py +718 -0
code_mower/next_steps.py +441 -0
code_mower/package.py +673 -0
code_mower/package_content.py +444 -0
code_mower/package_manifest.py +452 -0
code_mower/package_paths.py +53 -0
code_mower/package_rendering.py +90 -0
code_mower/package_static.py +585 -0
code_mower/prompts.py +267 -0
code_mower/provider_registry.py +469 -0
code_mower/provider_runners/__init__.py +60 -0
code_mower/provider_runners/comments.py +31 -0
code_mower/provider_runners/git.py +46 -0
code_mower/provider_runners/github_auth.py +61 -0
code_mower/provider_runners/github_pr.py +120 -0
code_mower/provider_runners/process.py +58 -0
code_mower/provider_runners/repo_paths.py +23 -0
code_mower/provider_runners/text_schema.py +41 -0
code_mower/provider_runners/verdict_artifacts.py +103 -0
code_mower/provider_runners/workspace.py +57 -0
code_mower/release_readiness.py +549 -0
code_mower/reviewer_metrics.py +389 -0
code_mower/saas_reviewer_labeler.py +809 -0
code_mower/secrets.py +89 -0
code_mower/templates/builder-experiment.example.json +55 -0
code_mower/templates/calibration-corpus.example.json +129 -0
code_mower/templates/calibration-corpus.json +129 -0
code_mower/templates/code-mower.example.yml +423 -0
code_mower/templates/context-packs.example.json +150 -0
code_mower/templates/lane_prompts/base-audit.md +22 -0
code_mower/templates/lane_prompts/calibration-policy.md +21 -0
code_mower/templates/lane_prompts/context-driven-quality.md +21 -0
code_mower/templates/lane_prompts/docs-design.md +12 -0
code_mower/templates/lane_prompts/generic-programming.md +21 -0
code_mower/templates/lane_prompts/operability.md +22 -0
code_mower/templates/lane_prompts/package-runtime.md +12 -0
code_mower/templates/lane_prompts/security-threat-model.md +22 -0
code_mower/templates/product-support/code_mower +216 -0
code_mower/templates/product-support/code_mower_standalone_pin.env +7 -0
code_mower/templates/product-support/code_mower_standalone_shadow.sh +151 -0
code_mower/templates/product-support/run_claude_audit_pr.sh +32 -0
code_mower/templates/product-support/run_codex_audit_pr.sh +32 -0
code_mower/templates/product-support/safe_gh_comment.py +96 -0
code_mower/templates/providers.yml +454 -0
code_mower/templates/reviewer-spend.example.json +28 -0
code_mower/templates/reviewer-value-report.example.md +20 -0
code_mower/templates/workflows/private-standalone-shadow.yml.j2 +106 -0
code_mower/templates/workflows/review-clear-stale.yml.j2 +83 -0
code_mower/trailer_comment_labeler.py +207 -0
code_mower/versioning.py +32 -0
code_mower-0.5.0b5.dist-info/METADATA +302 -0
code_mower-0.5.0b5.dist-info/RECORD +185 -0
code_mower-0.5.0b5.dist-info/WHEEL +5 -0
code_mower-0.5.0b5.dist-info/entry_points.txt +2 -0
code_mower-0.5.0b5.dist-info/licenses/LICENSE +202 -0
code_mower-0.5.0b5.dist-info/licenses/NOTICE +10 -0
code_mower-0.5.0b5.dist-info/top_level.txt +1 -0

code_mower/calibration/auto_discovery.py ADDED Viewed

@@ -0,0 +1,348 @@
+"""Draft calibration corpus discovery from GitHub PR metadata."""
+from __future__ import annotations
+import datetime as _dt
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+from .corpus import parse_int
+from .identity import safe_slug
+from .run_status import RUN_STATUS_BLOCKED, RUN_STATUS_PASS, RUN_STATUS_UNKNOWN
+AUTO_DISCOVERY_SCHEMA = "code_mower.calibrationAutoDiscover.v1"
+TRUTH_EXPECTATION_UNKNOWN = "unknown"
+TRUTH_EXPECTATION_KNOWN_CLEAN = "known_clean"
+TRUTH_EXPECTATION_KNOWN_BLOCKED = "known_blocked"
+AUDIT_STATE_RE = re.compile(
+    r"<!--\s*(?P<provider>[A-Z0-9_]+)_AUDIT_STATE:\s*"
+    r"(?P<state>[a-z0-9_-]+)\s*-->",
+    re.IGNORECASE,
+)
+FINDINGS_COUNT_RE = re.compile(
+    r"Findings:\s*P0=(?P<p0>\d+),\s*P1=(?P<p1>\d+),\s*"
+    r"P2=(?P<p2>\d+),\s*P3=(?P<p3>\d+)",
+    re.IGNORECASE,
+)
+HEAD_SHA_RE = re.compile(r"Head SHA:\s*`?(?P<head>[0-9a-f]{7,40})`?", re.IGNORECASE)
+def gh_pr_list_fields() -> str:
+    return ",".join(
+        [
+            "number",
+            "title",
+            "headRefOid",
+            "baseRefName",
+            "mergedAt",
+            "changedFiles",
+            "comments",
+            "reviews",
+            "labels",
+        ]
+    )
+def load_auto_discovery_input(path: Path) -> list[dict[str, Any]]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError(f"unable to read {path}: {exc}") from exc
+    raw_items = (
+        payload.get("pull_requests", payload.get("prs", payload))
+        if isinstance(payload, Mapping)
+        else payload
+    )
+    if not isinstance(raw_items, list):
+        raise ValueError("auto-discover input must be a GitHub PR list JSON array")
+    items: list[dict[str, Any]] = []
+    for index, item in enumerate(raw_items):
+        if not isinstance(item, Mapping):
+            raise ValueError(f"auto-discover input[{index}] must be a JSON object")
+        items.append(dict(item))
+    return items
+def fetch_merged_prs_for_auto_discovery(
+    *,
+    repo: str,
+    last_n: int,
+    runner: Any = subprocess.run,
+) -> list[dict[str, Any]]:
+    if last_n < 1:
+        raise ValueError("--last-n must be at least 1")
+    completed = runner(
+        [
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            repo,
+            "--state",
+            "merged",
+            "--limit",
+            str(last_n),
+            "--json",
+            gh_pr_list_fields(),
+        ],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        stderr = str(getattr(completed, "stderr", "") or "").strip()
+        raise ValueError(
+            "gh pr list failed for calibration auto-discovery"
+            + (f": {stderr}" if stderr else "")
+        )
+    try:
+        payload = json.loads(str(getattr(completed, "stdout", "") or ""))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"gh pr list returned invalid JSON: {exc}") from exc
+    if not isinstance(payload, list):
+        raise ValueError("gh pr list returned a non-list payload")
+    return [dict(item) for item in payload if isinstance(item, Mapping)]
+def _provider_from_audit_state(provider: str, state: str) -> str:
+    provider_slug = provider.lower().replace("_", "-")
+    if provider_slug in {"codex", "claude", "devin", "gitar"}:
+        return f"{provider_slug}-audit"
+    state_parts = state.split("-audit-", 1)
+    if len(state_parts) == 2 and state_parts[0]:
+        return f"{state_parts[0]}-audit"
+    return f"{provider_slug}-audit"
+def _audit_status_from_state(state: str) -> str:
+    normalized = state.lower()
+    if normalized.endswith("-done") or normalized in {"done", "pass", "passed"}:
+        return RUN_STATUS_PASS
+    if normalized.endswith("-blocked") or normalized in {"blocked", "fail", "failed"}:
+        return RUN_STATUS_BLOCKED
+    return RUN_STATUS_UNKNOWN
+def _finding_count_from_comment(body: str) -> int:
+    match = FINDINGS_COUNT_RE.search(body)
+    if not match:
+        return 0
+    return sum(int(match.group(name)) for name in ("p0", "p1", "p2", "p3"))
+def _head_sha_from_comment(body: str) -> str:
+    match = HEAD_SHA_RE.search(body)
+    return match.group("head") if match else ""
+def _audit_runs_from_comments(comments: Sequence[Any]) -> list[dict[str, Any]]:
+    runs: list[dict[str, Any]] = []
+    for comment in comments:
+        if not isinstance(comment, Mapping):
+            continue
+        body = str(comment.get("body") or "")
+        if not body:
+            continue
+        for match in AUDIT_STATE_RE.finditer(body):
+            state = match.group("state")
+            reviewer = _provider_from_audit_state(match.group("provider"), state)
+            status = _audit_status_from_state(state)
+            run: dict[str, Any] = {
+                "reviewer": reviewer,
+                "status": status,
+                "finding_count": _finding_count_from_comment(body),
+                "source": "github-comment-trailer",
+            }
+            head_sha = _head_sha_from_comment(body)
+            if head_sha:
+                run["head_sha"] = head_sha
+            if status == RUN_STATUS_BLOCKED:
+                run["expected_blocker_caught"] = True
+                run["disposition"] = "true_positive"
+            runs.append(run)
+    return runs
+def _review_signal_count(reviews: Sequence[Any], comments: Sequence[Any]) -> int:
+    count = 0
+    for review in reviews:
+        if not isinstance(review, Mapping):
+            continue
+        state = str(review.get("state") or "").upper()
+        if state == "CHANGES_REQUESTED":
+            count += 1
+    for comment in comments:
+        if not isinstance(comment, Mapping):
+            continue
+        body = str(comment.get("body") or "").lower()
+        if "changes requested" in body or "requested changes" in body:
+            count += 1
+    return count
+def _difficulty_from_changed_files(value: Any) -> str:
+    changed_files = parse_int(value or 0, field="changedFiles")
+    if changed_files >= 20:
+        return "hard"
+    if changed_files >= 6:
+        return "medium"
+    return "easy"
+def build_auto_discovered_corpus(
+    *,
+    repo: str,
+    pull_requests: Sequence[Mapping[str, Any]],
+    last_n: int,
+) -> dict[str, Any]:
+    if "/" not in repo:
+        raise ValueError("--repo must be an owner/repo slug")
+    items: list[dict[str, Any]] = []
+    for raw in pull_requests:
+        pr_number = parse_int(raw.get("number"), field="pull_request.number")
+        final_head_sha = str(raw.get("headRefOid") or "")
+        comments = list(raw.get("comments", []) or [])
+        reviews = list(raw.get("reviews", []) or [])
+        reviewer_runs = _audit_runs_from_comments(comments)
+        blocked_runs = [
+            run for run in reviewer_runs if run.get("status") == RUN_STATUS_BLOCKED
+        ]
+        pass_runs = [
+            run for run in reviewer_runs if run.get("status") == RUN_STATUS_PASS
+        ]
+        review_signals = _review_signal_count(reviews, comments)
+        shared_signal_summary = {
+            "audit_blocked_runs": len(blocked_runs),
+            "review_signal_count": review_signals,
+            "audit_run_count": len(reviewer_runs),
+        }
+        def make_item(
+            *,
+            head_sha: str,
+            source: str,
+            expectation: str,
+            runs: list[dict[str, Any]],
+            signal_summary: Mapping[str, Any],
+        ) -> dict[str, Any]:
+            return {
+                "repo": repo,
+                "pr_number": pr_number,
+                "head_sha": head_sha,
+                "base_ref": str(raw.get("baseRefName") or ""),
+                "difficulty": _difficulty_from_changed_files(raw.get("changedFiles")),
+                "review_class": "auto-discovered",
+                "source": source,
+                "truth": {
+                    "expectation": expectation,
+                    "notes": (
+                        "Draft auto-discovered from merged PR metadata. Confirm this "
+                        "disposition before using it for lane promotion or merge policy."
+                    ),
+                },
+                "expected_findings": [],
+                "reviewer_runs": runs,
+                "notes": (
+                    f"PR title: {raw.get('title') or ''}. "
+                    f"Discovery signals: {json.dumps(dict(signal_summary), sort_keys=True)}"
+                ),
+                "auto_discovery": dict(signal_summary),
+            }
+        blocked_runs_by_head: dict[str, list[dict[str, Any]]] = {}
+        for run in blocked_runs:
+            head_sha = str(run.get("head_sha") or "")
+            blocked_runs_by_head.setdefault(head_sha, []).append(run)
+        for head_sha, runs in sorted(blocked_runs_by_head.items()):
+            signal_summary = {
+                **shared_signal_summary,
+                "case": "historical-blocked-head",
+                "case_head_sha": head_sha,
+            }
+            items.append(
+                make_item(
+                    head_sha=head_sha,
+                    source="auto-discovered-structured-blocker",
+                    expectation=TRUTH_EXPECTATION_KNOWN_BLOCKED,
+                    runs=runs,
+                    signal_summary=signal_summary,
+                )
+            )
+        final_pass_runs = [
+            run
+            for run in pass_runs
+            if not run.get("head_sha") or run.get("head_sha") == final_head_sha
+        ]
+        explicit_blocked_heads = {
+            str(run.get("head_sha")) for run in blocked_runs if run.get("head_sha")
+        }
+        if (
+            final_head_sha
+            and final_head_sha not in explicit_blocked_heads
+            and (not blocked_runs or final_pass_runs)
+        ):
+            signal_summary = {
+                **shared_signal_summary,
+                "case": "merged-final-head",
+                "case_head_sha": final_head_sha,
+            }
+            items.append(
+                make_item(
+                    head_sha=final_head_sha,
+                    source=(
+                        "auto-discovered-merged-clean-after-fix"
+                        if blocked_runs
+                        else "auto-discovered-merged-clean"
+                    ),
+                    expectation=TRUTH_EXPECTATION_KNOWN_CLEAN
+                    if not review_signals or blocked_runs
+                    else TRUTH_EXPECTATION_UNKNOWN,
+                    runs=final_pass_runs,
+                    signal_summary=signal_summary,
+                )
+            )
+        elif review_signals and not blocked_runs:
+            signal_summary = {
+                **shared_signal_summary,
+                "case": "review-signal-needs-human-disposition",
+                "case_head_sha": final_head_sha,
+            }
+            items.append(
+                make_item(
+                    head_sha=final_head_sha,
+                    source="auto-discovered-review-signal-needs-human-disposition",
+                    expectation=TRUTH_EXPECTATION_UNKNOWN,
+                    runs=[],
+                    signal_summary=signal_summary,
+                )
+            )
+    return {
+        "version": 1,
+        "name": f"auto-discovered-{safe_slug(repo)}",
+        "description": (
+            "Draft calibration corpus generated from recent merged GitHub PRs. "
+            "Review every disposition before treating it as benchmark truth."
+        ),
+        "discovery": {
+            "schema": AUTO_DISCOVERY_SCHEMA,
+            "repo": repo,
+            "last_n": last_n,
+            "generated_at": _dt.datetime.now(tz=_dt.timezone.utc)
+            .replace(microsecond=0)
+            .isoformat()
+            .replace("+00:00", "Z"),
+            "source": "gh pr list --state merged",
+            "caveat": (
+                "Known-clean and known-blocked labels are heuristics from merged "
+                "PR history, structured audit trailers, and review request signals. "
+                "They are starter dispositions, not automatic merge-gating truth."
+            ),
+        },
+        "corpus": items,
+    }

code_mower/calibration/commands.py ADDED Viewed

@@ -0,0 +1,192 @@
+"""Calibration command materialization helpers."""
+from __future__ import annotations
+import re
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+from .identity import safe_slug
+def parse_repo_path_map(entries: Sequence[str]) -> dict[str, str]:
+    mapping: dict[str, str] = {}
+    for entry in entries:
+        if "=" not in entry:
+            raise ValueError(
+                "repo path map entries must be OWNER/REPO=PATH, "
+                f"OWNER/REPO#PR=PATH, or OWNER/REPO@HEAD=PATH: {entry}"
+            )
+        selector, path = entry.split("=", 1)
+        selector = selector.strip()
+        path = path.strip()
+        repo = re.split(r"[#@]", selector, maxsplit=1)[0]
+        if "/" not in repo or not path:
+            raise ValueError(
+                "repo path map entries must be OWNER/REPO=PATH, "
+                f"OWNER/REPO#PR=PATH, or OWNER/REPO@HEAD=PATH: {entry}"
+            )
+        mapping[selector] = path
+    return mapping
+def repo_path_for_item(item: Mapping[str, Any], repo_path_map: Mapping[str, str]) -> str:
+    repo = str(item.get("repo") or "")
+    pr_number = str(item.get("pr_number") or "")
+    head_sha = str(item.get("head_sha") or "")
+    selectors = [
+        f"{repo}#{pr_number}@{head_sha}" if repo and pr_number and head_sha else "",
+        f"{repo}#{pr_number}" if repo and pr_number else "",
+        f"{repo}@{head_sha}" if repo and head_sha else "",
+        repo,
+    ]
+    for selector in selectors:
+        if selector and selector in repo_path_map:
+            return repo_path_map[selector]
+    return ""
+def command_lane_id(command: Sequence[Any]) -> str:
+    parts = [str(part) for part in command]
+    if len(parts) >= 2 and parts[0] == "code-mower":
+        if parts[1] == "local-llm" and len(parts) >= 3 and parts[2] == "bakeoff":
+            return "local-llm"
+        return parts[1].replace("_", "-")
+    return safe_slug(parts[0] if parts else "command", "command")
+def option_value(command: Sequence[str], option: str) -> str:
+    for index, part in enumerate(command):
+        if part == option and index + 1 < len(command):
+            return command[index + 1]
+        if part.startswith(f"{option}="):
+            return part.split("=", 1)[1]
+    return ""
+def reviewer_id_from_command(command: Sequence[Any]) -> str:
+    lane_id = command_lane_id(command)
+    output_dir = option_value([str(part) for part in command], "--output-dir")
+    output_leaf = safe_slug(Path(output_dir).name if output_dir else "", "")
+    default_leaf = {
+        "antigravity-cli": "antigravity-cli",
+        "gemini-cli": "gemini-cli",
+        "hermes-cli": "hermes-cli",
+        "coderabbit-cli": "coderabbit-cli",
+        "local-llm": "local-llm",
+    }.get(lane_id, lane_id)
+    if output_leaf and output_leaf != default_leaf:
+        return output_leaf
+    return lane_id
+def command_metadata_for_run(run: Mapping[str, Any], command_index: int) -> dict[str, Any]:
+    command_metadata = run.get("command_metadata", [])
+    if (
+        isinstance(command_metadata, list)
+        and 0 <= command_index < len(command_metadata)
+        and isinstance(command_metadata[command_index], Mapping)
+    ):
+        return dict(command_metadata[command_index])
+    return {}
+def local_llm_profiles_from_command(command: Sequence[Any]) -> list[str]:
+    profiles = option_value([str(part) for part in command], "--profiles")
+    return [profile.strip() for profile in profiles.split(",") if profile.strip()]
+def set_option_value(command: list[str], option: str, value: str) -> None:
+    for index, part in enumerate(command):
+        if part == option and index + 1 < len(command):
+            command[index + 1] = value
+            return
+        if part.startswith(f"{option}="):
+            command[index] = f"{option}={value}"
+            return
+    command.extend([option, value])
+def has_flag(command: Sequence[str], flag: str) -> bool:
+    return any(part == flag for part in command)
+def rewrite_code_mower_command(
+    command: Sequence[Any],
+    *,
+    code_mower_command: Sequence[str],
+) -> list[str]:
+    parts = [str(part) for part in command]
+    if parts and parts[0] == "code-mower":
+        return [*code_mower_command, *parts[1:]]
+    return parts
+def materialize_command(
+    command: Sequence[Any],
+    *,
+    item: Mapping[str, Any],
+    code_mower_command: Sequence[str],
+    repo_path_map: Mapping[str, str],
+    allow_historical_head: bool,
+) -> list[str]:
+    materialized = rewrite_code_mower_command(
+        command,
+        code_mower_command=code_mower_command,
+    )
+    lane_id = command_lane_id(command)
+    repo = str(item.get("repo") or "")
+    repo_path = repo_path_for_item(item, repo_path_map)
+    historical_local_cli_lanes = {"antigravity-cli", "gemini-cli", "hermes-cli"}
+    if lane_id in {"coderabbit-cli", "local-llm", *historical_local_cli_lanes}:
+        existing_repo_path = option_value(materialized, "--repo-path")
+        if repo_path:
+            set_option_value(materialized, "--repo-path", repo_path)
+            if lane_id in {"coderabbit-cli", "local-llm", *historical_local_cli_lanes} and allow_historical_head:
+                if not has_flag(materialized, "--allow-historical-head"):
+                    materialized.append("--allow-historical-head")
+                if lane_id in historical_local_cli_lanes and not has_flag(
+                    materialized,
+                    "--historical-calibration",
+                ):
+                    materialized.append("--historical-calibration")
+        elif existing_repo_path == "/path/to/pr-worktree":
+            raise ValueError(
+                f"{lane_id} for {repo} needs --repo-path-map {repo}=/path/to/pr-worktree"
+            )
+    return materialized
+def summary_path_for_command(command: Sequence[Any]) -> Path | None:
+    lane_id = command_lane_id(command)
+    output_dir = option_value([str(part) for part in command], "--output-dir")
+    if not output_dir:
+        return None
+    root = Path(output_dir)
+    if lane_id == "local-llm":
+        return root / "summary.json"
+    if lane_id == "antigravity-cli":
+        return root / "antigravity-cli.summary.json"
+    if lane_id == "gemini-cli":
+        return root / "gemini-cli.summary.json"
+    if lane_id == "hermes-cli":
+        return root / "hermes-cli.summary.json"
+    if lane_id == "coderabbit-cli":
+        return root / "coderabbit-cli.summary.json"
+    return None
+def resolve_path_for_cwd(path: Path | None, cwd: Path | None) -> Path | None:
+    if path is None:
+        return None
+    if path.is_absolute():
+        return path
+    return (cwd or Path.cwd()) / path
+def text_from_timeout_stream(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bytes):
+        return value.decode("utf-8", errors="replace")
+    return str(value)