patchi 0.7.5__py3-none-any.whl

patchi/core/snapshot.py

@@ -0,0 +1,242 @@
+"""
+Snapshot / rollback system for Patchi.
+
+Before any fix is applied, Patchi creates a snapshot of the target file(s).
+If tests fail after a fix, the snapshot is used to restore the original state.
+
+Snapshots are stored as JSON in .patchi/snapshots/<snapshot_id>.json.
+They contain the full original file content, so rollback is always possible
+regardless of how many changes were made.
+
+Design decisions:
+- Full-file snapshots rather than diffs: simpler to implement, always reliable.
+- Diffs are computed separately for display (review panel) but rollback always
+  uses the full-file snapshot.
+- Snapshots are never deleted automatically. The user cleans them via `p memory`.
+"""
+
+import json
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from patchi.core.atomic import atomic_replace, atomic_write_json
+from patchi.core.config import require_project_root
+from patchi.core.constants import SNAPSHOT_DIR
+
+# ── Data model ─────────────────────────────────────────────────────────────────
+#
+# A snapshot record looks like:
+# {
+#   "id": "a1b2c3d4",
+#   "patch_id": "e5f6g7h8",   # the fix this snapshot guards
+#   "created": "2025-01-01T00:00:00+00:00",
+#   "files": {
+#     "src/auth/middleware.py": "<full original content>",
+#     ...
+#   }
+# }
+
+
+def _snapshots_dir(root: Path) -> Path:
+    return root / SNAPSHOT_DIR
+
+
+def _snapshot_path(snapshot_id: str, root: Path) -> Path:
+    return _snapshots_dir(root) / f"{snapshot_id}.json"
+
+
+def _root(root: Path | None) -> Path:
+    return root or require_project_root()
+
+
+# ── Create ─────────────────────────────────────────────────────────────────────
+
+
+def create(file_paths: list[str], patch_id: str, root: Path | None = None) -> str:
+    """
+    Read the current content of every file in file_paths and store a snapshot.
+    Returns the snapshot_id.
+
+    file_paths should be relative to the project root.
+    Files that don't exist are recorded with content = None (new-file case).
+    """
+    r = _root(root)
+    _snapshots_dir(r).mkdir(parents=True, exist_ok=True)
+
+    files: dict[str, str | None] = {}
+    for rel_path in file_paths:
+        abs_path = r / rel_path
+        if abs_path.exists():
+            files[rel_path] = abs_path.read_text(encoding="utf-8")
+        else:
+            files[rel_path] = None  # file doesn't exist yet (creation fix)
+
+    snapshot_id = str(uuid.uuid4())[:8]
+    record = {
+        "id": snapshot_id,
+        "patch_id": patch_id,
+        "created": _now(),
+        "files": files,
+    }
+
+    _write_json(_snapshot_path(snapshot_id, r), record)
+    return snapshot_id
+
+
+# ── Restore (rollback) ─────────────────────────────────────────────────────────
+
+
+def restore(snapshot_id: str, root: Path | None = None) -> list[str]:
+    """
+    Roll back all files covered by this snapshot to their original content.
+    Returns a list of file paths that were restored.
+
+    If the original content was None (file didn't exist), the file is deleted.
+    """
+    r = _root(root)
+    record = load(snapshot_id, r)
+    if record is None:
+        raise FileNotFoundError(f"Snapshot {snapshot_id!r} not found.")
+
+    restored: list[str] = []
+    for rel_path, original_content in record["files"].items():
+        abs_path = r / rel_path
+        if original_content is None:
+            # File was created by the fix — delete it on rollback
+            if abs_path.exists():
+                abs_path.unlink()
+        else:
+            abs_path.parent.mkdir(parents=True, exist_ok=True)
+            # Atomic write: tmp + rename to prevent half-rolled-back state
+            tmp = abs_path.with_suffix(abs_path.suffix + ".rollback_tmp")
+            tmp.write_text(original_content, encoding="utf-8")
+            tmp.replace(abs_path)
+        restored.append(rel_path)
+
+    return restored
+
+
+# ── Read ───────────────────────────────────────────────────────────────────────
+
+
+def load(snapshot_id: str, root: Path | None = None) -> dict | None:
+    """Return the snapshot record, or None if it doesn't exist."""
+    r = _root(root)
+    path = _snapshot_path(snapshot_id, r)
+    if not path.exists():
+        return None
+    return _read_json(path)
+
+
+def list_all(root: Path | None = None) -> list[dict]:
+    """Return all snapshots, sorted newest first, with file content omitted."""
+    r = _root(root)
+    snap_dir = _snapshots_dir(r)
+    if not snap_dir.exists():
+        return []
+
+    records: list[dict] = []
+    for snap_file in sorted(snap_dir.glob("*.json"), reverse=True):
+        record = _read_json(snap_file)
+        # Strip file contents for the list view — only show paths
+        records.append(
+            {
+                "id": record["id"],
+                "patch_id": record.get("patch_id"),
+                "created": record.get("created"),
+                "file_count": len(record.get("files", {})),
+                "file_paths": list(record.get("files", {}).keys()),
+            }
+        )
+    return records
+
+
+def get_by_patch_id(patch_id: str, root: Path | None = None) -> dict | None:
+    """Find the snapshot that guards a specific patch."""
+    r = _root(root)
+    snap_dir = _snapshots_dir(r)
+    if not snap_dir.exists():
+        return None
+    for snap_file in snap_dir.glob("*.json"):
+        record = _read_json(snap_file)
+        if record.get("patch_id") == patch_id:
+            return record
+    return None
+
+
+# ── Delete ─────────────────────────────────────────────────────────────────────
+
+
+def delete(snapshot_id: str, root: Path | None = None) -> bool:
+    """Delete a single snapshot. Returns True if it existed."""
+    r = _root(root)
+    path = _snapshot_path(snapshot_id, r)
+    if path.exists():
+        path.unlink()
+        return True
+    return False
+
+
+def delete_all(root: Path | None = None) -> int:
+    """Delete all snapshots. Returns count deleted."""
+    r = _root(root)
+    snap_dir = _snapshots_dir(r)
+    if not snap_dir.exists():
+        return 0
+    count = 0
+    for snap_file in snap_dir.glob("*.json"):
+        snap_file.unlink()
+        count += 1
+    return count
+
+
+# ── Diff helper ────────────────────────────────────────────────────────────────
+
+
+def compute_diff(snapshot_id: str, root: Path | None = None) -> dict[str, str]:
+    """
+    Compute unified diffs for all files in this snapshot vs their current state.
+    Returns a dict of {relative_path: unified_diff_string}.
+    """
+    import difflib
+
+    r = _root(root)
+    record = load(snapshot_id, r)
+    if record is None:
+        return {}
+
+    diffs: dict[str, str] = {}
+    for rel_path, original in record["files"].items():
+        abs_path = r / rel_path
+        current = abs_path.read_text(encoding="utf-8") if abs_path.exists() else ""
+        original = original or ""
+
+        diff_lines = list(
+            difflib.unified_diff(
+                original.splitlines(keepends=True),
+                current.splitlines(keepends=True),
+                fromfile=f"a/{rel_path}",
+                tofile=f"b/{rel_path}",
+            )
+        )
+        diffs[rel_path] = "".join(diff_lines)
+
+    return diffs
+
+
+# ── Utilities ──────────────────────────────────────────────────────────────────
+
+
+def _write_json(path: Path, data: Any) -> None:
+    atomic_write_json(path, data)
+
+
+def _read_json(path: Path) -> Any:
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()

