patchi 0.7.5__py3-none-any.whl

patchi/core/reliability/fault_injector.py

@@ -0,0 +1,172 @@
+"""FaultInjector — identify fault injection points in code.
+
+Scans for patterns that should handle failures gracefully but don't
+(network calls without try/except, DB writes without rollback, file I/O
+without close/finally, etc.).
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from patchi.core.assurance.graph import AssuranceGraph
+
+_log = logging.getLogger("patchi.reliability.fault_injection")
+
+
+@dataclass
+class FaultInjectionPoint:
+    """A location in code where fault injection would be valuable."""
+
+    file: str
+    line: int
+    fault_type: str  # "network", "disk", "database", "memory", "cpu"
+    pattern: str  # what was detected
+    recovery_strategy: str  # what should be there
+    severity: str  # "high", "medium", "low"
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "line": self.line,
+            "fault_type": self.fault_type,
+            "pattern": self.pattern,
+            "recovery_strategy": self.recovery_strategy,
+            "severity": self.severity,
+        }
+
+
+# Patterns that indicate missing fault handling
+_FAULT_PATTERNS: list[tuple[str, str, str, str, str]] = [
+    # (regex pattern, fault_type, description, recovery, severity)
+    (
+        r"\.read\(|\.write\(",
+        "disk",
+        "File I/O without try/except",
+        "Add try/except with IOError handling",
+        "medium",
+    ),
+    (
+        r"requests\.(get|post|put|delete)\(",
+        "network",
+        "HTTP request without timeout/retry",
+        "Add timeout and retry with backoff",
+        "high",
+    ),
+    (
+        r"subprocess\.run\(|subprocess\.Popen\(",
+        "network",
+        "Subprocess without error handling",
+        "Add try/except and check returncode",
+        "medium",
+    ),
+    (
+        r"\.execute\(|\.commit\(",
+        "database",
+        "DB operation without rollback",
+        "Add try/except with rollback in finally",
+        "high",
+    ),
+    (
+        r"json\.loads\(",
+        "disk",
+        "JSON parse without try/except",
+        "Add try/except for JSONDecodeError",
+        "medium",
+    ),
+    (
+        r"open\(",
+        "disk",
+        "File open without context manager",
+        "Use with-statement for guaranteed close",
+        "medium",
+    ),
+    (
+        r"pickle\.loads?\(",
+        "memory",
+        "Unsafe deserialization",
+        "Use safe deserialization or json",
+        "high",
+    ),
+    (
+        r"eval\(|exec\(",
+        "memory",
+        "Dynamic code execution",
+        "Replace with safe alternatives",
+        "high",
+    ),
+]
+
+
+class FaultInjector:
+    """Analyze code for missing fault handling."""
+
+    def __init__(self, root: Path, graph: AssuranceGraph | None = None):
+        self._root = root
+        self._graph = graph
+
+    def scan_file(self, file_path: Path) -> list[FaultInjectionPoint]:
+        """Scan a single file for fault injection points."""
+        results: list[FaultInjectionPoint] = []
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return results
+
+        lines = content.splitlines()
+        rel_path = (
+            str(file_path.relative_to(self._root))
+            if self._root in file_path.parents
+            else str(file_path)
+        )
+
+        for line_num, line in enumerate(lines, 1):
+            stripped = line.strip()
+            if stripped.startswith("#") or stripped.startswith("//"):
+                continue
+
+            for pattern, fault_type, description, recovery, severity in _FAULT_PATTERNS:
+                import re
+
+                if re.search(pattern, line):
+                    # Check if already has try/except nearby
+                    if not self._has_error_handling(lines, line_num - 1):
+                        results.append(
+                            FaultInjectionPoint(
+                                file=rel_path,
+                                line=line_num,
+                                fault_type=fault_type,
+                                pattern=description,
+                                recovery_strategy=recovery,
+                                severity=severity,
+                            )
+                        )
+                        break  # one finding per line
+
+        return results
+
+    def scan_project(self, max_files: int = 200) -> list[FaultInjectionPoint]:
+        """Scan the project for fault injection points."""
+        results: list[FaultInjectionPoint] = []
+        count = 0
+
+        for py_file in sorted(self._root.rglob("*.py")):
+            if count >= max_files:
+                break
+            if ".patchi" in str(py_file) or "__pycache__" in str(py_file):
+                continue
+            if ".venv" in str(py_file) or "node_modules" in str(py_file):
+                continue
+            results.extend(self.scan_file(py_file))
+            count += 1
+
+        return results
+
+    def _has_error_handling(self, lines: list[str], line_idx: int) -> bool:
+        """Check if a line is inside a try/except block (±5 lines)."""
+        start = max(0, line_idx - 5)
+        end = min(len(lines), line_idx + 6)
+        block = "\n".join(lines[start:end])
+        return "try:" in block and ("except" in block or "finally:" in block)

patchi/core/reliability/idempotency.py

@@ -0,0 +1,128 @@
+"""IdempotencyAnalyzer — find operations that should be idempotent but aren't.
+
+Detects side effects that happen on every call (file writes without checks,
+DB inserts without upserts, network calls without deduplication).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_log = logging.getLogger("patchi.reliability.idempotency")
+
+
+@dataclass
+class IdempotencyIssue:
+    """An operation that should be idempotent but has side effects."""
+
+    file: str
+    line: int
+    issue_type: str  # "append_without_check", "insert_without_upsert", "write_without_guard"
+    description: str
+    fix_suggestion: str
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "line": self.line,
+            "issue_type": self.issue_type,
+            "description": self.description,
+            "fix_suggestion": self.fix_suggestion,
+        }
+
+
+# Patterns indicating non-idempotent operations
+_IDEMPOTENCY_PATTERNS: list[tuple[str, str, str, str]] = [
+    (
+        r"\.append\(",
+        "append_without_check",
+        "List append without dedup check",
+        "Check if item exists before appending",
+    ),
+    (
+        r"conn\.execute\(['\"]INSERT",
+        "insert_without_upsert",
+        "SQL INSERT without upsert",
+        "Use INSERT OR REPLACE or check existence first",
+    ),
+    (
+        r"\.write_text\(",
+        "write_without_guard",
+        "File write without content comparison",
+        "Compare content before writing to avoid unnecessary I/O",
+    ),
+    (
+        r"json\.dumps.*\.write_text\(",
+        "write_without_guard",
+        "JSON write without read-compare",
+        "Read existing content and compare before writing",
+    ),
+    (
+        r"\.add\(",
+        "set_add_without_check",
+        "Set add without membership check",
+        "Use set.add() (already idempotent) or document non-idempotent semantics",
+    ),
+]
+
+
+class IdempotencyAnalyzer:
+    """Analyze code for idempotency issues."""
+
+    def __init__(self, root: Path):
+        self._root = root
+
+    def scan_file(self, file_path: Path) -> list[IdempotencyIssue]:
+        """Scan a single file for idempotency issues."""
+        results: list[IdempotencyIssue] = []
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return results
+
+        lines = content.splitlines()
+        rel_path = (
+            str(file_path.relative_to(self._root))
+            if self._root in file_path.parents
+            else str(file_path)
+        )
+
+        for line_num, line in enumerate(lines, 1):
+            stripped = line.strip()
+            if stripped.startswith("#") or stripped.startswith("//"):
+                continue
+
+            for pattern, issue_type, description, fix in _IDEMPOTENCY_PATTERNS:
+                if re.search(pattern, line):
+                    results.append(
+                        IdempotencyIssue(
+                            file=rel_path,
+                            line=line_num,
+                            issue_type=issue_type,
+                            description=description,
+                            fix_suggestion=fix,
+                        )
+                    )
+                    break  # one per line
+
+        return results
+
+    def scan_project(self, max_files: int = 200) -> list[IdempotencyIssue]:
+        """Scan the project for idempotency issues."""
+        results: list[IdempotencyIssue] = []
+        count = 0
+
+        for py_file in sorted(self._root.rglob("*.py")):
+            if count >= max_files:
+                break
+            if ".patchi" in str(py_file) or "__pycache__" in str(py_file):
+                continue
+            if ".venv" in str(py_file) or "node_modules" in str(py_file):
+                continue
+            results.extend(self.scan_file(py_file))
+            count += 1
+
+        return results

