@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/report_cmds.py

@@ -1,788 +0,0 @@
-"""Report discovery, inspection, and lifecycle commands for vds-audit CLI."""
-
-# pyright: reportUnusedVariable=false
-
-from __future__ import annotations
-
-import json
-import shutil
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
-from typing import Any
-
-import structlog
-import typer
-from rich.table import Table
-
-from .cli_common import _cli_state, console, report_app
-from .cli_impl import (
-    _DEFAULT_REPORT_DIR,
-    _emit_json,
-    _load_state_api,
-    _resolve_state_dsn_from_env,
-    _state_command_candidates,
-)
-from .phase151_projection import (
-    normalize_audit_outcome,
-    normalize_lifecycle_status,
-    project_profile_metadata,
-    project_status_summary,
-)
-
-_log = structlog.get_logger(__name__)
-
-
-def _resolve_history_path(project_key: str) -> Path:
-    """Resolve the default run-history.json path for a given project key."""
-    return _DEFAULT_REPORT_DIR / project_key / "runs" / "run-history.json"
-
-
-def _load_run_history_from_path(history_path: Path) -> list[dict[str, Any]]:
-    if not history_path.exists():
-        return []
-    try:
-        payload = json.loads(history_path.read_text(encoding="utf-8"))
-        entries = payload.get("entries")
-        return entries if isinstance(entries, list) else []
-    except (json.JSONDecodeError, OSError) as exc:
-        _log.warning("run_history_load_failed", path=str(history_path), error=str(exc))
-        return []
-
-
-def _state_run_root_history_paths(project_key: str) -> list[Path]:
-    state_dsn = _resolve_state_dsn_from_env()
-    if not state_dsn:
-        return []
-
-    state_api = _load_state_api(required=False)
-    if state_api is None:
-        return []
-
-    try:
-        rows = getattr(state_api, _state_command_candidates("list_run_roots")[0])(
-            state_dsn=state_dsn,
-            project_key=project_key,
-            limit=100,
-        )
-    except Exception as exc:
-        _log.debug("report_run_roots_lookup_failed", project_key=project_key, error=str(exc))
-        return []
-
-    history_paths: list[Path] = []
-    seen: set[Path] = set()
-    for row in rows or []:
-        if not isinstance(row, dict):
-            continue
-        run_root_raw = str(row.get("run_root") or "").strip()
-        if not run_root_raw:
-            continue
-        history_path = Path(run_root_raw).expanduser().resolve() / "run-history.json"
-        if history_path in seen:
-            continue
-        seen.add(history_path)
-        history_paths.append(history_path)
-    return history_paths
-
-
-def _resolve_existing_history_path(project_key: str) -> Path | None:
-    default_path = _resolve_history_path(project_key)
-    if default_path.exists():
-        return default_path
-
-    for history_path in _state_run_root_history_paths(project_key):
-        if history_path.exists():
-            return history_path
-    return None
-
-
-def _load_run_history(project_key: str) -> list[dict[str, Any]]:
-    """Load run-history entries for a project. Returns empty list if missing."""
-    history_path = _resolve_existing_history_path(project_key)
-    if history_path is None:
-        return []
-    return _load_run_history_from_path(history_path)
-
-
-@report_app.command(name="list")
-def report_list(
-    project: str = typer.Option(
-        ...,
-        "--project",
-        help="Project storage key to scope the listing.",
-    ),
-    repo: str | None = typer.Option(
-        None,
-        "--repo",
-        help="Filter by repo storage key.",
-    ),
-    latest_only: bool = typer.Option(
-        False,
-        "--latest-only",
-        help="Show only the most recent entry per repo.",
-    ),
-) -> None:
-    """List audit run history entries for a project.
-
-    Reads from the run-history.json index and displays a summary table.
-    Supports --json-only for machine-readable output.
-
-    Examples:
-        vds-audit report list --project my_project
-        vds-audit --json-only report list --project my_project --repo merchant-billing
-        vds-audit report list --project my_project --latest-only
-    """
-    entries = _load_run_history(project)
-    if not entries:
-        _emit_report_error(f"No run history found for project '{project}'.")
-        return
-
-    if repo:
-        entries = [e for e in entries if e.get("repo_storage_key") == repo]
-
-    if latest_only:
-        entries = _filter_latest_per_repo(entries)
-
-    entries = [_project_entry(entry) for entry in entries]
-
-    # Sort by updated_at descending
-    entries.sort(key=lambda e: e.get("updated_at", ""), reverse=True)
-
-    if _cli_state.get("json_only"):
-        _emit_json({"status": "ok", "project": project, "count": len(entries), "entries": entries})
-        return
-
-    table = Table(title=f"Run History — {project}", show_lines=False)
-    table.add_column("Run ID", style="cyan", no_wrap=True)
-    table.add_column("Repo", style="green")
-    table.add_column("Updated", style="dim")
-    table.add_column("Lifecycle", style="bold")
-    table.add_column("Outcome", style="bold")
-    table.add_column("Score", justify="right")
-    table.add_column("Findings", justify="right")
-    table.add_column("Target", style="dim")  # Phase 96 (TSK-940.83)
-
-    for entry in entries:
-        summary = entry.get("summary") or {}
-        lifecycle_status = _normalized_lifecycle_status(summary)
-        audit_outcome = _normalized_audit_outcome(summary)
-        score = summary.get("overall_score")
-        score_str = f"{score:.1f}" if score is not None else "—"
-        findings = summary.get("total_findings")
-        findings_str = str(findings) if findings is not None else "—"
-        updated = entry.get("updated_at", "?")
-        if len(updated) > 19:
-            updated = updated[:19]  # Trim timezone for display
-        target_selector = summary.get("target_selector") or ""
-
-        table.add_row(
-            entry.get("run_id", "?"),
-            entry.get("repo_storage_key", "?"),
-            updated,
-            f"[{_status_style(lifecycle_status)}]{lifecycle_status}[/{_status_style(lifecycle_status)}]",
-            f"[{_status_style(audit_outcome)}]{audit_outcome}[/{_status_style(audit_outcome)}]",
-            score_str,
-            findings_str,
-            target_selector or "—",
-        )
-
-    console.print(table)
-    console.print(f"\n  Total entries: {len(entries)}")
-
-
-@report_app.command(name="show")
-def report_show(
-    project: str = typer.Option(
-        ...,
-        "--project",
-        help="Project storage key.",
-    ),
-    run_id: str = typer.Option(
-        ...,
-        "--run-id",
-        help="Run ID to inspect.",
-    ),
-    repo: str = typer.Option(
-        ...,
-        "--repo",
-        help="Repo storage key within the run.",
-    ),
-) -> None:
-    """Show details for a specific audit run entry.
-
-    Resolves the report directory and displays the workflow summary,
-    checklist files, and checkpoint binding if available.
-
-    Examples:
-        vds-audit report show --project my_project --run-id phase95-xxx --repo merchant-billing
-        vds-audit --json-only report show --project my_project --run-id phase95-xxx --repo merchant-billing
-    """
-    entries = _load_run_history(project)
-    match = _find_entry(entries, run_id=run_id, repo=repo)
-    if not match:
-        _emit_report_error(f"No entry found for run_id='{run_id}', repo='{repo}' in project '{project}'.")
-        return
-
-    match = _project_entry(match)
-
-    report_dir = Path(match.get("report_dir", ""))
-    dir_exists = report_dir.is_dir()
-
-    # Discover report artifacts
-    artifacts: dict[str, Any] = {"report_dir": str(report_dir), "exists": dir_exists}
-    if dir_exists:
-        checklist_files = sorted(report_dir.glob("checklist-*.json"))
-        if not checklist_files:
-            checklist_files = sorted(report_dir.glob("audit-checklist*.json"))
-        artifacts["checklist_files"] = [f.name for f in checklist_files]
-        artifacts["checklist_count"] = len(checklist_files)
-
-        summary_path = report_dir / "workflow-summary.json"
-        if summary_path.exists():
-            try:
-                artifacts["workflow_summary"] = json.loads(summary_path.read_text(encoding="utf-8"))
-            except (json.JSONDecodeError, OSError):
-                artifacts["workflow_summary"] = None
-        else:
-            artifacts["workflow_summary"] = None
-
-        # Total size
-        total_bytes = sum(f.stat().st_size for f in report_dir.rglob("*") if f.is_file())
-        artifacts["total_size_bytes"] = total_bytes
-        artifacts["total_size_human"] = _human_size(total_bytes)
-
-    payload: dict[str, Any] = {
-        "status": "ok",
-        "entry": match,
-        "artifacts": artifacts,
-    }
-    category_scores = _extract_category_scores(
-        summary=match.get("summary"),
-        workflow_summary=artifacts.get("workflow_summary"),
-    )
-    if category_scores:
-        payload["category_scores"] = category_scores
-
-    if _cli_state.get("json_only"):
-        _emit_json(payload)
-        return
-
-    console.print(f"\n[bold]Report Details[/bold] — {run_id}")
-    console.print(f"  Project:    {match.get('project_storage_key', '?')}")
-    console.print(f"  Repo:       {match.get('repo_storage_key', '?')}")
-    console.print(f"  Updated:    {match.get('updated_at', '?')}")
-    console.print(f"  Confluence: {match.get('confluence_page_id') or '—'}")
-    console.print(f"  Checkpoint: {match.get('checkpoint_path') or '—'}")
-    console.print()
-
-    summary = match.get("summary") or {}
-    lifecycle_status = _normalized_lifecycle_status(summary)
-    audit_outcome = _normalized_audit_outcome(summary)
-    console.print(f"  Lifecycle:  {lifecycle_status}")
-    console.print(f"  Outcome:    {audit_outcome}")
-    score = summary.get("overall_score")
-    console.print(f"  Score:      {f'{score:.1f}' if score is not None else '—'}")
-    console.print(f"  Findings:   {summary.get('total_findings', '—')}")
-    if category_scores:
-        console.print("  Categories:")
-        for category, values in category_scores.items():
-            category_score = _coerce_score(values.get("overall_score"))
-            findings_count = int(values.get("findings_count", 0) or 0)
-            category_count = int(values.get("count", values.get("scorable_count", 0)) or 0)
-            score_display = f"{category_score:.1f}" if category_score is not None else "—"
-            console.print(
-                f"    - {category}: score={score_display}, findings={findings_count}, checks={category_count}"
-            )
-    target_selector = summary.get("target_selector")
-    if target_selector:
-        console.print(f"  Target:     {target_selector}")
-    console.print()
-
-    console.print(f"  Report dir: {report_dir}")
-    console.print(f"  Dir exists: {dir_exists}")
-    if dir_exists:
-        console.print(f"  Checklists: {artifacts.get('checklist_count', 0)}")
-        console.print(f"  Total size: {artifacts.get('total_size_human', '?')}")
-        for name in artifacts.get("checklist_files", []):
-            console.print(f"    - {name}")
-
-
-@report_app.command(name="prune")
-def report_prune(
-    project: str = typer.Option(
-        ...,
-        "--project",
-        help="Project storage key to scope the prune.",
-    ),
-    older_than_days: int = typer.Option(
-        30,
-        "--older-than",
-        min=1,
-        help="Remove runs older than N days.",
-    ),
-    keep_latest: bool = typer.Option(
-        True,
-        "--keep-latest/--no-keep-latest",
-        help="Always preserve the latest run per repo (default: keep).",
-    ),
-    cleanup_checkpoints: bool = typer.Option(
-        True,
-        "--cleanup-checkpoints/--no-cleanup-checkpoints",
-        help="Also remove expired /tmp/vds-audit-checkpoint-* dirs.",
-    ),
-    dry_run: bool = typer.Option(
-        True,
-        "--dry-run/--execute",
-        help="Dry-run (default) shows candidates; --execute performs deletion.",
-    ),
-) -> None:
-    """Prune old audit run directories and optionally clean up checkpoints.
-
-    Default is dry-run mode. Use --execute for actual deletion.
-
-    Examples:
-        vds-audit report prune --project my_project --older-than 14
-        vds-audit report prune --project my_project --older-than 7 --execute
-        vds-audit --json-only report prune --project my_project --older-than 30
-    """
-    entries = _load_run_history(project)
-    cutoff = datetime.now(UTC) - timedelta(days=older_than_days)
-
-    # Identify candidates for removal
-    candidates: list[dict[str, Any]] = []
-    kept: list[dict[str, Any]] = []
-    latest_per_repo: dict[str, dict[str, Any]] = {}
-
-    if keep_latest:
-        latest_per_repo = _latest_per_repo_map(entries)
-
-    for entry in entries:
-        updated_str = entry.get("updated_at", "")
-        entry_time = _parse_datetime(updated_str)
-        if entry_time is None:
-            kept.append(entry)
-            continue
-
-        is_latest = (
-            keep_latest
-            and entry.get("repo_storage_key") in latest_per_repo
-            and latest_per_repo[entry["repo_storage_key"]].get("run_id") == entry.get("run_id")
-        )
-
-        if entry_time < cutoff and not is_latest:
-            candidates.append(entry)
-        else:
-            kept.append(entry)
-
-    # Checkpoint cleanup
-    checkpoint_candidates: list[str] = []
-    if cleanup_checkpoints:
-        checkpoint_candidates = _find_expired_checkpoints(cutoff)
-
-    payload: dict[str, Any] = {
-        "status": "dry_run" if dry_run else "executed",
-        "project": project,
-        "older_than_days": older_than_days,
-        "keep_latest": keep_latest,
-        "cutoff": cutoff.isoformat(),
-        "candidates_count": len(candidates),
-        "kept_count": len(kept),
-        "checkpoint_candidates_count": len(checkpoint_candidates),
-    }
-
-    if not dry_run:
-        deleted_dirs = 0
-        deleted_checkpoints = 0
-
-        for entry in candidates:
-            report_dir = Path(entry.get("report_dir", ""))
-            if report_dir.is_dir():
-                shutil.rmtree(report_dir, ignore_errors=True)
-                deleted_dirs += 1
-                _log.info("report_dir_deleted", report_dir=str(report_dir), run_id=entry.get("run_id"))
-
-        for cp_path in checkpoint_candidates:
-            cp = Path(cp_path)
-            if cp.is_dir():
-                shutil.rmtree(cp, ignore_errors=True)
-                deleted_checkpoints += 1
-            elif cp.is_file():
-                cp.unlink(missing_ok=True)
-                deleted_checkpoints += 1
-
-        # Update run-history.json to remove pruned entries
-        _write_run_history(project, kept)
-
-        payload["deleted_dirs"] = deleted_dirs
-        payload["deleted_checkpoints"] = deleted_checkpoints
-    else:
-        payload["candidate_run_ids"] = [e.get("run_id") for e in candidates]
-        payload["checkpoint_paths"] = checkpoint_candidates
-
-    if _cli_state.get("json_only"):
-        _emit_json(payload)
-        return
-
-    mode = "[yellow]DRY RUN[/yellow]" if dry_run else "[red]EXECUTED[/red]"
-    console.print(f"\n[bold]Report Prune[/bold] — {mode}")
-    console.print(f"  Project:          {project}")
-    console.print(f"  Older than:       {older_than_days} days (cutoff: {cutoff.strftime('%Y-%m-%d')})")
-    console.print(f"  Keep latest:      {keep_latest}")
-    console.print()
-    console.print(f"  Candidates:       {len(candidates)}")
-    console.print(f"  Kept:             {len(kept)}")
-    console.print(f"  Checkpoint dirs:  {len(checkpoint_candidates)}")
-
-    if dry_run and candidates:
-        console.print("\n  [dim]Candidate runs for removal:[/dim]")
-        for entry in candidates:
-            console.print(f"    - {entry.get('run_id')} ({entry.get('repo_storage_key')})")
-    elif not dry_run:
-        console.print(f"\n  Deleted dirs:         {payload.get('deleted_dirs', 0)}")
-        console.print(f"  Deleted checkpoints:  {payload.get('deleted_checkpoints', 0)}")
-
-
-@report_app.command(name="trend")
-def report_trend(
-    project: str = typer.Option(
-        ...,
-        "--project",
-        help="Project storage key to scope trend analysis.",
-    ),
-    repo: str | None = typer.Option(
-        None,
-        "--repo",
-        help="Optional repo storage key filter.",
-    ),
-    last_n: int = typer.Option(
-        5,
-        "--last-n",
-        min=1,
-        max=50,
-        help="Number of most recent completed runs to compare (default: 5).",
-    ),
-) -> None:
-    """Show per-check score trends across recent completed runs.
-
-    Trend classification:
-    - improving: delta >= +5
-    - stable: -5 < delta < +5
-    - degrading: delta <= -5
-    """
-    entries = _load_run_history(project)
-    if repo:
-        entries = [entry for entry in entries if str(entry.get("repo_storage_key") or "") == repo]
-
-    completed_entries = [entry for entry in entries if _is_completed_entry(entry)]
-    completed_entries.sort(key=lambda e: e.get("updated_at", ""), reverse=True)
-    selected_entries = completed_entries[:last_n]
-
-    if len(selected_entries) <= 1:
-        payload = {
-            "status": "ok",
-            "project": project,
-            "repo": repo,
-            "last_n": last_n,
-            "runs_considered": len(selected_entries),
-            "trends": [],
-            "message": "Insufficient completed run history (need at least 2 runs).",
-        }
-        if _cli_state.get("json_only"):
-            _emit_json(payload)
-            return
-        console.print("[yellow]Insufficient completed run history (need at least 2 runs).[/yellow]")
-        return
-
-    trend_rows = _build_trend_rows(selected_entries)
-
-    payload = {
-        "status": "ok",
-        "project": project,
-        "repo": repo,
-        "last_n": last_n,
-        "runs_considered": len(selected_entries),
-        "trends": trend_rows,
-    }
-    if _cli_state.get("json_only"):
-        _emit_json(payload)
-        return
-
-    table = Table(title=f"Run Trends — {project}", show_lines=False)
-    table.add_column("Check ID", style="cyan", no_wrap=True)
-    table.add_column("Check Name", style="green")
-    table.add_column("Latest", justify="right")
-    table.add_column("Delta", justify="right")
-    table.add_column("Trend", style="bold")
-
-    for row in trend_rows:
-        trend = str(row.get("trend") or "stable")
-        trend_style = "green" if trend == "improving" else "red" if trend == "degrading" else "yellow"
-        latest_score = row.get("latest_score")
-        latest_str = f"{float(latest_score):.1f}" if latest_score is not None else "—"
-        delta = row.get("delta")
-        delta_str = f"{float(delta):+.1f}" if delta is not None else "—"
-        table.add_row(
-            str(row.get("check_id") or ""),
-            str(row.get("check_name") or ""),
-            latest_str,
-            delta_str,
-            f"[{trend_style}]{trend}[/{trend_style}]",
-        )
-
-    console.print(table)
-    console.print(f"\n  Runs considered: {len(selected_entries)}")
-    console.print(f"  Checks trended: {len(trend_rows)}")
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────
-
-
-def _extract_category_scores(
-    *,
-    summary: Any,
-    workflow_summary: Any,
-) -> dict[str, dict[str, Any]]:
-    candidates: list[Any] = []
-    if isinstance(summary, dict):
-        candidates.append(summary.get("category_scores"))
-    if isinstance(workflow_summary, dict):
-        candidates.append(workflow_summary.get("category_scores"))
-        synthesis = workflow_summary.get("synthesis")
-        if isinstance(synthesis, dict):
-            candidates.append(synthesis.get("category_scores"))
-    for candidate in candidates:
-        normalized = _normalize_category_scores(candidate)
-        if normalized:
-            return normalized
-    return {}
-
-
-def _normalize_category_scores(value: Any) -> dict[str, dict[str, Any]]:
-    if not isinstance(value, dict):
-        return {}
-    normalized: dict[str, dict[str, Any]] = {}
-    for raw_category, raw_payload in value.items():
-        category = str(raw_category or "").strip().lower().replace("-", "_").replace(" ", "_")
-        if not category or not isinstance(raw_payload, dict):
-            continue
-        normalized[category] = dict(raw_payload)
-    return dict(sorted(normalized.items(), key=lambda item: item[0]))
-
-
-def _filter_latest_per_repo(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Return only the most recent entry per repo_storage_key."""
-    latest_map = _latest_per_repo_map(entries)
-    return list(latest_map.values())
-
-
-def _project_entry(entry: dict[str, Any]) -> dict[str, Any]:
-    projected = dict(entry)
-    raw_summary = entry.get("summary")
-    summary = raw_summary if isinstance(raw_summary, dict) else None
-    projected["summary"] = project_status_summary(summary)
-    profile_projection = project_profile_metadata(summary)
-    if profile_projection:
-        projected["profile_projection"] = profile_projection
-    return projected
-
-
-def _normalized_lifecycle_status(summary: dict[str, Any]) -> str:
-    return normalize_lifecycle_status(summary)
-
-
-def _normalized_audit_outcome(summary: dict[str, Any]) -> str:
-    return normalize_audit_outcome(summary)
-
-
-def _status_style(status: str) -> str:
-    if status in {"completed", "pass"}:
-        return "green"
-    if status in {"failed", "error", "fail"}:
-        return "red"
-    return "yellow"
-
-
-def _is_completed_entry(entry: dict[str, Any]) -> bool:
-    summary = entry.get("summary") or {}
-    return _normalized_lifecycle_status(summary) == "completed"
-
-
-def _extract_check_scores_from_report(entry: dict[str, Any]) -> dict[str, dict[str, Any]]:
-    report_dir = Path(str(entry.get("report_dir") or "").strip())
-    if not report_dir.is_dir():
-        return {}
-
-    checks: dict[str, dict[str, Any]] = {}
-    for checklist_file in sorted(report_dir.glob("checklist-*.json")):
-        try:
-            payload = json.loads(checklist_file.read_text(encoding="utf-8"))
-        except (json.JSONDecodeError, OSError):
-            continue
-        for row in _iter_check_rows(payload):
-            check_id = str(row.get("check_id") or row.get("id") or row.get("row_key") or "").strip()
-            if not check_id:
-                continue
-            score = _coerce_score(row.get("score"))
-            if score is None:
-                continue
-            check_name = str(
-                row.get("check_name") or row.get("name") or row.get("row_name") or row.get("title") or ""
-            ).strip()
-            checks[check_id] = {
-                "check_name": check_name or check_id,
-                "score": score,
-            }
-    return checks
-
-
-def _iter_check_rows(payload: Any) -> list[dict[str, Any]]:
-    if isinstance(payload, list):
-        return [row for row in payload if isinstance(row, dict)]
-    if not isinstance(payload, dict):
-        return []
-
-    for key in ("rows", "items", "results", "checklist_rows", "checks"):
-        value = payload.get(key)
-        if isinstance(value, list):
-            return [row for row in value if isinstance(row, dict)]
-    return []
-
-
-def _coerce_score(value: Any) -> float | None:
-    if isinstance(value, (int, float)):
-        return float(value)
-    if isinstance(value, str):
-        raw = value.strip()
-        if not raw:
-            return None
-        try:
-            return float(raw)
-        except ValueError:
-            return None
-    return None
-
-
-def _build_trend_rows(entries_desc: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    entries = list(reversed(entries_desc))
-    history_by_check: dict[str, list[dict[str, Any]]] = {}
-
-    for entry in entries:
-        run_id = str(entry.get("run_id") or "")
-        updated_at = str(entry.get("updated_at") or "")
-        for check_id, check_payload in _extract_check_scores_from_report(entry).items():
-            history_by_check.setdefault(check_id, []).append(
-                {
-                    "run_id": run_id,
-                    "updated_at": updated_at,
-                    "score": float(check_payload["score"]),
-                    "check_name": str(check_payload.get("check_name") or check_id),
-                }
-            )
-
-    trend_rows: list[dict[str, Any]] = []
-    for check_id, history in sorted(history_by_check.items()):
-        if len(history) <= 1:
-            continue
-        first = history[0]
-        latest = history[-1]
-        delta = float(latest["score"]) - float(first["score"])
-        if delta >= 5.0:
-            trend = "improving"
-        elif delta <= -5.0:
-            trend = "degrading"
-        else:
-            trend = "stable"
-        trend_rows.append(
-            {
-                "check_id": check_id,
-                "check_name": str(latest.get("check_name") or check_id),
-                "delta": round(delta, 4),
-                "trend": trend,
-                "latest_score": float(latest["score"]),
-                "scores": [
-                    {
-                        "run_id": str(item.get("run_id") or ""),
-                        "updated_at": str(item.get("updated_at") or ""),
-                        "score": float(item["score"]),
-                    }
-                    for item in history
-                ],
-            }
-        )
-    return trend_rows
-
-
-def _latest_per_repo_map(entries: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
-    """Build a map of repo_storage_key -> latest entry."""
-    latest: dict[str, dict[str, Any]] = {}
-    for entry in entries:
-        repo_key = entry.get("repo_storage_key", "")
-        existing = latest.get(repo_key)
-        if existing is None or entry.get("updated_at", "") > existing.get("updated_at", ""):
-            latest[repo_key] = entry
-    return latest
-
-
-def _find_entry(
-    entries: list[dict[str, Any]],
-    *,
-    run_id: str,
-    repo: str,
-) -> dict[str, Any] | None:
-    """Find a specific entry by run_id and repo key."""
-    for entry in entries:
-        if entry.get("run_id") == run_id and entry.get("repo_storage_key") == repo:
-            return entry
-    return None
-
-
-def _parse_datetime(s: str) -> datetime | None:
-    """Parse an ISO datetime string, returning None on failure."""
-    if not s:
-        return None
-    try:
-        return datetime.fromisoformat(s)
-    except (ValueError, TypeError):
-        return None
-
-
-def _find_expired_checkpoints(cutoff: datetime) -> list[str]:
-    """Find /tmp/vds-audit-checkpoint-* dirs older than cutoff."""
-    tmp = Path("/tmp")
-    results: list[str] = []
-    if not tmp.is_dir():
-        return results
-    for item in tmp.iterdir():
-        if not item.name.startswith("vds-audit-checkpoint-"):
-            continue
-        try:
-            mtime = datetime.fromtimestamp(item.stat().st_mtime, tz=UTC)
-            if mtime < cutoff:
-                results.append(str(item))
-        except OSError:
-            continue
-    return results
-
-
-def _write_run_history(project_key: str, entries: list[dict[str, Any]]) -> None:
-    """Write updated run-history.json after pruning."""
-    history_path = _resolve_existing_history_path(project_key) or _resolve_history_path(project_key)
-    payload = {"entries": entries}
-    history_path.parent.mkdir(parents=True, exist_ok=True)
-    history_path.write_text(json.dumps(payload, indent=2, default=str), encoding="utf-8")
-
-
-def _human_size(num_bytes: int) -> str:
-    """Convert bytes to human-readable string."""
-    for unit in ("B", "KB", "MB", "GB"):
-        if abs(num_bytes) < 1024:
-            return f"{num_bytes:.1f} {unit}"
-        num_bytes //= 1024
-    return f"{num_bytes:.1f} TB"
-
-
-def _emit_report_error(message: str) -> None:
-    """Emit error for report commands."""
-    if _cli_state.get("json_only"):
-        _emit_json({"status": "error", "error": message})
-    else:
-        console.print(f"[yellow]{message}[/yellow]")