patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/fix_review_cmd.py

@@ -0,0 +1,273 @@
+"""
+`p fix review` — Interactive review of proposed fixes.
+
+Usage:
+  p fix review              — review all pending patches
+  p fix review --patch <id> — review a specific patch
+
+Interactive prompts:
+  ✓ Accept  — apply the patch
+  ✗ Reject  — discard the patch
+  ↷ Skip    — keep in queue
+  ↳ View    — show full diff
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.cli.ux import (
+    colored_status,
+    format_error,
+    format_header,
+    format_step,
+    status_icon,
+    summary_panel,
+)
+from patchi.core.config import require_project_root
+from patchi.core.fix.patch import Patch, PatchState
+
+_log = logging.getLogger("patchi.cli.fix.review")
+
+
+def _load_pending_patches(root: Path) -> list[Patch]:
+    """Load pending patches from memory."""
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(root)
+    pending = brain.get("pending_patches", [])
+
+    patches = []
+    for p_data in pending:
+        try:
+            patch = Patch(
+                id=p_data.get("id", "unknown"),
+                file=Path(p_data.get("file", "")),
+                finding=p_data.get("finding", {}),
+                message=p_data.get("message", ""),
+                diff=p_data.get("diff", ""),
+                strategy=p_data.get("strategy", ""),
+                blast_radius=p_data.get("blast_radius"),
+                requires_review=p_data.get("requires_review", False),
+            )
+            patch.state = PatchState.PENDING
+            patches.append(patch)
+        except Exception as e:
+            _log.debug("Failed to load patch: %s", e)
+
+    return patches
+
+
+def _save_patch_status(root: Path, patch_id: str, accepted: bool) -> None:
+    """Save patch acceptance status."""
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(root)
+    pending = brain.get("pending_patches", [])
+
+    # Remove from pending
+    pending = [p for p in pending if isinstance(p, dict) and p.get("id") != patch_id]
+
+    # Add to accepted or rejected list
+    if accepted:
+        accepted_list = brain.get("accepted_patches", [])
+        accepted_list.append(patch_id)
+        brain["accepted_patches"] = accepted_list[-100:]  # Keep last 100
+    else:
+        rejected_list = brain.get("rejected_patches", [])
+        rejected_list.append(patch_id)
+        brain["rejected_patches"] = rejected_list[-100:]
+
+    brain["pending_patches"] = pending
+    mem.save_brain(root, brain)
+
+
+def _display_patch(patch: Patch, index: int, total: int) -> None:
+    """Display a patch in a rich format."""
+    con.print()
+    con.print(
+        format_step(
+            index + 1,
+            total,
+            f"[cyan]{patch.id}[/cyan] — {patch.message[:60]}{'...' if len(patch.message) > 60 else ''}",
+        )
+    )
+    con.print()
+
+    # Patch details table
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="cyan", ratio=1)
+    table.add_column("Value", ratio=3)
+
+    table.add_row("File", str(patch.file))
+    table.add_row("Strategy", patch.strategy)
+    if patch.blast_radius is not None:
+        table.add_row("Blast Radius", str(patch.blast_radius))
+    if patch.finding:
+        table.add_row("Finding", patch.finding.get("type", "unknown"))
+        table.add_row("Severity", patch.finding.get("severity", "unknown"))
+
+    con.print(table)
+
+    # Show diff if available
+    if patch.diff:
+        con.print()
+        con.print("[dim]Diff:[/dim]")
+        con.print(
+            Syntax(
+                patch.diff,
+                "diff",
+                theme="monokai",
+                line_numbers=False,
+                word_wrap=True,
+            )
+        )
+
+
+def _prompt_action() -> str:
+    """Prompt user for patch action."""
+    con.print()
+    con.print(
+        "[dim]Actions:[/dim] "
+        "[green]a[/green]ccept  "
+        "[red]r[/red]eject  "
+        "[yellow]s[/yellow]kip  "
+        "[blue]v[/blue]iew diff  "
+        "[dim]q[/dim]uit"
+    )
+    con.print()
+
+    while True:
+        try:
+            choice = input("Action: ").strip().lower()
+            if choice in ("a", "accept"):
+                return "accept"
+            elif choice in ("r", "reject"):
+                return "reject"
+            elif choice in ("s", "skip"):
+                return "skip"
+            elif choice in ("v", "view", "d", "diff"):
+                return "view"
+            elif choice in ("q", "quit", "exit"):
+                return "quit"
+            else:
+                con.print("[dim]Invalid choice. Try a/r/s/v/q[/dim]")
+        except (EOFError, KeyboardInterrupt):
+            return "quit"
+
+
+def _apply_patch(patch: Patch, root: Path) -> bool:
+    """Apply a patch."""
+    from patchi.core.fix.applier import PatchApplier
+
+    applier = PatchApplier(root)
+    result = applier.apply(patch)
+    return result.success
+
+
+def run(
+    patch_id: str | None = None,
+    root: Path | None = None,
+) -> None:
+    """Entry point for `p fix review`."""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(format_error(str(e)))
+        return
+
+    con.print()
+    con.print(format_header("Fix Review", "Review and decide on proposed patches"))
+    con.print()
+
+    patches = _load_pending_patches(r)
+
+    if not patches:
+        con.print("[dim]No pending patches to review.[/dim]")
+        con.print()
+        con.print("[dim]Run [bold]p fix[/bold] to generate patches first.[/dim]")
+        con.print()
+        return
+
+    # Filter by patch_id if specified
+    if patch_id:
+        patches = [p for p in patches if p.id == patch_id]
+        if not patches:
+            con.print(f"[red]Patch {patch_id} not found or not pending.[/red]")
+            return
+
+    total = len(patches)
+    accepted = 0
+    rejected = 0
+    skipped = 0
+
+    con.print(f"[dim]{total} patch(es) to review[/dim]")
+
+    for i, patch in enumerate(patches):
+        _display_patch(patch, i, total)
+
+        action = _prompt_action()
+
+        if action == "accept":
+            if _apply_patch(patch, r):
+                _save_patch_status(r, patch.id, accepted=True)
+                con.print(f"[green]✓ Patch {patch.id} applied successfully[/green]")
+                accepted += 1
+            else:
+                con.print(f"[red]✗ Failed to apply patch {patch.id}[/red]")
+        elif action == "reject":
+            _save_patch_status(r, patch.id, accepted=False)
+            con.print(f"[yellow]✗ Patch {patch.id} rejected[/yellow]")
+            rejected += 1
+        elif action == "skip":
+            con.print(f"[dim]– Patch {patch.id} skipped[/dim]")
+            skipped += 1
+        elif action == "view":
+            # Show diff again (already shown above)
+            con.print("[dim]Diff shown above. Continuing...[/dim]")
+            # Re-prompt in a loop
+            while True:
+                action2 = _prompt_action()
+                if action2 == "accept":
+                    if _apply_patch(patch, r):
+                        _save_patch_status(r, patch.id, accepted=True)
+                        con.print(f"[green]✓ Patch {patch.id} applied successfully[/green]")
+                        accepted += 1
+                    else:
+                        con.print(f"[red]✗ Failed to apply patch {patch.id}[/red]")
+                    break
+                elif action2 == "reject":
+                    _save_patch_status(r, patch.id, accepted=False)
+                    con.print(f"[yellow]✗ Patch {patch.id} rejected[/yellow]")
+                    rejected += 1
+                    break
+                elif action2 == "skip":
+                    con.print(f"[dim]– Patch {patch.id} skipped[/dim]")
+                    skipped += 1
+                    break
+                elif action2 == "quit":
+                    break
+                # If they chose "view" again, just loop
+        elif action == "quit":
+            break
+
+        con.print()
+
+    # Summary
+    items = {
+        "Accepted": accepted > 0,
+        "Rejected": rejected > 0,
+        "Skipped": skipped > 0,
+        "Remaining": total - accepted - rejected - skipped > 0,
+    }
+
+    con.print(summary_panel("Review Complete", items))
+    con.print()
+    con.print(f"[dim]Accepted: {accepted} | Rejected: {rejected} | Skipped: {skipped}[/dim]")
+    con.print()

patchi/cli/commands/heatmap_cmd.py

@@ -0,0 +1,62 @@
+"""
+p heatmap — Risk Heatmap §9.1.3 color-coded file map of bug-prone hotspots.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from rich.panel import Panel
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+
+
+def run(json_output: bool = False, root: Path | None = None) -> None:
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+    from patchi.core.brain.heatmap import build_heatmap
+
+    data = build_heatmap(r)
+    if json_output:
+        con.print(json.dumps(data, indent=2))
+        return
+    hotspots = data.get("hotspots", [])
+    if not hotspots:
+        con.print("[dim]No hotspots — run `p scan` first.[/dim]")
+        return
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("File", style="bold #F2EDD6", width=50)
+    table.add_column("Score", justify="right", width=8)
+    table.add_column("Severity", width=10)
+    table.add_column("Findings", justify="right", width=9)
+    for h in hotspots[:15]:
+        sev = h.get("severity", "low")
+        color = {"critical": "#FF4D6D", "high": "#FF8C42", "medium": "#FACC15", "low": "#4ADE80"}.get(sev, "dim")
+        table.add_row(h["file"][:50], f"{h['score']:.1f}", f"[{color}]{sev}[/{color}]", str(next((c for c in data['tree']['children'] if False), "")))
+    # findings count per hotspot already in score, show directly
+    # rebuild with findings
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("File", style="bold #F2EDD6")
+    table.add_column("Score", justify="right")
+    table.add_column("Severity")
+    for h in hotspots[:15]:
+        sev = h.get("severity", "low")
+        color = {"critical": "#FF4D6D", "high": "#FF8C42", "medium": "#FACC15", "low": "#4ADE80"}.get(sev, "dim")
+        table.add_row(h["file"], f"{h['score']:.1f}", f"[{color}]{sev}[/{color}]")
+    con.print()
+    con.print(Panel(table, title="🔥 Risk Heatmap — bug-prone hotspots (score = findings×10 + churn×2 + size/10)", border_style="#C8621A"))
+    con.print(f"\n[dim]Total files with findings: {data.get('total_files', 0)} — tree stored for web D3 treemap at .patchi/heatmap.json[/dim]")
+    # persist for web
+    try:
+        out = r / ".patchi" / "heatmap.json"
+        out.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except Exception as _exc:
+        logging.getLogger("patchi").debug('suppressed: %s', _exc)
+    con.print()

