evo-cli 0.9.1__tar.gz → 0.10.1__tar.gz

{evo_cli-0.9.1 → evo_cli-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.9.1
+Version: 0.10.1
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.10.1/evo_cli/VERSION

@@ -0,0 +1 @@
+0.10.1

{evo_cli-0.9.1 → evo_cli-0.10.1}/evo_cli/commands/mcp.py

@@ -1,5 +1,6 @@
 """Set up MCP servers for Claude Code and OpenCode in one shot."""
 
+import shlex
 import shutil
 import subprocess
 from pathlib import Path
@@ -15,46 +16,18 @@ from evo_cli.commands.opencode import (
     save_jsonc,
 )
 from evo_cli.console import console, error, info, run_command, step, success, warning
+from evo_cli.mcp_registry import MCP_REGISTRY, is_remote, to_opencode_config
 
 EPILOG = Text.from_markup(
     "[bold]Examples[/bold]\n\n"
     "  [cyan]evo mcp list[/cyan]\n"
-    "  [cyan]evo mcp add notion[/cyan]\n"
+    "  [cyan]evo mcp add playwright[/cyan]\n"
     "  [cyan]evo mcp add notion --claude-only[/cyan]\n"
     "  [cyan]evo mcp add notion --opencode-only --project .[/cyan]\n"
-    "  [cyan]evo mcp add my-server --url https://example.com/mcp --transport http[/cyan]"
+    "  [cyan]evo mcp add my-remote --url https://example.com/mcp --transport http[/cyan]\n"
+    '  [cyan]evo mcp add my-local --command "npx -y some-mcp" --env API_KEY=xxx[/cyan]'
 )
 
-MCP_REGISTRY = {
-    "notion": {
-        "transport": "http",
-        "url": "https://mcp.notion.com/mcp",
-        "description": "Notion workspace - pages, databases, search. OAuth on first use.",
-    },
-    "context7": {
-        "transport": "http",
-        "url": "https://mcp.context7.com/mcp",
-        "description": "Context7 - up-to-date library docs and code examples.",
-    },
-    "deepwiki": {
-        "transport": "sse",
-        "url": "https://mcp.deepwiki.com/sse",
-        "description": "DeepWiki - ask questions about any public GitHub repo.",
-    },
-}
-
-
-def to_opencode_config(spec):
-    if spec["transport"] in ("http", "sse"):
-        config = {"type": "remote", "url": spec["url"], "enabled": True}
-        if spec.get("headers"):
-            config["headers"] = dict(spec["headers"])
-        return config
-    config = {"type": "local", "command": list(spec["command"]), "enabled": True}
-    if spec.get("env"):
-        config["environment"] = dict(spec["env"])
-    return config
-
 
 def claude_has_server(name):
     result = subprocess.run(
@@ -77,7 +50,7 @@ def add_to_claude(name, spec, scope):
         return True
 
     cmd = ["claude", "mcp", "add", "--scope", scope]
-    if spec["transport"] in ("http", "sse"):
+    if is_remote(spec):
         cmd += ["--transport", spec["transport"], name, spec["url"]]
     else:
         for key, value in (spec.get("env") or {}).items():
@@ -128,15 +101,26 @@ def add_to_opencode(name, spec, project):
     return True
 
 
-def resolve_spec(name, url, transport):
+def resolve_spec(name, url, transport, command=None, env=None):
+    if url and command:
+        raise click.BadParameter("Use either --url (remote) or --command (local), not both.")
     if url:
         if transport not in ("http", "sse"):
             raise click.BadParameter("--transport must be http or sse when using --url")
-        return {"transport": transport, "url": url, "description": "custom"}
+        return {"transport": transport, "url": url, "description": "custom remote server"}
+    if command:
+        argv = shlex.split(command) if isinstance(command, str) else list(command)
+        if not argv:
+            raise click.BadParameter("--command must contain a command to run.")
+        spec = {"transport": "stdio", "command": argv, "description": "custom local server"}
+        if env:
+            spec["env"] = dict(env)
+        return spec
     if name in MCP_REGISTRY:
         return MCP_REGISTRY[name]
     raise click.BadParameter(
-        f"Unknown MCP server '{name}'. Run `evo mcp list` to see known servers, or pass --url to add a custom one."
+        f"Unknown MCP server '{name}'. Run `evo mcp list` to see the catalog, "
+        "or pass --url (remote) / --command (local) to add a custom one."
     )
 
 
@@ -147,25 +131,38 @@ def mcp_group():
 
 @mcp_group.command("list")
 def list_servers():
-    """List the MCP servers bundled in the registry."""
-    table = Table(title="Known MCP servers", title_style="step", expand=False)
+    """List the MCP servers in the curated library."""
+    table = Table(title="MCP server library", title_style="step", expand=False)
     table.add_column("Name", style="accent")
-    table.add_column("Transport", style="info")
-    table.add_column("Endpoint", style="dim")
+    table.add_column("Category", style="info")
+    table.add_column("Type", style="info")
+    table.add_column("Endpoint / command", style="dim", overflow="fold")
     table.add_column("Description")
     for name, spec in MCP_REGISTRY.items():
         endpoint = spec.get("url") or " ".join(spec.get("command", []))
-        table.add_row(name, spec["transport"], endpoint, spec["description"])
+        kind = "remote" if is_remote(spec) else "local"
+        table.add_row(name, spec.get("category", "-"), kind, endpoint, spec["description"])
     console.print(table)
     console.print(
-        "\nAdd one with [accent]evo mcp add <name>[/accent], "
-        "or a custom server with [accent]evo mcp add <name> --url <url>[/accent]."
+        "\nAdd one with [accent]evo mcp add <name>[/accent], a custom remote with "
+        '[accent]--url <url>[/accent], or a custom local with [accent]--command "<cmd>"[/accent].'
     )
 
 
 @mcp_group.command("add", epilog=EPILOG)
 @click.argument("name")
-@click.option("--url", help="Custom remote MCP endpoint (for servers not in the registry).")
+@click.option("--url", help="Custom remote MCP endpoint (for servers not in the library).")
+@click.option(
+    "--command",
+    help='Custom local (stdio) MCP server command, e.g. "npx -y some-mcp".',
+)
+@click.option(
+    "--env",
+    "env",
+    multiple=True,
+    metavar="KEY=VALUE",
+    help="Environment variable for a custom --command server (repeatable).",
+)
 @click.option(
     "--transport",
     type=click.Choice(["http", "sse"]),
@@ -187,12 +184,13 @@ def list_servers():
     type=click.Path(file_okay=False, dir_okay=True),
     help="Also write into a project-level opencode.json at this directory.",
 )
-def add_server(name, url, transport, scope, claude_only, opencode_only, project):
+def add_server(name, url, command, env, transport, scope, claude_only, opencode_only, project):
     """Add an MCP server to Claude Code and OpenCode.
 
-    NAME is a key from the registry (`evo mcp list`) or any label when paired
-    with --url for a custom remote server. By default the server is registered
-    in both tools; use --claude-only or --opencode-only to limit the scope.
+    NAME is a key from the library (`evo mcp list`), or any label when paired
+    with --url (custom remote server) or --command (custom local server). By
+    default the server is registered in both tools; use --claude-only or
+    --opencode-only to limit the scope.
 
     Remote servers that use OAuth (like notion) prompt for sign-in on first use:
     run /mcp inside Claude Code, and OpenCode triggers the flow on next launch.
@@ -201,8 +199,16 @@ def add_server(name, url, transport, scope, claude_only, opencode_only, project)
         error("--claude-only and --opencode-only are mutually exclusive")
         return
 
+    env_map = {}
+    for item in env:
+        if "=" not in item:
+            error(f"Invalid --env '{item}'; expected KEY=VALUE")
+            return
+        key, value = item.split("=", 1)
+        env_map[key] = value
+
     try:
-        spec = resolve_spec(name, url, transport)
+        spec = resolve_spec(name, url, transport, command, env_map or None)
     except click.BadParameter as exc:
         error(str(exc))
         return

{evo_cli-0.9.1 → evo_cli-0.10.1}/evo_cli/commands/opencode.py

@@ -10,7 +10,8 @@ import rich_click as click
 from rich.panel import Panel
 from rich.text import Text
 
-from evo_cli.console import console, error, info, run_command, step, success, warning
+from evo_cli.console import console, error, info, resolve_executable, run_command, step, success, warning
+from evo_cli.mcp_registry import opencode_servers
 
 EPILOG = Text.from_markup(
     "[bold]Examples[/bold]\n\n"
@@ -19,18 +20,14 @@ EPILOG = Text.from_markup(
     "  [cyan]evo setup opencode --project .[/cyan]"
 )
 
-DEFAULT_MCP_SERVERS = {
-    "google-search": {
-        "type": "local",
-        "command": ["npx", "-y", "@mcp-server/google-search-mcp@latest"],
-        "enabled": True,
-    },
-    "playwright": {
-        "type": "local",
-        "command": ["npx", "-y", "@playwright/mcp@latest"],
-        "enabled": True,
-    },
-}
+# Servers bootstrapped by `evo setup opencode`, pulled from the shared library
+# (evo_cli/mcp_registry.py). Add more servers anytime with `evo mcp add <name>`.
+DEFAULT_MCP_SERVERS = opencode_servers("google-search", "playwright")
+
+
+def _local_mcp_commands():
+    """Commands for the local (stdio) servers in DEFAULT_MCP_SERVERS."""
+    return [(name, list(cfg["command"])) for name, cfg in DEFAULT_MCP_SERVERS.items() if cfg.get("type") == "local"]
 
 
 def is_windows():
@@ -55,7 +52,7 @@ def ensure_node_installed():
     npx_cmd = shutil.which("npx")
 
     if node_cmd and npm_cmd and npx_cmd:
-        result = subprocess.run(["node", "--version"], capture_output=True, text=True, check=True)
+        result = subprocess.run(resolve_executable(["node", "--version"]), capture_output=True, text=True, check=True)
         info(f"Node.js found: {result.stdout.strip()}")
         return node_cmd, npm_cmd, npx_cmd
 
@@ -122,15 +119,11 @@ def install_mcp_servers():
     the whole setup; the verify step confirms the servers actually work.
     """
     step("Installing MCP servers")
-    servers = [
-        "@mcp-server/google-search-mcp@latest",
-        "@playwright/mcp@latest",
-    ]
-    for server in servers:
-        info(f"Fetching {server}")
+    for name, command in _local_mcp_commands():
+        info(f"Fetching {name}")
         run_command(
-            ["npx", "-y", server, "--version"],
-            status=f"Fetching {server}",
+            [*command, "--version"],
+            status=f"Fetching {name}",
             stdin=subprocess.DEVNULL,
             timeout=180,
             check=False,
@@ -154,6 +147,47 @@ def install_playwright_browsers():
         info("You can retry later with: npx playwright install chromium")
 
 
+def opencode_version():
+    """Return the installed OpenCode version string, or None if not on PATH."""
+    if not shutil.which("opencode"):
+        return None
+    try:
+        result = subprocess.run(
+            resolve_executable(["opencode", "--version"]), capture_output=True, text=True, timeout=30
+        )
+        return result.stdout.strip() or "unknown"
+    except Exception:
+        return "unknown"
+
+
+def install_opencode(npm_cmd="npm"):
+    """Install the OpenCode CLI globally via npm if it is not already present."""
+    step("Installing OpenCode")
+    version = opencode_version()
+    if version is not None:
+        info(f"OpenCode already installed ({version}); skipping")
+        return True
+
+    try:
+        run_command(
+            [npm_cmd, "install", "-g", "opencode-ai@latest"],
+            status="Installing OpenCode via npm",
+            timeout=300,
+        )
+    except Exception as exc:
+        warning(f"Could not install OpenCode automatically: {exc}")
+        info("Install manually: npm i -g opencode-ai@latest (or curl -fsSL https://opencode.ai/install | bash)")
+        return False
+
+    version = opencode_version()
+    if version is None:
+        warning("OpenCode installed but `opencode` is not on PATH yet")
+        info("Open a new shell, or add your npm global bin directory to PATH")
+        return False
+    success(f"OpenCode installed ({version})")
+    return True
+
+
 def load_jsonc(path):
     """Load a JSONC file, stripping // comments.
 
@@ -258,14 +292,10 @@ def verify_mcp_servers():
         '"params":{"protocolVersion":"2024-11-05","capabilities":{},'
         '"clientInfo":{"name":"evo-cli","version":"1.0"}}}'
     )
-    checks = [
-        ("playwright", ["npx", "-y", "@playwright/mcp@latest"]),
-        ("google-search", ["npx", "-y", "@mcp-server/google-search-mcp@latest"]),
-    ]
-    for name, cmd in checks:
+    for name, cmd in _local_mcp_commands():
         try:
             result = subprocess.run(
-                cmd,
+                resolve_executable(cmd),
                 input=init_message,
                 capture_output=True,
                 text=True,
@@ -279,15 +309,17 @@ def verify_mcp_servers():
             warning(f"Could not verify MCP server [accent]{name}[/accent]: {exc}")
 
 
-def run_setup_opencode(global_only, project):
+def run_setup_opencode(global_only, project, skip_install=False):
     step("evo setup opencode")
 
     try:
-        ensure_node_installed()
+        _, npm_cmd, _ = ensure_node_installed()
     except Exception as exc:
         error(str(exc))
         return
 
+    if not skip_install:
+        install_opencode(npm_cmd)
     install_mcp_servers()
     install_playwright_browsers()
 
@@ -304,10 +336,15 @@ def run_setup_opencode(global_only, project):
     if project_path:
         paths_text += f"\nProject: [accent]{project_path}[/accent]"
 
+    opencode_note = (
+        "Run `opencode` to start."
+        if opencode_version() is not None
+        else "Install OpenCode with: npm i -g opencode-ai@latest"
+    )
     console.print(
         Panel(
             f"OpenCode configured with google-search and playwright MCP servers.\n\n{paths_text}\n\n"
-            "Restart OpenCode to load the new MCP tools.",
+            f"{opencode_note} Restart OpenCode to load the new MCP tools.",
             title="setup opencode complete",
             border_style="success",
             expand=False,
@@ -321,19 +358,25 @@ def run_setup_opencode(global_only, project):
     is_flag=True,
     help="Only update the global OpenCode config; skip project-level config.",
 )
+@click.option(
+    "--skip-install",
+    is_flag=True,
+    help="Skip installing the OpenCode CLI; only set up MCP servers and config.",
+)
 @click.option(
     "--project",
     type=click.Path(file_okay=False, dir_okay=True, writable=True),
     help="Project directory to write opencode.json into. Defaults to the current directory.",
 )
-def setup_opencode(global_only, project):
-    """Install Node.js (if needed), OpenCode MCP servers, and write config files.
+def setup_opencode(global_only, skip_install, project):
+    """Install OpenCode and Node.js (if needed), its MCP servers, and write config files.
 
     This command bootstraps a fresh machine with the same OpenCode + MCP setup
-    used across devices. It installs the google-search and playwright MCP servers,
-    downloads the Playwright Chromium browser, and writes both global
+    used across devices. It installs the OpenCode CLI (via npm, unless
+    --skip-install) and the google-search and playwright MCP servers, downloads
+    the Playwright Chromium browser, and writes both global
     (~/.config/opencode/opencode.jsonc) and project-level (opencode.json) configs.
 
     No credentials are bundled; only public MCP server references are added.
     """
-    run_setup_opencode(global_only, project)
+    run_setup_opencode(global_only, project, skip_install=skip_install)

{evo_cli-0.9.1 → evo_cli-0.10.1}/evo_cli/console.py

@@ -1,3 +1,4 @@
+import shutil
 import subprocess
 import urllib.request
 
@@ -52,9 +53,19 @@ def step(title):
     console.rule(f"[step]{title}[/step]", style="step", align="left")
 
 
+def resolve_executable(cmd):
+    cmd = [str(part) for part in cmd]
+    if cmd:
+        resolved = shutil.which(cmd[0])
+        if resolved:
+            cmd[0] = resolved
+    return cmd
+
+
 def run_command(cmd, capture=False, check=True, input_text=None, status=None, timeout=None, stdin=None):
     cmd = [str(part) for part in cmd]
     console.print(f"[cmd]$ {' '.join(cmd)}[/cmd]")
+    exec_cmd = resolve_executable(cmd)
 
     run_kwargs = {"text": True, "input": input_text, "timeout": timeout}
     # subprocess.run rejects passing both `input` and `stdin`. Only attach an
@@ -66,12 +77,12 @@ def run_command(cmd, capture=False, check=True, input_text=None, status=None, ti
     try:
         if status:
             with console.status(f"[info]{status}[/info]", spinner="dots"):
-                result = subprocess.run(cmd, capture_output=True, **run_kwargs)
+                result = subprocess.run(exec_cmd, capture_output=True, **run_kwargs)
             output = (result.stdout or "").strip()
             if output:
                 console.print(output)
         else:
-            result = subprocess.run(cmd, capture_output=capture, **run_kwargs)
+            result = subprocess.run(exec_cmd, capture_output=capture, **run_kwargs)
     except subprocess.TimeoutExpired as exc:
         console.print(f"[error]command timed out after {timeout}s: {' '.join(cmd)}[/error]")
         if check:

evo_cli-0.10.1/evo_cli/mcp_registry.py

@@ -0,0 +1,101 @@
+"""Curated library of common MCP servers, shared across evo commands.
+
+This is the single source of truth for the MCP servers evo knows about. Both
+``evo mcp add`` / ``evo mcp list`` (commands/mcp.py) and ``evo setup opencode``
+(commands/opencode.py) read from this catalog, so a server is defined once and
+wired everywhere.
+
+Each entry is a transport-neutral spec:
+
+  - remote: {"transport": "http" | "sse", "url": ...}
+  - local:  {"transport": "stdio", "command": [...], "env": {...}}
+
+plus metadata used by ``evo mcp list``: "category", "homepage", "description".
+"""
+
+MCP_REGISTRY = {
+    # --- Local servers (run on demand via npx; nothing to host) ---
+    "playwright": {
+        "transport": "stdio",
+        "command": ["npx", "-y", "@playwright/mcp@latest"],
+        "category": "browser",
+        "homepage": "https://github.com/microsoft/playwright-mcp",
+        "description": "Playwright (Microsoft) - drive a real browser: navigate, click, snapshot.",
+    },
+    "google-search": {
+        "transport": "stdio",
+        "command": ["npx", "-y", "@mcp-server/google-search-mcp@latest"],
+        "category": "search",
+        "homepage": "https://www.npmjs.com/package/@mcp-server/google-search-mcp",
+        "description": "Google Search - run web searches and fetch result pages.",
+    },
+    "sequential-thinking": {
+        "transport": "stdio",
+        "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],
+        "category": "reasoning",
+        "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
+        "description": "Sequential Thinking - structured step-by-step reasoning scratchpad.",
+    },
+    "memory": {
+        "transport": "stdio",
+        "command": ["npx", "-y", "@modelcontextprotocol/server-memory"],
+        "category": "memory",
+        "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
+        "description": "Memory - persistent knowledge-graph memory across sessions.",
+    },
+    # --- Remote servers (hosted; OAuth/token on first use where noted) ---
+    "context7": {
+        "transport": "http",
+        "url": "https://mcp.context7.com/mcp",
+        "category": "docs",
+        "homepage": "https://github.com/upstash/context7",
+        "description": "Context7 - up-to-date library docs and code examples.",
+    },
+    "deepwiki": {
+        "transport": "sse",
+        "url": "https://mcp.deepwiki.com/sse",
+        "category": "docs",
+        "homepage": "https://deepwiki.com",
+        "description": "DeepWiki - ask questions about any public GitHub repo.",
+    },
+    "github": {
+        "transport": "http",
+        "url": "https://api.githubcopilot.com/mcp/",
+        "category": "dev",
+        "homepage": "https://github.com/github/github-mcp-server",
+        "description": "GitHub - repos, issues, PRs, code search. OAuth/PAT on first use.",
+    },
+    "notion": {
+        "transport": "http",
+        "url": "https://mcp.notion.com/mcp",
+        "category": "productivity",
+        "homepage": "https://github.com/makenotion/notion-mcp-server",
+        "description": "Notion workspace - pages, databases, search. OAuth on first use.",
+    },
+}
+
+
+def is_remote(spec):
+    """Whether a spec describes a hosted (remote) MCP server."""
+    return spec["transport"] in ("http", "sse")
+
+
+def to_opencode_config(spec):
+    """Translate a registry spec into an OpenCode ``mcp`` entry."""
+    if is_remote(spec):
+        config = {"type": "remote", "url": spec["url"], "enabled": True}
+        if spec.get("headers"):
+            config["headers"] = dict(spec["headers"])
+        return config
+    config = {"type": "local", "command": list(spec["command"]), "enabled": True}
+    if spec.get("env"):
+        config["environment"] = dict(spec["env"])
+    return config
+
+
+def opencode_servers(*names):
+    """Build an OpenCode ``mcp`` mapping for the named registry servers.
+
+    Order follows the arguments so callers control how servers appear in config.
+    """
+    return {name: to_opencode_config(MCP_REGISTRY[name]) for name in names}

{evo_cli-0.9.1 → evo_cli-0.10.1}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.9.1
+Version: 0.10.1
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.9.1 → evo_cli-0.10.1}/evo_cli.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ evo_cli/__main__.py
 evo_cli/base.py
 evo_cli/cli.py
 evo_cli/console.py
+evo_cli/mcp_registry.py
 evo_cli.egg-info/PKG-INFO
 evo_cli.egg-info/SOURCES.txt
 evo_cli.egg-info/dependency_links.txt

{evo_cli-0.9.1 → evo_cli-0.10.1}/tests/test_mcp.py

@@ -46,12 +46,41 @@ def test_resolve_spec_from_registry():
     assert spec["url"] == "https://mcp.notion.com/mcp"
 
 
+def test_resolve_spec_playwright_is_local():
+    spec = resolve_spec("playwright", None, "http")
+    assert spec["transport"] == "stdio"
+    assert spec["command"] == ["npx", "-y", "@playwright/mcp@latest"]
+    assert to_opencode_config(spec) == {
+        "type": "local",
+        "command": ["npx", "-y", "@playwright/mcp@latest"],
+        "enabled": True,
+    }
+
+
+def test_mcp_list_shows_playwright(runner):
+    result = runner.invoke(cli, ["mcp", "list"])
+    assert result.exit_code == 0
+    assert "playwright" in result.output
+
+
 def test_resolve_spec_custom_url():
     spec = resolve_spec("anything", "https://x.dev/mcp", "http")
     assert spec["transport"] == "http"
     assert spec["url"] == "https://x.dev/mcp"
 
 
+def test_resolve_spec_custom_command():
+    spec = resolve_spec("my-local", None, "http", command="npx -y some-mcp", env={"K": "V"})
+    assert spec["transport"] == "stdio"
+    assert spec["command"] == ["npx", "-y", "some-mcp"]
+    assert spec["env"] == {"K": "V"}
+
+
+def test_resolve_spec_url_and_command_conflict():
+    with pytest.raises(Exception):
+        resolve_spec("x", "https://x.dev/mcp", "http", command="npx -y some-mcp")
+
+
 def test_resolve_spec_unknown_raises():
     with pytest.raises(Exception):
         resolve_spec("nope", None, "http")
@@ -75,6 +104,19 @@ def test_add_opencode_only_writes_configs(runner, tmp_path, monkeypatch):
     assert load_jsonc(project / "opencode.json")["mcp"]["notion"]["type"] == "remote"
 
 
+def test_add_playwright_opencode_only_writes_local(runner, tmp_path, monkeypatch):
+    global_path = tmp_path / "global.jsonc"
+    monkeypatch.setattr(
+        "evo_cli.commands.mcp.get_global_config_path",
+        lambda: global_path,
+    )
+    result = runner.invoke(cli, ["mcp", "add", "playwright", "--opencode-only"])
+    assert result.exit_code == 0
+    entry = load_jsonc(global_path)["mcp"]["playwright"]
+    assert entry["type"] == "local"
+    assert entry["command"] == ["npx", "-y", "@playwright/mcp@latest"]
+
+
 def test_add_rejects_both_only_flags(runner, tmp_path, monkeypatch):
     monkeypatch.setattr(
         "evo_cli.commands.mcp.get_global_config_path",

{evo_cli-0.9.1 → evo_cli-0.10.1}/tests/test_opencode.py

@@ -10,6 +10,7 @@ from evo_cli.commands.opencode import (
     configure_opencode_global,
     configure_opencode_project,
     install_mcp_servers,
+    install_opencode,
     load_jsonc,
     merge_mcp_config,
     save_jsonc,
@@ -34,7 +35,7 @@ def test_opencode_help_runs(runner):
 
 def test_load_jsonc_ignores_comments(tmp_path):
     path = tmp_path / "config.jsonc"
-    path.write_text("// header\n{\"a\": 1}\n// footer")
+    path.write_text('// header\n{"a": 1}\n// footer')
     assert load_jsonc(path) == {"a": 1}
 
 
@@ -93,7 +94,37 @@ def test_install_mcp_servers_detaches_stdin_and_sets_timeout(monkeypatch):
         assert kwargs.get("check") is False
 
 
-def test_setup_opencode_writes_global_and_project(runner, tmp_path, monkeypatch):
+def test_install_opencode_skips_when_present(monkeypatch):
+    monkeypatch.setattr("evo_cli.commands.opencode.shutil.which", lambda _: "/usr/bin/opencode")
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.subprocess.run",
+        lambda *a, **k: type("R", (), {"stdout": "1.2.3\n"})(),
+    )
+
+    def fail_run_command(*a, **k):
+        raise AssertionError("run_command should not be called when opencode is present")
+
+    monkeypatch.setattr("evo_cli.commands.opencode.run_command", fail_run_command)
+    assert install_opencode("npm") is True
+
+
+def test_install_opencode_runs_npm_when_missing(monkeypatch):
+    states = iter([None, "/usr/bin/opencode"])  # missing before install, present after
+    monkeypatch.setattr("evo_cli.commands.opencode.shutil.which", lambda _: next(states))
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.subprocess.run",
+        lambda *a, **k: type("R", (), {"stdout": "1.2.3\n"})(),
+    )
+    calls = []
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.run_command",
+        lambda cmd, **k: calls.append(cmd),
+    )
+    assert install_opencode("npm") is True
+    assert calls == [["npm", "install", "-g", "opencode-ai@latest"]]
+
+
+def test_setup_opencode_skip_install(runner, tmp_path, monkeypatch):
     monkeypatch.setattr(
         "evo_cli.commands.opencode.get_global_config_path",
         lambda: tmp_path / "global.jsonc",
@@ -102,10 +133,31 @@ def test_setup_opencode_writes_global_and_project(runner, tmp_path, monkeypatch)
         "evo_cli.commands.opencode.ensure_node_installed",
         lambda: ("node", "npm", "npx"),
     )
+
+    def fail_install_opencode(*a, **k):
+        raise AssertionError("install_opencode must not run with --skip-install")
+
+    monkeypatch.setattr("evo_cli.commands.opencode.install_opencode", fail_install_opencode)
     monkeypatch.setattr("evo_cli.commands.opencode.install_mcp_servers", lambda: None)
+    monkeypatch.setattr("evo_cli.commands.opencode.install_playwright_browsers", lambda: None)
+    monkeypatch.setattr("evo_cli.commands.opencode.verify_mcp_servers", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "opencode", "--global-only", "--skip-install"])
+    assert result.exit_code == 0
+
+
+def test_setup_opencode_writes_global_and_project(runner, tmp_path, monkeypatch):
     monkeypatch.setattr(
-        "evo_cli.commands.opencode.install_playwright_browsers", lambda: None
+        "evo_cli.commands.opencode.get_global_config_path",
+        lambda: tmp_path / "global.jsonc",
     )
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.ensure_node_installed",
+        lambda: ("node", "npm", "npx"),
+    )
+    monkeypatch.setattr("evo_cli.commands.opencode.install_opencode", lambda *a, **k: True)
+    monkeypatch.setattr("evo_cli.commands.opencode.install_mcp_servers", lambda: None)
+    monkeypatch.setattr("evo_cli.commands.opencode.install_playwright_browsers", lambda: None)
     monkeypatch.setattr("evo_cli.commands.opencode.verify_mcp_servers", lambda: None)
 
     result = runner.invoke(cli, ["setup", "opencode", "--project", str(tmp_path)])
@@ -124,10 +176,9 @@ def test_setup_opencode_global_only(runner, tmp_path, monkeypatch):
         "evo_cli.commands.opencode.ensure_node_installed",
         lambda: ("node", "npm", "npx"),
     )
+    monkeypatch.setattr("evo_cli.commands.opencode.install_opencode", lambda *a, **k: True)
     monkeypatch.setattr("evo_cli.commands.opencode.install_mcp_servers", lambda: None)
-    monkeypatch.setattr(
-        "evo_cli.commands.opencode.install_playwright_browsers", lambda: None
-    )
+    monkeypatch.setattr("evo_cli.commands.opencode.install_playwright_browsers", lambda: None)
     monkeypatch.setattr("evo_cli.commands.opencode.verify_mcp_servers", lambda: None)
 
     project = tmp_path / "project"

evo_cli-0.9.1/evo_cli/VERSION

@@ -1 +0,0 @@
-0.9.1