snodo-engine 0.7.2__py3-none-any.whl

snodo/coders/opencode_container.py

@@ -0,0 +1,267 @@
+"""OpenCode Docker container lifecycle manager.
+
+FILE: snodo/coders/opencode_container.py
+
+Manages the opencode server container — start, stop, health check.
+Built on docker-py (same dependency as DockerSandbox).
+"""
+
+import logging
+import os
+import time
+import urllib.parse
+from pathlib import Path
+
+_logger = logging.getLogger(__name__)
+
+_IMAGE = "snodo-opencode:latest"
+_PORT = 55440
+
+
+class OpenCodeContainerError(Exception):
+    """Container operation failed."""
+
+
+class OpenCodeContainer:
+    """Manages a long-lived opencode server container.
+
+    The container runs ``opencode serve --port {port}`` inside the
+    workspace directory and exposes the HTTP API on localhost.
+    """
+
+    def __init__(self, image: str = _IMAGE, port: int = _PORT):
+        self._image = image
+        self._port = port
+        self._client = None
+        self._container = None
+
+        docker_host = os.environ.get("DOCKER_HOST", "")
+        if docker_host.startswith(("ssh://", "tcp://")):
+            self._host = urllib.parse.urlparse(docker_host).hostname or "localhost"
+        else:
+            self._host = "localhost"
+
+    @property
+    def client(self):
+        if self._client is None:
+            import docker
+            self._client = docker.from_env()
+        return self._client
+
+    def is_available(self) -> bool:
+        """Check if Docker daemon is reachable."""
+        try:
+            self.client.ping()
+            return True
+        except Exception:
+            return False
+
+    def image_exists(self) -> bool:
+        """Check if the opencode image exists locally."""
+        try:
+            self.client.images.get(self._image)
+            return True
+        except Exception:
+            return False
+
+    def build_image(self) -> str:
+        """Build the opencode Docker image.
+
+        Returns the image ID.
+
+        Raises OpenCodeContainerError on failure.
+        """
+        dockerfile_dir = Path(__file__).parent.parent.parent / "docker"
+        dockerfile_path = dockerfile_dir / "Dockerfile.opencode"
+        if not dockerfile_path.exists():
+            raise OpenCodeContainerError(
+                f"Dockerfile not found at {dockerfile_path}"
+            )
+        try:
+            image, _ = self.client.images.build(
+                path=str(dockerfile_dir),
+                dockerfile=dockerfile_path.name,
+                tag=self._image,
+                rm=True,
+            )
+            return image.id
+        except Exception as e:
+            raise OpenCodeContainerError(f"Failed to build image: {e}") from e
+
+    def start(self, workspace: Path) -> None:
+        """Start the opencode server container, reusing an existing one if healthy.
+
+        The *workspace* directory is mounted at /workspace inside the
+        container so opencode can read project files.
+
+        Raises OpenCodeContainerError if startup fails.
+        """
+        # If we already hold a reference and it's healthy, skip
+        if self._container is not None and self._is_container_healthy():
+            return
+
+        # Check for an existing container from a previous session
+        existing = self._find_existing_container()
+        if existing is not None:
+            self._container = existing
+            if self._is_container_healthy():
+                _logger.info("Reusing existing opencode container %s", existing.id[:12])
+                return
+            _logger.debug("Existing container %s is unhealthy — removing", existing.id[:12])
+            self.stop()
+
+        # Start fresh
+        try:
+            volumes = {
+                str(workspace.resolve()): {"bind": "/workspace", "mode": "rw"},
+            }
+            env = _build_provider_env()
+            env["OPENCODE_PORT"] = str(self._port)
+            self._container = self.client.containers.run(
+                self._image,
+                detach=True,
+                volumes=volumes,
+                ports={f"{self._port}/tcp": self._port},
+                publish_all_ports=False,
+                remove=True,
+                environment=env,
+            )
+        except Exception as e:
+            self._container = None
+            raise OpenCodeContainerError(f"Failed to start container: {e}") from e
+
+        self._wait_ready()
+
+        _logger.info("Started new opencode container")
+        self._log_readiness()
+
+    def _find_existing_container(self):
+        """Return an existing running container with this image, or None."""
+        try:
+            containers = self.client.containers.list(
+                filters={"ancestor": self._image, "status": "running"},
+            )
+            if containers:
+                return containers[0]
+        except Exception as e:
+            _logger.debug("Failed to list running container by image: %s", e)
+        return None
+
+    def _is_container_healthy(self) -> bool:
+        """Check if the container is running AND /global/health responds."""
+        import httpx
+
+        if not self.is_running():
+            return False
+        try:
+            resp = httpx.get(
+                f"{self.base_url}/global/health", timeout=2.0,
+            )
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    def _wait_ready(self, timeout: float = 60.0) -> None:
+        """Poll the opencode HTTP API until it responds or times out."""
+        import httpx
+
+        deadline = time.time() + timeout
+        url = self.base_url + "/global/health"
+        while time.time() < deadline:
+            if self._container is None:
+                raise OpenCodeContainerError("Container stopped during startup")
+            try:
+                resp = httpx.get(url, timeout=2.0)
+                if resp.status_code < 500:
+                    _logger.debug("OpenCode server ready at %s", self.base_url)
+                    return
+            except Exception as e:
+                _logger.debug("OpenCode server health check poll error: %s", e)
+            time.sleep(0.5)
+        raise OpenCodeContainerError(
+            f"OpenCode server did not become ready within {timeout}s"
+        )
+
+    def _log_readiness(self) -> None:
+        """Log container health information at DEBUG level."""
+        import httpx
+
+        try:
+            resp = httpx.get(
+                f"{self.base_url}/global/health", timeout=2.0,
+            )
+            data = resp.json() if resp.status_code == 200 else {}
+            version = data.get("version", "unknown")
+            _logger.debug(
+                "OpenCode container ready: http://%s:%d (v%s)",
+                self._host, self._port, version,
+            )
+        except Exception:
+            _logger.debug(
+                "OpenCode container ready: http://%s:%d",
+                self._host, self._port,
+            )
+
+    @property
+    def base_url(self) -> str:
+        return f"http://{self._host}:{self._port}"
+
+    def is_running(self) -> bool:
+        """Return True if the container is alive."""
+        if self._container is None:
+            return False
+        try:
+            self._container.reload()
+            return self._container.status == "running"
+        except Exception:
+            return False
+
+    def stop(self) -> None:
+        """Stop and remove the container."""
+        if self._container is not None:
+            try:
+                self._container.stop(timeout=5)
+            except Exception as e:
+                _logger.debug("Failed to stop opencode container: %s", e)
+            try:
+                self._container.remove(force=True)
+            except Exception as e:
+                _logger.debug("Failed to remove opencode container: %s", e)
+            self._container = None
+
+
+_PROVIDER_ENV_MAP = {
+    "google": ("GOOGLE_API_KEY", "GEMINI_API_KEY"),
+    "anthropic": ("ANTHROPIC_API_KEY",),
+    "openai": ("OPENAI_API_KEY",),
+    "deepseek": ("DEEPSEEK_API_KEY",),
+    "openrouter": ("OPENROUTER_API_KEY",),
+    "opencode": ("OPENCODE_API_KEY",),
+}
+
+
+def _build_provider_env() -> dict:
+    """Read provider API keys from snodo config and return env vars for opencode."""
+    env: dict[str, str] = {}
+    try:
+        from snodo.config import ConfigManager
+        import os as _os
+        config = ConfigManager().load()
+        providers = config.get("providers", {})
+        if not isinstance(providers, dict):
+            return env
+        for provider_name, env_var_names in _PROVIDER_ENV_MAP.items():
+            provider_config = providers.get(provider_name, {})
+            if not isinstance(provider_config, dict):
+                continue
+            key = provider_config.get("api_key", "")
+            if not key:
+                api_key_env_name = provider_config.get("api_key_env", "")
+                if api_key_env_name:
+                    key = _os.environ.get(api_key_env_name, "")
+            if key:
+                for env_name in env_var_names:
+                    env[env_name] = key
+    except Exception as e:
+        _logger.warning("Failed to build provider env for opencode: %s", e)
+    return env