patchi/cli/commands/help_cmd.py

@@ -0,0 +1,159 @@
+"""
+`p help` — Show command help.
+
+Also provides `p command` — List all commands with their tags and descriptions.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from patchi.cli.registry import COMMANDS
+
+
+def _collect_commands(commands: list, prefix: str = "") -> list[dict]:
+    """Recursively collect all commands with their metadata."""
+    result = []
+    for cmd in commands:
+        full_name = f"{prefix}{cmd.name}" if prefix else cmd.name
+        entry = {
+            "name": full_name,
+            "help": cmd.help,
+            "handler": cmd.handler,
+            "namespace_handler": cmd.namespace_handler,
+            "args": [],
+            "subcommands": [],
+        }
+        if cmd.args:
+            for arg in cmd.args:
+                entry["args"].append({
+                    "name": arg.name,
+                    "help": arg.help,
+                    "type": getattr(arg, "type", "string"),
+                    "required": getattr(arg, "required", False),
+                    "choices": getattr(arg, "choices", None),
+                    "default": getattr(arg, "default", None),
+                    "action": getattr(arg, "action", None),
+                    "nargs": getattr(arg, "nargs", None),
+                    "dest": getattr(arg, "dest", None),
+                })
+        if cmd.subcommands:
+            entry["subcommands"] = _collect_commands(cmd.subcommands, full_name + " ")
+        result.append(entry)
+    return result
+
+
+def _print_commands_table(commands: list[dict], show_all: bool = False) -> None:
+    """Print commands in a formatted table."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(title="Patchi Commands", show_header=True, header_style="bold cyan")
+    table.add_column("Command", style="green", no_wrap=True)
+    table.add_column("Description", style="white")
+    if show_all:
+        table.add_column("Args", style="yellow")
+        table.add_column("Subcommands", style="blue")
+
+    for cmd in commands:
+        if show_all:
+            args_str = ""
+            if cmd["args"]:
+                args_list = []
+                for arg in cmd["args"]:
+                    arg_str = arg["name"]
+                    if arg.get("help"):
+                        arg_str += f" - {arg['help']}"
+                    if arg.get("required"):
+                        arg_str += " (required)"
+                    if arg.get("choices"):
+                        arg_str += f" [choices: {', '.join(arg['choices'])}]"
+                    if arg.get("default") is not None:
+                        arg_str += f" [default: {arg['default']}]"
+                    args_list.append(arg_str)
+                args_str = "\n".join(args_list)
+
+            subc_str = ""
+            if cmd["subcommands"]:
+                subc_list = []
+                for sub in cmd["subcommands"]:
+                    subc_list.append(f"{sub['name']} - {sub['help']}")
+                subc_str = "\n".join(subc_list)
+
+            table.add_row(cmd["name"], cmd["help"], args_str, subc_str)
+        else:
+            table.add_row(cmd["name"], cmd["help"])
+
+    console.print(table)
+
+
+def _write_command_list_md(commands: list[dict], output_path: Path) -> None:
+    """Write the command list to a Markdown file."""
+    lines = [
+        "# Patchi Command Reference",
+        "",
+        "Auto-generated from the command registry. **Do not edit manually.**",
+        "When adding a new command, update this file by running `p command --write-md`.",
+        "",
+        "## Commands",
+        "",
+    ]
+
+    def write_cmds(cmds: list[dict], indent: int = 0):
+        for cmd in cmds:
+            prefix = "  " * indent
+            lines.append(f"{prefix}- **{cmd['name']}**: {cmd['help']}")
+            if cmd["args"]:
+                lines.append(f"{prefix}  - Arguments:")
+                for arg in cmd["args"]:
+                    req = " (required)" if arg.get("required") else ""
+                    choices = f" (choices: {', '.join(arg['choices'])})" if arg.get("choices") else ""
+                    default = f" (default: {arg['default']})" if arg.get("default") is not None else ""
+                    lines.append(f"{prefix}    - `{arg['name']}`{req}{choices}{default}: {arg.get('help', '')}")
+            if cmd["subcommands"]:
+                lines.append(f"{prefix}  - Subcommands:")
+                write_cmds(cmd["subcommands"], indent + 2)
+
+    write_cmds(commands)
+    output_path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def run(args) -> None:
+    """Entry point for `p help` and `p command`."""
+    import sys
+
+    # Check if called as `p command` (first arg after command)
+    if len(sys.argv) > 1 and sys.argv[1] == "command":
+        # `p command [--all] [--json] [--write-md]`
+        import argparse
+
+        parser = argparse.ArgumentParser(prog="p command")
+        parser.add_argument("--all", action="store_true", help="Show all commands with arguments and subcommands")
+        parser.add_argument("--json", action="store_true", help="Output as JSON")
+        parser.add_argument("--write-md", action="store_true", help="Write command_list.md")
+        sub_args = parser.parse_args(sys.argv[2:])
+
+        all_cmds = _collect_commands(COMMANDS)
+
+        if sub_args.write_md:
+            output_path = Path("command_list.md")
+            _write_command_list_md(all_cmds, output_path)
+            return
+
+        if sub_args.json:
+            return
+
+        _print_commands_table(all_cmds, show_all=sub_args.all)
+        return
+
+    # Original `p help` behavior
+    group = getattr(args, "group", None)
+    if group:
+        # Filter commands by group
+        filtered = [c for c in COMMANDS if c.name.startswith(group)]
+        if not filtered:
+            return
+        _print_commands_table(_collect_commands(filtered))
+    else:
+        _print_commands_table(_collect_commands(COMMANDS))