patchi 0.7.5__py3-none-any.whl

patchi/core/fix/risk_gate.py

@@ -0,0 +1,383 @@
+"""
+Risk Gate for Patchi.
+
+Every patch passes through the risk gate before anything touches disk.
+The gate decides: auto-apply | ask user | block
+
+Three modes (from config):
+  CONFIRM     — every patch requires explicit user approval (Y/N)
+  AUTO        — patches with risk_score ≤ threshold auto-apply; riskier ones ask
+  AUTOPILOT   — all patches auto-apply; gate only blocks if contract is broken
+
+Risk threshold for AUTO mode: config["risk_threshold"] (default 30).
+
+Additional hard blocks (fire regardless of mode):
+  1. App contract not locked — no fix runs until user confirms the contract
+  2. No-touch restriction violated — patch targets a restricted path
+  3. Blast radius report required — config["require_blast_radius_on_high_risk"] = True
+     and risk_score ≥ 61 — blast radius must be computed and shown before applying
+
+Gate decisions:
+  ALLOW_AUTO   — apply without asking (low risk + AUTO/AUTOPILOT mode)
+  REQUIRE_REVIEW — surface to user for approval (confirm mode OR high risk)
+  BLOCK        — refuse entirely (contract not locked, restricted path)
+
+The gate NEVER raises exceptions. It always returns a GateDecision.
+"""
+
+from __future__ import annotations
+
+import datetime
+import logging
+from dataclasses import dataclass, field
+from enum import StrEnum
+from pathlib import Path
+
+from patchi.core import config as cfg
+from patchi.core import memory as mem
+from patchi.core.constants import Mode, RiskLevel
+from patchi.core.fix.patch import Patch
+
+_log = logging.getLogger("patchi.fix.risk_gate")
+
+# ── Gate decision ──────────────────────────────────────────────────────────────
+
+
+class GateDecision(StrEnum):
+    ALLOW_AUTO = "allow_auto"  # apply immediately
+    REQUIRE_REVIEW = "require_review"  # surface to user
+    BLOCK = "block"  # hard stop
+
+
+@dataclass
+class GateResult:
+    decision: GateDecision
+    reason: str
+    patch_id: str
+    risk_score: int
+    risk_level: str
+    confidence: int
+    blast_radius: int
+    blocks: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    requires_blast_report: bool = False
+
+    @property
+    def is_blocked(self) -> bool:
+        return self.decision == GateDecision.BLOCK
+
+    @property
+    def is_auto(self) -> bool:
+        return self.decision == GateDecision.ALLOW_AUTO
+
+    @property
+    def needs_review(self) -> bool:
+        return self.decision == GateDecision.REQUIRE_REVIEW
+
+    def to_dict(self) -> dict:
+        return {
+            "decision": self.decision.value,
+            "reason": self.reason,
+            "patch_id": self.patch_id,
+            "risk_score": self.risk_score,
+            "risk_level": self.risk_level,
+            "confidence": self.confidence,
+            "blast_radius": self.blast_radius,
+            "blocks": self.blocks,
+            "warnings": self.warnings,
+            "requires_blast_report": self.requires_blast_report,
+        }
+
+
+# ── Risk gate ──────────────────────────────────────────────────────────────────
+
+
+class RiskGate:
+    """
+    Evaluates every patch before it is applied.
+
+    Usage:
+        gate = RiskGate(project_root)
+        result = gate.evaluate(patch)
+        if result.is_blocked:
+            # tell user why
+        elif result.is_auto:
+            # apply now
+        else:
+            # surface for review
+    """
+
+    def __init__(self, root: Path):
+        self.root = root
+        try:
+            self._config = cfg.load(root)
+        except Exception as e:
+            _log.warning(
+                "Failed to load config for %s — falling back to defaults (restricted-path "
+                "protections may be affected): %s",
+                root,
+                e,
+            )
+            self._config = {}
+        try:
+            self._brain = mem.get_brain(root)
+        except Exception as e:
+            _log.warning("Failed to load brain data for %s — falling back to empty: %s", root, e)
+            self._brain = {}
+
+    def evaluate(self, patch: Patch) -> GateResult:
+        """Run all gate checks and return a decision."""
+        blocks: list[str] = []
+        warnings: list[str] = []
+
+        mode = self._get_mode()
+        risk_threshold = self._config.get("risk_threshold", 30)
+        risk_level = RiskLevel.from_score(patch.risk_score).value
+        requires_blast = False
+
+        # ── Hard blocks ────────────────────────────────────────────────────────
+
+        # 1. Contract must be locked before any fix runs
+        if not self._brain.get("contract_locked"):
+            blocks.append(
+                "App contract not confirmed. Run 'p scan' and confirm your critical flows first. "
+                "No fixes will apply until the contract is locked."
+            )
+
+        # 2. Restricted path check
+        restricted = self._restricted_paths()
+        for change in patch.changes:
+            for path, rtype in restricted:
+                if change.path.startswith(path.rstrip("/")):
+                    if rtype == "sensitive":
+                        warnings.append(
+                            f"'{change.path}' is in a sensitive zone ({path}). "
+                            "Proceed with caution."
+                        )
+                    else:
+                        blocks.append(
+                            f"'{change.path}' is in a restricted {rtype} zone ({path}). "
+                            "Modify restrictions with 'p restrict'."
+                        )
+
+        # 3. Charter boundary check — agent fixes must not violate guard rails
+        try:
+            from patchi.core.security.charter import (
+                RuleType,
+                check_boundary_violations,
+                load_charter,
+            )
+
+            charter = load_charter(self.root)
+            if charter.rules:
+                # Build import edges from proposed changes
+                import_edges: list[tuple[str, str]] = []
+                for change in patch.changes:
+                    if change.proposed:
+                        # Extract import statements from proposed code
+                        import re as _re
+                        for m in _re.finditer(
+                            r'from\s+(\S+)\s+import\s+\w+', change.proposed
+                        ):
+                            import_edges.append((change.path, m.group(1)))
+                        for m in _re.finditer(
+                            r'import\s+(\S+)', change.proposed
+                        ):
+                            import_edges.append((change.path, m.group(1)))
+
+                # Check boundary rules
+                boundary_violations = check_boundary_violations(charter, import_edges)
+                for v in boundary_violations:
+                    blocks.append(
+                        f"Charter violation [{v.rule_id}]: {v.message}. "
+                        f"{v.suggestion}"
+                    )
+
+                # Check convention rules (file size limits)
+                max_lines = 0
+                for rule in charter.rules:
+                    if rule.type == RuleType.CONVENTION and rule.enabled:
+                        if rule.max_value > 0 and rule.metric == "lines":
+                            max_lines = rule.max_value
+                        if max_lines > 0:
+                            for change in patch.changes:
+                                if change.path.endswith((".py", ".ts", ".js")):
+                                    new_lines = (
+                                        (change.proposed or "").count("\n") + 1
+                                    )
+                                    if new_lines > max_lines:
+                                        blocks.append(
+                                            f"Charter violation [{rule.id}]: "
+                                            f"{change.path} would be {new_lines} lines "
+                                            f"(max {max_lines}). {rule.description}"
+                                        )
+        except Exception as e:
+            _log.debug("Charter check skipped: %s", e)
+
+        # 4. Blast radius report required for high-risk patches
+        if (
+            self._config.get("require_blast_radius_on_high_risk", True)
+            and patch.risk_score >= 61
+            and patch.blast_radius == 0
+        ):
+            blocks.append(
+                f"High-risk patch (score {patch.risk_score}) requires a blast radius report. "
+                "Patchi is computing it — this patch will be re-evaluated once ready."
+            )
+            requires_blast = True
+
+        # ── Warnings ───────────────────────────────────────────────────────────
+
+        if patch.confidence < 70:
+            warnings.append(
+                f"Low confidence ({patch.confidence}%). "
+                "Patchi is less certain than usual about this fix."
+            )
+
+        if patch.blast_radius > 10:
+            warnings.append(
+                f"High blast radius: {patch.blast_radius} files depend on the changed file(s). "
+                "Thorough testing is recommended."
+            )
+
+        if patch.total_lines_changed > 100:
+            warnings.append(
+                f"Large patch: {patch.total_lines_changed} lines changed across "
+                f"{patch.file_count} file(s)."
+            )
+
+        # Secrets gate: check if proposed code introduces new secrets
+        try:
+            from patchi.core.security.secrets_guard import gate_check_proposed_code
+
+            for change in patch.changes:
+                if change.proposed:
+                    safe, secret_findings = gate_check_proposed_code(change.proposed, change.path)
+                    if not safe:
+                        blocks.append(
+                            f"Secrets guard: proposed change to '{change.path}' introduces "
+                            f"{len(secret_findings)} secret(s). Fix blocked."
+                        )
+        except ImportError:
+            pass
+
+        # ── Determine decision ─────────────────────────────────────────────────
+
+        if blocks:
+            return GateResult(
+                decision=GateDecision.BLOCK,
+                reason=blocks[0],
+                patch_id=patch.id,
+                risk_score=patch.risk_score,
+                risk_level=risk_level,
+                confidence=patch.confidence,
+                blast_radius=patch.blast_radius,
+                blocks=blocks,
+                warnings=warnings,
+                requires_blast_report=requires_blast,
+            )
+
+        # Test-weakening guard: a patch that only edits test files (set by the
+        # verify loop / fix command) must NEVER auto-apply — it goes to the
+        # human review queue regardless of mode, even AUTOPILOT.
+        if patch.requires_review:
+            return GateResult(
+                decision=GateDecision.REQUIRE_REVIEW,
+                reason=(
+                    "Patch only changes test file(s) — flagged for human review "
+                    "(test-weakening edits are never auto-applied)."
+                ),
+                patch_id=patch.id,
+                risk_score=patch.risk_score,
+                risk_level=risk_level,
+                confidence=patch.confidence,
+                blast_radius=patch.blast_radius,
+                blocks=[],
+                warnings=warnings + ["Test-weakening patch: only test files changed."],
+                requires_blast_report=requires_blast,
+            )
+
+        # Mode-based routing
+        if mode == Mode.CONFIRM:
+            # Always ask in CONFIRM mode
+            decision = GateDecision.REQUIRE_REVIEW
+            reason = "CONFIRM mode — every fix requires approval."
+
+        elif mode == Mode.AUTO:
+            if patch.risk_score <= risk_threshold:
+                decision = GateDecision.ALLOW_AUTO
+                reason = f"AUTO mode — risk score {patch.risk_score} ≤ threshold {risk_threshold}."
+            else:
+                decision = GateDecision.REQUIRE_REVIEW
+                reason = (
+                    f"AUTO mode — risk score {patch.risk_score} exceeds threshold {risk_threshold}. "
+                    "Surfaced for review."
+                )
+
+        else:  # AUTOPILOT
+            decision = GateDecision.ALLOW_AUTO
+            reason = "AUTOPILOT mode — all fixes apply automatically."
+            if patch.risk_score >= 61:
+                warnings.append(
+                    f"High-risk fix applied automatically (AUTOPILOT). "
+                    f"Risk score: {patch.risk_score}. Switch to AUTO mode for manual review."
+                )
+
+        # ── Quiet hours check ─────────────────────────────────────────────────
+        # In quiet hours, auto-apply is blocked even in AUTO/AUTOPILOT modes
+        if decision == GateDecision.ALLOW_AUTO and self._is_quiet_hours():
+            decision = GateDecision.REQUIRE_REVIEW
+            reason = f"Quiet hours active — auto-apply deferred to {self._config.get('quiet_hours_end', 'end')}."
+            warnings.append("Quiet hours: auto-apply blocked. Patch queued for review.")
+
+        return GateResult(
+            decision=decision,
+            reason=reason,
+            patch_id=patch.id,
+            risk_score=patch.risk_score,
+            risk_level=risk_level,
+            confidence=patch.confidence,
+            blast_radius=patch.blast_radius,
+            blocks=blocks,
+            warnings=warnings,
+            requires_blast_report=requires_blast,
+        )
+
+    def _is_quiet_hours(self) -> bool:
+        """Check if current local time falls within configured quiet hours."""
+        quiet_hours = self._config.get("quiet_hours", {})
+        if not quiet_hours.get("enabled", False):
+            return False
+        start = quiet_hours.get("start", "")
+        end = quiet_hours.get("end", "")
+        if not start or not end:
+            return False
+        try:
+            now = datetime.datetime.now()
+            now_minutes = now.hour * 60 + now.minute
+            start_parts = start.split(":")
+            end_parts = end.split(":")
+            start_minutes = int(start_parts[0]) * 60 + int(start_parts[1])
+            end_minutes = int(end_parts[0]) * 60 + int(end_parts[1])
+            if start_minutes <= end_minutes:
+                return start_minutes <= now_minutes < end_minutes
+            return now_minutes >= start_minutes or now_minutes < end_minutes
+        except (ValueError, IndexError, AttributeError):
+            return False
+
+    def _get_mode(self) -> Mode:
+        try:
+            return cfg.get_mode(self.root)
+        except Exception as e:
+            _log.warning(
+                "Failed to read mode from config — defaulting to CONFIRM (safest option): %s", e
+            )
+            return Mode.CONFIRM
+
+    def _restricted_paths(self) -> list[tuple[str, str]]:
+        restrictions = self._config.get("restrictions", [])
+        return [
+            (r["path"], r.get("type", "no_touch"))
+            for r in restrictions
+            if r.get("enabled", True) and r.get("type") in ("no_touch", "scan_only", "sensitive")
+        ]