patchi/core/reliability/recovery.py

@@ -0,0 +1,147 @@
+"""RecoveryAnalyzer — analyze data flows for recovery patterns.
+
+Checks that critical data paths have circuit breakers, retry logic,
+and graceful degradation.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from patchi.core.assurance.graph import AssuranceGraph
+
+_log = logging.getLogger("patchi.reliability.recovery")
+
+
+@dataclass
+class RecoveryGap:
+    """A data flow missing a recovery pattern."""
+
+    file: str
+    flow: str  # "source → sink"
+    missing_pattern: str  # "circuit_breaker", "retry", "fallback", "timeout"
+    severity: str
+    recommendation: str
+
+    def to_dict(self) -> dict:
+        return {
+            "file": self.file,
+            "flow": self.flow,
+            "missing_pattern": self.missing_pattern,
+            "severity": self.severity,
+            "recommendation": self.recommendation,
+        }
+
+
+class RecoveryAnalyzer:
+    """Analyze data flows for missing recovery patterns."""
+
+    def __init__(self, root: Path, graph: AssuranceGraph | None = None):
+        self._root = root
+        self._graph = graph
+
+    def analyze(self, max_gaps: int = 30) -> list[RecoveryGap]:
+        """Analyze the project for missing recovery patterns."""
+        gaps: list[RecoveryGap] = []
+
+        # Check data flows from the graph
+        if self._graph:
+            gaps.extend(self._graph_flow_analysis())
+
+        # Check common patterns in code
+        gaps.extend(self._code_pattern_analysis())
+
+        return gaps[:max_gaps]
+
+    def _graph_flow_analysis(self) -> list[RecoveryGap]:
+        """Analyze data flows from the assurance graph for recovery gaps."""
+        gaps: list[RecoveryGap] = []
+
+        for claim in self._graph.claims.values():
+            for ev in claim.evidence:
+                if not ev.supports:
+                    continue
+                artifact = ev.artifact
+                source = artifact.get("source", "")
+                sink = artifact.get("sink", "")
+
+                if not source or not sink:
+                    continue
+
+                # External sinks need circuit breakers
+                if any(kw in sink.lower() for kw in ["api", "http", "network", "remote"]):
+                    gaps.append(
+                        RecoveryGap(
+                            file=source,
+                            flow=f"{source} → {sink}",
+                            missing_pattern="circuit_breaker",
+                            severity="high",
+                            recommendation=f"Add circuit breaker between {source} and external {sink}",
+                        )
+                    )
+
+                # Database sinks need retry with backoff
+                if any(kw in sink.lower() for kw in ["db", "database", "sql", "redis"]):
+                    gaps.append(
+                        RecoveryGap(
+                            file=source,
+                            flow=f"{source} → {sink}",
+                            missing_pattern="retry",
+                            severity="medium",
+                            recommendation=f"Add retry with exponential backoff for {sink} operations",
+                        )
+                    )
+
+        return gaps
+
+    def _code_pattern_analysis(self) -> list[RecoveryGap]:
+        """Scan code for missing recovery patterns."""
+        gaps: list[RecoveryGap] = []
+
+        for py_file in sorted(self._root.rglob("*.py")):
+            if ".patchi" in str(py_file) or "__pycache__" in str(py_file):
+                continue
+            if ".venv" in str(py_file):
+                continue
+
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                continue
+
+            rel = (
+                str(py_file.relative_to(self._root))
+                if self._root in py_file.parents
+                else str(py_file)
+            )
+
+            # Check for network calls without retry
+            if re.search(r"requests\.(get|post|put|delete)\(", content):
+                if "retry" not in content.lower() and "tenacity" not in content.lower():
+                    gaps.append(
+                        RecoveryGap(
+                            file=rel,
+                            flow="HTTP request",
+                            missing_pattern="retry",
+                            severity="medium",
+                            recommendation="Add retry with backoff for HTTP requests",
+                        )
+                    )
+
+            # Check for DB operations without rollback
+            if re.search(r"\.execute\(|\.commit\(", content):
+                if "rollback" not in content.lower():
+                    gaps.append(
+                        RecoveryGap(
+                            file=rel,
+                            flow="Database operation",
+                            missing_pattern="rollback",
+                            severity="high",
+                            recommendation="Add try/except with rollback for database operations",
+                        )
+                    )
+
+        return gaps

patchi/core/runtime/__init__.py

@@ -0,0 +1,5 @@
+"""Runtime tracer package (E-3)."""
+
+from patchi.core.runtime.tracer import TraceReport, trace_file
+
+__all__ = ["TraceReport", "trace_file"]

patchi/core/runtime/tracer.py

@@ -0,0 +1,230 @@
+"""
+Runtime Tracer — AST-guided execution tracing for Python target code.
+
+Runs a Python file in a fresh subprocess under a sys.settrace-based tracer
+that records:
+  - every function call/return (name, file, line, duration)
+  - raised exceptions with full argument snapshot
+  - total wall time
+
+Bounded by design: wall-clock timeout kills the child; trace buffer is
+capped; output is a single JSON blob on a pipe — never interleaved with
+program stdout.
+
+This closes the gap between "scanner found it" and "reproduced it":
+RuntimeCrashScanner findings can be fed here for a reproduction trace.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+_log = logging.getLogger("patchi.core.runtime.tracer")
+
+# The child-side tracer source. Injected as a file so we don't fight
+# shell quoting; kept as one string so it stays reviewable.
+_CHILD_TRACER = r"""
+import json
+import sys
+import time
+import tracemalloc
+
+MAX_CALLS = int(sys.argv[1]) if len(sys.argv) > 1 else 5000
+
+calls = []          # completed call records
+exceptions = []     # captured exceptions
+order = [0]
+tracemalloc.start()
+
+def _tracer(frame, event, arg):
+    if len(calls) >= MAX_CALLS and event != "exception":
+        return None
+    co = frame.f_code
+    rec = {
+        "fn": co.co_name,
+        "file": co.co_filename,
+        "line": co.co_firstlineno,
+    }
+    if event == "call":
+        order[0] += 1
+        rec["seq"] = order[0]
+        rec["event"] = "call"
+        calls.append(rec)
+        return _tracer
+    if event == "return":
+        rec["event"] = "return"
+        calls.append(rec)
+        return None
+    if event == "exception":
+        exc_type, exc_val, _ = arg
+        tb = exc_val.__traceback__
+        exceptions.append({
+            "type": exc_type.__name__,
+            "message": str(exc_val)[:300],
+            "file": tb.tb_frame.f_code.co_filename if tb else co.co_filename,
+            "line": tb.tb_lineno if tb else 0,
+            "locals": {
+                k: repr(v)[:120]
+                for k, v in list(frame.f_locals.items())[:15]
+                if not k.startswith("__")
+            },
+        })
+        return _tracer
+    return None
+
+
+def main():
+    target = sys.argv[2]
+    out_path = sys.argv[3]
+    sys.argv = [target] + sys.argv[4:]
+    sys.settrace(_tracer)
+    t0 = time.perf_counter()
+    exit_code = 0
+    try:
+        with open(target, encoding="utf-8") as fh:
+            code = compile(fh.read(), target, "exec")
+        g = {"__name__": "__main__", "__file__": target}
+        exec(code, g)
+    except SystemExit as e:
+        exit_code = e.code if isinstance(e.code, int) else 0
+    except BaseException as e:
+        exit_code = 1
+        exceptions.append({
+            "type": type(e).__name__,
+            "message": str(e)[:300],
+            "file": target,
+            "line": getattr(getattr(e, "__traceback__", None), "tb_lineno", 0),
+            "locals": {},
+            "fatal": True,
+        })
+    finally:
+        sys.settrace(None)
+    duration = time.perf_counter() - t0
+    current, peak = tracemalloc.get_traced_memory()
+    out = {
+        "exit_code": exit_code,
+        "duration_s": round(duration, 4),
+        "peak_memory_bytes": peak,
+        "call_count": len(calls),
+        "truncated": len(calls) >= MAX_CALLS,
+        "calls": calls[-200:],       # tail: most recent activity
+        "exceptions": exceptions,
+    }
+    # Dedicated file, NOT stdout: the traced program owns stdout.
+    with open(out_path, "w", encoding="utf-8") as fh:
+        json.dump(out, fh, default=str)
+
+main()
+"""
+
+
+@dataclass
+class TraceReport:
+    """Structured result of one traced run."""
+
+    exit_code: int = -1
+    duration_s: float = 0.0
+    peak_memory_bytes: int = 0
+    call_count: int = 0
+    truncated: bool = False
+    calls: list[dict] = field(default_factory=list)
+    exceptions: list[dict] = field(default_factory=list)
+    error: str = ""
+
+    @property
+    def crashed(self) -> bool:
+        return bool(self.exceptions) or self.exit_code not in (0, None)
+
+    def hot_functions(self, top_n: int = 10) -> list[tuple[str, int]]:
+        """Most-called functions — N+1 query / loop-hotspot candidates."""
+        counts: dict[str, int] = {}
+        for c in self.calls:
+            if c.get("event") == "call":
+                key = f"{c['fn']} ({Path(c['file']).name}:{c['line']})"
+                counts[key] = counts.get(key, 0) + 1
+        return sorted(counts.items(), key=lambda kv: -kv[1])[:top_n]
+
+    def to_dict(self) -> dict:
+        return {
+            "exit_code": self.exit_code,
+            "duration_s": self.duration_s,
+            "peak_memory_bytes": self.peak_memory_bytes,
+            "call_count": self.call_count,
+            "truncated": self.truncated,
+            "crashed": self.crashed,
+            "hot_functions": [{"fn": fn, "calls": n} for fn, n in self.hot_functions()],
+            "exceptions": self.exceptions,
+            "error": self.error,
+        }
+
+
+def trace_file(
+    script: str | Path,
+    timeout: float = 60.0,
+    max_calls: int = 5000,
+    args: list[str] | None = None,
+) -> TraceReport:
+    """
+    Run *script* under the tracer; returns a TraceReport.
+
+    Never raises for program behavior — crashes are captured data. Raises
+    only for infrastructure failures (missing file, bad extension).
+    """
+    path = Path(script).resolve()
+    if path.suffix.lower() != ".py":
+        raise ValueError(f"tracer supports .py only, got {path.suffix}")
+    if not path.is_file():
+        raise FileNotFoundError(str(path))
+
+    with tempfile.TemporaryDirectory() as td:
+        tracer_path = Path(td) / "_patchi_tracer.py"
+        tracer_path.write_text(_CHILD_TRACER, encoding="utf-8")
+        out_path = Path(td) / "trace_out.json"
+
+        cmd = [
+            sys.executable,
+            str(tracer_path),
+            str(max_calls),
+            str(path),
+            str(out_path),
+            *(args or []),
+        ]
+        try:
+            proc = subprocess.run(
+                cmd,
+                capture_output=True,
+                timeout=timeout,
+                cwd=str(path.parent),
+            )
+        except subprocess.TimeoutExpired:
+            return TraceReport(error=f"timed out after {timeout}s")
+
+        if not out_path.is_file():
+            return TraceReport(
+                error=f"tracer failed rc={proc.returncode}: {proc.stderr.decode(errors='replace')[:300]}"
+            )
+
+        try:
+            raw = json.loads(out_path.read_text(encoding="utf-8", errors="replace"))
+        except (json.JSONDecodeError, UnicodeDecodeError) as e:
+            return TraceReport(error=f"unparseable trace output: {e}")
+
+        report = TraceReport(
+            exit_code=raw.get("exit_code", -1),
+            duration_s=raw.get("duration_s", 0.0),
+            peak_memory_bytes=raw.get("peak_memory_bytes", 0),
+            call_count=raw.get("call_count", 0),
+            truncated=raw.get("truncated", False),
+            calls=raw.get("calls", []),
+            exceptions=raw.get("exceptions", []),
+        )
+        # A fatal exception means exit handler captured it but exit stayed 1.
+        if any(x.get("fatal") for x in report.exceptions):
+            report.exit_code = 1
+        return report