patchi 0.7.5__py3-none-any.whl

patchi/core/brain/freshness.py

@@ -0,0 +1,273 @@
+"""
+Brain freshness tracker.
+
+Determines whether the Brain's knowledge is still current by comparing
+file modification times against the last scan timestamp.
+
+Also provides the file watcher used by `p watch`.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import threading
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+
+FRESHNESS_FILE = ".patchi/brain_freshness.json"
+
+
+# ── Freshness record ───────────────────────────────────────────────────────────
+
+
+_log = logging.getLogger("patchi.brain.freshness")
+
+
+def save_freshness_snapshot(root: Path, file_infos_paths: list[str]) -> None:
+    """
+    Record the current mtime of every scanned file.
+    Called at the end of a successful brain scan.
+    """
+    snapshot: dict[str, float] = {}
+    for rel_path in file_infos_paths:
+        abs_path = root / rel_path
+        try:
+            snapshot[rel_path] = abs_path.stat().st_mtime
+        except OSError:
+            pass
+
+    freshness_path = root / FRESHNESS_FILE
+    freshness_path.parent.mkdir(parents=True, exist_ok=True)
+    with freshness_path.open("w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "snapshot": snapshot,
+                "recorded_at": datetime.now(UTC).isoformat(),
+            },
+            f,
+            indent=2,
+        )
+
+
+def check_freshness(root: Path) -> dict:
+    """
+    Compare current file mtimes to the saved snapshot.
+
+    Returns:
+        {
+            "is_stale": bool,
+            "changed_files": [list of changed rel paths],
+            "new_files": [list of new files not in snapshot],
+            "deleted_files": [list of files that no longer exist],
+            "last_recorded": ISO timestamp or None,
+        }
+    """
+    freshness_path = root / FRESHNESS_FILE
+    if not freshness_path.exists():
+        return {
+            "is_stale": True,
+            "changed_files": [],
+            "new_files": [],
+            "deleted_files": [],
+            "last_recorded": None,
+            "reason": "No scan recorded yet.",
+        }
+
+    try:
+        with freshness_path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {
+            "is_stale": True,
+            "changed_files": [],
+            "new_files": [],
+            "deleted_files": [],
+            "last_recorded": None,
+            "reason": "Freshness file is corrupted.",
+        }
+
+    snapshot: dict[str, float] = data.get("snapshot", {})
+    last_recorded: str = data.get("recorded_at", "")
+
+    changed: list[str] = []
+    deleted: list[str] = []
+
+    for rel_path, old_mtime in snapshot.items():
+        abs_path = root / rel_path
+        try:
+            current_mtime = abs_path.stat().st_mtime
+            if current_mtime != old_mtime:
+                changed.append(rel_path)
+        except OSError:
+            deleted.append(rel_path)
+
+    # New files: scan for any source files not in snapshot
+    # (lightweight — just check common source roots)
+    new_files = _find_new_files(root, snapshot)
+
+    is_stale = bool(changed or deleted or new_files)
+    reason = ""
+    if is_stale:
+        parts: list[str] = []
+        if changed:
+            parts.append(f"{len(changed)} file(s) modified")
+        if deleted:
+            parts.append(f"{len(deleted)} file(s) deleted")
+        if new_files:
+            parts.append(f"{len(new_files)} new file(s) found")
+        reason = "; ".join(parts) + " since last scan."
+
+    return {
+        "is_stale": is_stale,
+        "changed_files": changed,
+        "new_files": new_files,
+        "deleted_files": deleted,
+        "last_recorded": last_recorded,
+        "reason": reason,
+    }
+
+
+def _find_new_files(root: Path, snapshot: dict[str, float]) -> list[str]:
+    """
+    Quick scan for source files that exist now but weren't in the snapshot.
+    Checks only source directories, not node_modules etc.
+    """
+    from patchi.core.brain.languages import DEFAULT_IGNORE_DIRS, Lang, detect_language
+
+    new_files: list[str] = []
+    count = 0
+
+    for dirpath, dirnames, filenames in root_walk(root):
+        # Prune ignored dirs
+        dirnames[:] = [d for d in dirnames if d not in DEFAULT_IGNORE_DIRS]
+        for fname in filenames:
+            fpath = Path(dirpath) / fname
+            try:
+                rel = fpath.relative_to(root).as_posix()
+            except ValueError:
+                continue
+            if rel not in snapshot:
+                lang = detect_language(fpath)
+                if lang != Lang.UNKNOWN:
+                    new_files.append(rel)
+            count += 1
+            if count > 5000:  # bail early on huge projects
+                return new_files
+
+    return new_files
+
+
+def root_walk(root: Path):
+    """os.walk wrapper that stays inside root."""
+    import os
+
+    yield from os.walk(root)
+
+
+# ── File watcher (for p watch) ─────────────────────────────────────────────────
+
+
+class BrainWatcher:
+    """
+    Watches the project directory for file changes using watchfiles (Rust-backed).
+
+    watchfiles is significantly faster than watchdog — it uses native OS file
+    events (inotify on Linux, FSEvents on macOS, ReadDirectoryChangesW on Windows)
+    via a Rust extension. Debouncing is built-in.
+
+    On change: marks brain stale and calls on_change callback with changed paths.
+
+    Usage:
+        watcher = BrainWatcher(root, on_change=lambda paths: ...)
+        watcher.start()   # blocks until stop() is called
+        watcher.stop()
+    """
+
+    def __init__(
+        self,
+        root: Path,
+        on_change: Callable[[list[str]], None],
+        area: str | None = None,
+        debounce_ms: int = 500,
+    ):
+        self.root = root
+        self.on_change = on_change
+        self.area = area
+        self.debounce_ms = debounce_ms
+        self._stop_event: threading.Event | None = None
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        """Start watching in a background thread. Returns immediately."""
+        import threading
+
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(
+            target=self._watch_loop,
+            daemon=True,
+            name="BrainWatcher",
+        )
+        self._thread.start()
+
+    def _watch_loop(self) -> None:
+        """Background thread: runs watchfiles.watch() and dispatches changes."""
+        try:
+            from watchfiles import Change  # noqa: F401 — used to check availability
+            from watchfiles import watch as wf_watch
+        except ImportError as e:
+            raise RuntimeError(
+                "watchfiles is required for p watch. Install it with: pip install watchfiles"
+            ) from e
+
+        from patchi.core.brain.languages import DEFAULT_IGNORE_DIRS, Lang, detect_language
+
+        watch_path = str(self.root / self.area) if self.area else str(self.root)
+
+        # watchfiles accepts stop_event directly — clean shutdown
+        for changes in wf_watch(
+            watch_path,
+            debounce=self.debounce_ms,
+            stop_event=self._stop_event,
+            ignore_permission_denied=True,
+        ):
+            if self._stop_event and self._stop_event.is_set():
+                break
+
+            changed_paths: list[str] = []
+            for _change_type, raw_path in changes:
+                path = Path(raw_path)
+
+                # Skip patchi internals and build artifacts
+                if any(part in DEFAULT_IGNORE_DIRS for part in path.parts):
+                    continue
+
+                lang = detect_language(path)
+                if lang == Lang.UNKNOWN:
+                    continue
+
+                try:
+                    rel = path.relative_to(self.root).as_posix()
+                    changed_paths.append(rel)
+                except ValueError:
+                    continue
+
+            if changed_paths:
+                # Mark brain stale for these files
+                try:
+                    from patchi.core import memory as mem
+
+                    mem.mark_brain_stale(changed_paths, self.root)
+                except Exception as e:
+                    _log.warning("BrainWatcher._watch_loop failed: %s", e)
+                self.on_change(changed_paths)
+
+    def stop(self) -> None:
+        """Signal the watcher to stop and wait for the thread to exit."""
+        if self._stop_event:
+            self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=3.0)
+
+    def is_alive(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()

patchi/core/brain/git_aware.py

@@ -0,0 +1,206 @@
+"""
+Git-aware intelligence for Patchi.
+
+Provides:
+  - Incremental scan: only scan files changed since last scan (via git diff)
+  - Blame integration: trace which commit introduced a finding
+  - Changelog generation: summarize what changed between scans
+
+Uses subprocess to call git — no Python git library required.
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+from patchi.core.agents.base import Finding
+
+_log = logging.getLogger("patchi.brain.git_aware")
+
+
+def _git(args: list[str], root: Path) -> str | None:
+    """Run a git command and return stdout, or None on failure."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return None
+    except Exception as e:
+        _log.debug("_git failed: %s", e)
+        return None
+
+
+def is_git_repo(root: Path) -> bool:
+    """Check if the project is a git repository."""
+    return _git(["rev-parse", "--is-inside-work-tree"], root) == "true"
+
+
+def get_changed_files(root: Path, since: str = "HEAD") -> list[str]:
+    """
+    Get list of files changed since a ref (commit, tag, branch).
+    Default: changes since last commit.
+    Returns relative paths.
+    """
+    output = _git(["diff", "--name-only", since], root)
+    if output is None:
+        # Try diffing against empty tree (all files)
+        output = _git(["diff", "--name-only", "--diff-filter=ACMR", "HEAD~1"], root)
+    if output is None:
+        return []
+
+    # Also include untracked files
+    untracked = _git(["ls-files", "--others", "--exclude-standard"], root)
+
+    files = [f for f in output.splitlines() if f.strip()]
+    if untracked:
+        files.extend(f for f in untracked.splitlines() if f.strip())
+
+    return list(set(files))
+
+
+def get_changed_since_scan(root: Path, last_scan_time: float | None = None) -> list[str]:
+    """
+    Get files changed since the last scan timestamp.
+    Falls back to git log if timestamps aren't available.
+    """
+    if last_scan_time is None:
+        # No previous scan — return all files
+        return []
+
+    # Use git log to find commits since last scan
+    import time
+
+    since_date = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(last_scan_time))
+
+    output = _git(["log", "--since=" + since_date, "--name-only", "--pretty=format:"], root)
+    if output is None:
+        return []
+
+    files = [f for f in output.splitlines() if f.strip()]
+    return list(set(files))
+
+
+def blame_line(file_path: str, line: int, root: Path) -> dict | None:
+    """
+    Git blame a specific line. Returns:
+    {"commit": "abc123", "author": "Name", "date": "2024-01-01", "summary": "msg"}
+    """
+    output = _git(["blame", "-L", f"{line},{line}", "--porcelain", file_path], root)
+    if not output:
+        return None
+
+    result: dict[str, str] = {}
+    for line_text in output.splitlines():
+        # Porcelain format: first line is "<hash> <orig-line> <final-line> <count>"
+        # No "commit " prefix — the hash IS the first token on the first line.
+        if not result.get("commit") and line_text and not line_text.startswith("\t"):
+            parts = line_text.split()
+            if parts and len(parts[0]) == 40 and all(c in "0123456789abcdef" for c in parts[0]):
+                result["commit"] = parts[0]
+        elif line_text.startswith("author "):
+            result["author"] = line_text[7:]
+        elif line_text.startswith("author-time "):
+            import time
+
+            ts = int(line_text[12:])
+            result["date"] = time.strftime("%Y-%m-%d", time.localtime(ts))
+        elif line_text.startswith("summary "):
+            result["summary"] = line_text[8:]
+
+    return result if result.get("commit") else None
+
+
+def annotate_findings_with_blame(findings: list, root: Path, max_workers: int = 4) -> int:
+    """
+    Enrich findings with git blame information.
+
+    For each finding with a file + line, runs `git blame` and stores
+    result in finding.extra["blame"] as {"commit", "author", "date", "summary"}.
+
+    Uses parallel processing for speed. Skips non-git repos silently.
+    Returns count of annotated findings.
+    """
+    if not is_git_repo(root):
+        return 0
+
+    annotated = 0
+    import concurrent.futures
+
+    def _blame_one(f: Finding) -> Finding:
+        if not f.file or f.line <= 0:
+            return f
+        try:
+            info = blame_line(f.file, f.line, root)
+            if info:
+                f.extra["blame"] = info
+        except Exception as e:
+            _log.debug("_blame_one failed: %s", e)
+        return f
+
+    batch = [f for f in findings if isinstance(f, Finding) and f.file and f.line > 0]
+    if not batch:
+        return 0
+
+    # Cap per-agent blame calls to avoid excessive subprocess overhead on Windows
+    if len(batch) > 200:
+        batch = batch[:200]
+
+    if len(batch) == 1 or max_workers <= 1:
+        for f in batch:
+            _blame_one(f)
+            if f.extra.get("blame"):
+                annotated += 1
+    else:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+            for f in pool.map(_blame_one, batch):
+                if f.extra.get("blame"):
+                    annotated += 1
+
+    return annotated
+
+
+def changelog(root: Path, since: str = "HEAD~10") -> list[dict]:
+    """
+    Generate a changelog from git log.
+    Returns list of {"hash", "author", "date", "summary", "files"}.
+    """
+    output = _git(
+        ["log", since, "--pretty=format:%H|%an|%ad|%s", "--date=short"],
+        root,
+    )
+    if not output:
+        return []
+
+    entries = []
+    for line in output.splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("|", 3)
+        if len(parts) < 4:
+            continue
+
+        commit_hash, author, date, summary = parts
+
+        # Get files changed in this commit
+        files_output = _git(["diff-tree", "--no-commit-id", "-r", "--name-only", commit_hash], root)
+        files = [f for f in (files_output or "").splitlines() if f.strip()]
+
+        entries.append(
+            {
+                "hash": commit_hash[:8],
+                "author": author,
+                "date": date,
+                "summary": summary,
+                "files": files[:20],  # Cap at 20 files
+            }
+        )
+
+    return entries

patchi/core/brain/heatmap.py

@@ -0,0 +1,104 @@
+"""
+Risk Heatmap §9.1.3 — file map colored by bug-prone score.
+
+Score per file: findings * 10 + churn * 2 + (size_kb / 10) + complexity_hint.
+Color intensity mapped to folder tree for web D3 treemap.
+
+Usage:
+  from patchi.core.brain.heatmap import build_heatmap
+  data = build_heatmap(root)  # {name, children, value, severity}
+  # CLI: p heatmap | p heatmap --json
+"""
+
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+from patchi.core import memory as mem
+
+_log = logging.getLogger("patchi.brain.heatmap")
+
+
+def _git_churn(root: Path, rel: str) -> int:
+    try:
+        import subprocess
+
+        out = subprocess.run(
+            ["git", "log", "--oneline", "--", rel],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            cwd=str(root),
+        )
+        if out.returncode == 0:
+            return len([line for line in out.stdout.splitlines() if line.strip()])
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("churn %s failed: %s", rel, exc)
+    return 0
+
+
+def build_heatmap(root: Path) -> dict:
+    scans = mem.get_scan_results(root) or {}
+    # findings per file
+    per_file: dict[str, int] = defaultdict(int)
+    sev_max: dict[str, str] = {}
+    order = {"critical": 4, "high": 3, "medium": 2, "low": 1, "info": 0}
+    for data in scans.values():
+        for f in data.get("findings", []) if isinstance(data, dict) else []:
+            fp = f.get("file", "")
+            if not fp:
+                continue
+            per_file[fp] += 1
+            sev = f.get("severity", "low")
+            if order.get(sev, 0) > order.get(sev_max.get(fp, "info"), 0):
+                sev_max[fp] = sev
+
+    # file sizes for complexity hint
+    from patchi.core.brain.file_corpus import FileCorpus
+
+    corpus = FileCorpus(root)
+    size_map = {e.path: e.size_bytes for e in corpus.files()}
+
+    # build tree
+    tree: dict = {}
+    for rel, cnt in per_file.items():
+        parts = rel.split("/")
+        cur = tree
+        for seg in parts[:-1]:
+            cur = cur.setdefault(seg, {})
+        leaf = parts[-1]
+        churn = _git_churn(root, rel) if cnt else 0
+        size_kb = size_map.get(rel, 0) / 1024
+        score = cnt * 10 + churn * 2 + size_kb / 10
+        cur[leaf] = {"_value": round(score, 1), "_severity": sev_max.get(rel, "low"), "_findings": cnt}
+
+    def to_children(d: dict, name: str = "root") -> dict:
+        children = []
+        for k, v in sorted(d.items()):
+            if isinstance(v, dict) and "_value" in v:
+                children.append({"name": k, "value": v["_value"], "severity": v["_severity"], "findings": v["_findings"]})
+            elif isinstance(v, dict):
+                sub = to_children(v, k)
+                if sub["children"]:
+                    total = sum(c.get("value", 0) for c in sub["children"])
+                    sub["value"] = round(total, 1)
+                    children.append(sub)
+        return {"name": name, "children": children}
+
+    root_node = to_children(tree)
+    # top hotspots
+    flat = []
+
+    def collect(node, prefix=""):
+        for ch in node.get("children", []):
+            path = f"{prefix}/{ch['name']}" if prefix else ch["name"]
+            if "children" in ch:
+                collect(ch, path)
+            else:
+                flat.append((path, ch["value"], ch["severity"]))
+
+    collect(root_node)
+    flat.sort(key=lambda x: -x[1])
+    return {"tree": root_node, "hotspots": [{"file": p, "score": s, "severity": sev} for p, s, sev in flat[:20]], "total_files": len(per_file)}