patchi 0.7.5__py3-none-any.whl

patchi/cli/display/live_audit.py

@@ -0,0 +1,269 @@
+"""
+Live audit display — rich.Live-powered dashboard with collapsible phase panels.
+
+Layout:
+┌─ p audit ──────────────────────────────────────────────────────┐
+│ ◉ Scan        → 47 files · 12 routes · 6 domains · 1.2s      │
+│ ┌──────────────────────────────────────────────────────────────┐│
+│ │  ● Discovering files...                                     ││
+│ │  ● Parsing src/main.py                                      ││
+│ │  ● FastAPI v0.115.0 detected                                ││
+│ │  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   ││
+│ └────────────────────────────────────────────────────────────┘│
+│ ◉ Security    → TaintAnalyzer running (3 findings so far)...   │
+│ ┌────────────────────────────────────────────────────────────┐│
+│ │  ● TaintAnalyzer — scanning src/routes.py                  ││
+│ │  ●   ⚑ Finding #3: Unsafe string concat in query builder  ││
+│ │  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ││
+│ └────────────────────────────────────────────────────────────┘│
+│ ○ Tests       → pending                                       │
+│ ○ Health      → pending                                       │
+└────────────────────────────────────────────────────────────────┘
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn
+from rich.text import Text
+
+_log = logging.getLogger("patchi.cli.live_audit")
+
+
+class PhaseStatus(Enum):
+    PENDING = "○"
+    RUNNING = "◉"
+    DONE = "✓"
+    FAILED = "✗"
+    SKIPPED = "⊘"
+
+
+_PHASE_COLORS = {
+    "scan": "#C8621A",
+    "security": "#4ADE80",
+    "tests": "#60A5FA",
+    "health": "#A78BFA",
+}
+
+
+@dataclass
+class PhaseState:
+    """Mutable state of a single phase. Updated by the audit runner threads."""
+
+    name: str
+    status: PhaseStatus = PhaseStatus.PENDING
+    summary: str = ""
+    duration_ms: int = 0
+    log_lines: list[tuple[str, str]] = field(default_factory=list)  # (style, text)
+    findings: int = 0
+    files_scanned: int = 0
+    total_steps: int = 0
+    current_step: int = 0
+    sub_label: str = ""
+
+
+class LiveAuditDisplay:
+    """
+    Manages a rich.live.Live renderable with collapsible phase panels.
+
+    Thread-safe — call from any thread. The display auto-refreshes.
+    """
+
+    def __init__(self, console: Console | None = None):
+        self.con = console or Console()
+        self._lock = threading.RLock()
+        self._phases: dict[str, PhaseState] = {}
+        self._expanded_phase: str | None = None  # None = auto (latest running)
+        self._live: Live | None = None
+        self._start_time: float = 0.0
+
+    def start(self, title: str = "p audit"):
+        """Start the live display. Must be called from main thread."""
+        self._start_time = time.monotonic()
+        self._live = Live(
+            self._render(),
+            console=self.con,
+            refresh_per_second=8,
+            transient=False,
+            screen=False,
+        )
+        self._live.__enter__()
+
+    def stop(self):
+        """Stop the live display and restore normal terminal."""
+        if self._live:
+            try:
+                self._live.__exit__(None, None, None)
+            except Exception as e:
+                _log.warning("LiveAuditDisplay.stop failed: %s", e)
+            self._live = None
+        self.con.print()
+
+    def phase(self, name: str) -> PhaseState:
+        """Get or create a phase by name."""
+        with self._lock:
+            if name not in self._phases:
+                self._phases[name] = PhaseState(name=name)
+            return self._phases[name]
+
+    def update(self):
+        """Trigger a refresh. Call after modifying any phase state."""
+        if self._live:
+            try:
+                self._live.update(self._render())
+            except Exception as e:
+                _log.warning("LiveAuditDisplay.update failed: %s", e)
+
+    def _render(self) -> RenderableType:
+        """Build the full renderable from current phase states."""
+        with self._lock:
+            elapsed = int((time.monotonic() - self._start_time) * 1000)
+            rows = []
+            color = _PHASE_COLORS
+
+            # Auto-expand the currently running phase
+            running = [p for p in self._phases.values() if p.status == PhaseStatus.RUNNING]
+            expanded = running[0].name if running else None
+
+            for phase_name in ("scan", "security", "tests", "health"):
+                phase = self._phases.get(phase_name)
+                if phase is None:
+                    rows.append(self._render_header_line(phase_name, PhaseStatus.PENDING, "", 0))
+                    continue
+
+                # Header line
+                header = self._render_header_line(
+                    phase_name, phase.status, phase.summary, phase.duration_ms
+                )
+
+                # Expanded body if this phase is running AND the running phase
+                is_expanded = phase_name == expanded
+                if is_expanded and phase.log_lines:
+                    body = self._render_expanded_body(phase)
+                    rows.append(Group(header, body))
+                else:
+                    rows.append(header)
+
+            total_findings = sum(p.findings for p in self._phases.values())
+            total_files = sum(p.files_scanned for p in self._phases.values())
+            footer = Text(
+                f" Total: {total_files} files · {total_findings} findings · {elapsed}ms",
+                style="dim",
+            )
+            grid = Group(*rows, Text(""), footer)
+            return Panel(
+                grid, title=f"[bold]{color.get('audit', '#C8621A')}audit[/bold]", border_style="dim"
+            )
+
+    def _render_header_line(
+        self, name: str, status: PhaseStatus, summary: str, duration_ms: int
+    ) -> RenderableType:
+        """A single-line phase header: ◉ Scan → 47 files · 1.2s"""
+        color = _PHASE_COLORS.get(name, "white")
+        status_icon = status.value
+        status_color = {
+            PhaseStatus.DONE: "green",
+            PhaseStatus.FAILED: "red",
+            PhaseStatus.RUNNING: "yellow",
+            PhaseStatus.PENDING: "dim",
+            PhaseStatus.SKIPPED: "dim",
+        }.get(status, "dim")
+
+        label = name.capitalize()
+        dur = f"· {duration_ms}ms" if duration_ms else ""
+        summary_part = f" → {summary}" if summary else ""
+
+        parts = [
+            f"[{status_color}]{status_icon}[/{status_color}] ",
+            f"[bold {color}]{label:<10}[/bold {color}]",
+        ]
+        if summary_part:
+            parts.append(f"[dim]{summary_part}[/dim]")
+        if duration_ms:
+            parts.append(f"[dim]{dur}[/dim]")
+        return Text.assemble(*parts)
+
+    def _render_expanded_body(self, phase: PhaseState) -> RenderableType:
+        """Expanded panel showing live log lines + progress bar."""
+        lines = []
+        for style, text in phase.log_lines:
+            if style:
+                lines.append(Text(text, style=style))
+            else:
+                lines.append(Text(text))
+
+        # Progress bar if there are sub-steps
+        if phase.total_steps > 0:
+            progress = Progress(
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                TimeElapsedColumn(),
+                console=self.con,
+            )
+            task_id = progress.add_task(
+                phase.sub_label or "",
+                total=phase.total_steps,
+                completed=phase.current_step,
+            )
+            progress.update(task_id, completed=phase.current_step)
+            lines.append(Text(""))
+            lines.append(progress)
+
+        # If findings found during live phase, show count
+        if phase.findings:
+            lines.append(Text(f"\n  ⚑ {phase.findings} finding(s) so far", style="yellow"))
+
+        panel = Panel(
+            Group(*lines),
+            border_style="dim",
+            padding=(0, 1),
+            width=None,
+        )
+        return panel
+
+    def log(self, phase_name: str, message: str, style: str = ""):
+        """Append a log line to a phase."""
+        with self._lock:
+            phase = self.phase(phase_name)
+            # Keep last 50 lines
+            phase.log_lines.append((style, message))
+            if len(phase.log_lines) > 50:
+                phase.log_lines = phase.log_lines[-50:]
+
+    def set_phase_status(
+        self,
+        name: str,
+        status: PhaseStatus,
+        summary: str = "",
+        duration_ms: int = 0,
+        findings: int = 0,
+        files_scanned: int = 0,
+    ):
+        with self._lock:
+            phase = self.phase(name)
+            phase.status = status
+            if summary:
+                phase.summary = summary
+            if duration_ms:
+                phase.duration_ms = duration_ms
+            if findings:
+                phase.findings = findings
+            if files_scanned:
+                phase.files_scanned = files_scanned
+
+    def set_phase_progress(self, name: str, current: int, total: int, label: str = ""):
+        with self._lock:
+            phase = self.phase(name)
+            phase.total_steps = total
+            phase.current_step = current
+            if label:
+                phase.sub_label = label

patchi/cli/display/live_progress.py

@@ -0,0 +1,169 @@
+"""
+Lightweight live progress display for single-command streaming.
+
+Shows an inline updating panel with:
+- Title header
+- Live log lines (ring buffer, last 20 shown)
+- Optional step-based progress bar
+- Auto-collapse to one-line summary when stopped
+
+Thread-safe — call from any thread.
+No screen/alt-screen mode — works inline in the terminal.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn
+from rich.text import Text
+
+_log = logging.getLogger("patchi.cli.live_progress")
+
+
+@dataclass
+class _ProgressState:
+    log_lines: list[tuple[str, str]] = field(default_factory=list)
+    total_steps: int = 0
+    current_step: int = 0
+    sub_label: str = ""
+    findings: int = 0
+    status_text: str = "running…"
+    done: bool = False
+    failed: bool = False
+
+
+class LiveProgress:
+    """
+    Inline live progress display for a single command.
+
+    Usage:
+        lp = LiveProgress(console, title="p security")
+        lp.start()
+        lp.log("Scanning foo.py")
+        lp.set_progress(5, 10, "TaintAnalyzer")
+        lp.update()
+        lp.stop(summary="3 findings in 1.2s")
+    """
+
+    def __init__(self, console: Console | None = None, title: str = "progress"):
+        self.con = console or Console()
+        self._title = title
+        self._lock = threading.RLock()
+        self._state = _ProgressState()
+        self._live: Live | None = None
+        self._start_time: float = 0.0
+
+    def start(self):
+        self._start_time = time.monotonic()
+        self._live = Live(
+            self._render(),
+            console=self.con,
+            refresh_per_second=8,
+            transient=False,
+            screen=False,
+        )
+        self._live.__enter__()
+
+    def stop(self, summary: str = ""):
+        if self._live:
+            with self._lock:
+                self._state.done = True
+            self._live.update(self._render())
+            try:
+                self._live.__exit__(None, None, None)
+            except Exception as e:
+                _log.warning("LiveProgress.stop failed: %s", e)
+            self._live = None
+
+        elapsed = int((time.monotonic() - self._start_time) * 1000)
+        if summary:
+            self.con.print(
+                f"  [bold #A78BFA]{self._title}:[/bold #A78BFA] {summary} [dim]({elapsed}ms)[/dim]"
+            )
+
+    def update(self):
+        if self._live:
+            try:
+                self._live.update(self._render())
+            except Exception as e:
+                _log.warning("LiveProgress.update failed: %s", e)
+
+    def log(self, message: str, style: str = ""):
+        with self._lock:
+            self._state.log_lines.append((style, message))
+            if len(self._state.log_lines) > 50:
+                self._state.log_lines = self._state.log_lines[-50:]
+
+    def set_progress(self, current: int, total: int, label: str = ""):
+        with self._lock:
+            self._state.total_steps = total
+            self._state.current_step = current
+            if label:
+                self._state.sub_label = label
+
+    def set_findings(self, count: int):
+        with self._lock:
+            self._state.findings = count
+
+    def set_status(self, text: str):
+        with self._lock:
+            self._state.status_text = text
+
+    def _render(self) -> RenderableType:
+        with self._lock:
+            lines = []
+            for style, text in self._state.log_lines[-20:]:
+                if style:
+                    lines.append(Text(text, style=style))
+                else:
+                    lines.append(Text(text))
+
+            # Progress bar
+            if self._state.total_steps > 0 and not self._state.done:
+                progress = Progress(
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                    TimeElapsedColumn(),
+                    console=self.con,
+                )
+                task_id = progress.add_task(
+                    self._state.sub_label or "",
+                    total=self._state.total_steps,
+                    completed=self._state.current_step,
+                )
+                progress.update(task_id, completed=self._state.current_step)
+                lines.append(Text(""))
+                lines.append(progress)
+
+            # Findings counter
+            if self._state.findings:
+                lines.append(Text(f"  ! {self._state.findings} finding(s)", style="yellow"))
+
+            elapsed = int((time.monotonic() - self._start_time) * 1000) if self._start_time else 0
+            footer = Text(
+                f" {self._state.status_text}  - {elapsed}ms",
+                style="dim",
+            )
+
+            grid = Group(*lines, Text(""), footer)
+            icon = (
+                "[#4ADE80]v[/#4ADE80]"
+                if self._state.done and not self._state.failed
+                else "[red]x[/red]"
+                if self._state.failed
+                else "[yellow]~[/yellow]"
+            )
+            return Panel(
+                grid,
+                title=f"{icon} [bold #A78BFA]{self._title}[/bold #A78BFA]",
+                border_style="dim",
+                padding=(0, 1),
+            )

