patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/learn_cmd.py

@@ -0,0 +1,140 @@
+"""
+`p learn` — Learning Brain (Phase 5).
+
+Shows what Patchi has learned from your accept/reject patterns and the reusable
+fix patterns it has captured, lets you re-derive conventions from a fresh scan,
+and lets you reset that learning.
+
+  p learn              — show learned accept/reject patterns + which fix types are skipped
+  p learn patterns     — show captured fix patterns
+  p learn --force      — re-derive conventions/patterns from the current project
+  p learn --reset      — forget all learned patterns for this project
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.core.brain import learning
+from patchi.core.config import require_project_root
+
+_log = logging.getLogger("patchi.cli.learn_cmd")
+
+
+def run(
+    force: bool = False,
+    sub: str | None = None,
+    reset: 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
+
+    if reset:
+        path = r / ".patchi" / "learning.json"
+        if path.exists():
+            try:
+                path.unlink()
+                con.print("[#4ADE80]✓[/#4ADE80] Learning data reset for this project.")
+            except Exception as e:
+                _log.warning("run failed: %s", e)
+                con.print("[red]Could not reset learning data.[/red]")
+        else:
+            con.print("[dim]Nothing to reset.[/dim]")
+        con.print()
+        return
+
+    if sub == "patterns":
+        _show_patterns(r)
+        return
+
+    if force:
+        _relearn(r)
+
+    summary = learning.get_summary(r)
+    has_data = summary["acceptances"] or summary["rejections"] or summary.get("agent_trust")
+    if not has_data:
+        con.print()
+        con.print(
+            "[dim]No learning data yet. Patchi learns from the fixes you accept or reject "
+            "(e.g. [bold]p auto <files> --reject <type>[/bold]).[/dim]"
+        )
+        con.print()
+        return
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Fix type", width=20)
+    table.add_column("Accepted", width=10)
+    table.add_column("Rejected", width=10)
+    table.add_column("Status", width=14)
+    types = list(summary["acceptances"].keys()) + list(summary["rejections"].keys())
+    for t in sorted(set(types)):
+        acc = summary["acceptances"].get(t, 0)
+        rej = summary["rejections"].get(t, 0)
+        status = "[yellow]skipped[/yellow]" if t in summary["skip_types"] else "[dim]active[/dim]"
+        table.add_row(t, str(acc), str(rej), status)
+
+    con.print()
+    con.print(table)
+    if summary.get("agent_trust"):
+        con.print()
+        con.print("[dim]Agent trust:[/dim]")
+        for agent, score in summary["agent_trust"].items():
+            con.print(f"  {agent}: {score}")
+    con.print()
+    con.print(
+        "[dim]Run [bold]p learn patterns[/bold] to see captured fix strategies, "
+        "[bold]p learn --reset[/bold] to forget.[/dim]"
+    )
+    con.print()
+
+
+def _show_patterns(r: Path) -> None:
+    patterns = learning.list_fix_patterns(r)
+    if not patterns:
+        con.print()
+        con.print("[dim]No fix patterns captured yet.[/dim]")
+        con.print()
+        return
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Type", width=18)
+    table.add_column("File", width=30)
+    table.add_column("Strategy", width=22)
+    table.add_column("Summary", width=34)
+    for p in patterns:
+        table.add_row(
+            p.get("finding_type", ""),
+            p.get("file_pattern", ""),
+            p.get("fix_strategy", ""),
+            p.get("fix_summary", ""),
+        )
+    con.print()
+    con.print(table)
+    con.print()
+
+
+def _relearn(r: Path) -> None:
+    """Re-derive conventions/patterns from a fresh proactive scan of the project."""
+    try:
+        from patchi.core.brain.proactive import ProactiveAgent
+        from patchi.core.brain.scanner import FileScanner
+
+        scanner = FileScanner(r)
+        file_infos = scanner.scan()
+        agent = ProactiveAgent(r)
+        captured = 0
+        for fi in file_infos:
+            fixes = agent.analyze_change([fi.path], file_infos, None, None, include_format=False)
+            for f in fixes:
+                learning.record_fix_pattern(f.fix_type, f.file, "auto", f.description, r)
+                captured += 1
+        con.print(f"[dim]Re-learned {captured} fix pattern(s) from the current project.[/dim]")
+    except Exception as e:
+        con.print(f"[dim]Re-learn skipped: {e}[/dim]")

patchi/cli/commands/link_cmd.py

@@ -0,0 +1,104 @@
+"""
+p link — hybrid linking for non-monorepo (auto discovery tag + manual).
+
+  p link status   — show linking config + suggestion
+  p link add --frontend ./ --backend ../backend --frontend-url http://localhost:3000 --backend-url http://localhost:5000
+  p link confirm  — confirm auto suggestion
+  p link remove   — remove linking
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rich.panel import Panel
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+
+_CFG = ".patchi/config.json"
+_SUG = ".patchi/linking_suggestion.json"
+
+
+def _load_cfg(root: Path) -> dict:
+    p = root / _CFG
+    if p.exists():
+        try:
+            return json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_cfg(root: Path, cfg: dict) -> None:
+    p = root / _CFG
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    tmp.replace(p)
+
+
+def run(action: str | None = None, root: Path | None = None, **kwargs) -> None:
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    if action in (None, "status"):
+        cfg = _load_cfg(r)
+        link = cfg.get("linking")
+        sug_path = r / _SUG
+        if link:
+            con.print(Panel(f"[bold]Linking:[/bold] {link}", border_style="#4ADE80"))
+        elif sug_path.exists():
+            try:
+                sug = json.loads(sug_path.read_text(encoding="utf-8"))
+                con.print(Panel(f"[yellow]Suggestion:[/yellow] frontend {sug.get('frontend')} ↔ backend {sug.get('backend')}\nRun [bold]p link confirm[/bold] to activate", border_style="#FF8C42"))
+            except Exception:
+                con.print("[dim]No linking suggestion[/dim]")
+        else:
+            con.print("[dim]No linking configured — monorepo auto-detected or run p link add[/dim]")
+        return
+
+    if action == "add":
+
+        # Called via registry: kwargs has frontend, backend, frontend_url, backend_url
+        front = kwargs.get("frontend") or "./"
+        back = kwargs.get("backend")
+        furl = kwargs.get("frontend_url") or "http://localhost:3000"
+        burl = kwargs.get("backend_url") or "http://localhost:5000"
+        if not back:
+            con.print("[red]--backend required (e.g. ../backend)[/red]")
+            return
+        cfg = _load_cfg(r)
+        cfg["linking"] = {"mode": "separate", "frontend": front, "backend": back, "frontend_url": furl, "backend_url": burl, "confirmed": True}
+        _save_cfg(r, cfg)
+        con.print(f"[green]Linking added:[/green] {front} ↔ {back}")
+        return
+
+    if action == "confirm":
+        sug_path = r / _SUG
+        if not sug_path.exists():
+            con.print("[yellow]No suggestion to confirm — run p scan first or p link add[/yellow]")
+            return
+        try:
+            sug = json.loads(sug_path.read_text(encoding="utf-8"))
+            cfg = _load_cfg(r)
+            cfg["linking"] = {**sug, "mode": "separate", "confirmed": True}
+            _save_cfg(r, cfg)
+            sug_path.unlink(missing_ok=True)
+            con.print(f"[green]Link confirmed:[/green] {sug}")
+        except Exception as e:
+            con.print(f"[red]Confirm failed: {e}[/red]")
+        return
+
+    if action == "remove":
+        cfg = _load_cfg(r)
+        cfg.pop("linking", None)
+        _save_cfg(r, cfg)
+        con.print("[dim]Linking removed[/dim]")
+        return
+
+    con.print(f"[yellow]Unknown link action {action!r}[/yellow]")

