patchi 0.7.5__py3-none-any.whl

patchi/core/brain/baseline.py

@@ -0,0 +1,195 @@
+"""
+Baseline locking for Patchi.
+
+Snapshots the current finding state and compares against previous baselines.
+Enables "only fail on new issues" workflow for CI/CD.
+
+Baseline is stored in `.patchi/memory/baseline.json`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+
+from patchi.core.agents.base import Finding, Severity
+
+_log = logging.getLogger("patchi.brain.baseline")
+
+
+@dataclass
+class BaselineSnapshot:
+    """A snapshot of findings at a point in time."""
+
+    created_at: str = ""
+    total_findings: int = 0
+    by_severity: dict[str, int] = field(default_factory=dict)
+    by_agent: dict[str, int] = field(default_factory=dict)
+    finding_hashes: set[str] = field(default_factory=set)
+    file_finding_counts: dict[str, int] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "created_at": self.created_at,
+            "total_findings": self.total_findings,
+            "by_severity": self.by_severity,
+            "by_agent": self.by_agent,
+            "finding_hashes": sorted(self.finding_hashes),
+            "file_finding_counts": self.file_finding_counts,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> BaselineSnapshot:
+        return cls(
+            created_at=data.get("created_at", ""),
+            total_findings=data.get("total_findings", 0),
+            by_severity=data.get("by_severity", {}),
+            by_agent=data.get("by_agent", {}),
+            finding_hashes=set(data.get("finding_hashes", [])),
+            file_finding_counts=data.get("file_finding_counts", {}),
+        )
+
+
+@dataclass
+class BaselineDiff:
+    """Difference between current scan and baseline."""
+
+    new_findings: list[Finding] = field(default_factory=list)
+    resolved_findings: list[dict] = field(default_factory=list)
+    total_baseline: int = 0
+    total_current: int = 0
+    new_count: int = 0
+    resolved_count: int = 0
+    has_regression: bool = False
+    summary: str = ""
+
+
+def _finding_hash(finding: Finding) -> str:
+    """Deterministic hash for a finding — used to detect new vs known issues."""
+    raw = f"{finding.file}:{finding.line}:{finding.type}:{finding.severity.value}:{finding.message}"
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def _finding_dict_hash(finding: dict) -> str:
+    raw = f"{finding.get('file', '')}:{finding.get('line', 0)}:{finding.get('type', '')}:{finding.get('severity', '')}:{finding.get('message', '')}"
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def _baseline_path(root: Path) -> Path:
+    return root / ".patchi" / "memory" / "baseline.json"
+
+
+def save_baseline(findings: list[Finding], root: Path) -> BaselineSnapshot:
+    """Snapshot current findings as the new baseline."""
+    snapshot = BaselineSnapshot(
+        created_at=datetime.now(UTC).isoformat(),
+        total_findings=len(findings),
+        by_severity={s.value: 0 for s in Severity},
+        by_agent={},
+        finding_hashes=set(),
+        file_finding_counts={},
+    )
+
+    for f in findings:
+        snapshot.by_severity[f.severity.value] = snapshot.by_severity.get(f.severity.value, 0) + 1
+        snapshot.by_agent[f.agent] = snapshot.by_agent.get(f.agent, 0) + 1
+        snapshot.finding_hashes.add(_finding_hash(f))
+        snapshot.file_finding_counts[f.file] = snapshot.file_finding_counts.get(f.file, 0) + 1
+
+    path = _baseline_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(snapshot.to_dict(), indent=2), encoding="utf-8")
+    return snapshot
+
+
+def load_baseline(root: Path) -> BaselineSnapshot | None:
+    """Load the saved baseline, if any."""
+    path = _baseline_path(root)
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return BaselineSnapshot.from_dict(data)
+    except Exception as e:
+        _log.warning("load_baseline failed: %s", e)
+        return None
+
+
+def diff_baseline(current_findings: list[dict | Finding], root: Path) -> BaselineDiff | None:
+    """
+    Compare current findings against baseline.
+    Returns None if no baseline exists.
+
+    Accepts both Finding objects and dicts (from JSON output).
+    """
+    baseline = load_baseline(root)
+    if baseline is None:
+        return None
+
+    # Convert all to Finding objects for uniform handling
+    normalized: list[Finding] = []
+    for item in current_findings:
+        if isinstance(item, Finding):
+            normalized.append(item)
+        elif isinstance(item, dict):
+            normalized.append(
+                Finding(
+                    agent=item.get("agent", ""),
+                    type=item.get("type", item.get("finding_type", "")),
+                    severity=Severity(item.get("severity", "info")),
+                    file=item.get("file", ""),
+                    line=item.get("line", 0),
+                    message=item.get("message", ""),
+                )
+            )
+
+    current_hashes = {_finding_hash(f) for f in normalized}
+
+    new_findings = [f for f in normalized if _finding_hash(f) not in baseline.finding_hashes]
+    resolved_hashes = baseline.finding_hashes - current_hashes
+
+    diff = BaselineDiff(
+        new_findings=new_findings,
+        resolved_findings=[{"hash": h} for h in resolved_hashes],
+        total_baseline=baseline.total_findings,
+        total_current=len(normalized),
+        new_count=len(new_findings),
+        resolved_count=len(resolved_hashes),
+        has_regression=len(new_findings) > 0,
+    )
+
+    # Build summary
+    parts = []
+    if diff.new_count > 0:
+        parts.append(f"{diff.new_count} new finding(s)")
+    if diff.resolved_count > 0:
+        parts.append(f"{diff.resolved_count} resolved")
+    parts.append(f"baseline: {diff.total_baseline}")
+    parts.append(f"current: {diff.total_current}")
+    diff.summary = ", ".join(parts)
+
+    return diff
+
+
+def update_baseline(findings: list[Finding | dict], root: Path) -> BaselineSnapshot:
+    """Convenience: load current findings, diff against baseline, save new baseline."""
+    normalized: list[Finding] = []
+    for item in findings:
+        if isinstance(item, Finding):
+            normalized.append(item)
+        elif isinstance(item, dict):
+            normalized.append(
+                Finding(
+                    agent=item.get("agent", ""),
+                    type=item.get("type", item.get("finding_type", "")),
+                    severity=Severity(item.get("severity", "info")),
+                    file=item.get("file", ""),
+                    line=item.get("line", 0),
+                    message=item.get("message", ""),
+                )
+            )
+    return save_baseline(normalized, root)

patchi/core/brain/blast_radius.py

@@ -0,0 +1,312 @@
+"""
+Blast radius calculation utilities.
+
+Two levels:
+  - File-level (v1, original): Uses ImportGraph. BFS on reverse edges.
+  - Symbol-level (v2): Uses SymbolGraph. Weighted by test coverage + criticality.
+    Both directions (downstream dependents + upstream dependencies).
+    Damage-vs-repair: structural diff before/after a change.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Any
+
+from patchi.core.brain.import_graph import ImportGraph
+
+# ── File-level (v1) ────────────────────────────────────────────────────────────
+
+
+@dataclass
+class BlastRadius:
+    """Information about the blast radius of a file."""
+
+    target: str
+    direct_dependents: list[str]
+    all_dependents: list[str]
+    risk_level: str  # 'low', 'medium', 'high'
+
+    @property
+    def total_affected(self) -> int:
+        return len(self.all_dependents)
+
+
+def calculate_blast_radius(target: str, graph: ImportGraph) -> BlastRadius:
+    """BFS on reverse graph to find all transitive dependents."""
+    direct = sorted(graph.reverse.get(target, set()))
+    all_affected: set[str] = set()
+    queue = deque(direct)
+    while queue:
+        node = queue.popleft()
+        if node == target or node in all_affected:
+            continue
+        all_affected.add(node)
+        for parent in graph.reverse.get(node, set()):
+            if parent not in all_affected:
+                queue.append(parent)
+
+    count = len(all_affected)
+    risk = "low" if count == 0 else ("medium" if count <= 5 else "high")
+
+    return BlastRadius(
+        target=target,
+        direct_dependents=direct,
+        all_dependents=sorted(all_affected),
+        risk_level=risk,
+    )
+
+
+def build_blast_radius_map(graph: ImportGraph) -> dict[str, BlastRadius]:
+    return {node: calculate_blast_radius(node, graph) for node in graph.nodes}
+
+
+# ── Symbol-level (v2) ──────────────────────────────────────────────────────────
+
+
+@dataclass
+class SymbolBlastResult:
+    """Symbol-level blast radius with weighted scoring."""
+
+    symbol_name: str
+    file: str
+    line: int
+    # Downstream: what depends on this symbol
+    downstream_direct: list[dict] = field(default_factory=list)
+    downstream_all: list[dict] = field(default_factory=list)
+    downstream_count: int = 0
+    # Upstream: what this symbol depends on
+    upstream_direct: list[dict] = field(default_factory=list)
+    upstream_count: int = 0
+    # Weighted scores
+    test_coverage_score: float = 1.0  # 0-1, higher = better tested
+    criticality_score: float = 0.0  # 0-1, higher = more critical
+    risk_score: float = 0.0  # weighted combination
+    risk_level: str = "low"
+    # Damage vs repair
+    structural_change_count: int = 0
+
+    @property
+    def total_affected(self) -> int:
+        return self.downstream_count
+
+    def to_dict(self) -> dict:
+        return {
+            "symbol": self.symbol_name,
+            "file": self.file,
+            "line": self.line,
+            "downstream": {
+                "direct": len(self.downstream_direct),
+                "all": self.downstream_count,
+                "samples": self.downstream_direct[:5],
+            },
+            "upstream": {
+                "direct": len(self.upstream_direct),
+                "samples": self.upstream_direct[:5],
+            },
+            "test_coverage_score": round(self.test_coverage_score, 3),
+            "criticality_score": round(self.criticality_score, 3),
+            "risk_score": round(self.risk_score, 3),
+            "risk_level": self.risk_level,
+            "structural_changes": self.structural_change_count,
+        }
+
+
+def calculate_symbol_blast_radius(
+    symbol_name: str,
+    file: str,
+    symbol_graph: Any,
+    test_coverage: dict[str, float] | None = None,
+    criticality_tags: dict[str, float] | None = None,
+    max_depth: int = 5,
+) -> SymbolBlastResult:
+    """Compute symbol-level blast radius with weighted scoring.
+
+    Args:
+        symbol_name: Name of the symbol to analyze.
+        file: File path where the symbol is defined.
+        symbol_graph: SymbolGraph instance.
+        test_coverage: Dict of {file_path: coverage_ratio 0-1}.
+        criticality_tags: Dict of {symbol_name: criticality_score 0-1}.
+        max_depth: Max transitive depth.
+    """
+    test_coverage = test_coverage or {}
+    criticality_tags = criticality_tags or {}
+
+    target = symbol_graph.get_symbol(symbol_name, file)
+    if not target:
+        return SymbolBlastResult(
+            symbol_name=symbol_name,
+            file=file,
+            line=0,
+            risk_level="unknown",
+            risk_score=0.0,
+        )
+
+    # Downstream: dependents
+    downstream_set: dict[str, dict] = {}
+    queue: list[tuple[str, str, int]] = [
+        (s.name, s.file, 1) for s in symbol_graph.get_dependents(symbol_name, file)
+    ]
+    visited: set[int] = {target.id}
+    direct_downstream: list[dict] = []
+
+    while queue:
+        name, fpath, depth = queue.pop(0)
+        if depth > max_depth:
+            continue
+        sym = symbol_graph.get_symbol(name, fpath)
+        if not sym or sym.id in visited:
+            continue
+        visited.add(sym.id)
+        entry = {"name": name, "file": fpath, "depth": depth}
+        downstream_set[f"{name}:{fpath}"] = entry
+        if depth == 1:
+            direct_downstream.append(entry)
+        # Recurse into their dependents
+        for dep in symbol_graph.get_dependents(name, fpath):
+            if dep.id not in visited:
+                queue.append((dep.name, dep.file, depth + 1))
+
+    # Upstream: dependencies
+    upstream_list: list[dict] = []
+    for dep in symbol_graph.get_dependencies(target.id):
+        upstream_list.append({"name": dep.name, "file": dep.file})
+
+    # File-level test coverage weight
+    file_coverage = test_coverage.get(file, 0.5)
+    downstream_file_coverage = 0.0
+    if downstream_set:
+        downstream_files = {v["file"] for v in downstream_set.values()}
+        covered = sum(test_coverage.get(f, 0.0) for f in downstream_files)
+        downstream_file_coverage = covered / len(downstream_files) if downstream_files else 0.0
+
+    test_coverage_score = (file_coverage + downstream_file_coverage) / 2.0
+
+    # Criticality: higher for exported/route/core symbols
+    criticality = criticality_tags.get(symbol_name, 0.3)
+    if target.kind == "route":
+        criticality = max(criticality, 0.8)
+    elif target.is_exported:
+        criticality = max(criticality, 0.5)
+    criticality_score = min(criticality, 1.0)
+
+    # Risk score: more downstream = higher risk, less test coverage = higher risk
+    downstream_risk = min(len(downstream_set) / 50.0, 1.0)
+    coverage_risk = 1.0 - test_coverage_score
+    risk_score = downstream_risk * 0.4 + coverage_risk * 0.3 + criticality_score * 0.3
+    risk_score = min(risk_score, 1.0)
+
+    risk_level = "low"
+    if risk_score > 0.3:
+        risk_level = "medium"
+    if risk_score > 0.6:
+        risk_level = "high"
+    if risk_score > 0.85:
+        risk_level = "critical"
+
+    return SymbolBlastResult(
+        symbol_name=symbol_name,
+        file=file,
+        line=target.line,
+        downstream_direct=direct_downstream,
+        downstream_all=list(downstream_set.values()),
+        downstream_count=len(downstream_set),
+        upstream_direct=upstream_list,
+        upstream_count=len(upstream_list),
+        test_coverage_score=test_coverage_score,
+        criticality_score=criticality_score,
+        risk_score=risk_score,
+        risk_level=risk_level,
+    )
+
+
+def calculate_file_symbol_blast_radius(
+    file_path: str,
+    symbol_graph: Any,
+    test_coverage: dict[str, float] | None = None,
+    criticality_tags: dict[str, float] | None = None,
+) -> list[SymbolBlastResult]:
+    """Compute symbol-level blast radius for all symbols in a file."""
+    symbols = symbol_graph.get_symbols_in_file(file_path)
+    return [
+        calculate_symbol_blast_radius(s.name, s.file, symbol_graph, test_coverage, criticality_tags)
+        for s in symbols
+    ]
+
+
+@dataclass
+class GraphDiffImpact:
+    """Structural impact analysis from a graph diff."""
+
+    file: str
+    symbols_added: int = 0
+    symbols_removed: int = 0
+    symbols_modified: int = 0
+    downstream_impact: int = 0
+    upstream_impact: int = 0
+    risk_level: str = "low"
+
+    @property
+    def total_changes(self) -> int:
+        return self.symbols_added + self.symbols_removed + self.symbols_modified
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "symbols_added": self.symbols_added,
+            "symbols_removed": self.symbols_removed,
+            "symbols_modified": self.symbols_modified,
+            "downstream_impact": self.downstream_impact,
+            "upstream_impact": self.upstream_impact,
+            "risk_level": self.risk_level,
+        }
+
+
+def analyze_graph_diff(
+    diff: Any,
+    symbol_graph: Any,
+) -> list[GraphDiffImpact]:
+    """Analyze structural impact of a graph diff (damage vs repair).
+
+    For each file with structural changes, compute downstream/upstream impact.
+    """
+    if not diff or not diff.has_changes:
+        return []
+
+    affected_files: dict[str, GraphDiffImpact] = {}
+
+    for sym in diff.added:
+        if sym.file not in affected_files:
+            affected_files[sym.file] = GraphDiffImpact(file=sym.file)
+        affected_files[sym.file].symbols_added += 1
+
+    for sym in diff.removed:
+        if sym.file not in affected_files:
+            affected_files[sym.file] = GraphDiffImpact(file=sym.file)
+        affected_files[sym.file].symbols_removed += 1
+
+    for sym in diff.modified:
+        if sym.file not in affected_files:
+            affected_files[sym.file] = GraphDiffImpact(file=sym.file)
+        affected_files[sym.file].symbols_modified += 1
+
+    for file, impact in affected_files.items():
+        symbols = symbol_graph.get_symbols_in_file(file)
+        for s in symbols:
+            result = calculate_symbol_blast_radius(s.name, s.file, symbol_graph)
+            impact.downstream_impact = max(impact.downstream_impact, result.downstream_count)
+            impact.upstream_impact = max(impact.upstream_impact, result.upstream_count)
+
+        total = impact.total_changes
+        downstream = impact.downstream_impact
+        impact.risk_level = "low"
+        if (total >= 3 and downstream >= 5) or (total >= 1 and downstream >= 20):
+            impact.risk_level = "critical"
+        elif (total >= 2 and downstream >= 3) or downstream >= 10:
+            impact.risk_level = "high"
+        elif total >= 1 and downstream >= 1:
+            impact.risk_level = "medium"
+
+    return list(affected_files.values())

