patchi 0.7.5__py3-none-any.whl

patchi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.5"

patchi/__main__.py

@@ -0,0 +1,13 @@
+"""Allow running patchi as a module: python -m patchi"""
+
+import sys
+
+
+def main():
+    from patchi.cli.main import main as cli_main
+
+    return cli_main()
+
+
+if __name__ == "__main__":
+    sys.exit(main() or 0)

patchi/cli/command_families.py

@@ -0,0 +1,235 @@
+"""
+Command Families — organized command discovery for Patchi CLI.
+
+Groups commands into families. `p <family>` runs the default action.
+`p <family> commands` shows all subcommands in that family.
+
+Usage:
+    from patchi.cli.command_families import FAMILIES, get_family, list_families
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CommandFamily:
+    """A family of related commands."""
+
+    name: str
+    description: str
+    default_command: str | None = None  # What `p <family>` runs
+    commands: list[str] = field(default_factory=list)  # Subcommands in this family
+    agent_domain: str | None = None  # Linked AgentDomain for agent discovery
+
+
+FAMILIES: dict[str, CommandFamily] = {
+    "test": CommandFamily(
+        name="test",
+        description="Testing — unit, e2e, visual, stress, regression",
+        default_command="test",
+        commands=["unit", "e2e", "visual", "stress", "generate", "report", "config", "regression"],
+        agent_domain="testing",
+    ),
+    "scan": CommandFamily(
+        name="scan",
+        description="Scanning — full analysis, security, structure",
+        default_command="scan",
+        commands=["deep", "security", "structure", "since", "contract", "changed"],
+        agent_domain="code_quality",
+    ),
+    "fix": CommandFamily(
+        name="fix",
+        description="Fixing — propose and apply fixes",
+        default_command="fix",
+        commands=["auto", "review", "patch", "undo", "redo", "rollback"],
+        agent_domain="integration",
+    ),
+    "ready": CommandFamily(
+        name="ready",
+        description="Ship readiness — is my code ready to ship?",
+        default_command="ready",
+        commands=["quick", "ci", "json", "baseline"],
+        agent_domain="testing",
+    ),
+    "security": CommandFamily(
+        name="security",
+        description="Security — vulnerability scanning and hardening",
+        default_command="security",
+        commands=["chains", "findings", "rules", "deps", "assure", "charter", "restrict"],
+        agent_domain="security",
+    ),
+    "web": CommandFamily(
+        name="web",
+        description="Web dashboard — launch and manage the web UI",
+        default_command="web",
+        commands=["host", "port", "open", "project"],
+        agent_domain="infrastructure",
+    ),
+    "status": CommandFamily(
+        name="status",
+        description="Status — project health and monitoring",
+        default_command="status",
+        commands=["doctor", "cockpit", "trend", "heatmap"],
+        agent_domain="infrastructure",
+    ),
+    "audit": CommandFamily(
+        name="audit",
+        description="Auditing — full project audit",
+        default_command="audit",
+        commands=["quick", "plan", "intent", "html", "json"],
+        agent_domain="code_quality",
+    ),
+    "config": CommandFamily(
+        name="config",
+        description="Configuration — settings and preferences",
+        default_command="config",
+        commands=["key", "model", "settings", "brain", "access", "link", "notify", "rules", "plugins"],
+        agent_domain="infrastructure",
+    ),
+    "agent": CommandFamily(
+        name="agent",
+        description="Agents — list, run, and manage agents",
+        default_command="agents",
+        commands=["list", "run", "stats", "reset"],
+        agent_domain="infrastructure",
+    ),
+    "git": CommandFamily(
+        name="git",
+        description="Git — blame and log integration",
+        default_command="git",
+        commands=["blame", "log"],
+        agent_domain="infrastructure",
+    ),
+    "maintain": CommandFamily(
+        name="maintain",
+        description="Maintenance — updates and cleanup",
+        default_command="update",
+        commands=["cleanup", "doctor"],
+        agent_domain="infrastructure",
+    ),
+    "hosted": CommandFamily(
+        name="hosted",
+        description="Hosted — production monitoring",
+        default_command="hosted",
+        commands=["init", "worker", "daemon", "guard", "status", "logs", "token", "block"],
+        agent_domain="infrastructure",
+    ),
+    "ai": CommandFamily(
+        name="ai",
+        description="AI — chat and model configuration",
+        default_command="ai",
+        commands=["status", "test", "add", "remove", "profiles"],
+        agent_domain="infrastructure",
+    ),
+    "report": CommandFamily(
+        name="report",
+        description="Reporting — generate and export reports",
+        default_command="report",
+        commands=["export", "weekly"],
+        agent_domain="testing",
+    ),
+    "init": CommandFamily(
+        name="init",
+        description="Initialize — project setup",
+        default_command="init",
+        commands=["auto", "no-logo"],
+        agent_domain="infrastructure",
+    ),
+    "queue": CommandFamily(
+        name="queue",
+        description="Queue — manage the scan queue",
+        default_command="queue",
+        commands=["pause", "resume", "skip", "mode"],
+        agent_domain="infrastructure",
+    ),
+    "plan": CommandFamily(
+        name="plan",
+        description="Planning — plan changes",
+        default_command="plan",
+        commands=["format", "missing-import"],
+        agent_domain="infrastructure",
+    ),
+    "verify": CommandFamily(
+        name="verify",
+        description="Verify — independent re-run of tests",
+        default_command="verify",
+        commands=[],
+        agent_domain="testing",
+    ),
+    "help": CommandFamily(
+        name="help",
+        description="Help — show help and documentation",
+        default_command="help",
+        commands=["all", "group", "json", "write-md"],
+        agent_domain="infrastructure",
+    ),
+    "watch": CommandFamily(
+        name="watch",
+        description="Watch — auto-scan on file saves",
+        default_command="watch",
+        commands=[],
+        agent_domain="infrastructure",
+    ),
+    "doctor": CommandFamily(
+        name="doctor",
+        description="Doctor — system health check",
+        default_command="doctor",
+        commands=[],
+        agent_domain="infrastructure",
+    ),
+    "trend": CommandFamily(
+        name="trend",
+        description="Trend — historical analysis",
+        default_command="trend",
+        commands=[],
+        agent_domain="testing",
+    ),
+    "memory": CommandFamily(
+        name="memory",
+        description="Memory — persistent context and learning",
+        default_command="memory",
+        commands=[],
+        agent_domain="infrastructure",
+    ),
+}
+
+
+def get_family(name: str) -> CommandFamily | None:
+    """Get a family by name."""
+    return FAMILIES.get(name)
+
+
+def list_families() -> list[CommandFamily]:
+    """List all families in order."""
+    return list(FAMILIES.values())
+
+
+def find_family_for_command(command: str) -> CommandFamily | None:
+    """Find which family a command belongs to."""
+    for family in FAMILIES.values():
+        if command in family.commands or command == family.default_command:
+            return family
+    return None
+
+
+def format_family_help(family: CommandFamily) -> str:
+    """Format help text for a family."""
+    lines = [f"p {family.name} — {family.description}"]
+    if family.commands:
+        lines.append("")
+        lines.append("Subcommands:")
+        for cmd in family.commands:
+            lines.append(f"  p {family.name} {cmd}")
+    return "\n".join(lines)
+
+
+def format_all_families() -> str:
+    """Format help text for all families."""
+    lines = ["Patchi Command Families", "=" * 40, ""]
+    for family in FAMILIES.values():
+        lines.append(f"p {family.name:12} — {family.description}")
+    lines.append("")
+    lines.append("Use 'p <family> commands' to see all subcommands in a family.")
+    return "\n".join(lines)

patchi/cli/commands/access_cmd.py

@@ -0,0 +1,65 @@
+"""
+`p access` — Manage dev access tokens.
+add [--env-var VAR] <name> | list | remove <name>
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from patchi.cli.console import con
+from patchi.core import memory as mem
+
+
+def run(
+    access_cmd: str | None = None,
+    name: str | None = None,
+    env_var: str | None = None,
+    root: Path | None = None,
+) -> None:
+    if access_cmd == "add":
+        run_add(name, env_var, root)
+    elif access_cmd == "list":
+        run_list(root)
+    elif access_cmd == "remove":
+        run_remove(name, root)
+
+
+def run_add(name: str | None = None, env_var: str | None = None, root: Path | None = None) -> None:
+    if not name:
+        con.print("[red]Usage: p access add <name> [--env-var VAR][/red]")
+        return
+    r = root or _require_root()
+    mem.save_token(name, env_var or name.upper(), r)  # type: ignore[arg-type]
+    con.print(f"[#4ADE80]✓[/#4ADE80] Token [bold]{name}[/bold] saved.")
+
+
+def run_list(root: Path | None = None) -> None:
+    r = root or _require_root()
+    tokens = mem.list_tokens(r)
+    if not tokens:
+        con.print("[dim]No dev access tokens configured.[/dim]")
+    for t in tokens:
+        con.print(f"  [bold]{t['name']}[/bold]  [dim]env: {t['env_var']}[/dim]")
+
+
+def run_remove(name: str | None, root: Path | None = None) -> None:
+    if not name:
+        con.print("[red]Usage: p access remove <name>[/red]")
+        return
+    r = root or _require_root()
+    ok = mem.remove_token(name, r)
+    if ok:
+        con.print(f"[#4ADE80]✓[/#4ADE80] Token [bold]{name}[/bold] removed.")
+    else:
+        con.print(f"[yellow]Token {name!r} not found.[/yellow]")
+
+
+def _require_root() -> Path:
+    try:
+        from patchi.core.config import require_project_root
+
+        return require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        raise SystemExit(1) from e

