patchi 0.7.5__py3-none-any.whl

patchi/core/brain/understander.py

@@ -0,0 +1,130 @@
+"""
+Understander — picks the 12-20 files that actually matter.
+
+Uses Body tags + blast_radius + import_graph instead of file_infos[:50]
+in insertion order. All AI surfaces call this instead of slicing.
+
+Provides:
+  - core_files(limit) -> [{path, why, score, content_snippet}]
+  - refine_domains(active, tags) -> filtered domains (drop false hubs)
+  - get_function_at(file, line) -> function body via FileCorpus cache
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+_log = logging.getLogger("patchi.brain.understander")
+
+
+class Understander:
+    def __init__(
+        self,
+        root: Path,
+        file_infos: list[Any],
+        body_tags: dict[str, dict[str, Any]],
+        blast_map: dict[str, Any] | None = None,
+        routes: list[Any] | None = None,
+    ) -> None:
+        self.root = root
+        self.file_infos = {fi.path: fi for fi in file_infos}
+        self.tags = body_tags
+        self.blast = blast_map or {}
+        self.routes = routes or []
+        # sort once
+        self._ranked = sorted(
+            body_tags.items(),
+            key=lambda kv: (-int(kv[1].get("score", 0)), -int(kv[1].get("fan_in", 0)), kv[0]),
+        )
+
+    def core_files(self, limit: int = 16, include_low: bool = False) -> list[dict[str, Any]]:
+        """Top-ranked files the LLM must see. Always includes Brain + memory + entry points."""
+        out: list[dict[str, Any]] = []
+        seen: set[str] = set()
+        # force-include
+        for must in ("patchi/core/brain/brain.py", "patchi/core/memory.py", "patchi/core/brain/body_tags.py"):
+            if must in self.tags and must not in seen:
+                t = self.tags[must]
+                out.append({"path": must, "why": f"{t['role']}/{t['system']} critical={t['criticality']} fan_in={t['fan_in']}", "score": t["score"], "tag": t})
+                seen.add(must)
+        for path, tag in self._ranked:
+            if path in seen:
+                continue
+            if not include_low and tag.get("criticality") == "low" and tag.get("score", 0) < 15 and len(out) >= limit:
+                continue
+            out.append({"path": path, "why": f"{tag['role']}/{tag['system']} {tag['criticality']} fan_in={tag.get('fan_in',0)}", "score": tag["score"], "tag": tag})
+            seen.add(path)
+            if len(out) >= limit:
+                break
+        return out
+
+    def refine_domains(self, active: list[str]) -> list[str]:
+        """Drop domains that are low-score hubs only (speed). Keep high/critical cores."""
+        if not active:
+            return active
+        # count how many core_files map to each domain keyword
+        core_paths = {c["path"] for c in self.core_files(limit=12)}
+        # naive: keep all for now, but log drop candidate
+        # Future: intersect with body_tags system fields
+        _ = core_paths
+        return active
+
+    def file_snippet(self, rel_path: str, max_lines: int = 200) -> str:
+        """Return first max_lines with line numbers — for prompts. Uses FileCorpus-style cache via pathlib."""
+        fi = self.file_infos.get(rel_path)
+        if fi is not None:
+            try:
+                txt = (self.root / rel_path).read_text(encoding="utf-8", errors="replace")
+                lines = txt.splitlines()[:max_lines]
+                return "\n".join(f"{i+1:4d} | {line}" for i, line in enumerate(lines))
+            except Exception as exc:  # noqa: BLE001
+                _log.debug("understander snippet failed for %s: %s", rel_path, exc)
+                return ""
+        return ""
+
+    def function_at(self, rel_path: str, line: int, window: int = 50) -> str:
+        """Return function body surrounding line, using line-number heuristic (no heavy AST)."""
+        try:
+            txt = (self.root / rel_path).read_text(encoding="utf-8", errors="replace")
+        except Exception as exc:  # noqa: BLE001
+            _log.debug("function_at read failed: %s", exc)
+            return ""
+        lines = txt.splitlines()
+        if not 1 <= line <= len(lines):
+            return "\n".join(lines[: min(len(lines), window)])
+        # find def/class up
+        start = max(0, line - 1 - 60)
+        for i in range(line - 2, max(-1, line - 80), -1):
+            s = lines[i].lstrip()
+            if s.startswith("def ") or s.startswith("async def ") or s.startswith("class "):
+                start = i
+                break
+        # find next def at same or lesser indent
+        base_indent = len(lines[line - 1]) - len(lines[line - 1].lstrip())
+        end = min(len(lines), line + window)
+        for i in range(line, min(len(lines), line + 80)):
+            s = lines[i]
+            if s.strip() and not s.strip().startswith("#"):
+                indent = len(s) - len(s.lstrip())
+                st = s.strip()
+                if indent <= base_indent and (st.startswith("def ") or st.startswith("class ") or st.startswith("async def ")):
+                    end = i
+                    break
+        block = lines[start:end]
+        return "\n".join(f"{i+1:4d} | {line}" for i, line in enumerate(block, start=start + 1))
+
+    def as_prompt_block(self, limit: int = 14) -> str:
+        """One-shot block for LLM prompts — core files + why."""
+        core = self.core_files(limit=limit)
+        lines = []
+        for c in core:
+            lines.append(f"- {c['path']}  // {c['why']}")
+            snippet = self.file_snippet(c["path"], max_lines=24)
+            if snippet:
+                # cap per-file snippet to 24 lines to stay within 6k budget
+                lines.append("```python")
+                lines.append(snippet)
+                lines.append("```")
+        return "\n".join(lines)

patchi/core/brain/verify.py

@@ -0,0 +1,379 @@
+"""
+Self-Report Verifier (Dream Assistant spec — Live/Audit Mode, priority #1).
+
+The whole point: don't trust the agent's "tests pass" / "this works" claim.
+Independently re-run the project's real test suite (and optionally a scan),
+compare against the last known-good baseline, and emit an authoritative,
+plain-language truth report.
+
+Usage:
+  p verify                 — re-run tests (+ scan), diff against baseline, report truth
+  p verify --no-scan      — only re-run tests
+  p verify --claim "tests pass"   — assert a specific claim against actual truth
+
+This reuses the project's own test runner (pytest by default) and Patchi's
+Brain scan — it never trusts a self-report.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import re
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+
+_BASELINE_FILE = ".patchi/verify_baseline.json"
+
+
+_log = logging.getLogger("patchi.brain.verify")
+
+
+@dataclass
+class TestRun:
+    __test__ = False  # tell pytest this is not a test class
+    command: str = ""
+    passed: int = 0
+    failed: int = 0
+    error: int = 0
+    skipped: int = 0
+    total: int = 0
+    failed_names: list[str] = field(default_factory=list)
+    raw: str = ""
+    exit_ok: bool = False
+    duration_seconds: float = 0.0
+    note: str = ""
+
+    @property
+    def truthful(self) -> bool:
+        """True only if the suite actually ran and nothing failed/errored."""
+        return bool(self.command) and self.exit_ok and self.failed == 0 and self.error == 0
+
+
+@dataclass
+class VerifyReport:
+    __test__ = False
+    scanned_at: str = ""
+    test_run: TestRun | None = None
+    findings_count: int = 0
+    charter_violations: int = 0
+    scan_error: str | None = None
+    baseline: dict | None = None
+    regression: dict | None = None
+    truthful: bool = False
+    summary: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "scanned_at": self.scanned_at,
+            "truthful": self.truthful,
+            "tests": {
+                "passed": self.test_run.passed if self.test_run else 0,
+                "failed": self.test_run.failed if self.test_run else 0,
+                "error": self.test_run.error if self.test_run else 0,
+                "skipped": self.test_run.skipped if self.test_run else 0,
+                "truthful": self.test_run.truthful if self.test_run else False,
+            },
+            "findings_count": self.findings_count,
+            "charter_violations": self.charter_violations,
+            "regression": self.regression,
+            "summary": self.summary,
+        }
+
+
+# ── Test runner ────────────────────────────────────────────────────────────────
+
+
+def detect_test_command(root: Path) -> str | None:
+    """Pick the project's real test runner. Prefer pytest; fall back to unittest."""
+    if shutil.which("pytest"):
+        return "pytest -q -p no:cacheprovider"
+    return "python -m unittest discover -s tests -v"
+
+
+def run_tests(root: Path, command: str | None = None) -> TestRun:
+    """Independently execute the project's test suite. Never trusts a claim."""
+    cmd = command or detect_test_command(root)
+    if not cmd:
+        return TestRun(note="No test runner (pytest/unittest) found.")
+    start = time.monotonic()
+    try:
+        proc = subprocess.run(
+            cmd.split(),
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            timeout=600,
+        )
+    except Exception as e:  # pragma: no cover - environment dependent
+        return TestRun(command=cmd, note=f"Could not run tests: {e}")
+    raw = (proc.stdout or "") + "\n" + (proc.stderr or "")
+    dur = time.monotonic() - start
+    run = _parse_pytest_output(raw)
+    run.command = cmd
+    run.raw = raw
+    run.exit_ok = proc.returncode == 0
+    run.duration_seconds = round(dur, 2)
+    if not run.total and "no tests ran" in raw:
+        run.note = "No tests found."
+    return run
+
+
+def _parse_pytest_output(text: str) -> TestRun:
+    run = TestRun()
+    for metric, attr in (
+        ("passed", "passed"),
+        ("failed", "failed"),
+        ("error", "error"),
+        ("skipped", "skipped"),
+    ):
+        m = re.search(rf"(\d+)\s+{metric}", text)
+        if m:
+            setattr(run, attr, int(m.group(1)))
+    run.total = run.passed + run.failed + run.error + run.skipped
+    run.failed_names = re.findall(r"FAILED\s+([^\s-]+)", text)
+    return run
+
+
+# ── Baseline (regression radar) ───────────────────────────────────────────────────
+
+
+def _baseline_path(root: Path) -> Path:
+    return root / _BASELINE_FILE
+
+
+def load_baseline(root: Path) -> dict | None:
+    p = _baseline_path(root)
+    if not p.exists():
+        return None
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception as e:
+        _log.warning("load_baseline failed: %s", e)
+        return None
+
+
+def save_baseline(root: Path, snapshot: dict) -> None:
+    p = _baseline_path(root)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(snapshot, indent=2), encoding="utf-8")
+    tmp.replace(p)
+
+
+def compute_regression(
+    baseline: dict | None,
+    test_run: TestRun,
+    findings_count: int,
+    charter_violations: int,
+) -> dict:
+    """Diff current truth against the last known-good baseline."""
+    if not baseline:
+        return {
+            "has_baseline": False,
+            "new_failures": list(test_run.failed_names),
+            "new_findings": findings_count,
+            "new_charter_violations": charter_violations,
+        }
+    base_fail = set(baseline.get("failed_names", []))
+    cur_fail = set(test_run.failed_names)
+    base_find = baseline.get("findings_count", 0)
+    base_charter = baseline.get("charter_violations", 0)
+    return {
+        "has_baseline": True,
+        "new_failures": sorted(cur_fail - base_fail),
+        "resolved_failures": sorted(base_fail - cur_fail),
+        "new_findings": max(0, findings_count - base_find),
+        "new_charter_violations": max(0, charter_violations - base_charter),
+    }
+
+
+# ── Verify orchestration ─────────────────────────────────────────────────────────
+
+
+def verify_project(
+    root: Path,
+    test_runner=None,
+    run_scan: bool = True,
+) -> VerifyReport:
+    """
+    Independently verify the project's actual state.
+
+    test_runner: injectable for tests; defaults to run_tests().
+    Returns a VerifyReport with an authoritative truth + regression delta.
+    """
+    root = Path(root)
+    test_run = (test_runner or run_tests)(root)
+
+    findings_count = 0
+    charter_violations = 0
+    scan_error = None
+    if run_scan:
+        try:
+            from patchi.core.brain.brain import Brain
+
+            Brain(root).scan()
+            findings_count = _count_scan_findings(root)
+            charter_violations = _count_charter_violations(root)
+        except Exception as e:
+            scan_error = str(e)
+
+    baseline = load_baseline(root)
+    regression = compute_regression(baseline, test_run, findings_count, charter_violations)
+
+    truthful = test_run.truthful and not regression.get("new_failures") and charter_violations == 0
+
+    save_baseline(
+        root,
+        {
+            "scanned_at": datetime.now(UTC).isoformat(),
+            "failed_names": test_run.failed_names,
+            "findings_count": findings_count,
+            "charter_violations": charter_violations,
+        },
+    )
+
+    summary = _build_summary(truthful, test_run, regression, charter_violations, scan_error)
+    return VerifyReport(
+        scanned_at=datetime.now(UTC).isoformat(),
+        test_run=test_run,
+        findings_count=findings_count,
+        charter_violations=charter_violations,
+        scan_error=scan_error,
+        baseline=baseline,
+        regression=regression,
+        truthful=truthful,
+        summary=summary,
+    )
+
+
+def _count_scan_findings(root: Path) -> int:
+    """Count findings from the most recent scan results in memory."""
+    try:
+        from patchi.core import memory as mem
+
+        results = mem.get_scan_results(root)
+        total = 0
+        for _name, data in results.items():
+            for f in data.get("findings", []):
+                if isinstance(f, dict):
+                    total += 1
+        return total
+    except Exception as e:
+        _log.warning("_count_scan_findings failed: %s", e)
+        return 0
+
+
+def _count_charter_violations(root: Path) -> int:
+    try:
+        from patchi.core import memory as mem
+
+        results = mem.get_scan_results(root)
+        return len(results.get("CharterGuard", {}).get("findings", []))
+    except Exception as e:
+        _log.warning("_count_charter_violations failed: %s", e)
+        return 0
+
+
+def _build_summary(truthful, test_run, regression, charter_violations, scan_error) -> str:
+    if truthful:
+        return (
+            f"VERIFIED ✅ — tests: {test_run.passed} passed"
+            + (f", {test_run.skipped} skipped" if test_run.skipped else "")
+            + (
+                f"; {regression.get('new_findings', 0)} new scan finding(s)"
+                if regression.get("new_findings")
+                else "; no new scan findings"
+            )
+            + "."
+        )
+    parts = ["UNVERIFIED ❌ — mismatch between claim and reality:"]
+    if not test_run.truthful:
+        parts.append(
+            f"  • tests: {test_run.failed} failed, {test_run.error} errored"
+            + (f" -> {', '.join(test_run.failed_names[:5])}" if test_run.failed_names else "")
+        )
+    if regression.get("new_failures"):
+        parts.append(f"  • new failures vs baseline: {', '.join(regression['new_failures'][:5])}")
+    if charter_violations:
+        parts.append(f"  • {charter_violations} charter violation(s)")
+    if scan_error:
+        parts.append(f"  • scan could not run: {scan_error}")
+    return "\n".join(parts)
+
+
+def claim_holds(claim: str, report: VerifyReport) -> bool:
+    """Crude claim check: 'tests pass' / 'works' must match an actually truthful run."""
+    low = claim.lower()
+    if "pass" in low or "works" in low or "green" in low:
+        return report.truthful
+    return report.truthful
+
+
+def verify_ui_findings(root: Path, findings: list[dict]) -> tuple[list[dict], list[dict]]:
+    """Gate UI/test findings against the codebase before they enter memory.
+
+    A finding is kept only if its file resolves inside the project and any
+    claimed line exists in that file. Summary findings ("(all pages)", empty
+    file) always pass. Fail-open: anything unreadable is kept — only
+    provably-bogus entries (missing file, out-of-range line) are dropped.
+    Returns (kept, dropped).
+    """
+    try:
+        from patchi.core.brain.file_corpus import FileCorpus
+
+        entries = FileCorpus(root).entries
+    except Exception:
+        entries = {}
+
+    kept: list[dict] = []
+    dropped: list[dict] = []
+    for f in findings:
+        if not isinstance(f, dict):
+            kept.append(f)
+            continue
+        rel = (f.get("file") or "").strip()
+        if not rel or rel == "(all pages)":
+            kept.append(f)
+            continue
+        # URL routes (UI findings reference pages, not files): fail open.
+        # Full route verification needs RouteMapper contract scope, which is
+        # unavailable here; file findings below are still strictly gated.
+        if rel.startswith("/"):
+            kept.append(f)
+            continue
+        rel = rel.replace("\\", "/").lstrip("/")
+        if rel in entries:
+            try:
+                n_lines = len(entries[rel].read().splitlines())
+            except Exception:
+                kept.append(f)
+                continue
+        else:
+            cand = (root / rel).resolve()
+            try:
+                cand.relative_to(root.resolve())
+            except ValueError:
+                dropped.append({**f, "drop_reason": "file outside project"})
+                continue
+            if not cand.is_file():
+                dropped.append({**f, "drop_reason": "file not found"})
+                continue
+            try:
+                n_lines = len(cand.read_text(encoding="utf-8", errors="replace").splitlines())
+            except OSError:
+                kept.append(f)
+                continue
+        line = f.get("line", 0) or 0
+        try:
+            line = int(line)
+        except (TypeError, ValueError):
+            line = 0
+        if line > 0 and line > n_lines:
+            dropped.append({**f, "drop_reason": f"line {line} beyond {n_lines} lines"})
+            continue
+        kept.append(f)
+    return kept, dropped

