gdmcode 0.1.0__py3-none-any.whl

src/agent/dag_validator.py

@@ -0,0 +1,153 @@
+from dataclasses import dataclass, field
+from typing import Optional
+import copy
+
+
+@dataclass
+class DagNode:
+    id: str
+    description: str
+    depends_on: list[str] = field(default_factory=list)
+    model_tier: str = "sonnet"
+    write_capable: bool = False
+
+
+@dataclass
+class ValidationResult:
+    is_valid: bool
+    dag: list[DagNode]
+    errors: list[str] = field(default_factory=list)
+    repairable: bool = False
+
+
+class DagValidator:
+    MAX_NODES = 12
+    MAX_DEPTH = 4
+    MAX_FAN_OUT = 3
+
+    def __init__(self, raw: list[dict]):
+        self._raw = raw
+
+    def validate(self) -> ValidationResult:
+        errors = []
+        try:
+            nodes = [
+                DagNode(**{k: v for k, v in n.items() if k in DagNode.__dataclass_fields__})
+                for n in self._raw
+            ]
+        except Exception as e:
+            return ValidationResult(is_valid=False, dag=[], errors=[str(e)], repairable=False)
+
+        ids = [n.id for n in nodes]
+        # Unique IDs
+        if len(ids) != len(set(ids)):
+            errors.append("Duplicate node IDs")
+        # Node cap
+        if len(nodes) > self.MAX_NODES:
+            errors.append(f"Too many nodes: {len(nodes)} > {self.MAX_NODES}")
+            return ValidationResult(is_valid=False, dag=nodes, errors=errors, repairable=False)
+        # All deps exist
+        id_set = set(ids)
+        for n in nodes:
+            for dep in n.depends_on:
+                if dep not in id_set:
+                    errors.append(f"Missing dep '{dep}' in node '{n.id}'")
+        # Self-deps
+        for n in nodes:
+            if n.id in n.depends_on:
+                errors.append(f"Self-dependency in '{n.id}'")
+        # Cycle detection (Kahn's algorithm)
+        if self._has_cycle(nodes):
+            errors.append("Cycle detected in DAG")
+            return ValidationResult(is_valid=False, dag=nodes, errors=errors, repairable=True)
+        # Depth cap
+        depth = self._max_depth(nodes)
+        if depth > self.MAX_DEPTH:
+            errors.append(f"DAG depth {depth} exceeds max {self.MAX_DEPTH}")
+        # Fan-out cap
+        for n in nodes:
+            fan_out = sum(1 for m in nodes if n.id in m.depends_on)
+            if fan_out > self.MAX_FAN_OUT:
+                errors.append(f"Node '{n.id}' fan-out {fan_out} exceeds max {self.MAX_FAN_OUT}")
+
+        return ValidationResult(
+            is_valid=len(errors) == 0,
+            dag=nodes,
+            errors=errors,
+            repairable=len(errors) > 0 and "Cycle" not in " ".join(errors),
+        )
+
+    def auto_repair(self) -> list[dict]:
+        """Remove back-edges that cause cycles. Returns raw dict list."""
+        raw = copy.deepcopy(self._raw)
+        id_map = {n["id"]: n for n in raw}
+        visited, stack = set(), set()
+        to_remove = []
+
+        def dfs(node_id):
+            visited.add(node_id)
+            stack.add(node_id)
+            for dep in list(id_map.get(node_id, {}).get("depends_on", [])):
+                if dep not in visited:
+                    dfs(dep)
+                elif dep in stack:
+                    to_remove.append((node_id, dep))
+            stack.discard(node_id)
+
+        for nid in id_map:
+            if nid not in visited:
+                dfs(nid)
+        for node_id, dep in to_remove:
+            id_map[node_id]["depends_on"].remove(dep)
+        return list(id_map.values())
+
+    def fallback_linear(self) -> list[dict]:
+        """Return a guaranteed-valid linear chain (no parallelism)."""
+        raw = copy.deepcopy(self._raw[: self.MAX_NODES])
+        for i, node in enumerate(raw):
+            node["depends_on"] = [raw[i - 1]["id"]] if i > 0 else []
+        return raw
+
+    def _has_cycle(self, nodes: list[DagNode]) -> bool:
+        """Kahn's algorithm: cycle exists if topological sort can't include all nodes."""
+        in_degree = {n.id: 0 for n in nodes}
+        for n in nodes:
+            for dep in n.depends_on:
+                if dep in in_degree:
+                    in_degree[n.id] += 1
+        queue = [nid for nid, deg in in_degree.items() if deg == 0]
+        count = 0
+        adj = {n.id: [] for n in nodes}
+        for n in nodes:
+            for dep in n.depends_on:
+                if dep in adj:
+                    adj[dep].append(n.id)
+        while queue:
+            nid = queue.pop()
+            count += 1
+            for child in adj.get(nid, []):
+                in_degree[child] -= 1
+                if in_degree[child] == 0:
+                    queue.append(child)
+        return count != len(nodes)
+
+    def _max_depth(self, nodes: list[DagNode]) -> int:
+        id_map = {n.id: n for n in nodes}
+        memo = {}
+
+        def depth(nid):
+            if nid in memo:
+                return memo[nid]
+            node = id_map.get(nid)
+            if not node or not node.depends_on:
+                memo[nid] = 1
+                return 1
+            valid_deps = [dep for dep in node.depends_on if dep in id_map]
+            if not valid_deps:
+                memo[nid] = 1
+                return 1
+            d = 1 + max(depth(dep) for dep in valid_deps)
+            memo[nid] = d
+            return d
+
+        return max((depth(n.id) for n in nodes), default=0)