patchi/cli/commands/agent_stats_cmd.py

@@ -0,0 +1,273 @@
+"""
+`p agent-stats` — Unified agent profiling and learning brain state.
+
+Combines the original `p profile` (agent profiler stats) and `p learning`
+(learning brain accept/reject patterns) into a single command.
+
+Usage:
+  p agent-stats              — show all agent profiles + learning state
+  p agent-stats auth_agent   — show details for one agent
+  p agent-stats --json       — machine-readable output
+  p agent-stats --profile    — show only agent profiler stats
+  p agent-stats --learning   — show only learning brain state
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+
+_log = logging.getLogger("patchi.cli.agent_stats_cmd")
+
+
+def run(
+    agent_name: str | None = None,
+    json_output: bool = False,
+    root: Path | None = None,
+    profile: bool = False,
+    learning: bool = False,
+) -> None:
+    """Entry point for `p agent-stats`."""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    # Specific agent detail
+    if agent_name:
+        _show_agent_detail(r, agent_name)
+        return
+
+    # Collect data from both sources
+    profile_data = _get_profile_data(r)
+    learning_data = _get_learning_data(r)
+
+    if json_output:
+        payload = {
+            "profile": profile_data,
+            "learning": learning_data,
+        }
+        con.print(json.dumps(payload, indent=2, default=str))
+        return
+
+    con.print()
+    con.print("[bold #C8621A]── Agent Stats ──[/bold #C8621A]")
+    con.print()
+
+    # Show profiler stats (unless --learning only)
+    if not learning:
+        _show_profile_section(profile_data)
+
+    # Show learning state (unless --profile only)
+    if not profile:
+        _show_learning_section(learning_data)
+
+    con.print()
+
+
+def _get_profile_data(root: Path) -> dict:
+    """Get agent profiler data."""
+    try:
+        from patchi.core.ai.agent_profiler import get_all_profiles, get_profile_summary
+
+        profiles = get_all_profiles(root)
+        summary = get_profile_summary(root)
+        return {
+            "summary": summary,
+            "profiles": {k: v.to_dict() for k, v in profiles.items()},
+        }
+    except ImportError:
+        return {"summary": {}, "profiles": {}}
+
+
+def _get_learning_data(root: Path) -> dict:
+    """Get learning brain data."""
+    try:
+        from patchi.core.brain.learning import get_summary
+
+        return get_summary(root)
+    except ImportError:
+        return {}
+
+
+def _show_profile_section(data: dict) -> None:
+    """Show the agent profiler section."""
+    summary = data.get("summary", {})
+    profiles = data.get("profiles", {})
+
+    if not profiles:
+        con.print("[dim]No agent profiles yet. Run a scan to start collecting data.[/dim]")
+        con.print()
+        return
+
+    con.print("[bold]Agent Profiler[/bold]")
+    con.print()
+
+    # Summary line
+    con.print(
+        f"  [bold]{summary.get('agents', 0)}[/bold] agents · "
+        f"[bold]{summary.get('total_runs', 0)}[/bold] total runs · "
+        f"[bold]${summary.get('total_cost', 0):.4f}[/bold] total cost · "
+        f"[bold]{summary.get('total_findings', 0)}[/bold] findings · "
+        f"accuracy [bold]{summary.get('avg_accuracy', 0) * 100:.1f}%[/bold]"
+    )
+    con.print()
+
+    # Table
+    table = Table(show_header=True, header_style="bold #C8621A", box=None)
+    table.add_column("Agent", style="bold")
+    table.add_column("Runs", justify="right")
+    table.add_column("P50", justify="right")
+    table.add_column("P95", justify="right")
+    table.add_column("Findings", justify="right")
+    table.add_column("Accuracy", justify="right")
+    table.add_column("Cost", justify="right")
+    table.add_column("Model")
+
+    for name, p in sorted(profiles.items(), key=lambda x: -x[1].get("run_count", 0)):
+        run_count = p.get("run_count", 0)
+        p50 = p.get("p50_wall_ms", 0)
+        p95 = p.get("p95_wall_ms", 0)
+        findings = p.get("total_findings", 0)
+        accuracy = p.get("accuracy", 0)
+        cost = p.get("total_cost_usd", 0)
+        model = p.get("most_used_model", "—")
+
+        acc_str = f"{accuracy * 100:.0f}%" if run_count >= 3 else "n/a"
+        acc_color = (
+            ("green" if accuracy >= 0.8 else "yellow" if accuracy >= 0.5 else "red")
+            if run_count >= 3
+            else "dim"
+        )
+
+        p95_str = f"{p95:.0f}ms"
+        p95_color = "red" if p95 > 5000 else "yellow" if p95 > 2000 else ""
+
+        table.add_row(
+            name,
+            str(run_count),
+            f"{p50:.0f}ms",
+            f"[{p95_color}]{p95_str}[/{p95_color}]" if p95_color else p95_str,
+            str(findings),
+            f"[{acc_color}]{acc_str}[/{acc_color}]",
+            f"${cost:.4f}",
+            model or "—",
+        )
+
+    con.print(table)
+
+    # Slowest agents
+    slowest = summary.get("slowest", [])
+    if slowest:
+        con.print()
+        con.print("  [bold]Slowest agents (P95):[/bold]")
+        for s in slowest[:5]:
+            con.print(f"    {s.get('agent', '?')}: [dim]{s.get('p95_ms', 0)}ms[/dim]")
+    con.print()
+
+
+def _show_learning_section(data: dict) -> None:
+    """Show the learning brain section."""
+    if not data:
+        con.print("[dim]No learning data yet. Run scans and accept/reject findings to build patterns.[/dim]")
+        con.print()
+        return
+
+    con.print("[bold]Learning Brain[/bold]")
+    con.print()
+
+    # Acceptances
+    acceptances = data.get("acceptances", {})
+    if acceptances:
+        con.print("[bold green]Accepted Findings[/bold green]")
+        table = Table(show_header=True, header_style="bold", box=None)
+        table.add_column("Finding Type")
+        table.add_column("Count", justify="right")
+        for ftype, count in sorted(acceptances.items(), key=lambda x: -x[1]):
+            table.add_row(ftype, str(count))
+        con.print(table)
+        con.print()
+    else:
+        con.print("[dim]No acceptance data yet.[/dim]")
+        con.print()
+
+    # Rejections
+    rejections = data.get("rejections", {})
+    if rejections:
+        con.print("[bold red]Rejected Findings[/bold red]")
+        table = Table(show_header=True, header_style="bold", box=None)
+        table.add_column("Finding Type")
+        table.add_column("Count", justify="right")
+        for ftype, count in sorted(rejections.items(), key=lambda x: -x[1]):
+            table.add_row(ftype, str(count))
+        con.print(table)
+        con.print()
+    else:
+        con.print("[dim]No rejection data yet.[/dim]")
+        con.print()
+
+    # Agent trust
+    trust = data.get("agent_trust", {})
+    if trust:
+        con.print("[bold]Agent Trust Scores[/bold]")
+        table = Table(show_header=True, header_style="bold", box=None)
+        table.add_column("Agent")
+        table.add_column("Trust", justify="right")
+        table.add_column("Bar")
+        for agent, score in sorted(trust.items(), key=lambda x: -x[1]):
+            bar_len = int(score * 20)
+            bar = "#" * bar_len + "." * (20 - bar_len)
+            color = "green" if score >= 0.7 else "yellow" if score >= 0.4 else "red"
+            table.add_row(
+                agent, f"[{color}]{score * 100:.0f}%[/{color}]", f"[{color}]{bar}[/{color}]"
+            )
+        con.print(table)
+        con.print()
+    else:
+        con.print("[dim]No agent trust data yet.[/dim]")
+        con.print()
+
+    # Skip types
+    skip = data.get("skip_types", [])
+    if skip:
+        con.print("[bold yellow]Auto-Skipped Types[/bold yellow]")
+        for ftype in skip:
+            con.print(f"  [yellow]* {ftype}[/yellow]")
+        con.print()
+
+
+def _show_agent_detail(root: Path, agent_name: str) -> None:
+    """Show detailed profile for one agent."""
+    try:
+        from patchi.core.ai.agent_profiler import get_profile
+    except ImportError:
+        con.print("[red]Agent profiler not available.[/red]")
+        return
+
+    profile = get_profile(root, agent_name)
+    if profile.run_count == 0:
+        con.print(f"[dim]No data for agent '{agent_name}'.[/dim]")
+        return
+
+    con.print()
+    con.print(f"[bold #C8621A]── Agent Profile: {agent_name} ──[/bold #C8621A]")
+    con.print()
+    con.print(f"  Runs:        [bold]{profile.run_count}[/bold]")
+    con.print(f"  P50 latency: [bold]{profile.p50_wall_ms:.0f}ms[/bold]")
+    con.print(f"  P95 latency: [bold]{profile.p95_wall_ms:.0f}ms[/bold]")
+    con.print(f"  Total wall:  {profile.total_wall_ms / 1000:.1f}s")
+    con.print(f"  Findings:    [bold]{profile.total_findings}[/bold]")
+    con.print(f"  Accepted:    [green]{profile.total_accepted}[/green]")
+    con.print(f"  Rejected:    [red]{profile.total_rejected}[/red]")
+    if profile.run_count >= 3:
+        con.print(f"  Accuracy:    [bold]{profile.accuracy * 100:.1f}%[/bold]")
+    con.print(f"  Avg/run:     {profile.avg_findings_per_run:.1f} findings")
+    con.print(f"  Total cost:  [bold]${profile.total_cost_usd:.4f}[/bold]")
+    con.print()