snodo-engine 0.7.2__py3-none-any.whl

snodo/coders/mock.py

@@ -0,0 +1,203 @@
+"""Mock coder adapter for testing.
+
+FILE: snodo/coders/mock.py (Fixes #12, #185, #187)
+
+Returns deterministic outputs without making LLM calls.
+
+The mock exists to exercise the engine loop deterministically.  Its output
+must therefore satisfy every validator that judges it — including the quality
+validator (pytest for Python, npm test for JavaScript).
+
+Language selection is driven by ``TaskSpec.project_context["language"]``:
+- ``javascript`` or ``typescript`` → ``src/hello.js`` + ``src/hello.test.js``
+  (uses Node's built-in ``node:test`` module; no npm install needed)
+- anything else (``python``, ``unknown``, or unset) → ``src/hello.py`` +
+  ``tests/test_hello.py`` (the original Python fixture, fixed in #185)
+
+Do not change the Python fixture paths or content: they are relied on by
+hundreds of tests in the suite.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+from unittest.mock import MagicMock
+
+from snodo.core.interfaces import TaskSpec, CodeArtifact, FileArtifact
+from snodo.coders.base import CoderAdapter
+from snodo.infrastructure.config import DEFAULT_MODEL
+
+_GLOBAL_MOCK_MODE: bool = False
+
+
+def set_mock_mode(enabled: bool) -> None:
+    """Enable or disable global hermetic mock mode for the process."""
+    global _GLOBAL_MOCK_MODE
+    _GLOBAL_MOCK_MODE = enabled
+
+
+def is_mock_mode_active() -> bool:
+    """Return True if global mock mode is enabled."""
+    return _GLOBAL_MOCK_MODE
+
+
+class MockChoiceMessage:
+    def __init__(self, content: str = "", tool_calls: Optional[list] = None):
+        self.content = content
+        self.tool_calls = tool_calls or []
+
+
+class MockChoice:
+    def __init__(self, message: MockChoiceMessage, finish_reason: str = "stop"):
+        self.message = message
+        self.finish_reason = finish_reason
+
+
+class MockModelResponse:
+    def __init__(self, content: str = "", tool_calls: Optional[list] = None, finish_reason: str = "stop"):
+        self.choices = [MockChoice(MockChoiceMessage(content, tool_calls), finish_reason)]
+
+
+def mock_completion_fn(*args: Any, **kwargs: Any) -> MockModelResponse:
+    """Hermetic mock completion function. Never touches network or credentials."""
+    messages = kwargs.get("messages", [])
+    tools = kwargs.get("tools", [])
+
+    # Check if tools contain submit_verdict or submit_files
+    tool_names = set()
+    if isinstance(tools, list):
+        for t in tools:
+            if isinstance(t, dict):
+                fn = t.get("function", {})
+                if isinstance(fn, dict) and "name" in fn:
+                    tool_names.add(fn["name"])
+
+    # LLMValidator tool loop
+    if "submit_verdict" in tool_names:
+        tc = MagicMock()
+        tc.id = "mock_val_call_1"
+        tc.function.name = "submit_verdict"
+        tc.function.arguments = json.dumps({"severity": "pass", "justification": "Mock validation pass"})
+        return MockModelResponse(content="", tool_calls=[tc])
+
+    # LiteLLMAdapter tool loop
+    if "submit_files" in tool_names:
+        tc = MagicMock()
+        tc.id = "mock_coder_call_1"
+        tc.function.name = "submit_files"
+        tc.function.arguments = json.dumps({"files": []})
+        return MockModelResponse(content="", tool_calls=[tc])
+
+    # Inspect messages to provide appropriate response
+    user_prompt = ""
+    for msg in reversed(messages):
+        if isinstance(msg, dict) and msg.get("role") == "user":
+            user_prompt = str(msg.get("content", ""))
+            break
+
+    # Wave classifier prompt
+    role_meta = str(kwargs.get("metadata", {}).get("role", ""))
+    if "wave" in user_prompt.lower() or "classifier" in role_meta.lower():
+        content = json.dumps({
+            "flow_type": "feature",
+            "wave_id": "W-MOCK-1",
+            "task_summary": "Mock task classification",
+            "feature_description": "Mock feature description",
+            "justification": "Mock wave 1 classification",
+        })
+        return MockModelResponse(content=content)
+
+    # Validator prompt
+    if "validator" in role_meta.lower() or "severity" in user_prompt.lower():
+        content = json.dumps({"severity": "pass", "justification": "Mock validation pass"})
+        return MockModelResponse(content=content)
+
+    # Spec authoring prompt
+    if "spec" in user_prompt.lower():
+        content = "Refined spec: mock task specification"
+        return MockModelResponse(content=content)
+
+    # Default fallback content
+    content = json.dumps([{"path": "src/mock.py", "content": "# Mock code", "action": "write"}])
+    return MockModelResponse(content=content)
+
+
+mock_completion_fn._is_mock = True  # type: ignore[attr-defined]
+
+
+def is_mock_completion_fn(fn: Any) -> bool:
+    """Return True if fn is mock_completion_fn or marked with _is_mock."""
+    if fn is None:
+        return False
+    target = getattr(fn, "func", fn)
+    if target == mock_completion_fn or getattr(target, "_is_mock", False) is True or getattr(fn, "_is_mock", False) is True:
+        return True
+    return is_mock_mode_active()
+
+
+class MockAdapter(CoderAdapter):
+    """Mock coder adapter for testing.
+
+    Returns deterministic outputs without making LLM calls.
+    Useful for fast, reliable unit tests.
+    """
+
+    def __init__(
+        self,
+        mock_files: Optional[list] = None,
+        model: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        self.model = model or DEFAULT_MODEL
+        self.mock_files = mock_files or [
+            FileArtifact(path="src/hello.py", content="def hello():\n    return 'world'\n"),
+            FileArtifact(path="tests/test_hello.py", content="from src.hello import hello\n\n\ndef test_hello():\n    assert hello() == 'world'\n"),
+        ]
+        self.call_count = 0
+        self.last_spec: Optional[TaskSpec] = None
+        self._completion_fn = mock_completion_fn
+
+    def _bare_model(self) -> str:
+        """Return the model the coder used to make LLM calls, or "" if none.
+
+        The mock makes no LLM call at all, so there is never a model to
+        attribute to it: the ``-m`` value is the judging model, which the
+        mock never forwards. Returning "" lets the halt payload and the
+        audit trail report ``coder_model: null`` for the mock path, the
+        same as an external CLI coder whose model was not namespaced.
+        """
+        return ""
+
+    def implement(self, spec: TaskSpec) -> CodeArtifact:
+        self.call_count += 1
+        self.last_spec = spec
+
+        language = spec.project_context.get("language", "").lower()
+        if language in ("javascript", "typescript"):
+            files = [
+                FileArtifact(
+                    path="src/hello.js",
+                    content="function hello() { return 'world'; }\nmodule.exports = { hello };\n",
+                ),
+                FileArtifact(
+                    path="src/hello.test.js",
+                    content=(
+                        "const { test } = require('node:test');\n"
+                        "const assert = require('node:assert');\n"
+                        "const { hello } = require('./hello.js');\n"
+                        "\n"
+                        "test('hello returns world', () => {\n"
+                        "  assert.strictEqual(hello(), 'world');\n"
+                        "});\n"
+                    ),
+                ),
+            ]
+        else:
+            files = self.mock_files
+
+        valid_files = [
+            f for f in files
+            if not (Path(f.path).parts and Path(f.path).parts[0] == ".snodo")
+        ]
+        return CodeArtifact(files=valid_files)
+

snodo/coders/openai_adapter.py

@@ -0,0 +1,16 @@
+"""OpenAI coder adapter.
+
+Inherits the base LiteLLMAdapter unchanged — already OpenAI-shaped.
+"""
+
+from snodo.coders.litellm import LiteLLMAdapter
+
+
+class OpenAIAdapter(LiteLLMAdapter):
+    """Coder adapter for OpenAI models (gpt-*, o1-*, o3-*).
+
+    Inherits the base _call_llm_with_tools unchanged — the OpenAI
+    message shape is the native format.
+    """
+
+    TRUNCATION_REASONS: set[str] = {"length", "max_tokens", "MAX_TOKENS"}

snodo/coders/opencode_adapter.py

@@ -0,0 +1,327 @@
+"""OpenCode coder adapter — delegates to opencode server in Docker.
+
+FILE: snodo/coders/opencode_adapter.py
+
+Implements CoderAdapter via the opencode HTTP API:
+  POST /session       → session_id
+  POST /session/{id}/message  → submit spec (model in message body)
+  GET  /event          → SSE subscription for completion signal
+  GET  /session/{id}/diff     → fetch changed files after completion
+
+After the session completes, changes are read from the volume-mounted
+workspace via git diff (the in-place edits are the source of truth).
+The /diff API is used as a best-effort fallback.
+
+The opencode server runs inside a Docker container managed by
+OpenCodeContainer.  Each implement() call creates a fresh session.
+"""
+
+import json
+import logging
+import threading
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+
+from snodo.core.interfaces import TaskSpec, CodeArtifact, FileArtifact
+from snodo.coders.base import InPlaceCoderAdapter, LLMCallError
+
+_logger = logging.getLogger(__name__)
+
+_SESSION_TIMEOUT = 300.0  # 5 minutes
+
+
+class OpenCodeAdapter(InPlaceCoderAdapter):
+    """Coder adapter backed by opencode CLI running in Docker.
+
+    Writes to the volume-mounted workspace in place (never through
+    WorkspaceMCP), so the .snodo/ boundary is enforced by the base class:
+    a post-run .snodo/ mutation raises ``SnodoMutationError`` instead of
+    being filtered out of the artifact report (Fixes #52, ADR 027).
+    """
+
+    coder_name: str = "opencode"
+    skip_engine_commit: bool = True
+    skip_workspace_write: bool = True
+
+    def __init__(
+        self,
+        model: str = "opencode/",
+        temperature: float = 0.7,
+        workspace: Optional[Path] = None,
+        container: Optional[Any] = None,
+        workspace_mcp: Optional[Any] = None,
+        **kwargs,
+    ):
+        self.model = model
+        self.temperature = temperature
+
+        if workspace is not None:
+            self._workspace = workspace
+        elif workspace_mcp is not None:
+            from snodo.tools.workspace import WorkspaceMCP
+            if isinstance(workspace_mcp, WorkspaceMCP):
+                self._workspace = workspace_mcp.project_root
+            else:
+                self._workspace = Path.cwd()
+        else:
+            self._workspace = Path.cwd()
+
+        if container is None:
+            from snodo.coders.opencode_container import OpenCodeContainer
+            self._container = OpenCodeContainer()
+        else:
+            self._container = container
+
+    @property
+    def base_url(self) -> str:
+        return self._container.base_url
+
+    def _implement_in_place(self, spec: TaskSpec) -> CodeArtifact:
+        """Generate code via the opencode HTTP API.
+
+        1. Ensure container is running (start if needed)
+        2. Create session via POST /session
+        3. Subscribe to SSE /event BEFORE sending message (race-safe)
+        4. Submit the task spec via POST /session/{id}/message (with model)
+        5. Wait for session.idle event (threading.Event, 300s timeout)
+        6. Read changed files from the volume-mounted workspace via git
+        7. Fall back to GET /session/{id}/diff if git readback is empty
+        8. Build CodeArtifact from on-disk file contents
+        """
+        if not self._container.is_running():
+            self._start_container()
+
+        session_id = self._create_session()
+        try:
+            self._wait_for_completion(session_id, spec)
+            # Primary: read from the volume-mounted workspace (git diff)
+            diff_entries = self._read_changes_from_disk()
+            # Fallback: use the /diff API
+            if not diff_entries:
+                _logger.debug("git readback empty — trying /session/{id}/diff")
+                diff_entries = self._fetch_diff(session_id)
+            return self._diff_to_artifact(diff_entries)
+        finally:
+            self._cleanup_session(session_id)
+
+    def _wait_for_completion(self, session_id: str, spec: TaskSpec) -> None:
+        """Subscribe to SSE, send message, wait for session.idle event."""
+        completed = threading.Event()
+
+        def _listen_sse():
+            try:
+                with httpx.stream(
+                    "GET",
+                    f"{self.base_url}/event",
+                    timeout=_SESSION_TIMEOUT,
+                ) as r:
+                    for line in r.iter_lines():
+                        if completed.is_set():
+                            break
+                        if not line.startswith("data: "):
+                            continue
+                        try:
+                            event = json.loads(line[6:])
+                        except json.JSONDecodeError:
+                            continue
+                        props = event.get("properties", {}) or {}
+                        event_sid = props.get("sessionID", "")
+                        if event_sid != session_id:
+                            continue
+                        event_type = event.get("type", "")
+                        if event_type == "session.idle":
+                            completed.set()
+                            return
+                        if (
+                            event_type == "session.status"
+                            and (props.get("status", {}) or {}).get("type") == "idle"
+                        ):
+                            completed.set()
+                            return
+            except Exception as e:
+                _logger.debug("opencode SSE listener error: %s", e)
+
+        thread = threading.Thread(target=_listen_sse, daemon=True)
+        thread.start()
+
+        self._send_message(session_id, spec)
+
+        if not completed.wait(timeout=_SESSION_TIMEOUT):
+            raise LLMCallError(
+                f"opencode session {session_id} timed out after {_SESSION_TIMEOUT}s"
+            )
+
+    def _fetch_diff(self, session_id: str) -> list:
+        """GET /session/{id}/diff — return changed files as a list (fallback)."""
+        diff_resp = httpx.get(
+            f"{self.base_url}/session/{session_id}/diff",
+            timeout=10.0,
+        )
+        data = diff_resp.json() if diff_resp.status_code == 200 else []
+        _logger.debug(
+            "opencode diff received: %d entries", len(data),
+        )
+        return data
+
+    def _start_container(self) -> None:
+        """Start the opencode container if not running."""
+        from snodo.coders.opencode_container import OpenCodeContainerError
+
+        if not self._container.is_available():
+            raise LLMCallError(
+                "Docker is not available. The opencode adapter requires Docker."
+            )
+        if not self._container.image_exists():
+            _logger.info("Building opencode Docker image (first run)...")
+            try:
+                self._container.build_image()
+            except OpenCodeContainerError as e:
+                raise LLMCallError(f"Failed to build opencode image: {e}") from e
+
+        try:
+            self._container.start(self._workspace)
+        except OpenCodeContainerError as e:
+            raise LLMCallError(f"Failed to start opencode container: {e}") from e
+
+    def _create_session(self) -> str:
+        """POST /session — create a new session and return the ID."""
+        try:
+            resp = httpx.post(
+                f"{self.base_url}/session",
+                json={
+                    "model": self._resolve_model_payload(),
+                },
+                timeout=10.0,
+            )
+            if resp.status_code != 200:
+                raise LLMCallError(
+                    f"opencode session creation failed (HTTP {resp.status_code}): "
+                    f"{resp.text[:500]}"
+                )
+            data = resp.json()
+            session_id = data.get("id") or data.get("session_id")
+            if not session_id:
+                raise LLMCallError(
+                    f"opencode session response missing id: {resp.text[:500]}"
+                )
+            _logger.debug("opencode session created: %s", session_id)
+            return session_id
+        except (httpx.RequestError, json.JSONDecodeError) as e:
+            raise LLMCallError(f"opencode session creation error: {e}") from e
+
+    def _send_message(self, session_id: str, spec: TaskSpec) -> None:
+        """POST /session/{id}/message — submit the task spec with model."""
+        prompt = self._build_prompt(spec)
+        try:
+            resp = httpx.post(
+                f"{self.base_url}/session/{session_id}/message",
+                json={
+                    "model": self._resolve_model_payload(),
+                    "parts": [{"type": "text", "text": prompt}],
+                },
+                timeout=60.0,
+            )
+            if resp.status_code != 200:
+                _logger.warning(
+                    "opencode message rejected (HTTP %d): %s",
+                    resp.status_code, resp.text[:500],
+                )
+                raise LLMCallError(
+                    f"opencode message rejected (HTTP {resp.status_code})"
+                )
+        except httpx.RequestError as e:
+            _logger.warning("opencode message send error: %s", e)
+
+    def _cleanup_session(self, session_id: str) -> None:
+        """Best-effort session cleanup."""
+        try:
+            httpx.delete(
+                f"{self.base_url}/session/{session_id}",
+                timeout=5.0,
+            )
+        except Exception as e:
+            _logger.debug("opencode session cleanup error for %s: %s", session_id, e)
+
+    def _diff_to_artifact(self, diff_entries: list) -> CodeArtifact:
+        """Convert opencode diff entries to a CodeArtifact.
+
+        Each entry: ``{file, patch, additions, deletions, status}``.
+        We need the full file content — re-read from disk after the
+        opencode session has written changes.
+        """
+        files = []
+        for entry in diff_entries:
+            path = entry.get("file", "")
+            if not path:
+                continue
+            status = entry.get("status", "modified")
+
+            if status == "deleted":
+                files.append(FileArtifact(path=path, content="", action="delete"))
+                continue
+
+            # Re-read the file from disk (opencode wrote to workspace)
+            file_path = Path(self._workspace) / path
+            try:
+                content = file_path.read_text()
+            except Exception:
+                content = ""
+
+            files.append(FileArtifact(path=path, content=content, action="write"))
+
+        if not files:
+            _logger.warning("opencode diff returned no files — task completed with no changes")
+            return CodeArtifact(files=[])
+
+        return CodeArtifact(files=files)
+
+    def _resolve_model_payload(self) -> dict:
+        """Map the snodo model string to an opencode model payload.
+
+        opencode's API expects ``{"providerID": <p>, "modelID": <m>}``
+        on ``POST /session/{id}/message``.
+        """
+        model = self.model
+        if model.startswith("opencode/"):
+            provider_and_id = model[len("opencode/"):]
+            if "/" in provider_and_id:
+                provider, model_id = provider_and_id.split("/", 1)
+                return {"providerID": provider, "modelID": model_id}
+            return {"modelID": provider_and_id}
+        return {"modelID": model}
+
+    def _build_prompt(self, spec: TaskSpec) -> str:
+        """Build a prompt from the TaskSpec for opencode."""
+        language = spec.project_context.get("language", "unknown")
+        lang_hint = f" ({language} project)" if language != "unknown" else ""
+
+        parts = [
+            f"You are an expert software engineer{lang_hint}.",
+            "Generate code based on the following specification.",
+            "",
+        ]
+
+        structure = spec.project_context.get("structure", "")
+        if structure:
+            parts.append(f"## Directory Structure\n```\n{structure}\n```")
+            parts.append("")
+
+        if spec.memory_summary:
+            parts.append(f"## Session History\n{spec.memory_summary}")
+            parts.append("")
+
+        parts.append(f"## Task\n{spec.description}")
+
+        if spec.constraints:
+            parts.append("\n## Constraints")
+            for c in spec.constraints:
+                parts.append(f"- {c}")
+
+        parts.append("")
+        parts.append(
+            "Write the implementation to disk. Create all necessary files."
+        )
+
+        return "\n".join(parts)

snodo/coders/opencode_cli_adapter.py

@@ -0,0 +1,34 @@
+"""OpenCode CLI coder adapter — shells `opencode run` on the host.
+
+FILE: snodo/coders/opencode_cli_adapter.py
+
+Runs opencode directly on the host machine via SubprocessCoderAdapter.
+"""
+
+from typing import List
+
+from snodo.coders.subprocess_adapter import SubprocessCoderAdapter
+
+
+class OpenCodeCLIAdapter(SubprocessCoderAdapter):
+    """Coder adapter backed by the host ``opencode run`` CLI."""
+
+    coder_name: str = "opencode-cli"
+    binary: str = "opencode"
+    model_prefix: str = "opencode-cli/"
+    install_hint: str = (
+        "Install opencode: curl -fsSL https://opencode.ai/install | bash"
+    )
+
+    def _build_argv(self, prompt: str, project_root: str, model: str) -> List[str]:
+        argv = [
+            "opencode",
+            "run",
+            "--dir",
+            project_root,
+            "--dangerously-skip-permissions",
+            prompt,
+        ]
+        if model:
+            argv.extend(["-m", model])
+        return argv