patchi/core/tenant.py

@@ -0,0 +1,386 @@
+"""
+Tenant Manager — Project-level state isolation for multi-tenant operation.
+
+Each project gets isolated:
+- Brain state (.patchi/)
+- Scan results
+- Cost tracking
+- Findings history
+- Configuration
+
+The active project is tracked in the server state and can be switched at runtime.
+Supports request-scoped tenant context for concurrent web requests.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+_log = logging.getLogger("patchi.tenant")
+
+# Thread-local storage for request-scoped tenant context
+_thread_local = threading.local()
+
+
+@dataclass
+class TenantState:
+    """State for a single project/tenant."""
+
+    root: Path
+    name: str
+    active: bool = True
+    last_accessed: str = ""
+    findings_count: int = 0
+    scan_count: int = 0
+    cost_estimate: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "root": str(self.root),
+            "name": self.name,
+            "active": self.active,
+            "last_accessed": self.last_accessed,
+            "findings_count": self.findings_count,
+            "scan_count": self.scan_count,
+            "cost_estimate": self.cost_estimate,
+        }
+
+
+class TenantManager:
+    """Manages multiple project tenants with state isolation."""
+
+    def __init__(self, state_dir: Path | None = None):
+        self._state_dir = state_dir or Path.home() / ".patchi" / "tenants"
+        self._state_dir.mkdir(parents=True, exist_ok=True)
+        self._tenants: dict[str, TenantState] = {}
+        self._active_tenant: str | None = None
+        self._load_state()
+
+    def register_project(self, root: Path, name: str | None = None) -> TenantState:
+        """Register a project as a tenant."""
+        key = str(root.resolve())
+        if key in self._tenants:
+            self._tenants[key].active = True
+            return self._tenants[key]
+
+        tenant = TenantState(
+            root=root.resolve(),
+            name=name or root.name,
+            active=True,
+        )
+        self._tenants[key] = tenant
+        self._save_state()
+        _log.info("Registered tenant: %s (%s)", tenant.name, key)
+        return tenant
+
+    def switch_project(self, root: Path) -> TenantState:
+        """Switch to a different project."""
+        key = str(root.resolve())
+        if key not in self._tenants:
+            self.register_project(root)
+
+        # Deactivate previous
+        if self._active_tenant and self._active_tenant in self._tenants:
+            self._tenants[self._active_tenant].active = False
+
+        # Activate new
+        self._tenants[key].active = True
+        self._active_tenant = key
+
+        # Initialize the project state
+        self._init_project_state(root)
+
+        self._save_state()
+        _log.info("Switched to tenant: %s", self._tenants[key].name)
+        return self._tenants[key]
+
+    def get_active(self) -> TenantState | None:
+        """Get the currently active tenant."""
+        if self._active_tenant:
+            return self._tenants.get(self._active_tenant)
+        return None
+
+    def get_active_root(self) -> Path:
+        """Get the active project root path."""
+        tenant = self.get_active()
+        if tenant:
+            return tenant.root
+        # Fallback to current working directory
+        return Path.cwd()
+
+    def list_projects(self) -> list[TenantState]:
+        """List all registered projects."""
+        return list(self._tenants.values())
+
+    def remove_project(self, root: Path) -> bool:
+        """Remove a project from the tenant list."""
+        key = str(root.resolve())
+        if key in self._tenants:
+            del self._tenants[key]
+            if self._active_tenant == key:
+                self._active_tenant = None
+            self._save_state()
+            return True
+        return False
+
+    def discover_projects(
+        self, near: Path | None = None, max_depth: int = 2, limit: int = 25
+    ) -> list[Path]:
+        """Find Patchi projects on disk near a reference directory.
+
+        Search bases (deduplicated):
+          - the reference dir itself and its parent (siblings pattern:
+            ~/repos/project-a while viewing project-b)
+          - one level of children of the parent (workspace folders)
+
+        Only directories containing .patchi/ count. Bounded scan — never
+        walks the whole filesystem, and never scans the system temp tree
+        (test fixtures would flood the results).
+        """
+        import tempfile
+
+        base = (near or Path.cwd()).resolve()
+        candidates: dict[str, Path] = {}
+        roots_to_scan: list[Path] = []
+
+        for candidate_base in (base, base.parent, base.parent.parent):
+            if not candidate_base.is_dir():
+                continue
+            if candidate_base not in roots_to_scan:
+                roots_to_scan.append(candidate_base)
+
+        # The system temp tree is full of throwaway test fixtures — exclude it
+        # and everything beneath it from discovery.
+        try:
+            sys_temp = Path(tempfile.gettempdir()).resolve()
+
+            def _in_temp(p: Path) -> bool:
+                try:
+                    return p == sys_temp or sys_temp in p.parents
+                except OSError:
+                    return False
+
+            roots_to_scan = [r for r in roots_to_scan if not _in_temp(r)]
+        except Exception as _exc:
+            _log.warning('discover_projects failed: %s', _exc)
+
+        for scan_root in roots_to_scan:
+            try:
+                for child in sorted(scan_root.iterdir()):
+                    if len(candidates) >= limit:
+                        break
+                    if not child.is_dir() or child.name.startswith("."):
+                        continue
+                    if _in_temp(child):
+                        continue
+                    if (child / ".patchi").is_dir():
+                        key = str(child.resolve())
+                        candidates.setdefault(key, child)
+                # Also the scan root itself may be a project
+                if (scan_root / ".patchi").is_dir():
+                    key = str(scan_root.resolve())
+                    candidates.setdefault(key, scan_root)
+            except (PermissionError, OSError):
+                continue
+
+        return list(candidates.values())
+
+    def update_stats(self, root: Path, **kwargs) -> None:
+        """Update tenant statistics."""
+        key = str(root.resolve())
+        if key in self._tenants:
+            for k, v in kwargs.items():
+                if hasattr(self._tenants[key], k):
+                    setattr(self._tenants[key], k, v)
+            self._save_state()
+
+    def _init_project_state(self, root: Path) -> None:
+        """Initialize .patchi/ directory for a project."""
+        patchi_dir = root / ".patchi"
+        patchi_dir.mkdir(parents=True, exist_ok=True)
+
+        # Ensure required subdirs
+        for subdir in ["logs", "evidence", "snapshots", "cache"]:
+            (patchi_dir / subdir).mkdir(exist_ok=True)
+
+        # Initialize config if not present
+        config_file = patchi_dir / "config.json"
+        if not config_file.exists():
+            config_file.write_text("{}")
+
+        # Initialize memory (full .patchi structure + default memory files)
+        from patchi.core.config import init_project
+
+        init_project(root)
+
+        # Initialize cost tracker
+        from patchi.core.ai import cost_tracker
+
+        cost_tracker.init(root)
+
+    def _load_state(self) -> None:
+        """Load tenant state from disk."""
+        state_file = self._state_dir / "tenants.json"
+        try:
+            with open(state_file, encoding="utf-8") as f:
+                data = json.load(f)
+            for key, tdata in data.get("tenants", {}).items():
+                self._tenants[key] = TenantState(
+                    root=Path(tdata["root"]),
+                    name=tdata.get("name", ""),
+                    active=tdata.get("active", True),
+                    last_accessed=tdata.get("last_accessed", ""),
+                    findings_count=tdata.get("findings_count", 0),
+                    scan_count=tdata.get("scan_count", 0),
+                    cost_estimate=tdata.get("cost_estimate", 0.0),
+                )
+            self._active_tenant = data.get("active_tenant")
+        except (FileNotFoundError, json.JSONDecodeError):
+            pass
+
+    def _save_state(self) -> None:
+        """Persist tenant state to disk."""
+        state_file = self._state_dir / "tenants.json"
+        data = {
+            "active_tenant": self._active_tenant,
+            "tenants": {k: v.to_dict() for k, v in self._tenants.items()},
+        }
+        try:
+            state_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception as e:
+            _log.warning("Failed to save tenant state: %s", e)
+
+
+# ── Global Tenant Manager ────────────────────────────────────────────────────
+
+_tenant_manager: TenantManager | None = None
+
+
+def get_tenant_manager() -> TenantManager:
+    """Get the global tenant manager."""
+    global _tenant_manager
+    if _tenant_manager is None:
+        _tenant_manager = TenantManager()
+    return _tenant_manager
+
+
+# ── Request-Scoped Tenant Context ───────────────────────────────────────────
+
+
+@contextmanager
+def tenant_context(root: Path):
+    """Context manager that scopes the active tenant for the current thread.
+
+    Used by web request handlers to ensure each request operates on the
+    correct project's state without global state corruption.
+
+    Usage::
+
+        with tenant_context(project_root):
+            # All memory/config calls use project_root
+            scan_results = mem.get_scan_results(project_root)
+    """
+    previous = getattr(_thread_local, "tenant_root", None)
+    _thread_local.tenant_root = root
+    try:
+        yield root
+    finally:
+        _thread_local.tenant_root = previous
+
+
+def get_current_tenant_root() -> Path | None:
+    """Get the request-scoped tenant root, or None if not in a context."""
+    return getattr(_thread_local, "tenant_root", None)
+
+
+# ── Per-Tenant Cost Tracking ────────────────────────────────────────────────
+
+_tenant_costs: dict[str, float] = {}  # root -> cumulative cost
+tenant_costs_lock = threading.Lock()
+
+
+def track_tenant_cost(root: Path, cost_usd: float) -> None:
+    """Record AI cost for a specific tenant."""
+    key = str(root.resolve())
+    with tenant_costs_lock:
+        _tenant_costs[key] = _tenant_costs.get(key, 0) + cost_usd
+
+
+def get_tenant_cost(root: Path) -> float:
+    """Get cumulative AI cost for a tenant."""
+    key = str(root.resolve())
+    with tenant_costs_lock:
+        return _tenant_costs.get(key, 0.0)
+
+
+def get_all_tenant_costs() -> dict[str, float]:
+    """Get costs for all tenants."""
+    with tenant_costs_lock:
+        return dict(_tenant_costs)
+
+
+def check_tenant_cost_alert(root: Path, config: dict | None = None) -> dict | None:
+    """Check if per-tenant spending exceeds the configured limit.
+
+    Returns a dict with alert info if threshold exceeded, None otherwise.
+    Never raises — handles None, missing keys, and non-numeric values gracefully.
+
+    Config keys (under ``ai``):
+      cost_limit          — dollar amount that triggers the alert (default 10.0)
+      cost_warn_pct       — percentage of limit that triggers warning (default 80)
+    """
+    try:
+        cfg = config or {}
+        ai_cfg = cfg.get("ai") or {}
+
+        # Safely parse cost_limit — handle None, empty string, non-numeric
+        raw_limit = ai_cfg.get("cost_limit")
+        if raw_limit in (None, "", "null", "None"):
+            limit = 10.0
+        else:
+            try:
+                limit = float(raw_limit)
+            except (TypeError, ValueError):
+                limit = 10.0
+
+        # Safely parse cost_warn_pct
+        raw_pct = ai_cfg.get("cost_warn_pct")
+        if raw_pct in (None, "", "null", "None"):
+            warn_pct = 80.0
+        else:
+            try:
+                warn_pct = float(raw_pct)
+            except (TypeError, ValueError):
+                warn_pct = 80.0
+
+        if limit <= 0:
+            return None
+
+        spent = get_tenant_cost(root)
+        pct = (spent / limit) * 100 if limit > 0 else 0
+
+        if pct >= 100:
+            return {
+                "level": "critical",
+                "message": f"AI budget exhausted: ${spent:.2f} / ${limit:.2f}",
+                "spent": spent,
+                "limit": limit,
+                "pct": round(pct, 1),
+            }
+        elif pct >= warn_pct:
+            return {
+                "level": "warning",
+                "message": f"AI spending at {pct:.0f}% of budget: ${spent:.2f} / ${limit:.2f}",
+                "spent": spent,
+                "limit": limit,
+                "pct": round(pct, 1),
+            }
+        return None
+    except Exception:
+        # Never crash — cost alerts are non-critical
+        return None

patchi/core/testing/__init__.py

@@ -0,0 +1,17 @@
+from .test_agents import (
+    BrowserTestAgent,
+    RegressionAgent,
+    StressTestAgent,
+    TestCase,
+    TestSuite,
+    UnitTestAgent,
+)
+
+__all__ = [
+    "TestCase",
+    "TestSuite",
+    "UnitTestAgent",
+    "BrowserTestAgent",
+    "StressTestAgent",
+    "RegressionAgent",
+]