misterdev 0.2.0__py3-none-any.whl

misterdev/task_executors/markdown_plan_executor/gates_mixin.py

@@ -0,0 +1,203 @@
+"""Test-gate acceptance, acceptance-criteria verification, and error context."""
+
+from typing import List, Optional, Tuple
+
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.core.execution.error_classifier import classify_error, ErrorCategory
+
+from .helpers import logger, _extract_acceptance_command, JUDGE_MIN_BUDGET_FRACTION
+
+
+class GatesMixin:
+    @staticmethod
+    def _prior_failures_history(prior_errors: List[str]) -> str:
+        """Render all-but-the-latest prior attempt errors as a retry-context
+        header, or '' when there is no earlier failure to summarize."""
+        if len(prior_errors) <= 1:
+            return ""
+        past = "\n".join(f"- {e}" for e in prior_errors[:-1])
+        return (
+            "### Previous Attempt Failures (a different approach is required)\n"
+            f"{past}\n\n"
+        )
+
+    def _build_error_context(
+        self,
+        prior_errors: List[str],
+        attempt: int,
+        output: str,
+        classified: str,
+        attributed_error: str,
+    ) -> str:
+        """Combine the current error with a summary of prior failed attempts.
+
+        Surfacing what already failed (and how it was classified) stops the LLM
+        from re-submitting the same broken fix across retries.
+        """
+        prior_errors.append(f"Attempt {attempt + 1}: {classify_error(output)}")
+        history = self._prior_failures_history(prior_errors)
+        return f"{history}{classified}\n\n{attributed_error}"
+
+    @staticmethod
+    def _gate_accepts(
+        success: bool, output: str, baseline_failures: int
+    ) -> Tuple[bool, Optional[int]]:
+        """Whether the test gate accepts this attempt, plus the parsed failure count.
+
+        A green suite always passes (returns ``(True, 0)``). On a RED baseline
+        (``baseline_failures`` > 0), an attempt that leaves the suite no worse —
+        parsed failures <= baseline — also passes, so a multi-failure project can
+        be reduced one task at a time instead of requiring a single task to make
+        the whole suite green. An unparseable red result stays strict (rejected),
+        since we will not accept on a number we cannot read.
+        """
+        if success:
+            return True, 0
+        if baseline_failures <= 0:
+            return False, None
+        from misterdev.core.verification.validator import (
+            _parse_test_counts,
+        )
+
+        total, post = _parse_test_counts(output)
+        if total > 0 and post <= baseline_failures:
+            return True, post
+        return False, post if total > 0 else None
+
+    def _verify_acceptance(
+        self,
+        project: Project,
+        task: Task,
+        verify_acceptance: bool,
+        llm_acceptance_judge: bool,
+        timeout: int,
+        cwd=None,
+    ) -> Tuple[bool, str]:
+        """Verify the task's acceptance_criteria after build/test gates pass.
+
+        Returns (passed, output). Deterministic primary path: extract an
+        explicit runnable command from acceptance_criteria and run it; a
+        non-zero exit fails acceptance. When acceptance_criteria is empty, the
+        gate is disabled, or no command can be confidently extracted, this is a
+        no-op that passes (behaviour identical to before this gate) unless the
+        default-off ``orchestrator.llm_acceptance_judge`` flag is set, in which
+        case an LLM judge is consulted. Never blocks on un-parseable free text.
+        """
+        if not verify_acceptance:
+            return True, ""
+        criteria = (task.acceptance_criteria or "").strip()
+        if not criteria:
+            return True, ""
+        command = _extract_acceptance_command(criteria)
+        if command:
+            logger.info(f"Verifying acceptance criteria via command: {command}")
+            success, output = self._run_command(
+                project, command, timeout=timeout, cwd=cwd
+            )
+            if success:
+                logger.info("Acceptance criteria command passed.")
+                return True, ""
+            # A command that can't locate the project manifest is a BROKEN
+            # acceptance command, not failing code: acceptance runs only AFTER
+            # the build/test gates pass, so the manifest demonstrably exists —
+            # a MANIFEST error here means the extracted command is malformed
+            # (the emathy run lost `--manifest-path` and every such task
+            # false-failed on `cargo test` from the repo root). Treat it as a
+            # pass-through. A genuine missing test path (FILE_NOT_FOUND) is left
+            # as a real failure.
+            if classify_error(output) == ErrorCategory.MANIFEST:
+                logger.warning(
+                    "Acceptance command could not locate the project manifest; "
+                    "the build/test gates already passed, so treating acceptance "
+                    f"as satisfied rather than failing on a broken command: {command}"
+                )
+                return True, ""
+            return False, (
+                f"Acceptance criterion not met: `{criteria}`\n"
+                f"Ran: {command}\n"
+                f"Command exited non-zero:\n{output}"
+            )
+        if llm_acceptance_judge and self._judge_affordable(project):
+            return self._llm_acceptance_judge(project, task, criteria)
+        return True, ""
+
+    def _judge_affordable(self, project: Project) -> bool:
+        """True while enough budget remains to spend on the LLM acceptance judge.
+
+        Cost control for the (now default-on) judge: once the run has burned
+        through all but ``JUDGE_MIN_BUDGET_FRACTION`` of the budget, stop paying
+        for free-text judging and let those criteria pass, reserving the last
+        funds for actually fixing code. Fail-open when budget can't be read.
+        """
+        client = project.llm_client
+        remaining = getattr(client, "budget_remaining", None)
+        total = getattr(client, "_budget", None)
+        if not isinstance(remaining, (int, float)) or not isinstance(
+            total, (int, float)
+        ):
+            return True
+        if total <= 0:
+            return True
+        return remaining > total * JUDGE_MIN_BUDGET_FRACTION
+
+    def _judge_generate(self, project: Project, prompt: str) -> str:
+        """Run an acceptance-judge prompt, on the INDEPENDENT ``judge.model`` when
+        configured (so the judge doesn't share the generator's blind spots), else
+        on the generator's own model. Routed through ``with_model`` when possible.
+        """
+        from misterdev.core.verification.independent import (
+            generate_independent,
+        )
+
+        judge_model = (project.config.get("judge") or {}).get("model")
+        return generate_independent(project.llm_client, prompt, "", model=judge_model)
+
+    def _llm_acceptance_judge(
+        self, project: Project, task: Task, criteria: str
+    ) -> Tuple[bool, str]:
+        """Default-off LLM fallback judging free-text acceptance criteria.
+
+        Only reached when ``orchestrator.llm_acceptance_judge`` is true and no
+        runnable command could be extracted. A failure to reach a confident
+        verdict passes (fail-open) so an unreliable judge never blocks a task.
+        """
+        try:
+            prompt = (
+                "A code task has just passed its build and test gates. Judge "
+                "ONLY whether the stated acceptance criterion is satisfied by "
+                "the task's implementation. Reply with PASS or FAIL on the "
+                "first line, then a brief reason.\n\n"
+                f"Task: {task.description}\n"
+                f"Acceptance criterion: {criteria}\n"
+            )
+            verdict = self._judge_generate(project, prompt)
+        except Exception as e:
+            logger.warning(f"LLM acceptance judge failed, passing open: {e}")
+            return True, ""
+        first = (verdict or "").strip().splitlines()
+        if first and first[0].strip().upper().startswith("FAIL"):
+            return False, (
+                f"Acceptance criterion not met (LLM judge): `{criteria}`\n{verdict}"
+            )
+        return True, ""
+
+    def _build_acceptance_error_context(
+        self,
+        prior_errors: List[str],
+        attempt: int,
+        task: Task,
+        classified: str,
+    ) -> str:
+        """Format an acceptance failure into the same retry context as other gates.
+
+        Makes the unmet criterion explicit so the next attempt targets it rather
+        than re-submitting a change that only satisfies the build/test gates.
+        """
+        prior_errors.append(f"Attempt {attempt + 1}: acceptance criteria not met")
+        history = self._prior_failures_history(prior_errors)
+        return (
+            f"{history}### Acceptance criterion not met\n"
+            f"The build and tests passed, but the task's acceptance criterion "
+            f"was not satisfied:\n{task.acceptance_criteria}\n\n{classified}"
+        )

