misterdev 0.2.0__py3-none-any.whl

misterdev/task_executors/markdown_plan_executor/llm_mixin.py

@@ -0,0 +1,238 @@
+"""LLM invocation, routing, caching, and ledger recording."""
+
+import contextlib
+import time
+from typing import Optional
+
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.llm.client import code_gen_abort_check
+from misterdev.config import get_setting
+
+from .helpers import logger, _is_truncated
+
+
+class LLMMixin:
+    def _invoke_llm(self, project: Project, prompt: str, system_prompt: str):
+        """Call the LLM, optionally streaming with early abort (config opt-in).
+
+        Returns (text, aborted). Streaming is enabled via llm.streaming=true. A
+        cache hit (llm.cache=true) returns the memoized output without a model
+        call; it is still re-applied through the gates downstream.
+        """
+        cache = getattr(project, "llm_cache", None)
+        if cache is not None:
+            hit = cache.get(system_prompt, prompt)
+            if hit is not None:
+                logger.info("LLM cache hit; reusing prior output (no model call).")
+                return hit, False
+        if get_setting(project.config, "llm", "use_tools") and hasattr(
+            project.llm_client, "generate_edits"
+        ):
+            # Structured edit extraction when the model supports tools; the
+            # client renders the result into the canonical fence format and
+            # falls back to plain generation for models without tool support.
+            resp = project.llm_client.generate_edits(prompt, system_prompt)
+            return resp.content, resp.finish_reason == "aborted"
+        if get_setting(project.config, "llm", "streaming"):
+            resp = project.llm_client.generate_stream(
+                prompt, system_prompt, abort_check=code_gen_abort_check
+            )
+            return resp.content, resp.finish_reason == "aborted"
+        return self._invoke_with_continuation(project, prompt, system_prompt), False
+
+    def _invoke_with_continuation(
+        self, project: Project, prompt: str, system_prompt: str
+    ) -> str:
+        """Plain-path generation that recovers a truncated response.
+
+        Uses ``generate()`` (which exposes ``finish_reason``) instead of
+        ``generate_code()``. When the response finishes normally this returns
+        ``.content`` exactly as ``generate_code`` would, so the no-truncation
+        path is byte-identical to before. When the model cuts the response off
+        at its output-token limit, it issues up to ``orchestrator.max_continuations``
+        bounded follow-up calls — each through the same client, so budget/usage
+        tracking is never bypassed — asking the model to continue where it
+        stopped, and concatenates the raw text before the edit parser sees it.
+        The loop always halts: it stops on a normal finish_reason or at the cap.
+        """
+        resp = project.llm_client.generate(prompt, system_prompt)
+        if not _is_truncated(resp.finish_reason):
+            return resp.content
+
+        max_continuations = get_setting(
+            project.config, "orchestrator", "max_continuations"
+        )
+        parts = [resp.content]
+        for _ in range(max(0, max_continuations)):
+            logger.info(
+                "Model response truncated (finish_reason="
+                f"{resp.finish_reason!r}); requesting continuation."
+            )
+            cont_prompt = (
+                f"{prompt}\n\n## Continuation\n"
+                "Your previous output was cut off. Here is what you produced so "
+                "far:\n\n" + "".join(parts) + "\n\nContinue the previous output "
+                "exactly where it stopped. Do not repeat any earlier text and do "
+                "not re-open code fences; emit only the remaining characters."
+            )
+            resp = project.llm_client.generate(cont_prompt, system_prompt)
+            parts.append(resp.content)
+            if not _is_truncated(resp.finish_reason):
+                break
+        return "".join(parts)
+
+    def _cache_store(self, project, system_prompt, prompt, output, model) -> None:
+        """Memoize a gate-passing output (no-op when caching is disabled)."""
+        cache = getattr(project, "llm_cache", None)
+        if cache is not None and output:
+            try:
+                cache.put(
+                    system_prompt, prompt, output, model=model, timestamp=time.time()
+                )
+            except OSError as e:
+                logger.warning(f"Failed to write LLM cache entry: {e}")
+
+    def _resolve_model(
+        self, project: Project, task: Task, strategy: str
+    ) -> Optional[str]:
+        """Pick a model for this task from llm.routing/llm.models config.
+
+        Routes by task complexity first, then strategy. Returns None when no
+        routing is configured so the client keeps its default model.
+        """
+        routing = get_setting(project.config, "llm", "routing")
+        models = get_setting(project.config, "llm", "models")
+        if not routing or not models:
+            return None
+        tier = routing.get(task.complexity) or routing.get(strategy)
+        if not tier:
+            return None
+        return models.get(tier) or models.get("default")
+
+    def _select_model(
+        self,
+        project: Project,
+        task: Task,
+        strategy: str,
+        attempt: int,
+        max_attempts: int,
+    ) -> Optional[str]:
+        """Resolve the model for this attempt.
+
+        Prefers the ledger-driven dynamic policy when enabled; otherwise falls
+        back to the static complexity/strategy routing. Returns None to keep the
+        client's default model.
+        """
+        selector = getattr(project, "model_selector", None)
+        if selector is not None and selector.enabled:
+            chosen = selector.select(
+                task.category, task.complexity, attempt, max_attempts
+            )
+            if chosen:
+                return chosen
+        return self._resolve_model(project, task, strategy)
+
+    def _invoke_routed(
+        self,
+        project,
+        task,
+        prompt: str,
+        system_prompt: str,
+        routed_model: Optional[str],
+        attempt: int,
+        track_models: bool,
+    ):
+        """Invoke the LLM on the routed model, degrading to the default on failure.
+
+        A routed cheap/free model can be unavailable (no provider permitted under
+        the data_collection policy) or rate-limited. Rather than fail the task,
+        record the routed model's failure (so the ledger deprioritizes it) and
+        retry the same attempt on the client's default model. Returns
+        (llm_response, aborted, pending_record).
+        """
+
+        def _cost() -> float:
+            return project.llm_client.task_cost(task.id) if track_models else 0.0
+
+        model_used = routed_model or getattr(project.llm_client, "model", "")
+        cost_before = _cost()
+        t_before = time.time()
+
+        with self._reasoning_ctx(project, task):
+            if not routed_model:
+                resp, aborted = self._invoke_llm(project, prompt, system_prompt)
+            else:
+                logger.info(
+                    f"[{task.id}] routing to {routed_model} ({task.complexity})"
+                )
+                try:
+                    with project.llm_client.with_model(routed_model):
+                        resp, aborted = self._invoke_llm(project, prompt, system_prompt)
+                except Exception as routed_err:
+                    logger.warning(
+                        f"[{task.id}] routed model {routed_model} failed "
+                        f"({routed_err}); falling back to the default model."
+                    )
+                    self._ledger_record(
+                        project,
+                        task,
+                        self._pending(
+                            routed_model, attempt, cost_before, t_before, False
+                        ),
+                        success=False,
+                    )
+                    model_used = getattr(project.llm_client, "model", "")
+                    cost_before = _cost()
+                    t_before = time.time()
+                    resp, aborted = self._invoke_llm(project, prompt, system_prompt)
+
+        pending = self._pending(model_used, attempt, cost_before, t_before, aborted)
+        return resp, aborted, pending
+
+    @staticmethod
+    def _pending(model, attempt, cost_before, t_before, aborted) -> dict:
+        """Build a per-attempt ledger record (latency measured from t_before)."""
+        return {
+            "model": model,
+            "attempt": attempt,
+            "cost_before": cost_before,
+            "latency": time.time() - t_before,
+            "aborted": aborted,
+        }
+
+    def _reasoning_ctx(self, project, task):
+        """Context manager requesting reasoning effort scaled to task complexity.
+
+        Effort comes from the llm.reasoning_effort map (by complexity); the
+        client only acts on it for models that support a reasoning budget. A
+        no-op when no effort is configured or the client lacks the hook.
+        """
+        mapping = get_setting(project.config, "llm", "reasoning_effort") or {}
+        effort = mapping.get(getattr(task, "complexity", None))
+        hook = getattr(project.llm_client, "with_reasoning_effort", None)
+        if effort and hook is not None:
+            return hook(effort)
+        return contextlib.nullcontext()
+
+    def _ledger_record(
+        self, project, task, pending: Optional[dict], *, success: bool
+    ) -> None:
+        """Record one attempt's outcome to the model ledger (no-op when off)."""
+        selector = getattr(project, "model_selector", None)
+        if pending is None or selector is None or not selector.enabled:
+            return
+        task_cost_fn = getattr(project.llm_client, "task_cost", None)
+        if task_cost_fn is None:
+            return
+        cost = max(0.0, task_cost_fn(task.id) - pending["cost_before"])
+        project.model_ledger.record(
+            pending["model"],
+            task.category,
+            task.complexity,
+            success=success,
+            first_try=pending["attempt"] == 0,
+            aborted=pending["aborted"],
+            cost=cost,
+            latency=pending["latency"],
+        )