patchi/cli/commands/log_cmd.py

@@ -0,0 +1,57 @@
+"""
+`p log` — Git changelog.
+
+Usage:
+  p log [--since HEAD~N]      — show recent commits with changed files
+  p log --since HEAD~5        — show last 5 commits
+  p log --since 2026-01-01    — show commits since a date
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.table import Table
+
+from patchi.cli.console import con
+from patchi.core.brain.git_aware import changelog
+from patchi.core.config import require_project_root
+
+
+def run(since: str = "HEAD~10", root: Path | None = None) -> None:
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    entries = changelog(r, since)
+
+    if not entries:
+        con.print("[dim]No git history found or not a git repository.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Hash", style="bold #F2EDD6", width=10)
+    table.add_column("Date", width=12)
+    table.add_column("Author", width=18)
+    table.add_column("Message", style="dim", width=50)
+    table.add_column("Files", style="dim", width=20)
+
+    for entry in entries:
+        files_str = ", ".join(entry.get("files", [])[:3])
+        if len(entry.get("files", [])) > 3:
+            files_str += f" +{len(entry['files']) - 3} more"
+        table.add_row(
+            entry.get("hash", "?"),
+            entry.get("date", ""),
+            entry.get("author", "")[:18],
+            entry.get("summary", "")[:50],
+            files_str,
+        )
+
+    con.print()
+    con.print(table)
+    con.print()
+    con.print(f"[dim]Total: {len(entries)} entries (since {since})[/dim]")
+    con.print()

patchi/cli/commands/memory_cmd.py

@@ -0,0 +1,215 @@
+from pathlib import Path
+
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich.text import Text
+
+from patchi.cli.console import con
+from patchi.core import memory as mem
+from patchi.core.config import require_project_root
+from patchi.core.constants import MemoryCategory
+
+"""
+`p memory` — view and manage Patchi's memory.
+
+Subcommands:
+  p memory                  — show all categories with counts
+  p memory show <category>  — show full data for a category
+  p memory delete <category>— clear a category (with warning)
+  p memory delete all       — full reset (requires CONFIRM)
+"""
+
+
+def run_show_all(root: Path | None = None) -> None:
+    """p memory — show all categories."""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    data = mem.summary(r)
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Category", style="bold #F2EDD6", width=16)
+    table.add_column("Items", style="#B8A898")
+    table.add_column("Description", style="dim")
+
+    descriptions = {
+        "brain": "Brain's understanding of your app",
+        "patches": "Applied fix history with diffs",
+        "failed": "Patches that failed and were rolled back",
+        "scans": "Last results from every scanner agent",
+        "issues": "Known unfixed issues",
+        "restrictions": "No-touch zones and scan-only paths",
+        "tokens": "Dev access token names (values never stored)",
+        "layers": "Layered brain (Pillar 1) — module/subsytem/project map",
+        "charter": "Project guard-rail charter (Pillar 2)",
+    }
+
+    for category, info in data.items():
+        if "count" in info:
+            count_str = str(info["count"])
+        elif "keys" in info:
+            count_str = f"{len(info['keys'])} sections"
+        else:
+            count_str = "—"
+
+        table.add_row(category, count_str, descriptions.get(category, ""))
+
+    con.print()
+    con.print(
+        Panel(table, title="[bold #C8621A]Patchi Memory[/bold #C8621A]", border_style="#2A3D28")
+    )
+    con.print()
+    con.print(
+        "[dim]Commands: [bold]p memory show <category>[/bold]  ·  [bold]p memory delete <category>[/bold][/dim]"
+    )
+    con.print()
+
+
+def run_show(category_str: str, root: Path | None = None) -> None:
+    """p memory show <category>"""
+    import json
+
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    # Special-case: 'scans' gets a formatted view instead of raw JSON
+    if category_str.lower() in ("scans", "scan"):
+        _show_scans(r)
+        return
+
+    try:
+        category = _parse_category(category_str)
+    except ValueError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    data = mem.read(category, r)
+    con.print()
+    con.print(f"[bold #F2EDD6]Memory: {category.value}[/bold #F2EDD6]")
+    con.print()
+    con.print_json(json.dumps(data, indent=2, default=str))
+    con.print()
+
+
+def _show_scans(root: Path) -> None:
+    """Structured view of scan results — one row per agent."""
+    from rich.table import Table
+
+    scans = mem.get_scan_results(root)
+    if not scans:
+        con.print("[dim]No scan results yet. Run [bold]p scan[/bold] first.[/dim]")
+        return
+
+    con.print()
+    con.print("[bold #F2EDD6]Last Scan Results by Agent[/bold #F2EDD6]")
+    con.print()
+
+    table = Table(show_header=True, header_style="bold #C8621A", box=None, pad_edge=False)
+    table.add_column("Agent", style="bold #F2EDD6", width=26)
+    table.add_column("Status", width=10)
+    table.add_column("Findings", justify="right", width=10)
+    table.add_column("Files", justify="right", width=8)
+    table.add_column("Duration", justify="right", width=10)
+
+    colors = {"done": "#4ADE80", "failed": "#FF4D6D", "skipped": "dim"}
+    for agent_name, data in sorted(scans.items()):
+        status = data.get("status", "?")
+        table.add_row(
+            agent_name,
+            Text(status, style=colors.get(status, "white")),
+            str(data.get("finding_count", 0)),
+            str(data.get("files_scanned", 0)),
+            f"{data.get('duration_ms', 0)}ms",
+        )
+
+    con.print(table)
+    con.print()
+
+
+def run_delete(category_str: str, root: Path | None = None) -> None:
+    """p memory delete <category> — with warning"""
+    try:
+        r = root or require_project_root()
+    except RuntimeError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    if category_str.lower() == "all":
+        _delete_all(r)
+        return
+
+    try:
+        category = _parse_category(category_str)
+    except ValueError as e:
+        con.print(f"[red]{e}[/red]")
+        return
+
+    consequence = _delete_consequence(category)
+    con.print()
+    con.print(f"[yellow]Warning:[/yellow] {consequence}")
+    con.print()
+
+    confirmed = Confirm.ask(f"Delete [bold]{category.value}[/bold] memory?", default=False)
+    if confirmed:
+        mem.delete(category, r)
+        con.print(f"[#4ADE80]✓[/#4ADE80] [bold]{category.value}[/bold] memory cleared.")
+    else:
+        con.print("[dim]Cancelled.[/dim]")
+    con.print()
+
+
+def _delete_all(root: Path) -> None:
+    """Full memory reset — requires typing CONFIRM."""
+    con.print()
+    con.print("[red bold]Full memory reset.[/red bold]\n")
+    con.print()
+    typed = Prompt.ask("[bold]Type CONFIRM to proceed[/bold]")
+    if typed.strip() == "CONFIRM":
+        mem.delete_all(root)
+        con.print("[#4ADE80]✓[/#4ADE80] All memory cleared. Patchi starts fresh on the next run.")
+    else:
+        con.print("[dim]Cancelled.[/dim]")
+    con.print()
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+
+def _parse_category(s: str) -> MemoryCategory:
+    valid = {c.value: c for c in MemoryCategory}
+    # Allow shorthand aliases
+    aliases = {
+        "patch": MemoryCategory.PATCHES,
+        "fail": MemoryCategory.FAILED,
+        "scan": MemoryCategory.SCANS,
+        "issue": MemoryCategory.ISSUES,
+        "restrict": MemoryCategory.RESTRICTIONS,
+        "token": MemoryCategory.TOKENS,
+    }
+    cleaned = s.lower().strip()
+    if cleaned in valid:
+        return valid[cleaned]
+    if cleaned in aliases:
+        return aliases[cleaned]
+    raise ValueError(f"Unknown category: {s!r}\nValid: {', '.join(valid.keys())}")
+
+
+def _delete_consequence(category: MemoryCategory) -> str:
+    consequences = {
+        MemoryCategory.BRAIN: "Deleting Brain state means Patchi will re-learn your entire app before the next action.",
+        MemoryCategory.PATCHES: "Deleting patch history means you can no longer undo or review past fixes.",
+        MemoryCategory.FAILED: "Deleting failed patch history clears all recorded failure reasons.",
+        MemoryCategory.SCANS: "Deleting scan results means Patchi will re-scan before the next action.",
+        MemoryCategory.ISSUES: "Deleting known issues clears all recorded unfixed findings.",
+        MemoryCategory.RESTRICTIONS: "Deleting restrictions removes all no-touch and scan-only zones. "
+        "Patchi will have access to all files on next run.",
+        MemoryCategory.TOKENS: "Deleting dev tokens removes all stored access token references.",
+    }
+    return consequences.get(category, "This area will be cleared and rescanned on next run.")