patchi/core/fix/security_fixer.py

@@ -0,0 +1,93 @@
+"""
+SecurityFixer - Patches confirmed vulnerabilities from security scanner agents.
+"""
+
+from __future__ import annotations
+
+from patchi.core.agents.base import (
+    AgentGroup,
+    AgentInput,
+    AgentResult,
+    BaseAgent,
+    register,
+)
+from patchi.core.fix.patch import FileChange, Patch, PatchType
+
+# Import common functionality from base module
+from .base import _make_patch, _read_file, compute_blast_radius
+
+
+@register
+class SecurityFixer(BaseAgent):
+    """Patches confirmed vulnerabilities from security scanner agents."""
+
+    name = "SecurityFixer"
+    group = AgentGroup.FIX
+    timeout = 120
+
+    def _run(self, inp: AgentInput, result: AgentResult) -> None:
+        from patchi.core.ai.prompts import Skill
+        from patchi.core.fix.fix_agents import _ai_fix
+
+        findings = [
+            f
+            for f in inp.extra.get("findings", [])
+            if (f.get("fix_agent") == self.name or f.get("severity") in ("critical", "high"))
+            and f.get("type") not in ("hardcoded_secret",)
+        ]
+
+        patches: list[Patch] = []
+
+        for finding in findings[:5]:
+            fpath = finding.get("file", "")
+            path = inp.root / fpath
+            original = _read_file(path)
+            if not original:
+                continue
+
+            framework = finding.get("framework", "")
+            blast_radius = 0
+            if hasattr(inp, "extra") and "brain_report" in inp.extra:
+                brain_report = inp.extra["brain_report"]
+                if (
+                    hasattr(brain_report, "blast_radius_map")
+                    and fpath in brain_report.blast_radius_map
+                ):
+                    blast_radius = len(brain_report.blast_radius_map[fpath].all_dependents)
+            else:
+                blast_radius = compute_blast_radius(fpath, inp.root)
+
+            proposed = _ai_fix(
+                inp.config,
+                Skill.SECURITY_FIX,
+                fpath,
+                original,
+                finding,
+                blast_radius,
+                root=inp.root,
+                framework=framework,
+            )
+            if not proposed:
+                continue
+
+            change = FileChange(path=fpath, original=original, proposed=proposed)
+            if not change.diff.strip():
+                continue
+
+            cwe = finding.get("cwe", "")
+            issue_desc = finding.get("message", "Security vulnerability")
+            patch = _make_patch(
+                agent_name=self.name,
+                patch_type=PatchType.SECURITY,
+                changes=[change],
+                description=f"Security fix: {issue_desc[:60]}",
+                ai_explanation=f"CWE-{cwe}: {issue_desc}",
+                finding_id=finding.get("type", ""),
+                blast_radius=blast_radius,
+            )
+            patches.append(patch)
+            result.data.setdefault("patches", []).append(patch.to_dict())
+
+        result.files_scanned = len(findings)
+        result.data["patch_count"] = len(patches)
+        result.ai_calls_made = len(patches)

