gdmcode 0.1.0__py3-none-any.whl

src/agent/orchestrator.py

@@ -0,0 +1,141 @@
+"""Multi-file edit orchestrator with atomic rollback."""
+from __future__ import annotations
+
+import os
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class FileEdit:
+    path: str          # relative to project root
+    content: str       # new file content (full replacement)
+    create: bool = False  # True if creating new file
+
+
+@dataclass
+class OrchestratorPlan:
+    edits: list[FileEdit]
+    description: str = ""
+    dependencies: dict[str, list[str]] = field(default_factory=dict)
+    # dependencies: {file_path: [files_that_must_be_edited_first]}
+
+
+@dataclass
+class OrchestratorResult:
+    success: bool
+    applied: list[str] = field(default_factory=list)   # paths successfully written
+    rolled_back: list[str] = field(default_factory=list)  # paths restored on failure
+    error: str | None = None
+
+
+class MultiFileOrchestrator:
+    """Coordinates multi-file edits with dependency ordering and atomic rollback.
+
+    On any failure, all already-applied edits are reverted to original content.
+    """
+
+    def __init__(self, project_root: str | Path = "."):
+        self._root = Path(project_root)
+
+    def apply(self, plan: OrchestratorPlan) -> OrchestratorResult:
+        """Apply all edits in dependency order. Roll back all on any failure."""
+        try:
+            ordered = self._topological_sort(plan.edits, plan.dependencies)
+        except ValueError as exc:
+            return OrchestratorResult(success=False, error=str(exc))
+
+        paths = [e.path for e in ordered]
+        backups = self._backup(paths)
+        applied: list[str] = []
+
+        try:
+            for edit in ordered:
+                self._write(edit)
+                applied.append(edit.path)
+        except Exception as exc:  # noqa: BLE001
+            self._restore(backups)
+            return OrchestratorResult(
+                success=False,
+                rolled_back=list(backups.keys()),
+                error=str(exc),
+            )
+
+        return OrchestratorResult(success=True, applied=applied)
+
+    def _topological_sort(
+        self, edits: list[FileEdit], deps: dict[str, list[str]]
+    ) -> list[FileEdit]:
+        """Return edits sorted by dependency order (Kahn''s algorithm).
+
+        Raises ValueError on circular dependency.
+        """
+        edit_by_path: dict[str, FileEdit] = {e.path: e for e in edits}
+
+        # Build in-degree and adjacency: prereq -> [dependents]
+        in_degree: dict[str, int] = {e.path: 0 for e in edits}
+        dependents: dict[str, list[str]] = {e.path: [] for e in edits}
+
+        for path, prereqs in deps.items():
+            if path not in in_degree:
+                continue
+            for prereq in prereqs:
+                if prereq not in in_degree:
+                    continue
+                in_degree[path] += 1
+                dependents[prereq].append(path)
+
+        # Kahn''s: start with zero-in-degree nodes (sorted for determinism)
+        queue: list[str] = sorted(p for p, d in in_degree.items() if d == 0)
+        result: list[FileEdit] = []
+
+        while queue:
+            path = queue.pop(0)
+            result.append(edit_by_path[path])
+            for dep in sorted(dependents[path]):
+                in_degree[dep] -= 1
+                if in_degree[dep] == 0:
+                    queue.append(dep)
+
+        if len(result) != len(edits):
+            raise ValueError("Circular dependency detected in edit plan")
+
+        return result
+
+    def _backup(self, paths: list[str]) -> dict[str, str | None]:
+        """Snapshot current file contents. None if file does not exist."""
+        backups: dict[str, str | None] = {}
+        for path in paths:
+            abs_path = self._root / path
+            backups[path] = abs_path.read_text(encoding="utf-8") if abs_path.exists() else None
+        return backups
+
+    def _restore(self, backups: dict[str, str | None]) -> None:
+        """Restore files from backup snapshot."""
+        for path, content in backups.items():
+            abs_path = self._root / path
+            if content is None:
+                # File did not exist before: remove it if it was created
+                if abs_path.exists():
+                    abs_path.unlink()
+            else:
+                abs_path.parent.mkdir(parents=True, exist_ok=True)
+                abs_path.write_text(content, encoding="utf-8")
+
+    def _write(self, edit: FileEdit) -> None:
+        """Write a single FileEdit atomically (write to temp, then rename)."""
+        abs_path = self._root / edit.path
+        abs_path.parent.mkdir(parents=True, exist_ok=True)
+
+        fd, tmp_str = tempfile.mkstemp(dir=abs_path.parent, prefix=".gdm_tmp_")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(edit.content)
+            os.replace(tmp_str, str(abs_path))
+        except Exception:
+            try:
+                os.unlink(tmp_str)
+            except OSError:
+                pass
+            raise

