patchi 0.7.5__py3-none-any.whl

patchi/core/queue.py

@@ -0,0 +1,375 @@
+"""
+Queue system for Patchi.
+
+All tasks go through the queue. Nothing runs immediately.
+Queue state persists to .patchi/queue.json between CLI invocations.
+
+Three modes:
+  single  — one task at a time, safest for low-end hardware
+  multi   — parallel up to hardware-detected limit
+  off     — no queue, tasks run immediately (power user mode)
+
+The queue stores task definitions as JSON records.
+Actual task execution is wired up in Agent System.
+The queue here is the data layer + control layer — fully functional.
+"""
+
+import json
+import platform
+import uuid
+from contextlib import contextmanager
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from patchi.core.config import require_project_root
+from patchi.core.constants import (
+    QUEUE_FILE,
+    QUEUE_MAX_DEPTH,
+    QUEUE_WARN_DEPTH,
+    QueueItemState,
+)
+
+# ── Cross-platform file lock ──────────────────────────────────────────────────
+
+
+@contextmanager
+def _file_lock(path: Path):
+    """Simple cross-platform file lock using lock file + atomic create."""
+    lock_path = path.with_suffix(".lock")
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    # Ensure lock file exists before opening
+    lock_path.touch(exist_ok=True)
+
+    if platform.system() == "Windows":
+        # Windows: use msvcrt for file locking
+        import msvcrt
+
+        f = open(lock_path, "r+")
+        try:
+            msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1)
+            yield
+        finally:
+            try:
+                msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+            except OSError:
+                pass
+            f.close()
+    else:
+        # Unix: use fcntl
+        import fcntl
+
+        f = open(lock_path, "r+")
+        try:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+            yield
+        finally:
+            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            f.close()
+
+
+# ── Data model ─────────────────────────────────────────────────────────────────
+#
+# Queue file structure:
+# {
+#   "paused": false,
+#   "items": [
+#     {
+#       "id": "a1b2c3",
+#       "type": "scan | fix | test | security | ...",
+#       "target": "full | src/auth/ | ...",
+#       "state": "waiting | active | done | failed | skipped",
+#       "created": "2025-01-01T00:00:00+00:00",
+#       "started": null,
+#       "completed": null,
+#       "result": null,
+#       "error": null,
+#       "agent": null,
+#       "priority": 0
+#     }
+#   ]
+# }
+
+
+def _queue_path(root: Path) -> Path:
+    return root / QUEUE_FILE
+
+
+def _root(r: Path | None) -> Path:
+    return r or require_project_root()
+
+
+# ── File I/O ───────────────────────────────────────────────────────────────────
+
+
+def _read(root: Path) -> dict:
+    path = _queue_path(root)
+    if not path.exists():
+        return {"paused": False, "items": []}
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _write(root: Path, data: dict) -> None:
+    path = _queue_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    with tmp.open("w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    tmp.replace(path)
+
+
+# ── Queue CRUD ─────────────────────────────────────────────────────────────────
+
+
+def enqueue(
+    task_type: str,
+    target: str = "full",
+    agent: str | None = None,
+    priority: int = 0,
+    extra: dict | None = None,
+    root: Path | None = None,
+) -> str:
+    """
+    Add a task to the queue. Returns the new item's ID.
+    Raises QueueFullError if the queue is at max depth.
+    Warns (via return metadata) if approaching warn depth.
+    """
+    r = _root(root)
+    queue_path = r / QUEUE_FILE
+    with _file_lock(queue_path):
+        data = _read(r)
+
+        waiting = [i for i in data["items"] if i["state"] == QueueItemState.WAITING.value]
+        if len(waiting) >= QUEUE_MAX_DEPTH:
+            raise QueueFullError(
+                f"Queue is full ({QUEUE_MAX_DEPTH} items). "
+                "Clear some tasks or increase queue_max_depth in settings."
+            )
+
+        item_id = str(uuid.uuid4())[:8]
+        item: dict[str, Any] = {
+            "id": item_id,
+            "type": task_type,
+            "target": target,
+            "state": QueueItemState.WAITING.value,
+            "created": _now(),
+            "started": None,
+            "completed": None,
+            "result": None,
+            "error": None,
+            "agent": agent,
+            "priority": priority,
+            **(extra or {}),
+        }
+
+        data["items"].append(item)
+        _write(r, data)
+    return item_id
+
+
+def get_item(item_id: str, root: Path | None = None) -> dict | None:
+    data = _read(_root(root))
+    for item in data["items"]:
+        if item["id"] == item_id:
+            return item
+    return None
+
+
+def list_items(
+    state: QueueItemState | None = None,
+    root: Path | None = None,
+) -> list[dict]:
+    """Return all items, optionally filtered by state."""
+    data = _read(_root(root))
+    items = data["items"]
+    if state is not None:
+        items = [i for i in items if i["state"] == state.value]
+    return items
+
+
+def list_all(root: Path | None = None) -> dict:
+    """Return full queue data including paused flag and all items."""
+    return _read(_root(root))
+
+
+# ── State transitions ──────────────────────────────────────────────────────────
+
+
+def mark_active(item_id: str, root: Path | None = None) -> bool:
+    return _update_item(
+        item_id,
+        {
+            "state": QueueItemState.ACTIVE.value,
+            "started": _now(),
+        },
+        root,
+    )
+
+
+def mark_done(item_id: str, result: Any = None, root: Path | None = None) -> bool:
+    return _update_item(
+        item_id,
+        {
+            "state": QueueItemState.DONE.value,
+            "completed": _now(),
+            "result": result,
+        },
+        root,
+    )
+
+
+def mark_failed(item_id: str, error: str, root: Path | None = None) -> bool:
+    return _update_item(
+        item_id,
+        {
+            "state": QueueItemState.FAILED.value,
+            "completed": _now(),
+            "error": error,
+        },
+        root,
+    )
+
+
+def mark_skipped(item_id: str, root: Path | None = None) -> bool:
+    return _update_item(
+        item_id,
+        {
+            "state": QueueItemState.SKIPPED.value,
+            "completed": _now(),
+        },
+        root,
+    )
+
+
+def _update_item(item_id: str, updates: dict, root: Path | None = None) -> bool:
+    r = _root(root)
+    queue_path = r / QUEUE_FILE
+    with _file_lock(queue_path):
+        data = _read(r)
+        for item in data["items"]:
+            if item["id"] == item_id:
+                item.update(updates)
+                _write(r, data)
+                return True
+    return False
+
+
+# ── Control ────────────────────────────────────────────────────────────────────
+
+
+def pause(root: Path | None = None) -> None:
+    r = _root(root)
+    queue_path = r / QUEUE_FILE
+    with _file_lock(queue_path):
+        data = _read(r)
+        data["paused"] = True
+        _write(r, data)
+
+
+def resume(root: Path | None = None) -> None:
+    r = _root(root)
+    queue_path = r / QUEUE_FILE
+    with _file_lock(queue_path):
+        data = _read(r)
+        data["paused"] = False
+        _write(r, data)
+
+
+def is_paused(root: Path | None = None) -> bool:
+    return _read(_root(root)).get("paused", False)
+
+
+def skip_active(root: Path | None = None) -> str | None:
+    """Mark the current active item as skipped. Returns its ID or None."""
+    r = _root(root)
+    queue_path = r / QUEUE_FILE
+    with _file_lock(queue_path):
+        data = _read(r)
+        for item in data["items"]:
+            if item["state"] == QueueItemState.ACTIVE.value:
+                item["state"] = QueueItemState.SKIPPED.value
+                item["completed"] = _now()
+                _write(r, data)
+                return item["id"]
+    return None
+
+
+def clear(root: Path | None = None) -> int:
+    """
+    Remove all WAITING items. Active/done/failed are preserved for history.
+    Returns the number of items removed.
+    """
+    r = _root(root)
+    data = _read(r)
+    before = len([i for i in data["items"] if i["state"] == QueueItemState.WAITING.value])
+    data["items"] = [i for i in data["items"] if i["state"] != QueueItemState.WAITING.value]
+    _write(r, data)
+    return before
+
+
+def clear_all(root: Path | None = None) -> int:
+    """Remove everything including done/failed history. Returns count removed."""
+    r = _root(root)
+    data = _read(r)
+    count = len(data["items"])
+    data["items"] = []
+    _write(r, data)
+    return count
+
+
+# ── Stats ──────────────────────────────────────────────────────────────────────
+
+
+def depth(root: Path | None = None) -> int:
+    """Number of WAITING items."""
+    return len(list_items(QueueItemState.WAITING, root))
+
+
+def is_near_limit(root: Path | None = None) -> bool:
+    return depth(root) >= QUEUE_WARN_DEPTH
+
+
+def stats(root: Path | None = None) -> dict:
+    data = _read(_root(root))
+    counts: dict[str, int] = {s.value: 0 for s in QueueItemState}
+    for item in data["items"]:
+        counts[item["state"]] = counts.get(item["state"], 0) + 1
+    return {
+        "paused": data.get("paused", False),
+        "total": len(data["items"]),
+        **counts,
+    }
+
+
+# ── Next item picker ─────────────────────────────────
+
+
+def next_waiting(root: Path | None = None) -> dict | None:
+    """
+    Return the next WAITING item (highest priority first, then FIFO).
+    Returns None if queue is empty or paused.
+    """
+    r = _root(root)
+    if is_paused(r):
+        return None
+    waiting = list_items(QueueItemState.WAITING, r)
+    if not waiting:
+        return None
+    # Sort by priority descending, then created ascending
+    waiting.sort(key=lambda i: (-i.get("priority", 0), i.get("created", "")))
+    return waiting[0]
+
+
+# ── Error types ────────────────────────────────────────────────────────────────
+
+
+class QueueFullError(Exception):
+    pass
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()

patchi/core/reliability/__init__.py

@@ -0,0 +1,13 @@
+"""Reliability testing module — fault injection, chaos, idempotency, recovery."""
+
+from .chaos import ChaosScenario
+from .fault_injector import FaultInjector
+from .idempotency import IdempotencyAnalyzer
+from .recovery import RecoveryAnalyzer
+
+__all__ = [
+    "FaultInjector",
+    "ChaosScenario",
+    "IdempotencyAnalyzer",
+    "RecoveryAnalyzer",
+]

patchi/core/reliability/chaos.py

@@ -0,0 +1,163 @@
+"""ChaosScenario — identify chaos engineering opportunities.
+
+Maps data flows and identifies points where failures would cascade,
+suggesting chaos experiments to validate resilience.
+"""
+
+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.chaos")
+
+
+@dataclass
+class ChaosExperiment:
+    """A suggested chaos experiment."""
+
+    name: str
+    target: str  # file or function
+    fault_type: str  # "network_partition", "disk_full", "cpu_spike", "memory_pressure"
+    description: str
+    blast_radius: str  # "low", "medium", "high"
+    expected_impact: str
+    recovery_check: str
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "target": self.target,
+            "fault_type": self.fault_type,
+            "description": self.description,
+            "blast_radius": self.blast_radius,
+            "expected_impact": self.expected_impact,
+            "recovery_check": self.recovery_check,
+        }
+
+
+class ChaosScenario:
+    """Analyze the project for chaos engineering opportunities."""
+
+    def __init__(self, root: Path, graph: AssuranceGraph | None = None):
+        self._root = root
+        self._graph = graph
+        self._flows: list[dict] = []
+
+    def load_flows(self, flows: list[dict]) -> None:
+        """Load data flows from brain data."""
+        self._flows = flows
+
+    def analyze(self, max_experiments: int = 20) -> list[ChaosExperiment]:
+        """Generate chaos experiments based on the project's data flows."""
+        experiments: list[ChaosExperiment] = []
+
+        # Analyze from graph if available
+        if self._graph:
+            experiments.extend(self._graph_based_experiments())
+
+        # Analyze from data flows
+        experiments.extend(self._flow_based_experiments())
+
+        # General resilience checks
+        experiments.extend(self._general_resilience_experiments())
+
+        return experiments[:max_experiments]
+
+    def _graph_based_experiments(self) -> list[ChaosExperiment]:
+        """Generate experiments from assurance graph data flows."""
+        experiments: list[ChaosExperiment] = []
+
+        # Find critical paths (data flows through auth boundaries)
+        for claim in self._graph.claims.values():
+            for ev in claim.evidence:
+                if not ev.supports:
+                    continue
+                artifact = ev.artifact
+                if "sink" in artifact and "source" in artifact:
+                    source = artifact["source"]
+                    sink = artifact["sink"]
+                    experiments.append(
+                        ChaosExperiment(
+                            name=f"partition_{source}_to_{sink}",
+                            target=source,
+                            fault_type="network_partition",
+                            description=f"Simulate network partition between {source} and {sink}",
+                            blast_radius="medium",
+                            expected_impact=f"Requests from {source} to {sink} should timeout gracefully",
+                            recovery_check=f"Verify {sink} returns 503 or cached response",
+                        )
+                    )
+
+        return experiments
+
+    def _flow_based_experiments(self) -> list[ChaosExperiment]:
+        """Generate experiments from data flow analysis."""
+        experiments: list[ChaosExperiment] = []
+
+        # Group flows by source
+        by_source: dict[str, list[dict]] = {}
+        for flow in self._flows:
+            source = flow.get("source", "unknown")
+            by_source.setdefault(source, []).append(flow)
+
+        # For each source with multiple outgoing flows, test dependency failure
+        for source, flows in by_source.items():
+            if len(flows) >= 2:
+                experiments.append(
+                    ChaosExperiment(
+                        name=f"dependency_failure_{source}",
+                        target=source,
+                        fault_type="dependency_failure",
+                        description=f"Simulate failure of one dependency of {source} (has {len(flows)} outgoing flows)",
+                        blast_radius="medium",
+                        expected_impact=f"{source} should degrade gracefully when one dependency fails",
+                        recovery_check="Verify partial results are returned, not a crash",
+                    )
+                )
+
+        return experiments
+
+    def _general_resilience_experiments(self) -> list[ChaosExperiment]:
+        """Generate general resilience experiments."""
+        return [
+            ChaosExperiment(
+                name="disk_full_on_scan",
+                target=".patchi/",
+                fault_type="disk_full",
+                description="Simulate disk full during scan result persistence",
+                blast_radius="low",
+                expected_impact="Scan should complete in memory and warn about persistence failure",
+                recovery_check="Verify scan results are still available in memory",
+            ),
+            ChaosExperiment(
+                name="memory_pressure_large_project",
+                target="scanner",
+                fault_type="memory_pressure",
+                description="Test scanner behavior with very large file corpus",
+                blast_radius="medium",
+                expected_impact="Scanner should process files in batches, not load all into memory",
+                recovery_check="Verify scan completes without OOM",
+            ),
+            ChaosExperiment(
+                name="database_locked",
+                target="history",
+                fault_type="database_lock",
+                description="Simulate SQLite database locked by another process",
+                blast_radius="low",
+                expected_impact="History writes should retry or queue, not crash",
+                recovery_check="Verify scan completes and results are eventually persisted",
+            ),
+            ChaosExperiment(
+                name="network_timeout_ai",
+                target="llm_security_agent",
+                fault_type="network_partition",
+                description="Simulate AI provider timeout during LLM security analysis",
+                blast_radius="low",
+                expected_impact="LLM analysis should timeout gracefully, deterministic agents still work",
+                recovery_check="Verify deterministic findings are still produced",
+            ),
+        ]