patchi/core/fix/verify_loop.py

@@ -0,0 +1,204 @@
+"""
+Verify Loop — apply → re-run the failing test → retry → never weaken tests.
+
+Reconstructed module (the original was lost before any commit existed;
+this build follows the exact call contract in cli/commands/fix_cmd.py):
+
+    outcome = run_verify_loop(patch, root=r, config=config, brain=brain,
+                              applier=applier, log=callable)
+    outcome.review_required   # patch only touches tests -> human must review
+    outcome.applied           # final state applied
+    outcome.verified          # the originally-failing test now passes
+    outcome.retries_used      # number of RETRIES after the first attempt
+    outcome.reason            # why it failed / could not be verified
+
+Honesty rules carried over from the fix_cmd contract:
+  - A patch whose changes are exclusively in test files is NEVER applied
+    automatically (test-weakening guard) — flagged for human review.
+  - Verification means the specific failing test passes again, not just
+    "the applier said ok".
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import logging
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+_log = logging.getLogger("patchi.fix.verify_loop")
+
+MAX_RETRIES = 2  # attempts after the first one ("up to 2 retries")
+_VERIFY_TIMEOUT_S = 120  # per-attempt cap for the targeted test re-run
+
+_TEST_FILE_PATTERNS = (
+    "test_*.py",
+    "*_test.py",
+    "conftest.py",
+    "*.spec.ts",
+    "*.spec.tsx",
+    "*.spec.js",
+    "*.spec.jsx",
+    "*.test.ts",
+    "*.test.tsx",
+    "*.test.js",
+    "*.test.jsx",
+    "*_test.go",
+    "*_test.rb",
+    "*Test.java",
+    "*Test.kt",
+    "*Tests.swift",
+)
+
+_TEST_DIR_MARKERS = ("test", "tests", "spec", "specs", "__tests__", "testing")
+
+
+def is_test_path(path: str) -> bool:
+    """True if a relative path points into test code."""
+    import posixpath
+
+    p = path.replace("\\", "/")
+    name = posixpath.basename(p)
+    if any(fnmatch.fnmatch(name, pat) for pat in _TEST_FILE_PATTERNS):
+        return True
+    dirs = {seg.lower() for seg in posixpath.dirname(p).split("/") if seg}
+    return bool(dirs & set(_TEST_DIR_MARKERS))
+
+
+def should_flag_for_review(patch) -> bool:
+    """Test-weakening guard: only-test-file patches always need a human."""
+    changes = getattr(patch, "changes", None) or []
+    if not changes:
+        return False
+    return all(is_test_path(getattr(c, "path", "")) for c in changes)
+
+
+@dataclass
+class VerifyOutcome:
+    """Result of one fix → verify → retry campaign."""
+
+    applied: bool = False
+    verified: bool = False
+    review_required: bool = False
+    patch: object | None = None
+    reason: str = ""
+    retries_used: int = 0
+
+
+def _rerun_failing_test(
+    root: Path,
+    test_file: str,
+    log=None,
+) -> tuple[bool, str]:
+    """Independently re-run one test file. Returns (passed, tail_of_output)."""
+    tf = Path(test_file)
+    target = tf if tf.is_absolute() else root / tf
+    if not target.is_file():
+        return False, f"cannot re-run: {test_file} not found"
+    try:
+        proc = subprocess.run(  # noqa: S603 — fixed argv, no shell
+            [sys.executable, "-m", "pytest", "-x", "-q", str(target)],
+            capture_output=True,
+            text=True,
+            timeout=_VERIFY_TIMEOUT_S,
+            cwd=str(root),
+        )
+        tail = (proc.stdout or "").strip().splitlines()[-6:]
+        output = " | ".join(tail)[:300]
+        passed = proc.returncode == 0
+        if log:
+            log(f"re-ran {test_file}: {'PASS' if passed else 'FAIL'}")
+        return passed, output
+    except subprocess.TimeoutExpired:
+        return False, f"test re-run timed out after {_VERIFY_TIMEOUT_S}s"
+    except OSError as exc:
+        return False, f"could not launch test runner: {exc}"
+
+
+def recheck_test_file(root: Path, test_file: str) -> dict:
+    """Re-run one previously-verified test file (REVERIFY phase helper).
+
+    Contract used by governor._recheck_applied_patches:
+      {"passed": True}   — test ran and passed
+      {"passed": False}  — test ran and failed (regression)
+      {"passed": None}   — could not run (file missing, runner error, timeout)
+    Always includes "output" (tail of runner output) and "error" (message).
+    """
+    if not test_file or not is_test_path(test_file):
+        return {"passed": None, "output": "", "error": f"not a runnable test path: {test_file}"}
+
+    passed, output = _rerun_failing_test(Path(root), test_file)
+    if "cannot re-run" in output or "could not launch" in output or "timed out" in output:
+        return {"passed": None, "output": output, "error": output}
+    return {"passed": bool(passed), "output": output, "error": "" if passed else output}
+
+
+def run_verify_loop(
+    patch,
+    root: Path,
+    config: dict | None = None,
+    brain=None,
+    applier=None,
+    log=None,
+) -> VerifyOutcome:
+    """Apply *patch*, re-verify the failing test, retry up to MAX_RETRIES.
+
+    Never raises: every failure mode becomes an honest VerifyOutcome.
+    """
+    say = log or (lambda _msg: None)
+
+    # Guard first: test-only patches go to a human, full stop.
+    if should_flag_for_review(patch):
+        return VerifyOutcome(review_required=True, patch=patch)
+
+    if applier is None:
+        from patchi.core.fix.applier import PatchApplier
+
+        applier = PatchApplier(root)
+
+    source_finding = getattr(patch, "source_finding", {}) or {}
+    test_file = source_finding.get("file", "")
+
+    attempts = 1 + MAX_RETRIES
+    last_reason = ""
+
+    for attempt in range(1, attempts + 1):
+        result = applier.apply(patch)  # never raises; rolls back on its own
+
+        if not getattr(result, "success", False):
+            last_reason = getattr(result, "error", "") or "apply failed"
+            say(f"attempt {attempt}/{attempts} failed to apply: {last_reason}")
+            patch.verify_retries = attempt - 1
+            continue
+
+        # Applied — now prove it: the original failing test must pass.
+        if test_file and is_test_path(test_file):
+            passed, detail = _rerun_failing_test(Path(root), test_file, log=say)
+            verified = passed
+            reason = "" if passed else f"verification failed: {detail}"
+        else:
+            verified = bool(getattr(result, "test_passed", False))
+            reason = "" if verified else "applied but applier-level tests did not pass"
+
+        if verified:
+            patch.verify_retries = attempt - 1
+            return VerifyOutcome(
+                applied=True,
+                verified=True,
+                patch=patch,
+                retries_used=attempt - 1,
+            )
+
+        last_reason = reason
+        say(f"attempt {attempt}/{attempts} applied but unverified: {reason}")
+        patch.verify_retries = attempt - 1
+
+    return VerifyOutcome(
+        applied=False,
+        verified=False,
+        patch=patch,
+        reason=last_reason or "exhausted retries",
+        retries_used=min(MAX_RETRIES, attempts - 1),
+    )

patchi/core/fuzz/__init__.py

@@ -0,0 +1,8 @@
+"""Fuzzing module — input mutation, sequence reordering, state-space exploration."""
+
+from .corpus import FuzzCorpus
+from .input_fuzzer import InputFuzzer
+from .sequence_fuzzer import SequenceFuzzer
+from .state_fuzzer import StateFuzzer
+
+__all__ = ["InputFuzzer", "SequenceFuzzer", "StateFuzzer", "FuzzCorpus"]