patchi 0.7.5__py3-none-any.whl

patchi/cli/commands/check_cmd.py

@@ -0,0 +1,232 @@
+"""
+P-Check Agent — sole job to get app into runnable, testable state.
+
+Spec:
+  1. Install all dependencies
+  2. Run formatting/lint checks
+  3. Run other required setup (env files, codegen, config validation)
+  4. Attempt to build and start the app as local dev server (localhost)
+
+When everything succeeds: output READY_TO_SERVE with exact local dev server URL and port. Stop.
+When something fails: flag what failed + exact error + what is needed, escalate to Brain, wait for fix, re-run from step 1. Never READY_TO_SERVE while blocking error remains.
+Hard rule: No other agent may treat app as usable until READY_TO_SERVE.
+
+Gate file: .patchi/p_check_status.json {status, url, port, timestamp, error}
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+
+from rich.panel import Panel
+
+from patchi.cli.console import con
+from patchi.core.config import require_project_root
+
+_STATUS_FILE = ".patchi/p_check_status.json"
+
+
+def _write_status(root: Path, status: str, url: str | None = None, port: int | None = None, error: str | None = None, domain: str | None = None) -> None:
+    p = root / _STATUS_FILE
+    p.parent.mkdir(parents=True, exist_ok=True)
+    data = {"status": status, "url": url, "port": port, "error": error, "domain": domain, "timestamp": time.time(), "iso": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())}
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    tmp.replace(p)
+
+
+def _read_status(root: Path) -> dict | None:
+    p = root / _STATUS_FILE
+    if not p.exists():
+        return None
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def is_ready(root: Path) -> tuple[bool, dict | None]:
+    """Gate Rule helper: returns (ready, status_dict)."""
+    st = _read_status(root)
+    if not st:
+        return False, None
+    if st.get("status") != "READY_TO_SERVE":
+        return False, st
+    # optional TTL: 1 hour? For now no expiry, but check url still reachable?
+    if not st.get("url"):
+        return False, st
+    # check timestamp within 1 hour or still running?
+    return True, st
+
+
+# Finding types p check --fix may auto-repair (its lane: type/deps/build/format/install).
+# Everything else (incl. all security findings) is reported for the Brain, never touched.
+_FIXABLE_TYPES = {"missing_env", "format_error"}
+
+
+def _apply_domain_fixes(r: Path, blocking: list) -> list[str]:
+    """Attempt safe auto-fixes for in-lane findings. Returns human-readable actions taken."""
+    import shutil
+    import subprocess
+
+    actions: list[str] = []
+    for f in blocking:
+        ftype = getattr(f, "type", "") or ""
+        if ftype == "missing_env":
+            src, dst = r / ".env.example", r / ".env"
+            try:
+                if src.exists() and not dst.exists():
+                    dst.write_text(src.read_text(encoding="utf-8"), encoding="utf-8")
+                    actions.append("copied .env.example → .env (fill values before run)")
+            except OSError:
+                pass
+        elif ftype == "format_error":
+            if shutil.which("ruff") and (r / "pyproject.toml").exists():
+                try:
+                    proc = subprocess.run(
+                        ["ruff", "format", "."],
+                        capture_output=True, text=True, timeout=60, cwd=str(r),
+                    )
+                    if proc.returncode == 0:
+                        actions.append("ran ruff format .")
+                except Exception as _exc:
+                    logging.getLogger("patchi").debug('suppressed: %s', _exc)
+    return actions
+
+
+def _run_side_agents(r: Path, brain: dict, config: dict):
+    from patchi.core.agents.base import AgentInput
+    from patchi.core.agents.base import list_agents as la
+
+    agents = [a for a in la() if a.name in ("InstallAgent", "BuildAgent", "FormatAgent")]
+    findings: list = []
+    blocking: list = []
+    for cls in agents:
+        res = cls().run(AgentInput(root=r, scope=[], brain=brain, config=config, extra={}))
+        findings.extend(res.findings)
+        for f in res.findings:
+            sev = f.severity.value if hasattr(f.severity, "value") else str(f.severity)
+            if sev in ("high", "critical"):
+                blocking.append(f)
+    return findings, blocking
+
+
+def run(fix: 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.agents.base import discover_agent_modules
+
+    discover_agent_modules()
+    import patchi.core.agents.side.build_agent  # noqa: F401
+    import patchi.core.agents.side.format_agent  # noqa: F401
+    import patchi.core.agents.side.install_agent  # noqa: F401
+
+    try:
+        from patchi.core import config as cfg
+        from patchi.core import memory as mem
+
+        brain = mem.get_brain(r)
+        config = cfg.load(r)
+    except Exception:
+        brain, config = {}, {}
+
+    # Step 1-3: run side agents
+    findings, blocking = _run_side_agents(r, brain, config)
+
+    # --fix: repair in-lane findings once, then re-run from step 1
+    if fix and blocking:
+        lane = [f for f in blocking if (getattr(f, "type", "") or "") in _FIXABLE_TYPES]
+        if lane:
+            actions = _apply_domain_fixes(r, lane)
+            if actions:
+                for a in actions:
+                    con.print(f"[dim]--fix: {a}[/dim]")
+                findings, blocking = _run_side_agents(r, brain, config)
+
+    # Step 3 extra: env file check (missing .env but .env.example exists)
+    try:
+        if (r / ".env.example").exists() and not (r / ".env").exists():
+            from patchi.core.agents.base import Severity, make_finding
+
+            findings.append(
+                make_finding(
+                    severity=Severity.HIGH,
+                    file=".env",
+                    line_start=0,
+                    title="Missing .env (have .env.example)",
+                    description="Copy .env.example to .env and fill values before app can run",
+                    finding_type="missing_env",
+                )
+            )
+            blocking.append(findings[-1])
+    except Exception as _exc:
+        logging.getLogger("patchi").debug('suppressed: %s', _exc)
+
+    if blocking:
+        # Escalate to Brain
+        msg = f"P-Check BLOCKED: {len(blocking)} blocking error(s) in {', '.join({f.file or 'unknown' for f in blocking})}"
+        con.print()
+        con.print(Panel(f"[red]{msg}[/red]\n" + "\n".join(f"  • {f.file}:{f.line} {f.message[:100]}" for f in blocking[:5]), title="P-Check — BLOCKED", border_style="#FF4D6D"))
+        con.print(f"[dim]Escalating to Brain (orchestrator) — domain: {[f.type for f in blocking[:3]]}[/dim]")
+        _write_status(r, "BLOCKED", error=msg, domain=",".join({f.type for f in blocking}))
+        try:
+            from patchi.core import memory as mem
+
+            mem.save_scan_result("PCheck", {"status": "BLOCKED", "findings": [f.to_dict() for f in findings]}, r)
+            # also save as issue for brain
+            for f in blocking[:5]:
+                mem.save_issue({"type": f.type, "file": f.file, "line": f.line, "message": f.message, "source": "PCheck"}, r)
+        except Exception as _exc:
+            logging.getLogger("patchi").debug('suppressed: %s', _exc)
+        con.print("[yellow]P-Check: fix blocking errors (or run p check --fix if in domain) then re-run `p check` from step 1. Never READY_TO_SERVE while blocked.[/yellow]")
+        con.print()
+        if json_output:
+            con.print(json.dumps({"status": "BLOCKED", "blocking": [f.to_dict() for f in blocking]}, indent=2))
+        return
+
+    # Step 4: attempt to build and start app as local dev server
+    url: str | None = None
+    port: int | None = None
+    try:
+        from patchi.core.testing.app_launcher import ensure_running
+
+        url = ensure_running(r, config, {})
+        if url:
+            # parse port
+            try:
+                port = int(url.rsplit(":", 1)[-1].split("/")[0])
+            except Exception:
+                port = None
+    except Exception as exc:  # noqa: BLE001
+        con.print(f"[red]P-Check start failed: {exc}[/red]")
+        _write_status(r, "BLOCKED", error=str(exc), domain="app_start")
+        return
+
+    if not url:
+        msg = "P-Check could not start app — no start command detected or port health check failed"
+        con.print()
+        con.print(Panel(f"[yellow]{msg}[/yellow]\n[dim]Check app_launcher logs at .patchi/launcher/app.log[/dim]", title="P-Check — BLOCKED (no URL)", border_style="#FF8C42"))
+        con.print()
+        _write_status(r, "BLOCKED", error=msg, domain="app_start")
+        return
+
+    # Success
+    con.print()
+    con.print(Panel(f"[bold #4ADE80]READY_TO_SERVE[/bold #4ADE80]\nLocal dev server URL: [bold]{url}[/bold] port {port}\n[dim]P-Check complete — app is runnable, testable. No other agent may proceed until this was emitted.[/dim]", border_style="#4ADE80"))
+    con.print()
+    _write_status(r, "READY_TO_SERVE", url=url, port=port)
+    try:
+        from patchi.core import memory as mem
+
+        mem.save_scan_result("PCheck", {"status": "READY_TO_SERVE", "url": url, "port": port, "findings": [f.to_dict() for f in findings]}, r)
+    except Exception as _exc:
+        logging.getLogger("patchi").debug('suppressed: %s', _exc)
+    if json_output:
+        con.print(json.dumps({"status": "READY_TO_SERVE", "url": url, "port": port}, indent=2))

patchi/cli/commands/cleanup_cmd.py

@@ -0,0 +1,328 @@
+"""
+`p cleanup` — Remove stale .patchi/ artifacts.
+
+Cleans up generated/temporary files while preserving essential state:
+  - JUnit XML reports from dev checks
+  - Flake databases (patchi_history.db, *.db-journal, etc.)
+  - Stale caches (AST, file_info, brain freshness, CVE, etc.)
+  - Old log files
+  - Ephemeral snapshots
+  - Browser test screenshots/evidence (optional)
+  - Profiling/stats files (.stats, .prof, .lprof)
+
+Preserves:
+  - config.json (project configuration)
+  - memory/ (charter, layers, known issues, brain state)
+  - api_key
+  - queue.json
+
+Usage:
+  p cleanup                          # Preview what would be removed (dry-run)
+  p cleanup --apply                  # Actually delete stale files
+  p cleanup --all                    # Also remove evidence/screenshots
+  p cleanup --older-than 7d          # Only remove files older than 7 days
+  p cleanup --dry-run --json         # JSON output for CI integration
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+
+from patchi.cli.console import con
+from patchi.core.config import find_project_root
+
+_log = logging.getLogger("patchi.cli.commands.cleanup_cmd")
+
+
+# ── Artifact Patterns ────────────────────────────────────────────────────────
+# (glob_pattern, description, keep_in_safe_mode)
+
+CLEANUP_TARGETS = [
+    # JUnit XML reports
+    ("**/*junit*.xml", "JUnit test reports", False),
+    ("**/*test-result*.xml", "pytest result files", False),
+    ("**/dev-check-*.xml", "dev-check XML reports", False),
+
+    # Flake/test databases
+    ("**/*.db", "database files", False),
+    ("**/*.db-journal", "database journals", False),
+    ("**/*.db-wal", "database WAL files", False),
+    ("**/*.db-shm", "database SHM files", False),
+
+    # Stale caches
+    ("ast_cache.json", "AST parse cache", False),
+    ("file_info_cache.json", "file info cache", False),
+    ("brain_freshness.json", "brain freshness cache", False),
+    ("diff_activation_cache.json", "diff activation cache", False),
+    ("threat_model.json", "threat model cache", False),
+    ("queue.json", "queue state", False),
+    ("cache/cve_cache.json", "CVE lookup cache", False),
+
+    # Logs
+    ("logs/*.log", "log files", False),
+    ("logs/*.jsonl", "structured logs", False),
+
+    # Snapshots
+    ("snapshots/**/*", "ephemeral snapshots", False),
+
+    # Profiling
+    ("*.stats", "profiling stats", False),
+    ("*.prof", "profiling data", False),
+    ("*.lprof", "line profiling data", False),
+
+    # Scratch files
+    ("b.json", "scratch data", False),
+    ("command_list.md", "generated command list", False),
+
+    # Evidence (only with --all)
+    ("evidence/dast/**/*", "DAST screenshots/evidence", True),
+    ("evidence/browser_tests/**/*", "browser test evidence", True),
+    ("evidence/test/**/*", "test evidence", True),
+]
+
+
+def _parse_age(age_str: str) -> float:
+    """Parse age string like '7d', '24h', '30m' into seconds."""
+    age_str = age_str.strip().lower()
+    if age_str.endswith("d"):
+        return float(age_str[:-1]) * 86400
+    elif age_str.endswith("h"):
+        return float(age_str[:-1]) * 3600
+    elif age_str.endswith("m"):
+        return float(age_str[:-1]) * 60
+    else:
+        # Assume days
+        return float(age_str) * 86400
+
+
+def _is_file_older_than(file_path: Path, max_age_seconds: float) -> bool:
+    """Check if a file is older than the specified age."""
+    try:
+        mtime = file_path.stat().st_mtime
+        age = time.time() - mtime
+        return age > max_age_seconds
+    except Exception:
+        return False
+
+
+def cleanup(
+    apply: bool = False,
+    include_evidence: bool = False,
+    older_than: str | None = None,
+    json_output: bool = False,
+    root: Path | None = None,
+):
+    """Remove stale .patchi/ artifacts.
+
+    Args:
+        apply: If True, actually delete files. If False, just show what would be removed.
+        include_evidence: If True, also remove evidence/screenshots.
+        older_than: Only remove files older than this (e.g. '7d', '24h', '30m').
+        json_output: If True, output as JSON for CI integration.
+        root: Override project root detection.
+    """
+    try:
+        r = root or find_project_root()
+    except Exception:
+        try:
+            from patchi.core.config import require_project_root
+            r = require_project_root()
+        except Exception as e:
+            if json_output:
+                pass
+            else:
+                con.print(f"[red]{e}[/red]")
+            return
+
+    patchi_dir = r / ".patchi"
+    if not patchi_dir.is_dir():
+        if json_output:
+            pass
+        else:
+            con.print(f"[yellow]No .patchi directory found at {r}[/yellow]")
+        return
+
+    # Parse age filter
+    max_age_seconds = _parse_age(older_than) if older_than else None
+
+    if not json_output:
+        con.print()
+        con.print("[bold #C8621A]Patchi Cleanup[/bold #C8621A]")
+        con.print(f"[dim]Directory: {patchi_dir}[/dim]")
+        mode_label = "DRY RUN (use --apply to delete)" if not apply else "[red]DELETING FILES[/red]"
+        age_label = f" | Age filter: > {older_than}" if older_than else ""
+        con.print(f"[dim]{mode_label}{age_label}[/dim]")
+        con.print()
+
+    total_files = 0
+    total_size = 0
+    deleted_files = 0
+    deleted_size = 0
+    skipped_files = 0
+    filtered_out = 0
+    cleanup_data = []
+
+    for pattern, description, evidence_only in CLEANUP_TARGETS:
+        if evidence_only and not include_evidence:
+            continue
+
+        matches = list(patchi_dir.glob(pattern))
+
+        if not matches:
+            continue
+
+        # Filter to actual files (not directories)
+        files = [f for f in matches if f.is_file()]
+
+        if not files:
+            continue
+
+        # Apply age filter
+        if max_age_seconds is not None:
+            old_files = [f for f in files if _is_file_older_than(f, max_age_seconds)]
+            filtered_out += len(files) - len(old_files)
+            files = old_files
+
+        if not files:
+            continue
+
+        # Calculate size
+        file_size = sum(f.stat().st_size for f in files if f.exists())
+        total_files += len(files)
+        total_size += file_size
+
+        size_str = _format_size(file_size)
+        count_str = f"{len(files)} file{'s' if len(files) != 1 else ''}"
+
+        if apply:
+            deleted_count = 0
+            for f in files:
+                try:
+                    file_size_actual = f.stat().st_size if f.exists() else 0
+                    f.unlink()
+                    deleted_count += 1
+                    deleted_files += 1
+                    deleted_size += file_size_actual
+                except Exception as e:
+                    skipped_files += 1
+                    if not json_output:
+                        con.print(f"  [yellow]⚠ Could not delete {f.name}: {e}[/yellow]")
+
+            if deleted_count > 0 and not json_output:
+                con.print(f"  [red]✗[/red] {description}: {count_str} ({size_str})")
+        else:
+            if not json_output:
+                con.print(f"  [yellow]?[/yellow] {description}: {count_str} ({size_str})")
+
+        # Collect data for JSON output
+        cleanup_data.append({
+            "description": description,
+            "pattern": pattern,
+            "count": len(files),
+            "size_bytes": file_size,
+            "files": [str(f.relative_to(patchi_dir)) for f in files[:20]],  # Limit to 20
+        })
+
+    # Also clean empty directories
+    empty_dirs = []
+    for d in sorted(patchi_dir.rglob("*"), reverse=True):
+        if d.is_dir() and not any(d.iterdir()):
+            empty_dirs.append(d)
+
+    if apply and empty_dirs:
+        for d in empty_dirs:
+            try:
+                d.rmdir()
+                if not json_output:
+                    con.print(f"  [red]✗[/red] Empty dir: {d.relative_to(patchi_dir)}")
+            except Exception as _exc:
+                _log.warning('cleanup failed: %s', _exc)
+
+    # JSON output for CI
+    if json_output:
+        {
+            "dry_run": not apply,
+            "older_than": older_than,
+            "total_files": total_files,
+            "total_size_bytes": total_size,
+            "deleted_files": deleted_files,
+            "deleted_size_bytes": deleted_size,
+            "skipped_files": skipped_files,
+            "filtered_out": filtered_out,
+            "categories": cleanup_data,
+            "preserved": _get_preserved(patchi_dir),
+        }
+        return
+
+    # Summary
+    con.print()
+    if apply:
+        if deleted_files > 0:
+            con.print(f"[green]✓ Cleaned {deleted_files} files ({_format_size(deleted_size)} freed)[/green]")
+        else:
+            con.print("[dim]No stale files to clean.[/dim]")
+        if skipped_files:
+            con.print(f"[yellow]⚠ {skipped_files} files could not be deleted[/yellow]")
+    else:
+        con.print(f"[yellow]Would remove {total_files} files ({_format_size(total_size)})[/yellow]")
+        if filtered_out > 0:
+            con.print(f"[dim]Filtered out {filtered_out} files (newer than {older_than})[/dim]")
+        con.print("[dim]Run with --apply to actually delete files.[/dim]")
+
+    # Show what's preserved
+    con.print()
+    con.print("[dim]Preserved:[/dim]")
+    preserved = _get_preserved(patchi_dir)
+    if preserved:
+        con.print(f"[dim]  {', '.join(preserved)}[/dim]")
+    else:
+        con.print("[dim]  (nothing to preserve)[/dim]")
+    con.print()
+
+
+def _get_preserved(patchi_dir: Path) -> list[str]:
+    """Get list of preserved items."""
+    preserved = []
+    if (patchi_dir / "config.json").exists():
+        preserved.append("config.json")
+    if (patchi_dir / "memory").is_dir():
+        preserved.append("memory/")
+    if (patchi_dir / "api_key").exists():
+        preserved.append("api_key")
+    return preserved
+
+
+def get_patchi_size(root: Path | None = None) -> dict:
+    """Get the total size of .patchi/ directory for doctor warnings."""
+    try:
+        r = root or find_project_root()
+    except Exception:
+        return {"total_bytes": 0, "total_files": 0}
+
+    patchi_dir = r / ".patchi"
+    if not patchi_dir.is_dir():
+        return {"total_bytes": 0, "total_files": 0}
+
+    total_bytes = 0
+    total_files = 0
+    for f in patchi_dir.rglob("*"):
+        if f.is_file():
+            try:
+                total_bytes += f.stat().st_size
+                total_files += 1
+            except Exception as _exc:
+                _log.warning('get_patchi_size failed: %s', _exc)
+
+    return {"total_bytes": total_bytes, "total_files": total_files}
+
+
+def _format_size(size: int) -> str:
+    """Format bytes as human-readable string."""
+    if size < 1024:
+        return f"{size} B"
+    elif size < 1024 * 1024:
+        return f"{size / 1024:.1f} KB"
+    else:
+        return f"{size / (1024 * 1024):.1f} MB"