patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/cockpit_cmd.py

@@ -0,0 +1,208 @@
+"""
+`p cockpit` — the live cockpit (a single glanceable dashboard for a coding session).
+
+    p cockpit                 live dashboard, refreshes as you save files
+    p cockpit --area src/api  scope the fix list to a subtree
+    p cockpit --once          render one frame and exit (CI / smoke test)
+    p cockpit --interval 30   seconds between full health/drift refreshes
+
+It is a *view layer only*: every number comes from signals Patchi already
+computes (health score, Plan-vs-Built drift, Prioritized Fix List, blast radius,
+secrets sweep). No new analysis lives here.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from rich.console import Group
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from patchi.cli.console import con
+from patchi.core.brain import cockpit as ck
+from patchi.core.config import require_project_root
+
+_FIX_LABEL = {
+    "charter_violation": ("Charter", "#FF4D6D"),
+    "signature_callers": ("Breaking", "#FF8C42"),
+    "missing_import": ("Missing import", "#FACC15"),
+    "dead_code": ("Dead code", "#9AA0A6"),
+    "unused_import": ("Unused import", "#9AA0A6"),
+    "format": ("Format", "#86EFAC"),
+}
+_LEVEL_STYLE = {"info": "#86EFAC", "warn": "#FACC15", "crit": "#FF4D6D"}
+
+
+# ── Panels ───────────────────────────────────────────────────────────────────────
+
+
+def _header(state: ck.CockpitState) -> Panel:
+    t = Table.grid(expand=True)
+    t.add_column(justify="left")
+    t.add_column(justify="right")
+
+    if state.health_total is None:
+        health = Text("Health  —  (run `p scan`)", style="#9AA0A6")
+    else:
+        health = Text.assemble(
+            ("Health  ", "#F2EDD6"),
+            (f"{state.health_total}", f"bold {state.health_color}"),
+            (f"  {state.health_grade}", state.health_color),
+        )
+
+    drift = state.drift or {}
+    if not drift.get("has_plan"):
+        plan = Text("Plan  no baseline (`p audit save`)", style="#9AA0A6")
+    elif drift.get("clean"):
+        plan = Text("Plan  ✓ ON PLAN", style="bold #86EFAC")
+    else:
+        sd = drift.get("scope_diff", {}) or {}
+        delta = sd.get("added_count", 0) + sd.get("removed_count", 0) + sd.get("modified_count", 0)
+        nf = drift.get("new_findings", 0)
+        plan = Text.assemble(
+            ("Plan  ⚠ DRIFT", "bold #FF4D6D"),
+            (f"  ({delta} file Δ, +{nf} findings)", "#FF8C42"),
+        )
+
+    t.add_row(health, plan)
+    return Panel(t, border_style="#2A3D28", padding=(0, 1))
+
+
+def _fix_panel(state: ck.CockpitState) -> Panel:
+    if not state.fixes:
+        if state.fixes_computing or state.fixes_at == 0:
+            body = Text("Computing fix list…", style="#FACC15")
+        else:
+            body = Text("No fixes proposed — clean, or run `p scan` first.", style="#9AA0A6")
+        return Panel(
+            body, title="[bold #C8621A]Prioritized Fix List[/bold #C8621A]", border_style="#2A3D28"
+        )
+
+    tbl = Table(show_header=True, header_style="dim", box=None, expand=True, pad_edge=False)
+    tbl.add_column("#", justify="right", width=2, style="dim")
+    tbl.add_column("Type", width=14)
+    tbl.add_column("Where", overflow="ellipsis", no_wrap=True)
+    tbl.add_column("", justify="right", width=6)
+
+    for i, f in enumerate(state.fixes[:12], 1):
+        label, color = _FIX_LABEL.get(f["fix_type"], (f["fix_type"], "#F2EDD6"))
+        where = f["file"] + (f" · {f['name']}" if f["name"] else "")
+        tag = Text("safe", style="#86EFAC") if f["safe"] else Text("review", style="#FF8C42")
+        tbl.add_row(str(i), Text(label, style=color), where, tag)
+
+    extra = len(state.fixes) - 12
+    title = f"[bold #C8621A]Prioritized Fix List[/bold #C8621A] [dim]({len(state.fixes)})[/dim]"
+    grp = Group(tbl, Text(f"  +{extra} more…", style="dim")) if extra > 0 else tbl
+    return Panel(grp, title=title, border_style="#2A3D28")
+
+
+def _blast_panel(state: ck.CockpitState) -> Panel:
+    if not state.last_file:
+        body = Text("Save a file to see its blast radius.", style="#9AA0A6")
+        return Panel(
+            body, title="[bold #C8621A]Blast Radius[/bold #C8621A]", border_style="#2A3D28"
+        )
+
+    lines: list = [Text(state.blast_summary or "", style="#F2EDD6"), Text("")]
+    if state.blast_affected:
+        lines.append(Text("Directly affected:", style="bold #F2EDD6"))
+        lines += [Text(f"  • {n}", style="#F2EDD6") for n in state.blast_affected]
+    if state.blast_impacted:
+        lines.append(Text("Downstream (blast):", style="bold #FF8C42"))
+        lines += [Text(f"  • {n}", style="#FF8C42") for n in state.blast_impacted]
+    elif state.blast_affected:
+        lines.append(Text("No downstream dependents.", style="dim"))
+
+    title = f"[bold #C8621A]Blast Radius[/bold #C8621A] [dim]{state.last_file}[/dim]"
+    return Panel(Group(*lines), title=title, border_style="#2A3D28")
+
+
+def _events_panel(state: ck.CockpitState) -> Panel:
+    if not state.events:
+        body = Text("Watching…", style="#9AA0A6")
+    else:
+        rows = []
+        for ev in list(state.events)[-8:]:
+            style = _LEVEL_STYLE.get(ev.level, "#F2EDD6")
+            mark = {"info": "·", "warn": "▲", "crit": "✖"}.get(ev.level, "·")
+            rows.append(
+                Text.assemble(
+                    (f"{ev.stamp()} ", "dim"),
+                    (f"{mark} ", style),
+                    (ev.text, style),
+                )
+            )
+        body = Group(*rows)
+    sec = f" · [#FF4D6D]{len(state.secrets)} secret(s)[/#FF4D6D]" if state.secrets else ""
+    return Panel(body, title=f"[bold #C8621A]Events[/bold #C8621A]{sec}", border_style="#2A3D28")
+
+
+# ── Layout ─────────────────────────────────────────────────────────────────────
+
+
+def _build_layout() -> Layout:
+    root = Layout()
+    root.split_column(
+        Layout(name="header", size=3),
+        Layout(name="body", ratio=1),
+        Layout(name="events", size=10),
+    )
+    root["body"].split_row(Layout(name="fixes"), Layout(name="blast"))
+    return root
+
+
+def _render(layout: Layout, state: ck.CockpitState) -> None:
+    layout["header"].update(_header(state))
+    layout["fixes"].update(_fix_panel(state))
+    layout["blast"].update(_blast_panel(state))
+    layout["events"].update(_events_panel(state))
+
+
+# ── Entry point ────────────────────────────────────────────────────────────────
+
+
+def run(
+    root: Path | None = None,
+    interval: float = 15.0,
+    area: str | None = None,
+    once: bool = False,
+    poll: float = 1.0,
+    scan_secrets: bool = False,
+) -> None:
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    state = ck.gather_full(r, area=area, scan_secrets=scan_secrets, fixes_sync=once)
+    layout = _build_layout()
+    _render(layout, state)
+
+    if once:
+        con.print(layout)
+        return
+
+    watcher = ck.SourceWatcher(r)
+    con.print("[dim]Cockpit live — press Ctrl+C to exit.[/dim]")
+    try:
+        with Live(layout, console=con, refresh_per_second=4, screen=True):
+            last_full = time.time()
+            while True:
+                changed = watcher.poll()
+                if changed:
+                    ck.refresh_on_change(state, changed)
+                    ck.refresh_fixes_async(state)
+                if time.time() - last_full >= interval:
+                    ck.update_metrics(state)
+                    ck.refresh_fixes_async(state)
+                    last_full = time.time()
+                _render(layout, state)
+                time.sleep(poll)
+    except KeyboardInterrupt:
+        con.print("[dim]Cockpit closed.[/dim]")

patchi/cli/commands/commands_cmd.py

@@ -0,0 +1,160 @@
+"""
+Commands command — shows command families and their subcommands.
+
+Usage:
+    p commands                    → lists all families with descriptions
+    p commands --flat             → alphabetical list of all commands
+    p commands --search <q>       → search commands by name/description
+    p <family> commands           → shows subcommands in that family
+"""
+
+from __future__ import annotations
+
+import sys
+
+from rich.table import Table
+
+from patchi.cli.command_families import (
+    FAMILIES,
+    format_all_families,
+    format_family_help,
+    get_family,
+    list_families,
+)
+from patchi.cli.console import con
+from patchi.cli.ux import format_header, colored_status
+
+
+def run(args=None):
+    """Handle the commands command."""
+    if args is None:
+        args = sys.argv[1:]
+
+    # Parse arguments
+    flat = "--flat" in args
+    search = None
+    for i, arg in enumerate(args):
+        if arg == "--search" and i + 1 < len(args):
+            search = args[i + 1]
+            break
+
+    if flat:
+        _print_flat_commands()
+    elif search:
+        _search_commands(search)
+    else:
+        _print_families()
+
+
+def _print_families():
+    """Print all families with descriptions."""
+    con.print()
+    con.print(format_header("Patchi Command Families"))
+    con.print()
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Family", style="cyan", ratio=1)
+    table.add_column("Description", ratio=3)
+    table.add_column("Subcommands", ratio=2)
+
+    for family in list_families():
+        cmds = ", ".join(family.commands[:5]) if family.commands else "—"
+        if len(family.commands) > 5:
+            cmds += f" (+{len(family.commands) - 5} more)"
+        table.add_row(
+            f"p {family.name}",
+            family.description,
+            f"[dim]{cmds}[/dim]",
+        )
+
+    con.print(table)
+    con.print()
+    con.print("[dim]Use 'p <family> commands' to see all subcommands in a family.[/dim]")
+    con.print()
+
+
+def _print_flat_commands():
+    """Print all commands in alphabetical order."""
+    all_commands = []
+    for family in list_families():
+        all_commands.append((family.name, family.description))
+        for cmd in family.commands:
+            all_commands.append((f"{family.name} {cmd}", family.description))
+
+    all_commands.sort(key=lambda x: x[0])
+
+    con.print()
+    con.print(format_header("All Patchi Commands"))
+    con.print()
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Command", style="cyan", ratio=1)
+    table.add_column("Description", ratio=3)
+
+    for cmd, desc in all_commands:
+        table.add_row(f"p {cmd}", desc)
+
+    con.print(table)
+    con.print()
+
+
+def _search_commands(query: str):
+    """Search commands by name or description."""
+    query = query.lower()
+    results = []
+
+    for family in list_families():
+        # Check family name and description
+        if query in family.name.lower() or query in family.description.lower():
+            results.append((family.name, family.description, "family"))
+
+        # Check subcommands
+        for cmd in family.commands:
+            if query in cmd.lower():
+                results.append((f"{family.name} {cmd}", family.description, "subcommand"))
+
+    con.print()
+    if results:
+        con.print(format_header(f"Commands matching '{query}'"))
+        con.print()
+
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("Command", style="cyan", ratio=1)
+        table.add_column("Description", ratio=2)
+        table.add_column("Type", ratio=1)
+
+        for cmd, desc, cmd_type in results:
+            type_style = "blue" if cmd_type == "family" else "dim"
+            table.add_row(f"p {cmd}", desc, f"[{type_style}]{cmd_type}[/{type_style}]")
+
+        con.print(table)
+    else:
+        con.print(f"[yellow]No commands found matching '{query}'[/yellow]")
+
+    con.print()
+
+
+def run_family_commands(family_name: str):
+    """Show commands for a specific family."""
+    family = get_family(family_name)
+    if family:
+        con.print()
+        con.print(format_header(f"p {family.name}", family.description))
+        con.print()
+
+        if family.commands:
+            table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+            table.add_column("Command", style="cyan", ratio=1)
+            table.add_column("Full Command", ratio=2)
+
+            for cmd in family.commands:
+                table.add_row(cmd, f"p {family.name} {cmd}")
+
+            con.print(table)
+        else:
+            con.print("[dim]No subcommands — use 'p {family.name}' directly.[/dim]")
+
+        con.print()
+    else:
+        con.print(f"[red]Unknown family: {family_name}[/red]")
+        con.print(f"[dim]Available families: {', '.join(sorted(FAMILIES.keys()))}[/dim]")

patchi/cli/commands/cross_repo_cmd.py

@@ -0,0 +1,113 @@
+"""
+Cross-repo CLI command.
+
+Runs cross-repository intelligence analysis to find
+Routes, Channels, and HTTP calls across multiple indexed projects.
+"""
+
+from __future__ import annotations
+
+
+def run(args):
+    """Entry point for the cross-repo command."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+
+    console = Console()
+
+    # Accept either the main.py subparser shape (action / --target) or the
+    # module's own register() shape (projects / --all / --mode).
+    target_projects = list(getattr(args, "projects", None) or [])
+    if getattr(args, "target", None):
+        target_projects = [args.target]
+    mode = getattr(args, "mode", None) or "cross-repo-intelligence"
+    action = getattr(args, "action", None)
+    if action == "health":
+        mode = "health"
+    elif action == "fix":
+        mode = "fix"
+    all_flag = getattr(args, "all", False)
+
+    if not target_projects:
+        console.print("[yellow]No target projects specified.[/yellow]")
+        console.print("Usage: p cross-repo project1 project2 [project3 ...]")
+        console.print("Or: p cross-repo --all  (analyze all indexed projects)")
+        return
+
+    console.print(
+        Panel(
+            f"[bold]Cross-Repository Intelligence[/bold]\n"
+            f"Mode: {mode}\n"
+            f"Targets: {', '.join(target_projects)}",
+            border_style="blue",
+        )
+    )
+
+    try:
+        from patchi.codebase_memory import index_repository, list_projects
+
+        if all_flag:
+            all_projects = list_projects()
+            target_projects = [p["name"] for p in all_projects if p.get("name")]
+            console.print(f"[dim]Found {len(target_projects)} indexed projects[/dim]")
+
+        if len(target_projects) < 2:
+            console.print("[red]Need at least 2 projects for cross-repo analysis.[/red]")
+            return
+
+        console.print(
+            f"\n[bold]Running cross-repo intelligence on {len(target_projects)} projects...[/bold]\n"
+        )
+
+        results = index_repository(
+            repo_path=".",
+            mode="cross-repo-intelligence",
+            target_projects=target_projects,
+        )
+
+        if not results:
+            console.print("[yellow]No cross-repo links found.[/yellow]")
+            return
+
+        table = Table(title="Cross-Repository Links", border_style="green")
+        table.add_column("Source", style="cyan")
+        table.add_column("Target", style="magenta")
+        table.add_column("Type", style="yellow")
+        table.add_column("Detail", style="white")
+
+        for link in results if isinstance(results, list) else []:
+            source = str(link.get("source", link.get("from", "")))
+            target = str(link.get("target", link.get("to", "")))
+            link_type = str(link.get("type", link.get("edge_type", "")))
+            detail = str(link.get("detail", link.get("label", "")))[:80]
+            table.add_row(source, target, link_type, detail)
+
+        console.print(table)
+        console.print(
+            f"\n[green]Found {len(results) if isinstance(results, list) else 0} cross-repo links.[/green]"
+        )
+
+    except ImportError:
+        console.print("[red]codebase-memory module not available.[/red]")
+        console.print("Install it with: pip install codebase-memory")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+def register(subparsers):
+    """Register the cross-repo subcommand."""
+    parser = subparsers.add_parser(
+        "cross-repo",
+        help="Cross-repository intelligence analysis",
+        description="Find Routes, Channels, and HTTP calls across multiple indexed projects.",
+    )
+    parser.add_argument("projects", nargs="*", help="Target project names to analyze")
+    parser.add_argument("--all", action="store_true", help="Analyze all indexed projects")
+    parser.add_argument(
+        "--mode",
+        default="cross-repo-intelligence",
+        help="Analysis mode (default: cross-repo-intelligence)",
+    )
+    parser.set_defaults(func=run)
+    return parser