misterdev/task_executors/markdown_plan_executor/git_mixin.py

@@ -0,0 +1,219 @@
+"""Git branch-per-task operations and regression bisection."""
+
+import shlex
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.core.verification.validator import _run_cmd
+
+from .helpers import logger, _bisect_first_failing
+
+
+class GitMixin:
+    # ----------------------------------------------------------------
+    # Git branch-per-task operations
+    # ----------------------------------------------------------------
+
+    def _is_git_repo(self, project: Project) -> bool:
+        return (project.path / ".git").exists()
+
+    # ----------------------------------------------------------------
+    # Regression bisection (post-build gate failure)
+    # ----------------------------------------------------------------
+
+    def find_task_commit(self, project: Project, task_id: str) -> Optional[str]:
+        """SHA of the commit recording a task (message 'task(<id>):'), or None."""
+        ok, out = self._git(
+            project,
+            f"git log --all -n 1 --format=%H --fixed-strings --grep={shlex.quote(f'task({task_id}):')}",
+        )
+        sha = out.strip().splitlines()[0] if ok and out.strip() else ""
+        return sha or None
+
+    def bisect_regression(
+        self,
+        project: Project,
+        task_commits: List,
+        test_command: str,
+        timeout: int = 180,
+    ) -> Optional[str]:
+        """Find the earliest task commit whose checkout fails the test command.
+
+        task_commits is [(task_id, sha)] ordered oldest->newest. Returns the
+        culprit task_id, or None if no checked-out commit actually fails (so a
+        flaky/non-task regression isn't misattributed). Restores HEAD after.
+        """
+        if not task_commits:
+            return None
+        # Restore to the BRANCH, not a bare SHA: checking out a SHA detaches
+        # HEAD, and a mid-build gate that left HEAD detached would make every
+        # subsequent task branch from / merge into a detached head instead of
+        # the working branch, silently diverging the build from the branch ref.
+        okb, branch = self._git(project, "git rev-parse --abbrev-ref HEAD")
+        branch = branch.strip() if okb else ""
+        if branch and branch != "HEAD":
+            restore = branch
+        else:
+            ok, head = self._git(project, "git rev-parse HEAD")
+            restore = head.strip() if ok else None
+
+        def passes_at(i: int) -> bool:
+            self._git(project, f"git checkout {shlex.quote(task_commits[i][1])}")
+            success, _ = self._run_command(project, test_command, timeout=timeout)
+            return success
+
+        try:
+            idx = _bisect_first_failing(len(task_commits), passes_at)
+            culprit = None if passes_at(idx) else task_commits[idx][0]
+        finally:
+            if restore:
+                self._git(project, f"git checkout {shlex.quote(restore)}")
+        return culprit
+
+    def revert_task_commit(self, project: Project, sha: str) -> bool:
+        """Revert a task's commit, leaving an explicit revert commit.
+
+        Aborts cleanly on conflict so a failed revert never leaves the working
+        tree in a half-reverted, conflict-marked state that would break later
+        suite runs and checkouts.
+        """
+        ok, _ = self._git(project, f"git revert --no-edit {shlex.quote(sha)}")
+        if not ok:
+            self._git(project, "git revert --abort")
+        return ok
+
+    def _get_current_branch(self, project: Project) -> Optional[str]:
+        ok, output = self._git(project, "git rev-parse --abbrev-ref HEAD")
+        return output.strip() if ok else None
+
+    def _create_task_branch(self, project: Project, branch_name: str) -> bool:
+        ok, _ = self._git(project, f"git checkout -b {shlex.quote(branch_name)}")
+        if ok:
+            logger.info(f"Created task branch: {branch_name}")
+        return ok
+
+    def _commit_task(
+        self,
+        project: Project,
+        branch_name: Optional[str],
+        base_branch: Optional[str],
+        task: Task,
+        files: Optional[List[str]] = None,
+    ):
+        """Commit the task's own changes and merge the task branch back to base.
+
+        Stages only the named files, never `git add -A`: a blanket add sweeps
+        unrelated untracked files (other uncommitted user work, or files carried
+        onto the task branch) into the commit, which then get destroyed if the
+        task is later reverted. With no files, commit empty rather than sweep.
+        """
+        msg = f"task({task.id}): {task.title or task.description[:50]}"
+        stage = list(files or [])
+        # Also commit the task's own source markdown so a status:completed write
+        # rides into the merge. Without this the status write is left uncommitted
+        # and the NEXT task's `git checkout -- .` (below) wipes it, so a finished
+        # devplan showed every task still "pending" (only the last survived).
+        source_rel = self._repo_relative(project, getattr(task, "source_ref", None))
+        if source_rel:
+            stage.append(source_rel)
+        if stage:
+            quoted = " ".join(shlex.quote(f) for f in stage)
+            self._git(project, f"git add -- {quoted}")
+        self._git(project, f"git commit -m {shlex.quote(msg)} --allow-empty")
+
+        if branch_name and base_branch:
+            # Drop tracked spillover before switching branches: a project-wide
+            # formatter (e.g. `ruff format .`) reformats files outside the task,
+            # which aren't committed and would otherwise be carried across the
+            # checkout and accumulate as a permanently dirty tree.
+            self._git(project, "git checkout -- .")
+            self._git(project, f"git checkout {shlex.quote(base_branch)}")
+            ok, output = self._git(
+                project,
+                f"git merge --no-ff {shlex.quote(branch_name)} -m {shlex.quote(f'Merge {branch_name}')}",
+            )
+            if ok:
+                self._git(project, f"git branch -d {shlex.quote(branch_name)}")
+                logger.info(f"Merged and cleaned up branch: {branch_name}")
+            else:
+                logger.error(f"Merge failed for {branch_name}: {output}")
+
+    def _repo_relative(self, project: Project, path: Optional[str]) -> Optional[str]:
+        """Repo-relative form of a path inside the project, else None.
+
+        Returns None for an empty path or one outside the repo (e.g. a
+        decomposed build() task with no backing file), so those are never staged.
+        """
+        if not path:
+            return None
+        try:
+            return str(Path(path).resolve().relative_to(project.path.resolve()))
+        except ValueError:
+            return None
+
+    def _untracked_files(self, project: Project) -> set:
+        """Set of untracked (non-ignored) paths in the working tree.
+
+        Used to bound revert cleanup: only files that became untracked DURING a
+        task are removed, so a user's pre-existing untracked work is never
+        touched.
+        """
+        ok, out = self._git(project, "git status --porcelain --untracked-files=all")
+        if not ok:
+            return set()
+        paths = set()
+        for line in out.splitlines():
+            if line.startswith("?? "):
+                paths.add(line[3:].strip().strip('"'))
+        return paths
+
+    def _abort_task(
+        self,
+        project: Project,
+        branch_name: Optional[str],
+        base_branch: Optional[str],
+        snapshot: Optional[Dict],
+        untracked_before: Optional[set] = None,
+    ):
+        """Revert a failed task: delete branch or restore file snapshots.
+
+        Also removes files the task left UNTRACKED (new files it wrote, whether
+        or not committed on the branch) — ``git reset --hard`` reverts tracked
+        changes but leaves those orphans behind, which otherwise accumulate in
+        the tree (the emathy run left signing.rs/crdt.rs/out/ this way). Only the
+        delta against ``untracked_before`` is cleaned, so pre-existing untracked
+        files are preserved.
+        """
+        if branch_name and base_branch:
+            self._git(project, "git reset --hard")
+            self._git(project, f"git checkout {shlex.quote(base_branch)}")
+            self._git(project, f"git branch -D {shlex.quote(branch_name)}")
+            logger.info(f"Aborted and deleted branch: {branch_name}")
+            self._clean_task_orphans(project, untracked_before)
+        elif snapshot is not None:
+            self._revert_files(project, snapshot)
+            self._clean_task_orphans(project, untracked_before)
+        # The revert changed the tree back; drop the stale graph so the next task
+        # rebuilds from the restored state.
+        topo = getattr(project, "topography", None)
+        if topo is not None and hasattr(topo, "invalidate"):
+            topo.invalidate()
+
+    def _clean_task_orphans(
+        self, project: Project, untracked_before: Optional[set]
+    ) -> None:
+        """Remove only files that became untracked during the aborted task."""
+        if untracked_before is None:
+            return
+        new_orphans = self._untracked_files(project) - untracked_before
+        if not new_orphans:
+            return
+        paths = " ".join(shlex.quote(p) for p in sorted(new_orphans))
+        self._git(project, f"git clean -fd -- {paths}")
+        logger.info(f"Cleaned {len(new_orphans)} orphan file(s) from reverted task.")
+
+    def _git(self, project: Project, command: str) -> tuple:
+        ok, output = _run_cmd(command, project.path, None, timeout=30)
+        return ok, output.strip()