gdmcode 0.1.0__py3-none-any.whl

src/agent/verification_loop.py

@@ -0,0 +1,133 @@
+"""Verification loop: run tests → debug → retry until green or max attempts."""
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass, field
+from typing import Callable
+
+
+@dataclass
+class VerificationRound:
+    attempt: int
+    passed: bool
+    test_output: str
+    patch_applied: str | None = None  # description of fix attempted
+    elapsed_s: float = 0.0
+
+
+@dataclass
+class VerificationResult:
+    success: bool                          # True if tests green at end
+    rounds: list[VerificationRound] = field(default_factory=list)
+    final_output: str = ""
+    total_attempts: int = 0
+
+
+class VerificationLoop:
+    """Run tests, debug failures, retry until green or max_attempts reached.
+
+    Workflow per round:
+      1. Run test suite (pytest)
+      2. If green → done
+      3. If red → extract failure message → call debug_fn → apply patch → go to 1
+    """
+
+    def __init__(
+        self,
+        test_cmd: list[str] | None = None,   # default: ["python", "-m", "pytest", "tests/", "-x", "-q"]
+        max_attempts: int = 3,
+        debug_fn: Callable[[str], str] | None = None,  # receives failure output, returns patch description
+        apply_fn: Callable[[str], None] | None = None, # receives patch description, applies it
+        timeout_s: float = 120.0,
+    ):
+        self._test_cmd = test_cmd or ["python", "-m", "pytest", "tests/", "-x", "-q"]
+        self._max_attempts = max_attempts
+        self._debug_fn = debug_fn
+        self._apply_fn = apply_fn
+        self._timeout_s = timeout_s
+
+    def run(self, test_paths: list[str] | None = None) -> VerificationResult:
+        """Run the verification loop. Returns result after green or exhausted attempts."""
+        rounds: list[VerificationRound] = []
+
+        for attempt in range(1, self._max_attempts + 1):
+            t0 = time.monotonic()
+            passed, output = self._run_tests(test_paths)
+            elapsed = time.monotonic() - t0
+
+            if passed:
+                rounds.append(
+                    VerificationRound(
+                        attempt=attempt,
+                        passed=True,
+                        test_output=output,
+                        elapsed_s=elapsed,
+                    )
+                )
+                return VerificationResult(
+                    success=True,
+                    rounds=rounds,
+                    final_output=output,
+                    total_attempts=attempt,
+                )
+
+            patch_desc: str | None = None
+            if self._debug_fn is not None:
+                failure_msg = self._extract_failure(output)
+                patch_desc = self._debug_fn(failure_msg)
+
+            if self._apply_fn is not None and patch_desc is not None:
+                self._apply_fn(patch_desc)
+
+            rounds.append(
+                VerificationRound(
+                    attempt=attempt,
+                    passed=False,
+                    test_output=output,
+                    patch_applied=patch_desc,
+                    elapsed_s=elapsed,
+                )
+            )
+
+        final_output = rounds[-1].test_output if rounds else ""
+        return VerificationResult(
+            success=False,
+            rounds=rounds,
+            final_output=final_output,
+            total_attempts=len(rounds),
+        )
+
+    def _run_tests(self, test_paths: list[str] | None) -> tuple[bool, str]:
+        """Run pytest subprocess. Returns (passed, output)."""
+        cmd = list(self._test_cmd)
+        if test_paths:
+            cmd.extend(test_paths)
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=self._timeout_s,
+            )
+            output = result.stdout + result.stderr
+            return result.returncode == 0, output
+        except subprocess.TimeoutExpired:
+            return False, "Test timed out"
+        except OSError as exc:
+            return False, f"Failed to run tests: {exc}"
+
+    def _extract_failure(self, output: str) -> str:
+        """Extract the most relevant failure message from pytest output."""
+        lines = output.splitlines()
+        failed_lines = [ln for ln in lines if ln.startswith("FAILED ")]
+        if failed_lines:
+            last = failed_lines[-1]
+            if " - " in last:
+                return last.split(" - ", 1)[1][:120]
+            return last[len("FAILED "):][:120]
+        # Fall back to last non-empty line
+        for ln in reversed(lines):
+            if ln.strip():
+                return ln.strip()[:120]
+        return output[:120]

src/agent/work_director.py