patchi/cli/framework.py

@@ -0,0 +1,241 @@
+"""
+Command framework — §3 Command Unification.
+
+Replaces the three-places-to-edit pattern (lazy-import factory function +
+argparse subparser block + elif dispatch chain) with one declarative
+`Command` per command, registered once in `registry.py`.
+
+Design note (refinement made during implementation, not in the original design
+doc): a handful of existing commands read GLOBAL flags (--quiet, --verbose)
+that are defined once on the top-level parser, not re-declared per-subcommand.
+`Arg(global_flag=True)` marks these — the builder skips calling add_argument
+for them (the global parser already defines it), but the dispatcher still
+reads them into the handler's kwargs. Without this distinction, migrating
+`scan` (which reads the global `quiet`) would either duplicate the flag
+definition (argparse conflict) or silently drop the value.
+
+Second design note: the `namespace_handler` shape (see Command). notify,
+hosted, test, security and cross-repo all dispatch on parsed values in ways a
+static Arg->kwarg mapping can't express (e.g. `p test generate` routes to a
+different function than `p test unit`), and their legacy handlers already
+received the whole Namespace. Rather than force those into per-subcommand
+handlers, the framework supports passing the Namespace straight through and
+letting the one handler self-route — `resolve` returns the top command
+regardless of how deep the subcommand path goes.
+
+Lazy loading is preserved exactly as the original factories did: `handler` is
+a dotted string ("module:function"), not a function object — nothing is
+imported until dispatch actually resolves it, so `p --help` / cold start
+stays fast regardless of how many commands are registered.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+_log = logging.getLogger("patchi.cli.framework")
+
+
+@dataclass(frozen=True)
+class Arg:
+    name: str  # "--area" or "area" (positional)
+    help: str = ""
+    default: Any = None
+    action: str | None = None  # "store_true", "store_false", etc.
+    choices: tuple | None = None
+    nargs: str | None = None
+    dest: str | None = None
+    type: type | None = None
+    global_flag: bool = False  # True = already defined on the top-level
+    # parser; don't re-add, just read it
+
+    def resolved_dest(self) -> str:
+        is_positional = not self.name.startswith("-")
+        if is_positional:
+            # argparse always uses the name itself as dest for positionals --
+            # any `dest` set here would be ignored by the real parser, so
+            # resolving it here too keeps kwarg-building consistent with what
+            # actually gets parsed.
+            return self.name.replace("-", "_")
+        if self.dest:
+            return self.dest
+        return self.name.lstrip("-").replace("-", "_")
+
+
+@dataclass(frozen=True)
+class Command:
+    name: str
+    help: str
+    handler: str = ""  # dotted path: "patchi.cli.commands.scan_cmd:run"
+    args: tuple[Arg, ...] = ()
+    subcommands: tuple[Command, ...] = ()
+    aliases: tuple[str, ...] = ()
+    fixed_kwargs: dict = field(default_factory=dict)
+    # ^ For cases where several subcommands share ONE handler but each needs a
+    # different hardcoded value baked in -- e.g. `restrict add`/`scan-only`/
+    # `sensitive` all call the same run_add(path, restriction_type, reason),
+    # only restriction_type differs per subcommand. These values are merged
+    # into the kwargs unconditionally, never derived from parsed args.
+    namespace_handler: bool = False
+    # ^ Self-routing Namespace-handler shape: the handler receives the WHOLE
+    # argparse Namespace (fn(args)) and routes on the subcommand dests itself
+    # (notify_cmd/hosted_cmd/token_cmd...). The subcommand tree is declared
+    # purely for parsing + help — resolve() always returns the top command, so
+    # one function owns the entire command tree. Used by notify, hosted, test,
+    # security, and cross-repo, which all dispatch on parsed values in ways a
+    # static Arg->kwarg mapping cannot express.
+
+
+def _add_args(parser: argparse.ArgumentParser, cmd: Command) -> None:
+    args = cmd.args
+    # Normalize: accept a single Arg or None as well as a list/tuple so a
+    # mis-registered command can never crash parser construction.
+    if args is None:
+        return
+    if isinstance(args, (list, tuple)):
+        arg_list = args
+    else:
+        arg_list = [args]
+    for a in arg_list:
+        if a.global_flag:
+            continue  # already defined on the top-level parser
+        is_positional = not a.name.startswith("-")
+        kwargs: dict[str, Any] = {"help": a.help}
+        if a.action:
+            kwargs["action"] = a.action
+        if a.default is not None:
+            kwargs["default"] = a.default
+        if a.choices:
+            kwargs["choices"] = a.choices
+        if a.nargs:
+            kwargs["nargs"] = a.nargs
+        if a.dest and not is_positional:
+            # argparse forbids dest= on positional args (the name IS the dest) --
+            # only pass it for optional flags. A positional Arg must name itself
+            # exactly what the handler's kwarg expects; there's no override.
+            kwargs["dest"] = a.dest
+        if a.type:
+            kwargs["type"] = a.type
+        parser.add_argument(a.name, **kwargs)
+
+
+def _add_command(sub, cmd: Command) -> None:
+    parser = sub.add_parser(cmd.name, help=cmd.help, aliases=list(cmd.aliases))
+    _add_args(parser, cmd)
+    if cmd.subcommands:
+        sub_sub = parser.add_subparsers(dest=f"{cmd.name}_cmd")
+        for child in cmd.subcommands:
+            _add_command(sub_sub, child)
+
+
+def register_commands(sub, commands: list[Command]) -> None:
+    """
+    Add every registered Command as a subparser on an EXISTING subparsers
+    object. Used during the incremental migration window, where most commands
+    still add themselves to the same `sub` the legacy code creates — this lets
+    registry-driven and legacy-declared commands coexist on one parser tree
+    without either side needing to know about the other.
+    """
+    for cmd in commands:
+        _add_command(sub, cmd)
+
+
+def build_parser(commands: list[Command], base: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    """
+    Standalone variant: builds a brand-new subparsers object on `base` and
+    registers every Command onto it. Only safe to use once nothing else adds
+    subparsers to `base` — during the migration window main.py uses
+    `register_commands` against its own existing `sub` instead.
+    """
+    sub = base.add_subparsers(dest="command")
+    register_commands(sub, commands)
+    return base
+
+
+def _find_command(commands: list[Command], name: str) -> Command | None:
+    for cmd in commands:
+        if cmd.name == name or name in cmd.aliases:
+            return cmd
+    return None
+
+
+def _lazy_import(dotted_handler: str):
+    mod_path, _, func_name = dotted_handler.partition(":")
+    module = importlib.import_module(mod_path)
+    return getattr(module, func_name)
+
+
+def _build_kwargs(cmd: Command, args: argparse.Namespace) -> dict[str, Any]:
+    kwargs = dict(cmd.fixed_kwargs)
+    for a in cmd.args:
+        dest = a.resolved_dest()
+        kwargs[dest] = getattr(args, dest, a.default)
+    return kwargs
+
+
+def resolve(commands: list[Command], args: argparse.Namespace) -> Command | None:
+    """Find the Command (and subcommand, if any) matching parsed args.command."""
+    top_name = getattr(args, "command", None)
+    if top_name is None:
+        return None
+    cmd = _find_command(commands, top_name)
+    if cmd is None:
+        return None
+    if cmd.namespace_handler:
+        # Self-routing command: one handler owns the whole subcommand tree and
+        # routes on the parsed dests itself, so the top Command is what gets
+        # dispatched no matter how deep the invocation went.
+        return cmd
+    if cmd.subcommands:
+        sub_name = getattr(args, f"{cmd.name}_cmd", None)
+        if sub_name:
+            child = _find_command(list(cmd.subcommands), sub_name)
+            if child is not None:
+                return child
+    return cmd
+
+
+def dispatch(commands: list[Command], args: argparse.Namespace):
+    """
+    Resolve the matching Command, lazily import its handler, and call it with
+    kwargs derived from the SAME Arg specs used to build the parser — so
+    parser and dispatch can never drift out of sync (the exact bug class this
+    design exists to eliminate).
+
+    Returns None if no registered Command matches (caller should fall through
+    to the legacy dispatch ladder during the incremental migration window).
+    """
+    cmd = resolve(commands, args)
+
+    # ── Handle `p <family> commands` ──────────────────────────────────────
+    # If the resolved command is a family (test, scan, fix, etc.) and the user
+    # typed `commands` as the subcommand, route to family commands display.
+    if cmd is not None:
+        top_name = getattr(args, "command", None)
+        sub_name = getattr(args, f"{top_name}_cmd", None)
+        if sub_name == "commands":
+            try:
+                from patchi.cli.command_families import get_family
+                from patchi.cli.commands.commands_cmd import run_family_commands
+
+                family = get_family(top_name)
+                if family:
+                    run_family_commands(top_name)
+                    return None, True
+            except Exception as e:
+                _log.debug("Family routing failed for %s: %s", top_name, e)
+
+    if cmd is None:
+        return None, False  # (result, handled) -- not handled, fall through
+    fn = _lazy_import(cmd.handler)
+    if cmd.namespace_handler:
+        # Self-routing shape: hand the whole parsed Namespace to the handler;
+        # it dispatches on the subcommand dests itself. Kwargs are deliberately
+        # not built — the subcommands are parsing/help sugar only.
+        return fn(args), True
+    kwargs = _build_kwargs(cmd, args)
+    return fn(**kwargs), True