spawn-cli 0.1.20__tar.gz → 0.1.21__tar.gz

{spawn_cli-0.1.20/src/spawn_cli.egg-info → spawn_cli-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawn-cli
-Version: 0.1.20
+Version: 0.1.21
 Summary: A minimal installable Python CLI package.
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

{spawn_cli-0.1.20 → spawn_cli-0.1.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spawn-cli"
-version = "0.1.20"
+version = "0.1.21"
 description = "A minimal installable Python CLI package."
 readme = "README.md"
 requires-python = ">=3.10"

{spawn_cli-0.1.20 → spawn_cli-0.1.21}/src/spawn_cli/core/low_level.py

@@ -33,6 +33,7 @@ CANONICAL_IDE_KEYS: tuple[str, ...] = (
     "github-copilot",
     "gemini-cli",
     "cline",
+    "opencode",
 )
 
 SPAWN_GITIGNORE_START = "# spawn:start"

{spawn_cli-0.1.20 → spawn_cli-0.1.21}/src/spawn_cli/ide/__init__.py

@@ -9,8 +9,10 @@ from . import gemini_cli  # noqa: F401
 from . import github_copilot  # noqa: F401
 from . import windsurf  # noqa: F401
 from . import cline  # noqa: F401
+from . import opencode  # noqa: F401
 from ._stub import StubAdapter
 from .cline import ClineAdapter
+from .opencode import OpenCodeAdapter
 from .claude_code import ClaudeCodeAdapter
 from .codex import CodexAdapter
 from .cursor import CursorAdapter
@@ -45,6 +47,7 @@ from .registry import (
 __all__ = [
     "ALIASES",
     "ClineAdapter",
+    "OpenCodeAdapter",
     "ClaudeCodeAdapter",
     "CodexAdapter",
     "CursorAdapter",

{spawn_cli-0.1.20 → spawn_cli-0.1.21}/src/spawn_cli/ide/_vacancy.py

@@ -226,6 +226,41 @@ def finalize_github_copilot_repo(target_root: Path) -> None:
         pass
 
 
+_OPENCODE_CONFIG = "opencode.json"
+
+
+def _opencode_config_vacant(path: Path) -> bool:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        return False  # user config in an unexpected shape: keep untouched
+    if data == {}:
+        return True
+    for key, value in data.items():
+        if key in ("mcp", "permission"):
+            if value:  # non-empty -> user content or live servers
+                return False
+        elif json_value_nonempty(value):  # unknown user key with substance
+            return False
+    return True
+
+
+def finalize_opencode_repo(target_root: Path) -> None:
+    """OpenCode adapter: root `opencode.json` (keys mcp, permission) and `.opencode/skills`; drop when vacant."""
+    config = target_root / _OPENCODE_CONFIG
+    if config.is_file():
+        try:
+            vacant = _opencode_config_vacant(config)
+        except json.JSONDecodeError:
+            vacant = False  # keep unparseable user config untouched
+        if vacant:
+            config.unlink()
+    skills_dir = target_root / ".opencode" / "skills"
+    if skills_dir.is_dir() and not dir_has_any_file(skills_dir):
+        prune_empty_directories_under(target_root / ".opencode")
+    if (target_root / ".opencode").is_dir() and not dir_has_any_file(target_root / ".opencode"):
+        (target_root / ".opencode").rmdir()
+
+
 def finalize_cline_repo(target_root: Path) -> None:
     """Cline adapter: `.cline/skills` dotdir and root `.clineignore`; drop both when vacant."""
     finalize_standard_dotdir_skills_and_mcp(
@@ -244,6 +279,7 @@ __all__ = [
     "dir_has_any_file",
     "finalize_claude_repo",
     "finalize_cline_repo",
+    "finalize_opencode_repo",
     "finalize_codex_repo",
     "finalize_github_copilot_repo",
     "finalize_standard_dotdir_skills_and_mcp",

spawn_cli-0.1.21/src/spawn_cli/ide/opencode.py

@@ -0,0 +1,187 @@
+"""OpenCode CLI adapter: .opencode/skills, root opencode.json (mcp + permission), AGENTS.md."""
+
+from __future__ import annotations
+
+import json
+import re
+import warnings
+from pathlib import Path
+
+from spawn_cli.core import low_level as ll
+from spawn_cli.errors import SpawnError, SpawnWarning
+from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
+from spawn_cli.ide.registry import (
+    DetectResult,
+    IdeAdapter,
+    IdeCapabilities,
+    normalize_skill_name,
+    register,
+    render_skill_md,
+    rewrite_managed_block,
+)
+from spawn_cli.models.mcp import McpServer, NormalizedMcp
+from spawn_cli.models.skill import SkillMetadata
+
+_CONFIG = "opencode.json"
+
+
+def _load_config(target_root: Path) -> dict:
+    path = target_root / _CONFIG
+    if not path.exists():
+        if (target_root / "opencode.jsonc").exists():
+            warnings.warn(
+                "OpenCode: Spawn manages opencode.json; existing opencode.jsonc is not merged",
+                SpawnWarning,
+            )
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise SpawnError(f"OpenCode config is not valid JSON: {path} ({exc})") from exc
+
+
+def _save_config(target_root: Path, data: dict) -> None:
+    (target_root / _CONFIG).write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def _sanitize_skill_name(name: str) -> str:
+    name = normalize_skill_name(name)
+    name = name.replace("_", "-").replace(".", "-")
+    name = re.sub(r"-{2,}", "-", name).strip("-")
+    return name
+
+
+def _build_mcp_entry(server: McpServer) -> dict:
+    transport = server.transport
+    if transport.type == "stdio":
+        if server.spawn_stdio_proxy:
+            entry = {
+                "type": "local",
+                "command": ["spawn"] + mcp_stdio_argv(server.extension, server.name),
+            }
+        else:
+            entry = {"type": "local", "command": [transport.command, *list(transport.args)]}
+    else:  # streamable-http and sse both render as remote
+        entry = {"type": "remote", "url": transport.url}
+        if transport.headers:
+            entry["headers"] = {k: f"{{env:{v}}}" for k, v in transport.headers.items()}
+    entry["enabled"] = True
+    if server.env:
+        entry["environment"] = {
+            k: f"{{env:{k}}}" if v.secret else (v.value or f"{{env:{k}}}")
+            for k, v in server.env.items()
+        }
+    return entry
+
+
+class OpenCodeAdapter(IdeAdapter):
+    key = "opencode"
+
+    def detect(self, target_root: Path) -> DetectResult:
+        used = (
+            (target_root / ".opencode").exists()
+            or (target_root / "opencode.json").exists()
+            or (target_root / "opencode.jsonc").exists()
+        )
+        return DetectResult(
+            used_in_repo=used,
+            capabilities=IdeCapabilities(
+                skills="native",
+                mcp="project",
+                agent_ignore="project",
+                entry_point="agents-md",
+            ),
+        )
+
+    def add_skills(self, target_root: Path, skill_metadata: list[SkillMetadata]) -> list[dict]:
+        results = []
+        for skill in skill_metadata:
+            name = _sanitize_skill_name(skill.name)
+            skill_dir = target_root / ".opencode" / "skills" / name
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_path = skill_dir / "SKILL.md"
+            if skill_path.exists():
+                warnings.warn(f"Overwriting existing rendered skill: {skill_path}", SpawnWarning)
+            # OpenCode requires frontmatter name == directory name.
+            rendered = render_skill_md(skill.model_copy(update={"name": name}))
+            skill_path.write_text(rendered, encoding="utf-8")
+            results.append({"skill": skill.name, "path": skill_path.relative_to(target_root).as_posix()})
+        return results
+
+    def remove_skills(self, target_root: Path, rendered_paths: list[dict]) -> None:
+        for entry in rendered_paths:
+            p = target_root / entry["path"]
+            if p.exists():
+                p.unlink()
+            if p.parent.exists() and not any(p.parent.iterdir()):
+                p.parent.rmdir()
+
+    def add_mcp(self, target_root: Path, normalized_mcp: NormalizedMcp) -> list[str]:
+        data = _load_config(target_root)
+        mcp = data.setdefault("mcp", {})
+        for server in normalized_mcp.servers:
+            mcp[server.name] = _build_mcp_entry(server)
+        _save_config(target_root, data)
+        return [s.name for s in normalized_mcp.servers]
+
+    def remove_mcp(self, target_root: Path, rendered_mcp_names: list[str]) -> None:
+        if not (target_root / _CONFIG).exists():
+            return
+        data = _load_config(target_root)
+        mcp = data.get("mcp")
+        if isinstance(mcp, dict):
+            for name in rendered_mcp_names:
+                mcp.pop(name, None)
+            if not mcp:
+                data.pop("mcp", None)
+        _save_config(target_root, data)
+
+    def add_agent_ignore(self, target_root: Path, globs: list[str]) -> None:
+        data = _load_config(target_root)
+        perms = data.setdefault("permission", {})
+        for section in ("read", "edit"):
+            rules = perms.setdefault(section, {})
+            if not isinstance(rules, dict):
+                rules = {}
+                perms[section] = rules
+            for glob in globs:
+                rules[glob] = "deny"
+        _save_config(target_root, data)
+
+    def remove_agent_ignore(self, target_root: Path, globs: list[str]) -> None:
+        if not (target_root / _CONFIG).exists():
+            return
+        data = _load_config(target_root)
+        perms = data.get("permission")
+        if not isinstance(perms, dict):
+            return
+        drop = set(globs)
+        for section in ("read", "edit"):
+            rules = perms.get(section)
+            if isinstance(rules, dict):
+                for glob in drop:
+                    rules.pop(glob, None)
+                if not rules:
+                    perms.pop(section, None)
+        if not perms:
+            data.pop("permission", None)
+        _save_config(target_root, data)
+
+    def clear_spawn_agent_ignore(self, target_root: Path) -> None:
+        recorded = ll.get_agent_ignore_list(target_root, self.key)
+        if recorded:
+            self.remove_agent_ignore(target_root, recorded)
+
+    def rewrite_entry_point(self, target_root: Path, prompt: str) -> str:
+        ep = target_root / "AGENTS.md"
+        rewrite_managed_block(ep, prompt)
+        return ep.relative_to(target_root).as_posix()
+
+    def finalize_repo_after_ide_removed(self, target_root: Path) -> None:
+        _vac.finalize_opencode_repo(target_root)
+
+
+register(OpenCodeAdapter())
+
+__all__ = ["OpenCodeAdapter"]

{spawn_cli-0.1.20 → spawn_cli-0.1.21/src/spawn_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawn-cli
-Version: 0.1.20
+Version: 0.1.21
 Summary: A minimal installable Python CLI package.
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

{spawn_cli-0.1.20 → spawn_cli-0.1.21}/src/spawn_cli.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ src/spawn_cli/ide/cursor.py
 src/spawn_cli/ide/gemini_cli.py
 src/spawn_cli/ide/github_copilot.py
 src/spawn_cli/ide/mcp_stdio_argv.py
+src/spawn_cli/ide/opencode.py
 src/spawn_cli/ide/registry.py
 src/spawn_cli/ide/windsurf.py
 src/spawn_cli/io/__init__.py