misterdev/task_executors/markdown_plan_executor/results_mixin.py

@@ -0,0 +1,23 @@
+"""Terminal task-status transitions (complete/fail)."""
+
+from misterdev.core.models import Task, ExecutionResult
+from misterdev.core.execution.project import Project
+
+
+class ResultsMixin:
+    def _complete_task(
+        self, project: Project, task: Task, msg: str, logs: str
+    ) -> ExecutionResult:
+        project.task_manager.update_task_status(task.id, "completed")
+        # The task changed the tree; mark the symbol graph stale so the next task
+        # rebuilds from the new state instead of a map that predates this edit.
+        topo = getattr(project, "topography", None)
+        if topo is not None and hasattr(topo, "invalidate"):
+            topo.invalidate()
+        return ExecutionResult(status="completed", message=msg, logs=logs)
+
+    def _fail_task(
+        self, project: Project, task: Task, msg: str, logs: str = ""
+    ) -> ExecutionResult:
+        project.task_manager.update_task_status(task.id, "failed")
+        return ExecutionResult(status="failed", message=msg, logs=logs)

misterdev/tools/__init__.py

@@ -0,0 +1,19 @@
+"""Built-in tools, registered on import so the registry resolves them.
+
+Importing this package registers the built-ins with ``misterdev.plugins.TOOLS``;
+third-party tools add themselves via the ``misterdev.tools`` entry-point group.
+"""
+
+from misterdev.plugins import TOOLS
+from misterdev.tools.command import CommandTool
+from misterdev.tools.file_io import FileIOTool
+from misterdev.tools.formatter import FormatterTool
+from misterdev.tools.git_tool import GitTool
+
+TOOLS.register("command", CommandTool)
+TOOLS.register("test_runner", CommandTool)  # alias: a test runner is a command
+TOOLS.register("file_io", FileIOTool)
+TOOLS.register("formatter", FormatterTool)
+TOOLS.register("git", GitTool)
+
+__all__ = ["CommandTool", "FileIOTool", "FormatterTool", "GitTool"]