patchi/cli/commands/deps_cmd.py

@@ -0,0 +1,110 @@
+"""
+`p deps` — Supply chain security scan.
+
+Usage:
+  p deps                        — run all dependency checks
+  p deps --sbom                 — generate SBOM
+  p deps --licenses             — check license compliance
+  p deps --outdated             — check for outdated packages
+  p deps --cve                  — check for known CVEs
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from patchi.cli.console import con
+from patchi.cli.display.live_progress import LiveProgress
+from patchi.core.agents.base import AgentGroup, AgentInput, list_agents
+from patchi.core.config import require_project_root
+
+
+def run(
+    sbom: bool = False,
+    licenses: bool = False,
+    outdated: bool = False,
+    cve: bool = False,
+    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 import config as cfg_mod
+    from patchi.core import memory as mem
+
+    brain = mem.get_brain(r)
+    config = cfg_mod.load(r)
+
+    all_agents = {a.name: a for a in list_agents(AgentGroup.SECURITY)}
+    target_agents = []
+
+    no_flags = not any([sbom, licenses, outdated, cve])
+    if cve or no_flags:
+        target_agents.append("CVEMonitorAgent")
+        target_agents.append("DependencyCVEChecker")
+    if sbom or licenses or no_flags:
+        target_agents.append("SupplyChainAgent")
+    if outdated or no_flags:
+        target_agents.append("DependencyVulnerabilityAgent")
+
+    target_agents = list(dict.fromkeys(target_agents))  # dedup
+
+    results = []
+    lp = LiveProgress(con, title="Dependency scan")
+    lp.start()
+    for name in target_agents:
+        cls = all_agents.get(name)
+        if not cls:
+            lp.log(f"  [yellow]Agent {name} not found.[/yellow]")
+            lp.update()
+            continue
+        lp.set_progress(len(results) + 1, len(target_agents), name)
+        lp.log(f"  {name}…")
+        lp.update()
+        inp = AgentInput(
+            root=r,
+            scope=[],
+            brain=brain,
+            config=config,
+            on_message=lambda n, msg, s: (lp.log(f"    {msg}", s), lp.update()),
+        )
+        try:
+            result = cls().run(inp)
+            results.append(result)
+            total_findings = sum(r.finding_count for r in results)
+            lp.set_findings(total_findings)
+            lp.log(f"  [#4ADE80]v[/#4ADE80] {result.finding_count} findings", "")
+        except Exception as e:
+            lp.log(f"  [red]x {name} failed: {e}[/red]", "red")
+        lp.update()
+
+    total_findings = sum(r.finding_count for r in results)
+    lp.stop(summary=f"{len(results)} agents - {total_findings} findings")
+
+    if json_output:
+        import json as _json
+
+        con.print(
+            _json.dumps(
+                {
+                    "agents": [
+                        {
+                            "agent": getattr(res, "agent_name", ""),
+                            "status": getattr(getattr(res, "status", None), "value", ""),
+                            "findings": [
+                                f.to_dict() if hasattr(f, "to_dict") else dict(f)
+                                for f in (getattr(res, "findings", []) or [])
+                            ],
+                        }
+                        for res in results
+                    ],
+                    "total_findings": total_findings,
+                },
+                indent=2,
+                default=str,
+            )
+        )