snodo/coders/subprocess_adapter.py

@@ -0,0 +1,219 @@
+"""Base adapter for host CLI tools that write files in place via subprocess.
+
+FILE: snodo/coders/subprocess_adapter.py
+
+Abstracts host CLI tools (opencode-cli, agy) that execute in-place edits in the
+working tree via subprocess invocation. Base class handles:
+- Prompt formatting (_build_prompt)
+- Subprocess invocation and error handling (missing binary, timeout, non-zero returncode)
+- Git working tree readback (_read_changes_from_disk)
+- Artifact construction (_diff_to_artifact)
+- .snodo/ mutation protection and git commit (inherited from InPlaceCoderAdapter)
+"""
+
+import logging
+import subprocess
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Optional
+
+from snodo.coders.base import InPlaceCoderAdapter, LLMCallError
+from snodo.core.interfaces import CodeArtifact, FileArtifact, TaskSpec
+
+_logger = logging.getLogger(__name__)
+
+
+class SubprocessCoderAdapter(InPlaceCoderAdapter):
+    """Base coder adapter for host CLI subprocess tools."""
+
+    skip_engine_commit: bool = True
+    skip_workspace_write: bool = True
+
+    binary: str = ""
+    model_prefix: str = ""
+    install_hint: str = ""
+    timeout_seconds: int = 1800
+
+    def __init__(
+        self,
+        model: str = "",
+        temperature: float = 0.7,
+        workspace: Optional[Path] = None,
+        workspace_mcp: Optional[Any] = None,
+        **kwargs: Any,
+    ):
+        self.model = model or self.model_prefix
+        self.temperature = temperature
+
+        if workspace is not None:
+            self._workspace = Path(workspace)
+        elif workspace_mcp is not None:
+            from snodo.tools.workspace import WorkspaceMCP
+            if isinstance(workspace_mcp, WorkspaceMCP):
+                self._workspace = Path(workspace_mcp.project_root)
+            elif hasattr(workspace_mcp, "project_root") and workspace_mcp.project_root is not None:
+                self._workspace = Path(workspace_mcp.project_root)
+            else:
+                raise ValueError(
+                    f"{self.__class__.__name__} requires an explicit workspace or a valid "
+                    f"WorkspaceMCP with project_root; received invalid workspace_mcp: {workspace_mcp!r}. "
+                    "Inferring a containment boundary from Path.cwd() is prohibited (ADR 024/025)."
+                )
+        else:
+            raise ValueError(
+                f"{self.__class__.__name__} requires an explicit workspace or workspace_mcp; "
+                "none was provided. Inferring a containment boundary from Path.cwd() is prohibited (ADR 024/025)."
+            )
+
+    def _bare_model(self) -> str:
+        """Return the model to pass to the CLI, or "" to let it choose.
+
+        An external coding agent owns its own model catalog — agy offers
+        "Gemini 3.6 Flash (Medium)", opencode offers whatever its providers
+        expose. snodo's ``-m`` names the model that JUDGES the work: it is
+        resolved through litellm for the validators and the classifier, and it
+        is meaningless to the CLI. Forwarding it produced:
+
+            agy run failed (rc=1): invalid model selection
+            (--model "deepseek/deepseek-v4-flash"): not recognized as a known
+            model or custom model in settings
+
+        So a model reaches the CLI only when the operator named one in THIS
+        adapter's namespace (``agy/...``, ``opencode-cli/...``). Anything else
+        yields "", and ``_build_argv`` omits the flag so the tool falls back to
+        its own last-selected default.
+
+        (Selecting the coder's model explicitly, while the validators keep
+        theirs, needs a separate flag — ``-m`` cannot carry both.)
+        """
+        model = self.model
+        if not self.model_prefix:
+            return model
+        prefixes = (self.model_prefix,)
+        if self.model_prefix == "opencode-cli/":
+            prefixes = ("opencode-cli/", "opencode/")
+        for prefix in prefixes:
+            if model.startswith(prefix):
+                return model[len(prefix):]
+        return ""
+
+    @abstractmethod
+    def _build_argv(self, prompt: str, project_root: str, model: str) -> list[str]:
+        """Construct the subprocess argument list for the specific CLI tool."""
+
+    def _implement_in_place(self, spec: TaskSpec) -> CodeArtifact:
+        prompt = self._build_prompt(spec)
+        project_root = str(self._workspace)
+        bare_model = self._bare_model()
+        argv = self._build_argv(prompt, project_root, bare_model)
+
+        _logger.info(
+            "%s: executing with containment boundary at %s",
+            self.binary, project_root,
+        )
+
+        try:
+            # noqa carried over from opencode_cli_adapter when this call moved
+            # here in the subprocess-adapter refactor. The binary name is a
+            # class attribute, never operator input; the prompt and model are
+            # single argv elements and are never shell-interpreted.
+            proc = subprocess.run(  # noqa: S603 - argv list, no shell; binary is a class attribute
+                argv,
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                timeout=self.timeout_seconds,
+            )
+        except FileNotFoundError as e:
+            raise LLMCallError(
+                f"{self.binary} not found on PATH. {self.install_hint}"
+            ) from e
+        except subprocess.TimeoutExpired as e:
+            raise LLMCallError(
+                f"{self.binary} run timed out after {self.timeout_seconds}s"
+            ) from e
+
+        if proc.returncode != 0:
+            tail = (proc.stderr or "")[:2000] or (proc.stdout or "")[:2000]
+            raise LLMCallError(
+                f"{self.binary} run failed (rc={proc.returncode}): {tail}"
+            )
+
+        diff_entries = self._read_changes_from_disk()
+        if not diff_entries:
+            combined = ((proc.stdout or "") + "\n" + (proc.stderr or "")).strip()
+            tail = combined[-1000:]
+            _logger.warning(
+                "%s run completed but no changes detected (rc=0). output tail: %s",
+                self.binary, tail,
+            )
+
+        return self._diff_to_artifact(diff_entries)
+
+    def _diff_to_artifact(self, diff_entries: list) -> CodeArtifact:
+        """Build a CodeArtifact from diff entries, re-reading content from disk."""
+        _ignored_dirs = {"__pycache__", ".venv", "venv", "node_modules", ".git", ".pytest_cache", ".mypy_cache"}
+        _ignored_exts = {".pyc", ".pyo", ".DS_Store"}
+
+        files = []
+        for entry in diff_entries:
+            path = entry.get("file", "")
+            if not path:
+                continue
+            parts = Path(path).parts
+            if any(p in _ignored_dirs for p in parts) or Path(path).suffix in _ignored_exts:
+                continue
+            status = entry.get("status", "modified")
+
+            if status == "deleted":
+                files.append(FileArtifact(path=path, content="", action="delete"))
+                continue
+
+            file_path = Path(self._workspace) / path
+            try:
+                content = file_path.read_text()
+            except Exception as exc:
+                _logger.warning("%s: failed to read %s: %s", self.binary, file_path, exc)
+                content = f"<unreadable: {exc}>"
+
+            files.append(FileArtifact(path=path, content=content, action="write"))
+
+        if not files:
+            _logger.warning("%s returned no files — task completed with no changes", self.binary)
+            return CodeArtifact(files=[])
+
+        return CodeArtifact(files=files)
+
+    def _build_prompt(self, spec: TaskSpec) -> str:
+        """Build prompt from TaskSpec."""
+        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)