@@ -0,0 +1,136 @@
+import json
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from typing import Optional
+
+from src.agent.dag_validator import DagValidator, DagNode, ValidationResult
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class SubTaskResult:
+    task_id: str
+    status: str  # "ok" | "failed" | "skipped"
+    output: str = ""
+    error: str = ""
+
+
+PLANNER_PROMPT = """
+Break the following instruction into specific subtasks.
+Return ONLY a JSON array. Each item must have these exact keys:
+  "id" (unique kebab-id), "description", "depends_on" (list of ids),
+  "model_tier" (haiku|sonnet|opus), "write_capable" (bool)
+Max 12 tasks. Keep dependencies minimal.
+Instruction: {instruction}
+"""
+
+
+class WorkDirector:
+    def __init__(self, client=None, worktree_manager=None):
+        self._client = client          # GdmClient or mock
+        self._wm = worktree_manager    # WorktreeManager or mock
+
+    def decompose(self, instruction: str) -> list[dict]:
+        """Stage 1: LLM proposes a DAG as JSON."""
+        if self._client is None:
+            # Fallback for tests: single-task linear plan
+            return [
+                {
+                    "id": "task-1",
+                    "description": instruction,
+                    "depends_on": [],
+                    "model_tier": "sonnet",
+                    "write_capable": False,
+                }
+            ]
+        prompt = PLANNER_PROMPT.format(instruction=instruction)
+        response = self._client.complete([{"role": "user", "content": prompt}])
+        content = (
+            response.choices[0].message.content
+            if hasattr(response, "choices")
+            else str(response)
+        )
+        # Extract JSON array
+        start = content.find("[")
+        end = content.rfind("]") + 1
+        return json.loads(content[start:end])
+
+    def build_dag(self, instruction: str) -> list[DagNode]:
+        """Stage 2: validate + repair the raw proposal."""
+        raw = self.decompose(instruction)
+        validator = DagValidator(raw)
+        result = validator.validate()
+        if result.is_valid:
+            return result.dag
+        if result.repairable:
+            repaired = validator.auto_repair()
+            result2 = DagValidator(repaired).validate()
+            if result2.is_valid:
+                log.info("DAG auto-repaired: %s", result.errors)
+                return result2.dag
+        log.warning("DAG invalid after repair, falling back to linear: %s", result.errors)
+        linear = validator.fallback_linear()
+        return DagValidator(linear).validate().dag
+
+    def execute_dag(
+        self, dag: list[DagNode], base_branch: str = "staging"
+    ) -> dict[str, SubTaskResult]:
+        """Execute DAG with ThreadPoolExecutor. Write-capable tasks in worktrees."""
+        results: dict[str, SubTaskResult] = {}
+        pending = {t.id: t for t in dag}
+
+        with ThreadPoolExecutor(max_workers=3) as pool:
+            while pending:
+                ready = [
+                    t
+                    for t in pending.values()
+                    if all(
+                        dep in results and results[dep].status != "failed"
+                        for dep in t.depends_on
+                    )
+                ]
+                if not ready:
+                    # Mark remaining tasks as skipped due to upstream failures
+                    for t in pending.values():
+                        results[t.id] = SubTaskResult(
+                            task_id=t.id,
+                            status="skipped",
+                            error="Upstream dependency failed",
+                        )
+                    break
+                futures = {
+                    pool.submit(self._run_subtask, t, base_branch): t for t in ready
+                }
+                for future in as_completed(futures):
+                    t = futures[future]
+                    try:
+                        results[t.id] = future.result()
+                    except Exception as e:
+                        results[t.id] = SubTaskResult(
+                            task_id=t.id, status="failed", error=str(e)
+                        )
+                    del pending[t.id]
+
+        return results
+
+    def _run_subtask(self, task: DagNode, base_branch: str) -> SubTaskResult:
+        worktree_path = None
+        try:
+            if task.write_capable and self._wm is not None:
+                worktree_path = self._wm.create_worktree(task.id, base_branch)
+            log.info("Running subtask %s (write=%s)", task.id, task.write_capable)
+            return SubTaskResult(
+                task_id=task.id,
+                status="ok",
+                output=f"Completed: {task.description}",
+            )
+        except Exception as e:
+            return SubTaskResult(task_id=task.id, status="failed", error=str(e))
+        finally:
+            if worktree_path and self._wm is not None:
+                try:
+                    self._wm.remove_worktree(task.id)
+                except Exception:
+                    pass

src/agent/worktree_manager.py

@@ -0,0 +1,53 @@
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ReconcileResult:
+    conflicts: list[str] = field(default_factory=list)
+    merged: list[str] = field(default_factory=list)
+
+    @property
+    def success(self) -> bool:
+        return len(self.conflicts) == 0
+
+
+class WorktreeManager:
+    BASE_DIR = Path(".gdm_worktrees")
+
+    def create_worktree(self, task_id: str, base_branch: str) -> Path:
+        branch = f"gdm/subtask-{task_id}"
+        path = self.BASE_DIR / task_id
+        path.parent.mkdir(parents=True, exist_ok=True)
+        subprocess.run(
+            ["git", "worktree", "add", "-b", branch, str(path), base_branch],
+            check=True,
+            capture_output=True,
+        )
+        return path
+
+    def remove_worktree(self, task_id: str) -> None:
+        path = self.BASE_DIR / task_id
+        subprocess.run(
+            ["git", "worktree", "remove", "--force", str(path)],
+            capture_output=True,
+        )
+        subprocess.run(
+            ["git", "branch", "-D", f"gdm/subtask-{task_id}"],
+            capture_output=True,
+        )
+
+    def reconcile(self, task_branches: list[str], target_branch: str) -> ReconcileResult:
+        conflicts, merged = [], []
+        for branch in task_branches:
+            result = subprocess.run(
+                ["git", "merge", "--no-ff", branch],
+                capture_output=True,
+            )
+            if result.returncode != 0:
+                conflicts.append(branch)
+                subprocess.run(["git", "merge", "--abort"], capture_output=True)
+            else:
+                merged.append(branch)
+        return ReconcileResult(conflicts=conflicts, merged=merged)

src/artifacts/__init__.py

@@ -0,0 +1,16 @@
+"""Artifact storage and retrieval for gdm code."""
+from src.artifacts.artifact_store import (
+    Artifact,
+    ArtifactDiff,
+    ArtifactNotFoundError,
+    ArtifactStore,
+    ArtifactVersion,
+)
+
+__all__ = [
+    "Artifact",
+    "ArtifactDiff",
+    "ArtifactNotFoundError",
+    "ArtifactStore",
+    "ArtifactVersion",
+]