src/agent/debug_loop.py

@@ -0,0 +1,473 @@
+"""Iterative debug loop — fix → test → fix cycle with model-tier escalation.
+
+Drives an automated bug-fix workflow:
+  1. Run the test suite.
+  2. If tests fail, ask the agent to apply a fix.
+  3. Re-run tests.
+  4. Repeat up to *max_cycles* times, escalating to stronger model tiers on
+     repeated failures and optionally trying an ensemble patch strategy.
+
+Phase 1: single-loop sequential fixes, ensemble stub (Phase 3 full impl).
+"""
+from __future__ import annotations
+
+import logging
+import shlex
+import subprocess
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Generator
+
+from src._internal.constants import _ENSEMBLE_PATCH_COST_CAP_USD, _MAX_DEBUG_CYCLES
+from src.agent.loop import AgentEvent, AgentLoop, EventType
+from src.models.definitions import ModelTier
+from src.tools.shell_tools import (
+    _extract_error_for_search,
+    _format_search_injection,
+    _parse_search_results,
+    web_search_raw,
+)
+
+if TYPE_CHECKING:
+    from src.config import GdmConfig
+
+__all__ = ["DebugAttempt", "DebugLoop", "DebugResult"]
+
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+_TEST_TIMEOUT_SECS: int = 120
+_CODER_MAX_ATTEMPT: int = 2
+_THINKER_ATTEMPT: int = 3
+_ENSEMBLE_TRIGGER_FAILURES: int = 2
+_MAX_FIX_PROMPT_ERROR_CHARS: int = 2_000
+_MAX_PATCH_DESC_CHARS: int = 200
+
+# Referenced by callers for budget enforcement.
+_COST_CAP_USD = _ENSEMBLE_PATCH_COST_CAP_USD
+
+
+# ---------------------------------------------------------------------------
+# Data classes
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class DebugAttempt:
+    """Record of one fix attempt in the debug loop."""
+
+    attempt_num: int
+    patch_applied: str      # brief description of what was changed
+    test_result: str        # "pass" | "fail"
+    error_output: str       # test output on failure, empty on pass
+    model_tier_used: str
+
+
+@dataclass
+class DebugResult:
+    """Outcome of a complete DebugLoop.run() call."""
+
+    success: bool
+    attempts: list[DebugAttempt] = field(default_factory=list)
+    final_model_tier: str = ModelTier.CODER
+    was_rolled_back: bool = False
+    regression_detected: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Debug loop
+# ---------------------------------------------------------------------------
+
+
+class DebugLoop:
+    """Iterative bug fix loop: fix -> test -> fix -> test (max 5 cycles).
+
+    Escalates model tier on repeated failures:
+
+    * Attempt 1-2: Coder tier
+    * Attempt 3:   Thinker tier
+    * Attempt 4-5: Reasoner tier
+
+    After 2 failures, attempts an ensemble patch (3 parallel Scout strategies)
+    and selects the one that passes the most tests. The ensemble is currently
+    a stub -- full implementation ships in Phase 3.
+
+    Usage::
+
+        debug = DebugLoop(loop, cfg)
+        result = debug.run(
+            task_description="Fix TypeError in auth.py line 45",
+            test_command="pytest tests/test_auth.py",
+            files_to_watch=["src/auth.py"],
+        )
+        if result.success:
+            print(f"Fixed in {len(result.attempts)} attempt(s)")
+        elif result.was_rolled_back:
+            print("All attempts failed -- changes rolled back")
+    """
+
+    def __init__(self, base_loop: AgentLoop, cfg: GdmConfig) -> None:
+        """Initialise the debug loop.
+
+        Args:
+            base_loop: A fully-configured AgentLoop used for fix turns.
+            cfg:       Session configuration (provider, cost limits, etc.).
+        """
+        self._loop = base_loop
+        self._cfg = cfg
+        self._test_command: str = ""  # stored at run() time; used by ensemble
+
+    # ------------------------------------------------------------------
+    # Public entry point
+    # ------------------------------------------------------------------
+
+    def run(
+        self,
+        task_description: str,
+        test_command: str,
+        files_to_watch: list[str] | None = None,
+        *,
+        max_cycles: int = _MAX_DEBUG_CYCLES,
+    ) -> DebugResult:
+        """Run the debug loop. Returns DebugResult (never raises).
+
+        Args:
+            task_description: Human-readable description of the bug to fix.
+            test_command:     Shell command whose exit code signals pass/fail.
+            files_to_watch:   Optional list of files relevant to the fix.
+            max_cycles:       Maximum fix attempts before giving up.
+        """
+        attempts: list[DebugAttempt] = []
+        final_tier = ModelTier.CODER
+        self._test_command = test_command  # expose to ensemble
+        _search_fired: bool = False  # one-shot flag; reset each run() call
+        _search_context: str = ""    # injection block; prepended to fix prompt once
+        _auto_search_iter: int = getattr(self._cfg, "debug_auto_search_iteration", 3)
+        try:
+            for attempt_num in range(1, max_cycles + 1):
+                tier = self._get_tier_for_attempt(attempt_num)
+                final_tier = tier
+                log.info("Debug attempt %d/%d tier=%s", attempt_num, max_cycles, tier)
+
+                passed, output = self._run_tests(test_command)
+                if passed:
+                    attempts.append(DebugAttempt(attempt_num, "(pre-check)", "pass", "", tier))
+                    return DebugResult(True, attempts, tier, False, False)
+
+                # One-shot auto web search at configured iteration number
+                if (
+                    _auto_search_iter > 0
+                    and attempt_num == _auto_search_iter
+                    and not _search_fired
+                ):
+                    _search_fired = True
+                    error_query = _extract_error_for_search(output)
+                    try:
+                        raw = web_search_raw(error_query)
+                        results = _parse_search_results(raw)
+                        _search_context = _format_search_injection(error_query, results)
+                        log.info(
+                            "DebugLoop: auto web-search fired (iter=%d query=%r results=%d)",
+                            attempt_num, error_query[:60], len(results),
+                        )
+                    except Exception as exc:  # noqa: BLE001
+                        log.warning("DebugLoop: auto web-search failed (continuing): %s", exc)
+                        _search_context = ""
+
+                failed_so_far = sum(1 for a in attempts if a.test_result == "fail")
+                if failed_so_far >= _ENSEMBLE_TRIGGER_FAILURES:
+                    ok, desc = self._try_ensemble_patch(task_description, output)
+                    if ok:
+                        attempts.append(DebugAttempt(attempt_num, desc, "pass", "", tier))
+                        return DebugResult(True, attempts, tier, False, False)
+
+                patch_desc = self._drain_fix(
+                    self._apply_fix(output, task_description, attempt_num, _search_context)
+                )
+                _search_context = ""  # consume search context — only used once
+                passed_after, out_after = self._run_tests(test_command)
+                test_result = "pass" if passed_after else "fail"
+                err_out = "" if passed_after else out_after
+                attempts.append(DebugAttempt(attempt_num, patch_desc, test_result, err_out, tier))
+
+                if passed_after:
+                    return DebugResult(True, attempts, tier, False, False)
+
+            rolled_back = self._should_rollback(attempts)
+            if rolled_back:
+                try:
+                    from src.git_workflow import GitWorkflow  # noqa: PLC0415
+                    wf = GitWorkflow(self._cfg.project_root)
+                    if wf.is_git_repo():
+                        wf.rollback_to_pre_task(hard=False)
+                        log.warning(
+                            "DebugLoop: all %d attempts failed — soft rollback applied",
+                            len(attempts),
+                        )
+                except Exception as exc:  # noqa: BLE001
+                    log.warning("DebugLoop: rollback skipped: %s", exc)
+            # Debate debug: generate fresh hypotheses after ensemble exhaustion
+            try:
+                from src.agent.review_gate import ReviewGate  # noqa: PLC0415
+                last_error_text = attempts[-1].error_output if attempts else ""
+                gate = ReviewGate(cfg=self._cfg)
+                hypotheses = gate.debate_debug(
+                    error=last_error_text,
+                    attempts_history=[str(a.patch_applied) for a in attempts[-3:]],
+                )
+                log.info(
+                    "debate_debug hypotheses: %s",
+                    "; ".join(hypotheses.hypotheses[:3]),
+                )
+            except Exception as exc:  # noqa: BLE001
+                log.debug("debate_debug skipped: %s", exc)
+            return DebugResult(False, attempts, final_tier, rolled_back, False)
+        except Exception as exc:  # noqa: BLE001
+            log.exception("DebugLoop.run failed: %s", exc)
+            return DebugResult(False, attempts, final_tier, False, False)
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _run_tests(self, test_command: str) -> tuple[bool, str]:
+        """Run the test command. Returns (passed, combined output).
+
+        Uses subprocess.run with a 120-second timeout.
+        TimeoutExpired returns (False, "Test timed out") rather than raising.
+        """
+        try:
+            result = subprocess.run(
+                shlex.split(test_command, posix=(not __import__("sys").platform.startswith("win"))),
+                shell=False,
+                capture_output=True,
+                text=True,
+                timeout=_TEST_TIMEOUT_SECS,
+            )
+            output = result.stdout + result.stderr
+            passed = result.returncode == 0
+            log.debug("Test run: rc=%d output_chars=%d", result.returncode, len(output))
+            return passed, output
+        except subprocess.TimeoutExpired:
+            log.warning("Test command timed out after %ds", _TEST_TIMEOUT_SECS)
+            return False, "Test timed out"
+        except OSError as exc:
+            log.error("Failed to run test command %r: %s", test_command, exc)
+            return False, f"Failed to run tests: {exc}"
+
+    def _apply_fix(
+        self,
+        error_output: str,
+        task_description: str,
+        attempt_num: int,
+        search_context: str = "",
+    ) -> Generator[AgentEvent, None, None]:
+        """Run one agent turn asking it to fix the failing tests.
+
+        Yields AgentEvents from the underlying AgentLoop.run() call.
+
+        Args:
+            error_output:     Combined test output from the failing run.
+            task_description: Original bug description for context.
+            attempt_num:      Current attempt number (used in the prompt).
+            search_context:   Optional web-search injection block (one-shot).
+        """
+        tier = self._get_tier_for_attempt(attempt_num)
+        search_block = f"\n\n{search_context}" if search_context else ""
+        fix_prompt = (
+            f"Task: {task_description}\n\n"
+            f"Attempt {attempt_num} -- model tier: {tier}.\n\n"
+            "The following tests are failing. Analyse the error carefully "
+            "and apply a targeted fix:\n\n"
+            f"```\n{error_output[:_MAX_FIX_PROMPT_ERROR_CHARS]}\n```"
+            f"{search_block}"
+        )
+        log.info("Applying fix (attempt=%d tier=%s)", attempt_num, tier)
+        yield from self._loop.run(fix_prompt)
+
+    def _drain_fix(self, events: Generator[AgentEvent, None, None]) -> str:
+        """Drain an _apply_fix generator and return a brief patch description.
+
+        Collects all RESPONSE event content and trims to _MAX_PATCH_DESC_CHARS.
+        """
+        parts: list[str] = []
+        for event in events:
+            if event.type == EventType.RESPONSE:
+                parts.append(event.content)
+        return (" ".join(parts))[:_MAX_PATCH_DESC_CHARS] or "(fix applied)"
+
+    def _get_tier_for_attempt(self, attempt_num: int) -> str:
+        """Return the appropriate ModelTier string for *attempt_num*.
+
+        Escalation schedule:
+        * 1-2 -> CODER
+        * 3   -> THINKER
+        * 4+  -> REASONER
+        """
+        if attempt_num <= _CODER_MAX_ATTEMPT:
+            return ModelTier.CODER
+        if attempt_num == _THINKER_ATTEMPT:
+            return ModelTier.THINKER
+        return ModelTier.REASONER
+
+    def _try_ensemble_patch(
+        self, task_description: str, error_output: str
+    ) -> tuple[bool, str]:
+        """Try 3 fix strategies; pick the one that passes tests.
+
+        Each strategy runs in a fresh git working tree (stash-isolated) so
+        strategies don't interfere.  Applies the winning patch and returns
+        ``(True, "ensemble/<strategy>")``.  If all strategies fail or git is
+        not available, returns ``(False, reason)``.
+
+        Cost guard: we stop early on the first passing strategy to minimise
+        API spend.  Strategies are tried sequentially, not in parallel, to
+        respect the ``_COST_CAP_USD`` ceiling.
+        """
+        import subprocess
+        import tempfile
+        from pathlib import Path as _Path
+
+        if not self._test_command:
+            log.info("Ensemble patch skipped: no test_command stored")
+            return False, "ensemble skipped (no test command)"
+
+        # Verify git is available
+        try:
+            root_proc = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if root_proc.returncode != 0:
+                return False, "ensemble skipped (not a git repo)"
+            root = root_proc.stdout.strip()
+        except Exception as exc:  # noqa: BLE001
+            log.debug("Ensemble: git check failed: %s", exc)
+            return False, "ensemble skipped (git unavailable)"
+
+        def _git(*args: str) -> subprocess.CompletedProcess[str]:
+            return subprocess.run(
+                ["git", *args], capture_output=True, text=True, cwd=root, timeout=60
+            )
+
+        # Stash current state → all strategies start from the same clean base
+        stash_tag = f"gdm-ensemble-{id(self)}"
+        stash_proc = _git("stash", "push", "-u", "-m", stash_tag)
+        did_stash = (
+            stash_proc.returncode == 0
+            and "No local changes" not in stash_proc.stdout
+        )
+
+        _STRATEGIES = [
+            (
+                "minimal",
+                "Apply the minimal possible fix. Change only what is strictly necessary.",
+            ),
+            (
+                "refactor",
+                "Refactor for correctness and clarity. Prioritise correctness over brevity.",
+            ),
+            (
+                "alternative",
+                "Re-think the root cause. Use a completely different algorithmic approach.",
+            ),
+        ]
+
+        best_pass_count = -1
+        best_patch = ""
+        best_name = ""
+
+        try:
+            for strategy_name, strategy_hint in _STRATEGIES:
+                # Reset working tree to the stashed base (last commit state)
+                _git("checkout", "--", ".")
+                _git("clean", "-fdq")
+
+                # Fresh loop for this strategy to avoid transcript pollution
+                try:
+                    strategy_loop = AgentLoop(
+                        session_id=(
+                            f"{getattr(self._loop, '_session_id', '')}"
+                            f"-ens-{strategy_name}"
+                        ),
+                        db=getattr(self._loop, "_db", None),
+                        cost_tracker=getattr(self._loop, "_cost_tracker", None),
+                        config=self._cfg,
+                    )
+                except Exception:  # noqa: BLE001
+                    strategy_loop = self._loop  # fallback: reuse main loop
+
+                prompt = (
+                    f"Task: {task_description}\n\n"
+                    f"Ensemble strategy: {strategy_hint}\n\n"
+                    f"Failing tests:\n```\n"
+                    f"{error_output[:_MAX_FIX_PROMPT_ERROR_CHARS]}\n```"
+                )
+                self._drain_fix(strategy_loop.run(prompt))
+
+                diff = _git("diff", "HEAD").stdout
+                if not diff.strip():
+                    log.info("Ensemble strategy=%s: no changes produced", strategy_name)
+                    continue
+
+                passed, _ = self._run_tests(self._test_command)
+                pass_count = 1 if passed else 0
+                log.info(
+                    "Ensemble strategy=%s passed=%s diff_lines=%d",
+                    strategy_name,
+                    passed,
+                    len(diff.splitlines()),
+                )
+
+                if pass_count > best_pass_count:
+                    best_pass_count = pass_count
+                    best_patch = diff
+                    best_name = strategy_name
+
+                if passed:
+                    break  # found working strategy — stop early to save cost
+
+        except Exception as exc:  # noqa: BLE001
+            log.exception("Ensemble inner loop failed: %s", exc)
+
+        finally:
+            # Reset working tree to clean state.  If changes were stashed
+            # before the ensemble started, restore them so the outer loop
+            # can continue from its pre-ensemble state (case: no patch found).
+            _git("checkout", "--", ".")
+            _git("clean", "-fdq")
+            if did_stash:
+                _git("stash", "pop")  # restore; if a patch was found we clean again below
+
+        if best_pass_count > 0 and best_patch:
+            # Discard the restored pre-ensemble changes — the ensemble patch is better.
+            _git("checkout", "--", ".")
+            _git("clean", "-fdq")
+            with tempfile.NamedTemporaryFile(
+                mode="w", suffix=".patch", delete=False, encoding="utf-8"
+            ) as fh:
+                fh.write(best_patch)
+                patch_path = fh.name
+            try:
+                apply_proc = _git("apply", patch_path)
+                if apply_proc.returncode != 0:
+                    log.warning(
+                        "Ensemble apply failed: %s", apply_proc.stderr[:200]
+                    )
+                    return False, "ensemble: patch apply failed"
+            finally:
+                _Path(patch_path).unlink(missing_ok=True)
+            return True, f"ensemble/{best_name}"
+
+        return False, "ensemble: no strategy passed tests"
+
+    def _should_rollback(self, attempts: list[DebugAttempt]) -> bool:
+        """True if all attempts failed and changes should be rolled back.
+
+        Rollback is triggered when the failed-attempt count equals or exceeds
+        the configured maximum debug cycles.
+        """
+        failed_attempts = sum(1 for a in attempts if a.test_result == "fail")
+        return failed_attempts >= _MAX_DEBUG_CYCLES