patchi/core/brain/body_tags.py

@@ -0,0 +1,144 @@
+"""
+Body Tags — understander-first tagging for Patchi.
+
+Generates .patchi/memory/body_tags.json on every Brain.scan from
+deterministic signals already computed: import_graph fan-in, blast_radius,
+layered_brain level, route hit, stack framework, file size.
+
+Roles map to human anatomy (Body skill):
+  brain  = orchestrators, contracts, memory, config
+  muscle = agents, scanners, security, testing, fix
+  bone   = data types, schemas, constants, models
+  blood  = wiring (import_graph hubs, routing)
+  skin   = web/api/cli surface
+  nerve  = watchers, interceptors, guards, queue
+
+Criticality: critical|high|medium|low based on fan-in + dependents + route adjacency.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+_log = logging.getLogger("patchi.brain.body_tags")
+
+BODY_TAGS_FILE = ".patchi/memory/body_tags.json"
+
+
+def _classify_role(path: str, layers: dict, is_route_file: bool, is_hub: bool) -> tuple[str, str]:
+    p = path.lower()
+    if "brain" in p or "memory" in p or "config" in p or "contract" in p:
+        return "brain", "orchestrator"
+    if "web/routes" in p or "web/api" in p or "cli/commands" in p:
+        return "skin", "surface"
+    if "security" in p or "agents" in p or "testing" in p or "fix/" in p:
+        return "muscle", "scanner" if "security" in p or "agents" in p else "fixer"
+    if "constants" in p or "scanner" in p or "file_corpus" in p or "import_graph" in p:
+        return "bone", "structure"
+    if is_hub or "import_graph" in p or "route_mapper" in p or "blast_radius" in p:
+        return "blood", "wiring"
+    if "watch" in p or "interceptor" in p or "guard" in p or "queue" in p:
+        return "nerve", "guard"
+    # fallback via layered brain
+    for lname, lyr in layers.items():
+        if path in getattr(lyr, "files", []):
+            if lyr.level == 1:
+                return "bone", "module"
+            unicode = "skin" if "web" in lname or "cli" in lname else "muscle"
+            return unicode, lname
+    return "muscle", "general"
+
+
+def build_body_tags(
+    file_infos: list[Any],
+    graph: Any,
+    layers: dict,
+    routes: list[Any],
+    blast_map: dict[str, Any] | None = None,
+) -> dict[str, dict[str, Any]]:
+    # fan-in via graph.reverse, hub threshold
+    reverse = getattr(graph, "reverse", {}) if graph else {}
+    fan_in_counts = {fp: len(reverse.get(fp, [])) for fp in [fi.path for fi in file_infos]}
+    hub_threshold = 5  # top hubs
+    sorted_fan = sorted(fan_in_counts.items(), key=lambda x: -x[1])
+    hubs = {fp for fp, _ in sorted_fan[:20] if _ >= hub_threshold}
+    # route adjacency
+    _route_paths = {getattr(r, "path", "") for r in (routes or [])}
+    route_files = set()
+    for fi in file_infos:
+        low = fi.path.lower()
+        if any(seg in low for seg in ["route", "web", "api", "handler"]):
+            route_files.add(fi.path)
+
+    tags: dict[str, dict[str, Any]] = {}
+    for fi in file_infos:
+        path = fi.path
+        fan_in = fan_in_counts.get(path, 0)
+        is_hub = path in hubs
+        is_route = path in route_files
+        role, system = _classify_role(path, layers, is_route, is_hub)
+        # criticality
+        br = blast_map.get(path) if blast_map and path in blast_map else None
+        all_deps = getattr(br, "all_dependents", None) if br is not None else None
+        if all_deps is None:
+            all_deps = getattr(br, "dependents", []) if br is not None else []
+        dep_count = len(all_deps) if isinstance(all_deps, (list, set, tuple)) else 0
+        if fan_in >= 10 or dep_count >= 15 or path.lower() in ("patchi/core/brain/brain.py", "patchi/core/memory.py"):
+            crit = "critical"
+        elif fan_in >= 5 or is_hub or is_route or "core/brain" in path:
+            crit = "high"
+        elif fan_in >= 2 or "core/" in path:
+            crit = "medium"
+        else:
+            crit = "low"
+        # layer name
+        layer_name = ""
+        for lname, lyr in layers.items():
+            if path in getattr(lyr, "files", []):
+                layer_name = lname
+                break
+        # score for understander ranking
+        score = fan_in * 10 + dep_count * 3 + (20 if crit == "critical" else 10 if crit == "high" else 0) + (5 if is_route else 0)
+        tags[path] = {
+            "role": role,
+            "system": system,
+            "layer": layer_name,
+            "criticality": crit,
+            "fan_in": fan_in,
+            "score": score,
+            "is_hub": is_hub,
+            "is_route_file": is_route,
+        }
+    return tags
+
+
+def save_body_tags(tags: dict[str, dict], root: Path) -> Path:
+    out = root / BODY_TAGS_FILE
+    out.parent.mkdir(parents=True, exist_ok=True)
+    # atomic write
+    tmp = out.with_suffix(".tmp")
+    payload = {"version": 1, "count": len(tags), "tags": tags}
+    tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    # replace dance for win32
+    import sys as _sys
+
+    if _sys.platform == "win32" and out.exists():
+        out.unlink()
+    tmp.replace(out)
+    _log.info("body_tags: wrote %d tags to %s", len(tags), out)
+    return out
+
+
+def load_body_tags(root: Path) -> dict[str, dict]:
+    p = root / BODY_TAGS_FILE
+    if not p.exists():
+        return {}
+    try:
+        data: Any = json.loads(p.read_text(encoding="utf-8"))
+        return data.get("tags", {}) if isinstance(data, dict) else {}
+    except Exception as exc:  # noqa: BLE001
+        _log.debug("body_tags load failed: %s", exc)
+        return {}