misterdev/tools/base_tool.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseTool(ABC):
+    def __init__(self, config: dict):
+        self.config = config
+        self.name = config.get("name", "Unnamed Tool")
+        self.type = config.get("type", "base")
+
+    @abstractmethod
+    def execute(self, project: Any, **kwargs) -> Any:
+        """Executes the tool's action."""
+        pass

misterdev/tools/command.py

@@ -0,0 +1,75 @@
+import subprocess
+from pathlib import Path
+from typing import Any, Tuple
+
+from misterdev.tools.base_tool import BaseTool
+from misterdev.logging_setup import setup_logger
+from misterdev.utils.process import kill_process_group
+
+logger = setup_logger(__name__)
+
+
+class CommandTool(BaseTool):
+    def execute(
+        self, project: Any, command: str, cwd: str | Path = None, timeout: int = 120
+    ) -> Tuple[bool, str]:
+        """
+        Executes a shell command.
+        Returns a tuple of (success_boolean, output_or_error_string).
+        """
+        work_dir = cwd or project.path
+        logger.info(f"Executing command: '{command}' in {work_dir}")
+
+        try:
+            # start_new_session puts the command in its own process group so a
+            # timeout can SIGKILL the WHOLE tree, not just the shell — otherwise a
+            # backgrounded grandchild (server, compiler) is orphaned and keeps
+            # running after the tool returns. errors="replace" keeps a stray
+            # non-UTF8 byte from raising and being misreported as a failure.
+            proc = subprocess.Popen(
+                command,
+                shell=True,
+                cwd=work_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                errors="replace",
+                start_new_session=True,
+            )
+            try:
+                stdout, stderr = proc.communicate(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                kill_process_group(proc)
+                # Reap the killed group, but bound the wait: a grandchild that
+                # double-forked out of the group (a daemonizing server) keeps the
+                # inherited stdout/stderr pipe open, so an unbounded communicate()
+                # would hang the tool forever after the timeout already fired.
+                try:
+                    proc.communicate(timeout=5)
+                except subprocess.TimeoutExpired:
+                    pass
+                error_msg = f"Command timed out after {timeout}s: {command}"
+                logger.error(error_msg)
+                return False, error_msg
+
+            output = stdout
+            if stderr:
+                output += "\n" + stderr
+
+            success = proc.returncode == 0
+            if not success:
+                logger.warning(
+                    f"Command failed with exit code {proc.returncode}:\n{output}"
+                )
+
+            return success, output
+
+        except FileNotFoundError:
+            error_msg = f"Command not found: {command}"
+            logger.error(error_msg)
+            return False, error_msg
+
+        except Exception as e:
+            error_msg = f"Failed to execute command: {e}"
+            logger.error(error_msg)
+            return False, error_msg

misterdev/tools/file_io.py

@@ -0,0 +1,69 @@
+from typing import Any, Tuple, Optional
+import os
+
+from misterdev.tools.base_tool import BaseTool
+from misterdev.utils.file_utils import read_file_capped, write_file
+from misterdev.logging_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class FileIOTool(BaseTool):
+    """Tool for explicit file I/O operations."""
+
+    def execute(
+        self, project: Any, action: str, path: str, content: Optional[str] = None
+    ) -> Tuple[bool, Any]:
+        """
+        Executes a file I/O action.
+        Actions: read, write, exists, delete
+        """
+        project_root = project.path.resolve()
+        full_path = (project.path / path).resolve()
+        if not full_path.is_relative_to(project_root):
+            return False, f"Path traversal blocked: {path}"
+        # An empty/"."/"./ " path resolves to the project root itself, which passes
+        # the traversal guard above. Refuse to operate on the root so a model
+        # emitting such a path cannot delete (rmtree) the whole project.
+        if full_path == project_root:
+            return False, f"Refusing to operate on the project root: {path!r}"
+        # The orchestrator's rollback/bisect safety paths depend on version
+        # history, so a stray delete of .git would break its own ability to
+        # revert bad work. This tool edits project source, never git internals.
+        git_dir = project_root / ".git"
+        if full_path == git_dir or git_dir in full_path.parents:
+            return False, f"Refusing to operate on the git directory: {path!r}"
+
+        try:
+            if action == "read":
+                if not full_path.exists():
+                    return False, f"File not found: {path}"
+                return True, read_file_capped(full_path)
+
+            elif action == "write":
+                if content is None:
+                    return False, "No content provided for write action."
+                write_file(full_path, content)
+                return True, f"Successfully wrote to {path}"
+
+            elif action == "exists":
+                return True, full_path.exists()
+
+            elif action == "delete":
+                if full_path.exists():
+                    if full_path.is_file():
+                        os.remove(full_path)
+                    else:
+                        import shutil
+
+                        shutil.rmtree(full_path)
+                    return True, f"Deleted {path}"
+                return True, f"{path} did not exist."
+
+            else:
+                return False, f"Unsupported action: {action}"
+
+        except Exception as e:
+            error_msg = f"File I/O error: {e}"
+            logger.error(error_msg)
+            return False, error_msg

misterdev/tools/formatter.py

@@ -0,0 +1,26 @@
+from typing import Any, Tuple
+
+from misterdev.tools.command import CommandTool
+from misterdev.logging_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class FormatterTool(CommandTool):
+    def execute(self, project: Any, file_path: str = ".") -> Tuple[bool, str]:
+        """
+        Executes a code formatter.
+        """
+        command_template = self.config.get("command")
+        if not command_template:
+            return False, "No command template provided for formatter tool."
+
+        # Only substitute a path for per-file formatters (templates containing
+        # {path}). Project-wide formatters like `cargo fmt` or `ruff format .`
+        # have no placeholder and must run as-is, not once per modified file.
+        if "{path}" in command_template:
+            command = command_template.format(path=file_path)
+        else:
+            command = command_template
+        logger.info(f"Running formatter: {command}")
+        return super().execute(project, command=command)

misterdev/tools/git_tool.py

@@ -0,0 +1,90 @@
+import shlex
+from typing import Any, Tuple
+
+from misterdev.tools.command import CommandTool
+from misterdev.logging_setup import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class GitTool(CommandTool):
+    """Tool for common Git operations including worktrees and branching."""
+
+    def execute(self, project: Any, action: str, **kwargs) -> Tuple[bool, str]:
+        if action == "status":
+            return self.status(project)
+        elif action == "add":
+            return self.add(project, kwargs.get("files", "."))
+        elif action == "commit":
+            return self.commit(
+                project, kwargs.get("message", "Auto-commit by Project Orchestrator")
+            )
+        elif action == "diff":
+            return self.diff(project)
+        elif action == "worktree_add":
+            return self.worktree_add(project, kwargs.get("path"), kwargs.get("branch"))
+        elif action == "worktree_remove":
+            return self.worktree_remove(project, kwargs.get("path"))
+        elif action == "branch_create":
+            return self.branch_create(project, kwargs.get("branch"))
+        elif action == "branch_delete":
+            return self.branch_delete(project, kwargs.get("branch"))
+        elif action == "merge":
+            return self.merge(project, kwargs.get("branch"))
+        elif action == "checkout":
+            return self.checkout(project, kwargs.get("branch"))
+        else:
+            return super().execute(project, command=f"git {shlex.quote(action)}")
+
+    def worktree_add(
+        self, project: Any, path: str, branch: str, new_branch: bool = False
+    ) -> Tuple[bool, str]:
+        logger.info(
+            f"Creating git worktree at {path} (branch: {branch}, new={new_branch})"
+        )
+        flag = "-b " if new_branch else ""
+        return super().execute(
+            project,
+            command=f"git worktree add {shlex.quote(path)} {flag}{shlex.quote(branch)}",
+        )
+
+    def worktree_remove(self, project: Any, path: str) -> Tuple[bool, str]:
+        logger.info(f"Removing git worktree at {path}")
+        return super().execute(
+            project, command=f"git worktree remove --force {shlex.quote(path)}"
+        )
+
+    def merge_worktree(self, project: Any, branch: str) -> Tuple[bool, str]:
+        """Merge a worktree's branch into the current branch, then delete it."""
+        success, out = super().execute(
+            project, command=f"git merge --no-ff {shlex.quote(branch)} --no-edit"
+        )
+        if success:
+            super().execute(project, command=f"git branch -d {shlex.quote(branch)}")
+        return success, out
+
+    def branch_create(self, project: Any, branch: str) -> Tuple[bool, str]:
+        return super().execute(
+            project, command=f"git checkout -b {shlex.quote(branch)}"
+        )
+
+    def branch_delete(self, project: Any, branch: str) -> Tuple[bool, str]:
+        return super().execute(project, command=f"git branch -D {shlex.quote(branch)}")
+
+    def merge(self, project: Any, branch: str) -> Tuple[bool, str]:
+        return super().execute(project, command=f"git merge {shlex.quote(branch)}")
+
+    def checkout(self, project: Any, branch: str) -> Tuple[bool, str]:
+        return super().execute(project, command=f"git checkout {shlex.quote(branch)}")
+
+    def status(self, project: Any) -> Tuple[bool, str]:
+        return super().execute(project, command="git status")
+
+    def add(self, project: Any, files: str) -> Tuple[bool, str]:
+        return super().execute(project, command=f"git add {shlex.quote(files)}")
+
+    def commit(self, project: Any, message: str) -> Tuple[bool, str]:
+        return super().execute(project, command=f"git commit -m {shlex.quote(message)}")
+
+    def diff(self, project: Any) -> Tuple[bool, str]:
+        return super().execute(project, command="git diff")