src/agent/regression_guard.py

@@ -0,0 +1,251 @@
+"""Regression guard — capture test baselines before edits, verify after.
+
+Protocol:
+  BEFORE editing file X:
+    1. Locate test files that import X
+    2. Run those tests and record pass/fail baseline
+  AFTER editing file X:
+    1. Re-run the same tests
+    2. Compare against baseline — report any newly failing tests
+  On 2 consecutive failures: recommend git reset to last checkpoint.
+"""
+from __future__ import annotations
+
+import logging
+import random
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+__all__ = ["RegressionGuard", "RegressionResult"]
+
+log = logging.getLogger(__name__)
+
+_TEST_RUN_TIMEOUT: int = 120
+_MAX_SCOPED_TESTS: int = 50  # cap for performance scoping
+
+
+# ---------------------------------------------------------------------------
+# Data classes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TestRun:
+    """Result of a single test run."""
+
+    passed: bool
+    failed_tests: list[str] = field(default_factory=list)
+    output: str = ""
+    exit_code: int = 0
+    coverage_pct: float | None = None
+
+
+@dataclass
+class RegressionResult:
+    """Outcome of a before/after regression comparison."""
+
+    file_edited: Path
+    baseline: TestRun
+    after_edit: TestRun
+    regressions: list[str]     # test names that were passing and now fail
+    new_passes: list[str]      # test names that were failing and now pass
+    rollback_recommended: bool
+    coverage_drop: float | None = None  # pp drop in coverage, if measurable
+
+    @property
+    def new_failures(self) -> list[str]:
+        """Alias for regressions — tests that newly fail after the edit."""
+        return self.regressions
+
+    @property
+    def has_regression(self) -> bool:
+        return bool(self.regressions)
+
+    def summary(self) -> str:
+        """Human-readable summary for the agent."""
+        if not self.has_regression:
+            return f"✓ No regressions detected in {self.file_edited.name}"
+        lines = [f"⚠ Regressions in {self.file_edited.name}:"]
+        for t in self.regressions:
+            lines.append(f"  ✗ {t}")
+        if self.rollback_recommended:
+            lines.append("  → Rollback recommended (2+ consecutive failures)")
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# RegressionGuard
+# ---------------------------------------------------------------------------
+
+class RegressionGuard:
+    """Captures test baselines and detects regressions caused by file edits.
+
+    Usage::
+
+        guard = RegressionGuard(project_root)
+        guard.capture_baseline(Path("src/auth.py"))
+        # ... make edits ...
+        result = guard.verify_after_edit(Path("src/auth.py"))
+        if result.has_regression:
+            console.print(result.summary())
+    """
+
+    def __init__(self, project_root: Path) -> None:
+        self._root = project_root
+        self._baselines: dict[Path, TestRun] = {}
+        self._fail_streak: dict[Path, int] = {}
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def capture_baseline(self, file_path: Path) -> TestRun:
+        """Run tests for *file_path* and store baseline. Returns the run result."""
+        test_files = self._find_test_files(file_path)
+        if not test_files:
+            log.debug("No test files found for %s — skipping baseline", file_path)
+            baseline = TestRun(passed=True, output="(no tests found)")
+        else:
+            baseline = self._run_tests(test_files)
+        self._baselines[file_path] = baseline
+        return baseline
+
+    def verify_after_edit(self, file_path: Path) -> RegressionResult:
+        """Re-run tests and compare against stored baseline."""
+        baseline = self._baselines.get(file_path, TestRun(passed=True))
+        test_files = self._find_test_files(file_path)
+
+        if not test_files:
+            return RegressionResult(
+                file_edited=file_path,
+                baseline=baseline,
+                after_edit=TestRun(passed=True, output="(no tests found)"),
+                regressions=[],
+                new_passes=[],
+                rollback_recommended=False,
+            )
+
+        after = self._run_tests(test_files)
+        regressions = _compute_regressions(baseline, after)
+        new_passes = _compute_new_passes(baseline, after)
+
+        if regressions:
+            self._fail_streak[file_path] = self._fail_streak.get(file_path, 0) + 1
+        else:
+            self._fail_streak[file_path] = 0
+
+        rollback = self._fail_streak.get(file_path, 0) >= 2
+
+        coverage_drop: float | None = None
+        if baseline.coverage_pct is not None and after.coverage_pct is not None:
+            drop = baseline.coverage_pct - after.coverage_pct
+            if drop > 5.0:
+                coverage_drop = drop
+                log.warning(
+                    "Coverage drop of %.1fpp detected for %s (%.1f%% → %.1f%%)",
+                    drop, file_path, baseline.coverage_pct, after.coverage_pct,
+                )
+
+        return RegressionResult(
+            file_edited=file_path,
+            baseline=baseline,
+            after_edit=after,
+            regressions=regressions,
+            new_passes=new_passes,
+            rollback_recommended=rollback,
+            coverage_drop=coverage_drop,
+        )
+
+    def reset_streak(self, file_path: Path) -> None:
+        """Reset consecutive failure count for a file (e.g., after rollback)."""
+        self._fail_streak.pop(file_path, None)
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _find_test_files(self, file_path: Path) -> list[Path]:
+        """Find test files that likely test the given source file.
+
+        Performance scoping: skip baseline if 0 tests found; sample randomly
+        (max _MAX_SCOPED_TESTS) if too many are found.
+        """
+        stem = file_path.stem
+        candidates: list[Path] = []
+
+        for pattern in (f"test_{stem}.py", f"{stem}_test.py", f"test_{stem}.ts"):
+            found = list(self._root.rglob(pattern))
+            candidates.extend(found)
+
+        if not candidates:
+            candidates = [
+                Path(p) for p in self._grep_import_refs(stem, self._root)
+            ]
+
+        if not candidates:
+            return []
+
+        if len(candidates) > _MAX_SCOPED_TESTS:
+            candidates = random.sample(candidates, _MAX_SCOPED_TESTS)
+
+        return candidates[:_MAX_SCOPED_TESTS]
+
+    def _grep_import_refs(self, module_name: str, root: Path) -> list[str]:
+        """Find test files that reference the given module name (Windows-safe)."""
+        results: list[str] = []
+        for py_file in root.rglob("test_*.py"):
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+                if module_name in content:
+                    results.append(str(py_file))
+            except OSError:
+                pass
+        return results
+
+    def _run_tests(self, test_files: list[Path]) -> TestRun:
+        """Run pytest on specific test files. Returns TestRun."""
+        args = ["python", "-m", "pytest", "--tb=line", "-q",
+                *[str(f) for f in test_files]]
+        try:
+            proc = subprocess.run(
+                args, capture_output=True, text=True,
+                cwd=self._root, timeout=_TEST_RUN_TIMEOUT,
+            )
+            combined = proc.stdout + proc.stderr
+            failed = _extract_failed_tests(combined)
+            return TestRun(
+                passed=proc.returncode == 0,
+                failed_tests=failed,
+                output=combined[:3_000],
+                exit_code=proc.returncode,
+            )
+        except subprocess.TimeoutExpired:
+            return TestRun(passed=False, output="Tests timed out", exit_code=1)
+        except OSError as exc:
+            return TestRun(passed=False, output=str(exc), exit_code=1)
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+def _extract_failed_tests(output: str) -> list[str]:
+    """Parse pytest --tb=line output to extract failed test names."""
+    pattern = re.compile(r"FAILED (.+?) -")
+    return [m.group(1).strip() for m in pattern.finditer(output)]
+
+
+def _compute_regressions(before: TestRun, after: TestRun) -> list[str]:
+    """Tests that were passing before and are failing after."""
+    before_failed = set(before.failed_tests)
+    after_failed = set(after.failed_tests)
+    return sorted(after_failed - before_failed)
+
+
+def _compute_new_passes(before: TestRun, after: TestRun) -> list[str]:
+    """Tests that were failing before and are passing after."""
+    before_failed = set(before.failed_tests)
+    after_failed = set(after.failed_tests)
+    return sorted(before_failed - after_failed)