patchi 0.7.5__py3-none-any.whl

patchi/core/brain/cross_repo.py

@@ -0,0 +1,104 @@
+"""
+CrossRepo §11.3 — multi-repo index for shared library drift.
+
+Indexes multiple repo roots (siblings or explicit list) and compares dependency versions + API usage.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+
+_log = logging.getLogger("patchi.brain.cross_repo")
+
+def index_repos(roots: list[Path]) -> dict:
+    idx={}
+    for r in roots:
+        try:
+            from patchi.core.brain.file_corpus import FileCorpus
+            corpus=FileCorpus(r)
+            idx[str(r)]={"files": len(list(corpus.files())), "deps": _deps(r)}
+        except Exception:
+            idx[str(r)]={"files":0,"deps":{}}
+    return idx
+
+def _deps(root: Path) -> dict:
+    """Parsed {package: version} per manifest (not raw text)."""
+    deps: dict[str, dict[str, str]] = {}
+    try:
+        p = root / "package.json"
+        if p.exists():
+            pkg = json.loads(p.read_text(encoding="utf-8", errors="replace"))
+            merged = {}
+            for section in ("dependencies", "devDependencies", "peerDependencies"):
+                for name, ver in (pkg.get(section) or {}).items():
+                    merged[str(name)] = str(ver)
+            if merged:
+                deps["package.json"] = merged
+    except Exception as _exc:
+        _log.debug("package.json parse failed: %s", _exc)
+    try:
+        p = root / "requirements.txt"
+        if p.exists():
+            parsed = {}
+            for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
+                line = line.strip()
+                if not line or line.startswith(("#", "-", " ")):
+                    continue
+                m = re.match(r"^([A-Za-z0-9_.\-]+)\s*(?:==|>=|<=|~=|!=|>|<)?\s*([^;\s]*)", line)
+                if m:
+                    parsed[m.group(1).lower()] = m.group(2) or "unpinned"
+            if parsed:
+                deps["requirements.txt"] = parsed
+    except Exception as _exc:
+        _log.debug("requirements parse failed: %s", _exc)
+    try:
+        p = root / "go.mod"
+        if p.exists():
+            parsed = {}
+            for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
+                m = re.match(r"^\s*([a-z0-9./\-_]+)\s+(v[\w.+\-]+)", line.strip(), re.I)
+                if m and "module" not in line and "go " != line[:3]:
+                    parsed[m.group(1)] = m.group(2)
+            if parsed:
+                deps["go.mod"] = parsed
+    except Exception as _exc:
+        _log.debug("go.mod parse failed: %s", _exc)
+    try:
+        p = root / "Cargo.toml"
+        if p.exists():
+            parsed = {}
+            in_deps = False
+            for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
+                s = line.strip()
+                if s.startswith("["):
+                    in_deps = "dependencies" in s
+                    continue
+                if in_deps:
+                    m = re.match(r"^([A-Za-z0-9_\-]+)\s*=\s*\"?([^\"]*)\"?", s)
+                    if m:
+                        parsed[m.group(1)] = m.group(2) or "unpinned"
+            if parsed:
+                deps["Cargo.toml"] = parsed
+    except Exception as _exc:
+        _log.debug("Cargo.toml parse failed: %s", _exc)
+    return deps
+
+def drift_report(roots: list[Path]) -> dict:
+    idx=index_repos(roots)
+    # real version drift: same package, different versions across repos
+    seen: dict[str, dict[str, list]] = {}
+    for r, data in idx.items():
+        for pkgs in data.get("deps", {}).values():
+            if not isinstance(pkgs, dict):
+                continue
+            for name, ver in pkgs.items():
+                seen.setdefault(name, {}).setdefault(str(ver), []).append(r)
+    drift=[]
+    for name, versions in seen.items():
+        if len(versions) > 1:
+            drift.append({"package": name[:80],
+                          "versions": {v: rs[:3] for v, rs in versions.items()}})
+    return {"index": idx, "drift": drift[:10]}

patchi/core/brain/dead_code_tools.py

@@ -0,0 +1,157 @@
+"""
+External tool runners for symbol-level dead code detection.
+
+Each runner invokes a language-specific tool and normalizes its output
+into a list of dicts with keys: symbol, file, line, tool, confidence.
+
+Tools:
+  - vulture (Python) — already a dependency
+  - ts-prune (JS/TS) — npm package, optional
+  - deadcode (Python) — alternative to vulture
+  - ruff (Python) — unused imports via F401
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from patchi.core.brain.file_corpus import FileCorpus
+
+
+def run_vulture(root: Path, min_confidence: int = 60) -> list[dict]:
+    """Run vulture on a Python project and return unused symbols."""
+    if not shutil.which("vulture"):
+        return []
+    try:
+        proc = subprocess.run(
+            ["vulture", str(root), "--min-confidence", str(min_confidence), "--json"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if proc.returncode not in (0, 1):
+            return []
+        results = []
+        for line in proc.stdout.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+                results.append(
+                    {
+                        "symbol": entry.get("name", ""),
+                        "file": entry.get("filename", ""),
+                        "line": entry.get("lineno", 0),
+                        "tool": "vulture",
+                        "confidence": entry.get("confidence", min_confidence),
+                    }
+                )
+            except json.JSONDecodeError:
+                continue
+        return results
+    except (subprocess.TimeoutExpired, Exception):
+        return []
+
+
+def run_ruff_unused_imports(root: Path) -> list[dict]:
+    """Run ruff to find unused imports (F401) across the project."""
+    if not shutil.which("ruff"):
+        return []
+    try:
+        proc = subprocess.run(
+            ["ruff", "check", str(root), "--select=F401", "--output-format=json"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        results = []
+        for line in proc.stdout.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+                if entry.get("code") == "F401":
+                    results.append(
+                        {
+                            "symbol": entry.get("message", "").split("'")[1]
+                            if "'" in entry.get("message", "")
+                            else "",
+                            "file": entry.get("filename", ""),
+                            "line": entry.get("location", {}).get("row", 0),
+                            "tool": "ruff",
+                            "confidence": 90,
+                        }
+                    )
+            except (json.JSONDecodeError, IndexError):
+                continue
+        return results
+    except (subprocess.TimeoutExpired, Exception):
+        return []
+
+
+def run_ts_prune(root: Path) -> list[dict]:
+    """Run ts-prune on a TypeScript project to find unused exports."""
+    if not shutil.which("npx"):
+        return []
+    pkg_json = root / "package.json"
+    if not pkg_json.exists():
+        return []
+    try:
+        proc = subprocess.run(
+            ["npx", "--yes", "ts-prune", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            cwd=str(root),
+        )
+        results = []
+        for line in proc.stdout.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+                if entry.get("isDefault", False):
+                    continue
+                results.append(
+                    {
+                        "symbol": entry.get("symbol", ""),
+                        "file": entry.get("file", ""),
+                        "line": 0,
+                        "tool": "ts-prune",
+                        "confidence": 70,
+                    }
+                )
+            except json.JSONDecodeError:
+                continue
+        return results
+    except (subprocess.TimeoutExpired, Exception):
+        return []
+
+
+def detect_and_run(root: Path, corpus: FileCorpus | None = None) -> list[dict]:
+    """Auto-detect project type and run all applicable dead code tools."""
+    results: list[dict] = []
+
+    has_python = any(corpus.by_ext(".py")) if corpus else any(root.rglob("*.py"))
+    has_ts = (
+        any(corpus.by_ext(".ts", ".tsx"))
+        if corpus
+        else any(root.rglob("*.ts")) or any(root.rglob("*.tsx"))
+    )
+
+    if has_python:
+        results.extend(run_vulture(root))
+        results.extend(run_ruff_unused_imports(root))
+
+    if has_ts:
+        results.extend(run_ts_prune(root))
+
+    return results

patchi/core/brain/doc_validator.py

@@ -0,0 +1,197 @@
+"""
+Documentation claim validator.
+
+Parses README and documentation files for factual claims about the project
+(code features, API endpoints, supported formats, etc.), cross-references
+each claim against the actual scanned code, and stores validated claims in
+the brain for use by fix agents and contract inference.
+
+This prevents the classic problem of docs saying "supports X" when X was
+removed months ago.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from patchi.core.brain.languages import DEFAULT_IGNORE_DIRS
+from patchi.core.brain.route_mapper import RouteInfo
+from patchi.core.brain.scanner import FileInfo
+
+# ── Claim extraction ────────────────────────────────────────────────────────────
+
+# Patterns that look like documented features in README files
+_CLAIM_PATTERNS = [
+    re.compile(
+        r"(?:supports?|handles?|manages?|provides?|offers?|features?)\s+([^.,]+)", re.IGNORECASE
+    ),
+    re.compile(r"- \[x\]\s*(.+)", re.IGNORECASE),  # checkbox done
+    re.compile(r"\*\*(.+?)\*\*\s*(?:—|–|-|:)\s*.+", re.IGNORECASE),  # **Feature** — description
+    re.compile(
+        r"(?:API|endpoint|route)\s*[`:/]\s*([A-Za-z0-9_/{}]+)", re.IGNORECASE
+    ),  # inline API mentions
+    re.compile(
+        r"(?:CLI|command)\s*[`:]\s*([a-z][a-z0-9_-]+)", re.IGNORECASE
+    ),  # inline CLI mentions
+]
+
+
+def extract_claims(doc_path: Path) -> list[str]:
+    """Parse a documentation file and return a list of raw claim strings."""
+    if not doc_path.exists():
+        return []
+    try:
+        text = doc_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+
+    claims: list[str] = []
+    for pattern in _CLAIM_PATTERNS:
+        for m in pattern.finditer(text):
+            claim = m.group(1).strip()
+            if len(claim) > 15 and claim not in claims:
+                claims.append(claim)
+    return claims
+
+
+def _tokenize(text: str) -> set[str]:
+    """Split text into lowercase tokens for overlap matching."""
+    return set(re.findall(r"[a-z][a-z0-9_]{2,}", text.lower()))
+
+
+def _code_vocabulary(file_infos: list[FileInfo], routes: list[RouteInfo]) -> dict[str, list[str]]:
+    """Build a token→evidence map from the actual codebase."""
+    vocab: dict[str, list[str]] = {}
+    for fi in file_infos:
+        for token in _tokenize(fi.path):
+            vocab.setdefault(token, []).append(f"file: {fi.path}")
+        for func in fi.functions:
+            for token in _tokenize(func.name):
+                vocab.setdefault(token, []).append(f"file: {fi.path} function: {func.name}")
+        for cls in fi.classes:
+            for token in _tokenize(cls.name):
+                vocab.setdefault(token, []).append(f"file: {fi.path} class: {cls.name}")
+    for route in routes:
+        for token in _tokenize(route.path):
+            vocab.setdefault(token, []).append(f"route: {route.method} {route.path}")
+    return vocab
+
+
+def cross_reference_claim(
+    claim: str,
+    file_infos: list[FileInfo],
+    routes: list[RouteInfo],
+) -> tuple[bool, list[str]]:
+    """
+    Check if a claim is backed by actual code.
+    Uses token-overlap matching instead of hardcoded keyword lists.
+    Returns (verified, evidence_list).
+    """
+    claim_tokens = _tokenize(claim)
+    if not claim_tokens:
+        return False, []
+
+    vocab = _code_vocabulary(file_infos, routes)
+    evidence: list[str] = []
+    scored: dict[str, float] = {}
+
+    for token in claim_tokens:
+        for ev in vocab.get(token, []):
+            scored[ev] = scored.get(ev, 0) + 1
+
+    # Sort by overlap count, take top matches
+    for ev, _ in sorted(scored.items(), key=lambda x: -x[1]):
+        if ev not in evidence:
+            evidence.append(ev)
+        if len(evidence) >= 5:
+            break
+
+    verified = len(evidence) >= 1
+    return verified, evidence[:5]
+
+
+# ── Main validation entry point ────────────────────────────────────────────────
+
+
+def validate_project_docs(
+    root: Path,
+    file_infos: list[FileInfo],
+    routes: list[RouteInfo],
+    ai_config: dict | None = None,
+) -> dict[str, Any]:
+    """
+    Validate all documentation files in a project against scanned code.
+
+    Returns a dict with:
+      - validated_claims: list of {claim, evidence, verified}
+      - stale_claims: list of {claim, reason} (claims that could not be verified)
+      - summary: plain-English summary of doc health
+    """
+    # Find doc files (skip .venv, node_modules, __pycache__)
+    _EXCLUDED_DIRS = DEFAULT_IGNORE_DIRS | {"files 6", ".vscode", ".idea"}
+
+    doc_files = []
+    for pattern in ("README*", "*.md", "docs/**/*.md"):
+        if "*" in pattern:
+            matched = list(root.glob(pattern))
+            # Filter out excluded directories
+            matched = [
+                p
+                for p in matched
+                if not any(part in _EXCLUDED_DIRS for part in p.relative_to(root).parts)
+            ]
+        else:
+            p = root / pattern
+            if p.exists():
+                matched = [p]
+            else:
+                matched = []
+        doc_files.extend(matched)
+    doc_files = sorted(set(doc_files))
+
+    all_claims: list[tuple[str, Path]] = []
+    for doc_path in doc_files:
+        for claim in extract_claims(doc_path):
+            all_claims.append((claim, doc_path))
+
+    result = {
+        "validated_claims": [],
+        "stale_claims": [],
+        "summary": "",
+        "doc_files_found": [str(p) for p in doc_files],
+        "total_claims": 0,
+    }
+
+    for claim, doc_path in all_claims:
+        verified, evidence = cross_reference_claim(claim, file_infos, routes)
+        entry = {
+            "claim": claim,
+            "source": str(doc_path),
+            "verified": verified,
+            "evidence": evidence,
+        }
+        if verified:
+            result["validated_claims"].append(entry)
+        else:
+            result["stale_claims"].append(entry)
+
+    result["total_claims"] = len(all_claims)
+    result["summary"] = _build_summary(result)
+    return result
+
+
+def _build_summary(result: dict) -> str:
+    total = result["total_claims"]
+    validated = len(result["validated_claims"])
+    stale = len(result["stale_claims"])
+    doc_count = len(result["doc_files_found"])
+
+    if total == 0:
+        return f"Found {doc_count} doc file(s) but no verifiable claims."
+
+    parts = [f"Verified {validated}/{total} claims across {doc_count} doc file(s)."]
+    if stale:
+        parts.append(f"{stale} claim(s) could not be verified against code")
+    return " ".join(parts)