patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/trend_cmd.py

@@ -0,0 +1,296 @@
+"""
+`p trend` — Health and quality trend tracking over time.
+
+Shows how your project's health changes across scans:
+- Health score history with sparkline
+- Security finding trends
+- Test coverage progression
+- Dead code ratio changes
+- Dependency health over time
+
+This catches regressions before they become problems.
+No other tool tracks quality trends across time.
+
+Usage:
+  p trend                  — show health trend over last 20 scans
+  p trend --last 50        — show last 50 scans
+  p trend security         — security findings trend only
+  p trend tests            — test coverage trend only
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+
+_log = logging.getLogger("patchi.cli.trend_cmd")
+
+
+def run(
+    metric: str | None = None, last_n: int = 20, root: Path | None = None, json_output: bool = False
+) -> None:
+    """Entry point for `p trend`."""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(r)
+    scans = mem.get_scan_results(r)
+
+    # Build trend data from scan history
+    trend_data = _build_trend_data(scans, brain)
+
+    if not trend_data:
+        if json_output:
+            import json as _json
+
+            con.print(_json.dumps({"trend": [], "note": "no scan history yet"}))
+        else:
+            con.print(
+                "[dim]No scan history yet. Run `p scan` a few times to build trend data.[/dim]"
+            )
+        return
+
+    if json_output:
+        import json as _json
+
+        con.print(_json.dumps({"trend": trend_data[-last_n:]}, indent=2, default=str))
+        return
+
+    if metric == "security":
+        _show_security_trend(trend_data, last_n)
+    elif metric == "tests":
+        _show_test_trend(trend_data, last_n)
+    else:
+        _show_health_trend(trend_data, last_n)
+
+
+def _build_trend_data(scans: dict, brain: dict) -> list[dict]:
+    """Extract trend data from scan results."""
+    entries = []
+
+    for name, data in scans.items():
+        if not isinstance(data, dict):
+            continue
+        ts = data.get("timestamp", "")
+        finding_count = data.get("finding_count", 0)
+        status = data.get("status", "done")
+        duration = data.get("duration_ms", 0)
+
+        # Extract severity breakdown if available
+        findings = data.get("findings", [])
+        by_sev = {"critical": 0, "high": 0, "medium": 0, "low": 0}
+        for f in findings:
+            if isinstance(f, dict):
+                sev = f.get("severity", "low").lower()
+                if sev in by_sev:
+                    by_sev[sev] += 1
+
+        entries.append(
+            {
+                "timestamp": ts,
+                "agent": name,
+                "finding_count": finding_count,
+                "status": status,
+                "duration_ms": duration,
+                "by_severity": by_sev,
+            }
+        )
+
+    # Sort by timestamp
+    entries.sort(key=lambda x: x.get("timestamp", ""))
+    return entries
+
+
+def _show_health_trend(trend_data: list[dict], last_n: int) -> None:
+    """Show overall health trend."""
+    entries = trend_data[-last_n:]
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Time", style="dim", width=19)
+    table.add_column("Agent", style="bold #F2EDD6", width=22)
+    table.add_column("Status", width=8)
+    table.add_column("Findings", justify="right", width=9)
+    table.add_column("Critical", justify="right", width=9)
+    table.add_column("High", justify="right", width=7)
+    table.add_column("Duration", justify="right", width=10)
+    table.add_column("Trend", width=12)
+
+    prev_findings = None
+    for entry in entries:
+        ts = entry.get("timestamp", "")
+        try:
+            ts_fmt = time.strftime("%Y-%m-%d %H:%M", time.localtime(float(ts))) if ts else "—"
+        except Exception as e:
+            _log.warning("_show_health_trend failed: %s", e)
+            ts_fmt = str(ts)[:16]
+
+        agent = entry.get("agent", "—")
+        status = entry.get("status", "done")
+        findings = entry.get("finding_count", 0)
+        by_sev = entry.get("by_severity", {})
+        crit = by_sev.get("critical", 0)
+        high = by_sev.get("high", 0)
+        dur = entry.get("duration_ms", 0)
+
+        # Trend indicator
+        if prev_findings is not None:
+            if findings < prev_findings:
+                trend = Text("↓ improving", style="#4ADE80")
+            elif findings > prev_findings:
+                trend = Text("↑ regressing", style="#FF4D6D")
+            else:
+                trend = Text("→ stable", style="dim")
+        else:
+            trend = Text("—", style="dim")
+        prev_findings = findings
+
+        status_color = "#4ADE80" if status == "done" else "#FF4D6D"
+
+        table.add_row(
+            ts_fmt,
+            agent[:22],
+            Text(status, style=status_color),
+            str(findings) if findings else "—",
+            Text(str(crit), style="#FF4D6D bold") if crit else "—",
+            Text(str(high), style="#FF8C42") if high else "—",
+            f"{dur}ms" if dur else "—",
+            trend,
+        )
+
+    con.print()
+    con.print(Panel(table, title="📈 Health Trend", border_style="#C8621A"))
+
+    # Sparkline summary
+    findings_series = [e.get("finding_count", 0) for e in entries]
+    if findings_series:
+        sparkline = _sparkline(findings_series)
+        con.print(f"\n  Findings: {sparkline}")
+        con.print(
+            f"  [dim]Latest: {findings_series[-1]} findings "
+            f"(avg: {sum(findings_series) // len(findings_series)})[/dim]"
+        )
+    con.print()
+
+
+def _show_security_trend(trend_data: list[dict], last_n: int) -> None:
+    """Show security-specific trend."""
+    from patchi.core.agents.base import AgentGroup, list_agents
+
+    security_agents = {a.name for a in list_agents(AgentGroup.SECURITY)}
+
+    entries = [e for e in trend_data if e.get("agent") in security_agents][-last_n:]
+
+    if not entries:
+        con.print("[dim]No security scan data yet. Run `p security` first.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Time", style="dim", width=19)
+    table.add_column("Agent", style="bold #F2EDD6", width=22)
+    table.add_column("Critical", justify="right", width=9)
+    table.add_column("High", justify="right", width=7)
+    table.add_column("Medium", justify="right", width=8)
+    table.add_column("Low", justify="right", width=6)
+    table.add_column("Total", justify="right", width=7)
+
+    for entry in entries:
+        ts = entry.get("timestamp", "")
+        try:
+            ts_fmt = time.strftime("%Y-%m-%d %H:%M", time.localtime(float(ts))) if ts else "—"
+        except Exception as e:
+            _log.warning("_show_security_trend failed: %s", e)
+            ts_fmt = str(ts)[:16]
+
+        by_sev = entry.get("by_severity", {})
+        crit = by_sev.get("critical", 0)
+        high = by_sev.get("high", 0)
+        med = by_sev.get("medium", 0)
+        low = by_sev.get("low", 0)
+        total = crit + high + med + low
+
+        table.add_row(
+            ts_fmt,
+            entry.get("agent", "—")[:22],
+            Text(str(crit), style="#FF4D6D bold") if crit else "—",
+            Text(str(high), style="#FF8C42") if high else "—",
+            str(med) if med else "—",
+            str(low) if low else "—",
+            str(total) if total else "—",
+        )
+
+    con.print()
+    con.print(Panel(table, title="🛡 Security Trend", border_style="#C8621A"))
+    con.print()
+
+
+def _show_test_trend(trend_data: list[dict], last_n: int) -> None:
+    """Show test-related trend."""
+    from patchi.core.agents.base import AgentGroup, list_agents
+
+    test_agents = {a.name for a in list_agents(AgentGroup.TEST)}
+
+    entries = [e for e in trend_data if e.get("agent") in test_agents][-last_n:]
+
+    if not entries:
+        con.print("[dim]No test data yet. Run `p test` first.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Time", style="dim", width=19)
+    table.add_column("Agent", style="bold #F2EDD6", width=22)
+    table.add_column("Status", width=8)
+    table.add_column("Findings", justify="right", width=9)
+    table.add_column("Duration", justify="right", width=10)
+
+    for entry in entries:
+        ts = entry.get("timestamp", "")
+        try:
+            ts_fmt = time.strftime("%Y-%m-%d %H:%M", time.localtime(float(ts))) if ts else "—"
+        except Exception as e:
+            _log.warning("_show_test_trend failed: %s", e)
+            ts_fmt = str(ts)[:16]
+
+        status = entry.get("status", "done")
+        findings = entry.get("finding_count", 0)
+        dur = entry.get("duration_ms", 0)
+
+        status_color = "#4ADE80" if findings == 0 else "#FF4D6D"
+
+        table.add_row(
+            ts_fmt,
+            entry.get("agent", "—")[:22],
+            Text(status, style=status_color),
+            str(findings) if findings else "—",
+            f"{dur}ms" if dur else "—",
+        )
+
+    con.print()
+    con.print(Panel(table, title="🧪 Test Trend", border_style="#C8621A"))
+    con.print()
+
+
+def _sparkline(values: list[int], width: int = 40) -> str:
+    """Create a text sparkline from numeric values."""
+    if not values:
+        return ""
+    blocks = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
+    mn = min(values)
+    mx = max(values)
+    rng = mx - mn if mx != mn else 1
+    # Downsample to width
+    step = max(1, len(values) // width)
+    sampled = values[::step][:width]
+    return "".join(blocks[min(int((v - mn) / rng * 7), 7)] for v in sampled)

patchi/cli/commands/undo_cmd.py

@@ -0,0 +1,235 @@
+"""
+`p undo`, `p redo`, `p rollback` — Patch history navigation.
+
+p undo              — undo last applied fix
+p undo <id>         — undo specific patch by ID
+p redo              — redo last undone fix
+p redo <id>         — redo specific patch by ID
+p rollback <id>     — rollback all patches back to before a specific patch
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC
+from pathlib import Path
+
+from rich.prompt import Confirm
+
+from patchi.cli.console import con
+from patchi.core import memory as mem
+from patchi.core.config import require_project_root
+from patchi.core.fix.applier import PatchApplier
+from patchi.core.fix.patch import Patch, PatchState
+
+_log = logging.getLogger("patchi.cli.undo_cmd")
+
+
+def run_undo(patch_id: str | None = None, root: Path | None = None) -> None:
+    """p undo [id]"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    target = _find_for_undo(patch_id, r)
+    if not target:
+        con.print("[dim]Nothing to undo.[/dim]")
+        return
+
+    patch = Patch.from_dict(target)
+    snapshot_id = patch.snapshot_id
+
+    if not snapshot_id:
+        con.print(f"[red]Patch {patch.id} has no snapshot — cannot undo.[/red]")
+        return
+
+    con.print(f"Undoing [bold]{patch.id}[/bold]: {patch.description[:60]}")
+
+    applier = PatchApplier(r)
+    result = applier.rollback(patch.id, snapshot_id)
+
+    if result.success:
+        _mark_undone(patch.id, r)
+        con.print(
+            f"[#4ADE80]✓ Undone.[/#4ADE80]  [dim]Files restored from snapshot {snapshot_id}[/dim]"
+        )
+    else:
+        con.print(f"[red]✗ Undo failed.[/red]  [dim]{result.error}[/dim]")
+
+
+def run_redo(patch_id: str | None = None, root: Path | None = None) -> None:
+    """p redo [id]"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    target = _find_for_redo(patch_id, r)
+    if not target:
+        con.print("[dim]Nothing to redo.[/dim]")
+        return
+
+    patch = Patch.from_dict(target)
+
+    con.print(f"Re-applying [bold]{patch.id}[/bold]: {patch.description[:60]}")
+
+    from patchi.core.fix.risk_gate import RiskGate
+
+    gate_result = RiskGate(r).evaluate(patch)
+    if gate_result.is_blocked:
+        con.print(f"[red]Blocked:[/red] {gate_result.blocks[0]}")
+        return
+
+    # Re-apply the patch from its stored changes
+    patch.state = PatchState.PENDING
+    applier = PatchApplier(r)
+    result = applier.apply(patch)
+
+    if result.success:
+        _mark_applied(patch.id, r)
+        con.print(
+            f"[#4ADE80]✓ Re-applied.[/#4ADE80]  "
+            f"[dim]Tests: {'passed' if result.test_passed else 'skipped'}[/dim]"
+        )
+    else:
+        con.print(f"[red]✗ Failed.[/red]  [dim]{result.error}[/dim]")
+
+
+def run_rollback(patch_id: str, root: Path | None = None) -> None:
+    """
+    p rollback <id> — rollback all changes back to the state before this patch.
+
+    Restores the snapshot taken before patch_id was applied.
+    All patches applied AFTER patch_id are also undone (oldest first).
+    """
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    patches_raw = mem.list_patches(r)
+    target = next((p for p in patches_raw if p.get("id") == patch_id), None)
+
+    if not target:
+        con.print(f"[red]Patch {patch_id!r} not found.[/red]")
+        return
+
+    # Find all patches applied at or after target (in order)
+    applied_patches = [p for p in patches_raw if p.get("state") in ("applied", "auto_applied")]
+    applied_patches.sort(key=lambda p: p.get("applied_at", ""))
+
+    try:
+        target_idx = next(i for i, p in enumerate(applied_patches) if p.get("id") == patch_id)
+    except StopIteration:
+        con.print(
+            f"[yellow]Patch {patch_id} was not applied (state: {target.get('state')})[/yellow]"
+        )
+        return
+
+    patches_to_undo = applied_patches[target_idx:]
+    count = len(patches_to_undo)
+
+    con.print()
+    con.print(f"[yellow]This will undo {count} patch(es):[/yellow]")
+    for p in patches_to_undo:
+        con.print(f"  [dim]● {p['id']}[/dim] {p.get('description', '')[:60]}")
+    con.print()
+
+    if not Confirm.ask("Proceed with rollback?", default=False):
+        con.print("[dim]Cancelled.[/dim]")
+        return
+
+    applier = PatchApplier(r)
+    undone = 0
+
+    # Undo in reverse order (newest first)
+    for p_dict in reversed(patches_to_undo):
+        snap_id = p_dict.get("snapshot_id", "")
+        if not snap_id:
+            con.print(f"  [yellow]⚠[/yellow] {p_dict['id']} — no snapshot, skipping")
+            continue
+        result = applier.rollback(p_dict["id"], snap_id)
+        if result.success:
+            _mark_undone(p_dict["id"], r)
+            con.print(f"  [#4ADE80]✓[/#4ADE80] {p_dict['id']} undone")
+            undone += 1
+        else:
+            con.print(f"  [red]✗[/red] {p_dict['id']} — {result.error[:60]}")
+            break  # Stop on first failure — don't continue partial rollback
+
+    con.print()
+    con.print(f"[dim]Rollback complete: {undone}/{count} patches undone.[/dim]")
+    con.print()
+
+
+# ── Finders ────────────────────────────────────────────────────────────────────
+
+
+def _find_for_undo(patch_id: str | None, root: Path) -> dict | None:
+    patches = mem.list_patches(root)
+    applied = [p for p in patches if p.get("state") in ("applied", "auto_applied")]
+    if not applied:
+        return None
+    if patch_id:
+        return next((p for p in applied if p.get("id") == patch_id), None)
+    # Last applied
+    applied.sort(key=lambda p: p.get("applied_at", ""))
+    return applied[-1]
+
+
+def _find_for_redo(patch_id: str | None, root: Path) -> dict | None:
+    patches = mem.list_patches(root)
+    undone = [p for p in patches if p.get("state") == "undone"]
+    if not undone:
+        return None
+    if patch_id:
+        return next((p for p in undone if p.get("id") == patch_id), None)
+    # Most recently undone
+    undone.sort(key=lambda p: p.get("rolled_back_at", ""), reverse=True)
+    return undone[0]
+
+
+# ── State update ───────────────────────────────────────────────────────────────
+
+
+def _mark_undone(patch_id: str, root: Path) -> None:
+    try:
+        import json
+        from datetime import datetime
+
+        from patchi.core.constants import MEMORY_FILES, MemoryCategory
+
+        patches = mem.list_patches(root)
+        for p in patches:
+            if p.get("id") == patch_id:
+                p["state"] = PatchState.UNDONE.value
+                p["rolled_back_at"] = datetime.now(UTC).isoformat()
+                break
+        mem_path = root / MEMORY_FILES[MemoryCategory.PATCHES]
+        mem_path.write_text(json.dumps(patches, indent=2), encoding="utf-8")
+    except Exception as e:
+        _log.warning("_mark_undone failed: %s", e)
+
+
+def _mark_applied(patch_id: str, root: Path) -> None:
+    """Mark a patch as applied (used after redo succeeds)."""
+    try:
+        import json
+        from datetime import datetime
+
+        from patchi.core.constants import MEMORY_FILES, MemoryCategory
+
+        patches = mem.list_patches(root)
+        for p in patches:
+            if p.get("id") == patch_id:
+                p["state"] = PatchState.APPLIED.value
+                p["applied_at"] = datetime.now(UTC).isoformat()
+                break
+        mem_path = root / MEMORY_FILES[MemoryCategory.PATCHES]
+        mem_path.write_text(json.dumps(patches, indent=2), encoding="utf-8")
+    except Exception as e:
+        _log.warning("_mark_applied failed: %s", e)