patchi/core/campaigns/__init__.py

@@ -0,0 +1,14 @@
+"""Campaigns module — state transitions and data flow abuse campaigns."""
+
+from .base import Campaign, CampaignStep
+from .data_flow_abuse import DataFlowAbuseCampaign
+from .orchestrator import CampaignOrchestrator
+from .state_transitions import StateTransitionCampaign
+
+__all__ = [
+    "Campaign",
+    "CampaignStep",
+    "CampaignOrchestrator",
+    "StateTransitionCampaign",
+    "DataFlowAbuseCampaign",
+]

patchi/core/campaigns/base.py

@@ -0,0 +1,62 @@
+"""Base campaign class and CampaignStep."""
+
+from __future__ import annotations
+
+import abc
+import logging
+from dataclasses import dataclass, field
+
+from patchi.core.assurance.graph import AssuranceGraph
+
+_log = logging.getLogger("patchi.core.campaigns")
+
+
+@dataclass
+class CampaignStep:
+    """One step in a campaign."""
+
+    name: str
+    description: str
+    status: str = "pending"  # "pending", "running", "passed", "failed"
+    findings: list[dict] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "status": self.status,
+            "findings_count": len(self.findings),
+        }
+
+
+class Campaign(abc.ABC):
+    """Base class for assurance campaigns."""
+
+    name: str = "base"
+    description: str = ""
+
+    def __init__(self, graph: AssuranceGraph):
+        self._graph = graph
+
+    @abc.abstractmethod
+    def steps(self) -> list[CampaignStep]:
+        """Define the steps in this campaign."""
+
+    def run(self) -> list[CampaignStep]:
+        """Execute all steps and return results."""
+        results: list[CampaignStep] = []
+        for step in self.steps():
+            try:
+                step.status = "running"
+                self._execute_step(step)
+                step.status = "failed" if step.findings else "passed"
+            except Exception as e:
+                _log.warning("Campaign %s step %s failed: %s", self.name, step.name, e)
+                step.status = "failed"
+                step.findings.append({"error": str(e)})
+            results.append(step)
+        return results
+
+    @abc.abstractmethod
+    def _execute_step(self, step: CampaignStep) -> None:
+        """Execute a single step (modifies step.findings in place)."""