evo-cli 0.7.0__tar.gz → 0.8.0__tar.gz

{evo_cli-0.7.0 → evo_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.7.0
+Version: 0.8.0
 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.8.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.8.0

{evo_cli-0.7.0 → evo_cli-0.8.0}/evo_cli/cli.py

@@ -7,12 +7,18 @@ from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.localproxy import localproxy
 from evo_cli.commands.miniconda import miniconda
 from evo_cli.commands.netcheck import netcheck
+from evo_cli.commands.opencode import setup_opencode
 from evo_cli.commands.plantuml import plantuml
 from evo_cli.commands.site2s import site2s
 from evo_cli.commands.ssh import setupssh
 from evo_cli.commands.sysmon import sysmon
 from evo_cli.commands.wifi import wifi
 
+
+@click.group("setup", help="Set up development tools and environments.")
+def setup_group():
+    """Commands for bootstrapping tools on a fresh machine."""
+
 click.rich_click.USE_MARKDOWN = True
 click.rich_click.SHOW_ARGUMENTS = True
 click.rich_click.STYLE_OPTIONS_TABLE_BOX = "SIMPLE"
@@ -34,8 +40,11 @@ def cli():
     """
 
 
-cli.add_command(setupssh)
-cli.add_command(miniconda)
+setup_group.add_command(setup_opencode)
+setup_group.add_command(miniconda)
+setup_group.add_command(setupssh)
+
+cli.add_command(setup_group)
 cli.add_command(cfssh)
 cli.add_command(f_claude)
 cli.add_command(gdrive)

evo_cli-0.8.0/evo_cli/commands/opencode.py

@@ -0,0 +1,323 @@
+"""Install and configure OpenCode with common MCP servers."""
+
+import json
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+
+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
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo setup opencode[/cyan]\n"
+    "  [cyan]evo setup opencode --global-only[/cyan]\n"
+    "  [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", "--headless"],
+        "enabled": True,
+    },
+}
+
+
+def is_windows():
+    return platform.system() == "Windows"
+
+
+def get_global_config_dir():
+    home = Path.home()
+    if is_windows():
+        return home / "AppData" / "Roaming" / "opencode"
+    return home / ".config" / "opencode"
+
+
+def get_global_config_path():
+    return get_global_config_dir() / "opencode.jsonc"
+
+
+def ensure_node_installed():
+    """Ensure Node.js and npm are available; return their paths."""
+    node_cmd = shutil.which("node")
+    npm_cmd = shutil.which("npm")
+    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)
+        info(f"Node.js found: {result.stdout.strip()}")
+        return node_cmd, npm_cmd, npx_cmd
+
+    info("Node.js/npm not found. Installing via package manager...")
+    system = platform.system()
+    if system == "Linux":
+        try:
+            if shutil.which("apt-get"):
+                run_command(
+                    ["sudo", "apt-get", "update"],
+                    status="Updating apt package lists",
+                )
+                run_command(
+                    ["sudo", "apt-get", "install", "-y", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("dnf"):
+                run_command(
+                    ["sudo", "dnf", "install", "-y", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("pacman"):
+                run_command(
+                    ["sudo", "pacman", "-Sy", "--noconfirm", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("apk"):
+                run_command(
+                    ["sudo", "apk", "add", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            else:
+                raise RuntimeError("No supported package manager found (apt-get, dnf, pacman, apk)")
+        except Exception as exc:
+            error(f"Could not install Node.js automatically: {exc}")
+            info("Please install Node.js 18+ manually from https://nodejs.org/")
+            raise
+    elif system == "Darwin":
+        if shutil.which("brew"):
+            run_command(["brew", "install", "node"], status="Installing Node.js via Homebrew")
+        else:
+            raise RuntimeError("Homebrew not found. Please install Node.js 18+ manually.")
+    elif system == "Windows":
+        raise RuntimeError("Please install Node.js 18+ manually from https://nodejs.org/")
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+    node_cmd = shutil.which("node")
+    npm_cmd = shutil.which("npm")
+    npx_cmd = shutil.which("npx")
+    if not (node_cmd and npm_cmd and npx_cmd):
+        raise RuntimeError("Node.js installation succeeded but binaries are not on PATH")
+    return node_cmd, npm_cmd, npx_cmd
+
+
+def install_mcp_servers():
+    """Install MCP server npm packages globally via npx."""
+    step("Installing MCP servers")
+    servers = [
+        "@mcp-server/google-search-mcp@latest",
+        "@playwright/mcp@latest",
+    ]
+    for server in servers:
+        info(f"Installing {server}")
+        run_command(["npx", "-y", server, "--version"], status=f"Fetching {server}")
+    success("MCP server packages ready")
+
+
+def install_playwright_browsers():
+    """Install Playwright Chromium browser binaries."""
+    step("Installing Playwright browsers")
+    try:
+        run_command(
+            ["npx", "playwright", "install", "chromium"],
+            status="Downloading Chromium for Playwright",
+        )
+        success("Playwright Chromium installed")
+    except Exception as exc:
+        warning(f"Playwright browser install failed: {exc}")
+        info("You can retry later with: npx playwright install chromium")
+
+
+def load_jsonc(path):
+    """Load a JSONC file, stripping // comments.
+
+    Be careful not to truncate URLs that contain '://' inside a JSON string.
+    """
+    path = Path(path)
+    if not path.exists():
+        return {}
+    text = path.read_text(encoding="utf-8")
+    cleaned_lines = []
+    for line in text.splitlines():
+        new_line = []
+        in_string = False
+        escape = False
+        for idx, ch in enumerate(line):
+            if escape:
+                new_line.append(ch)
+                escape = False
+                continue
+            if ch == "\\":
+                new_line.append(ch)
+                escape = True
+                continue
+            if ch == '"':
+                in_string = not in_string
+                new_line.append(ch)
+                continue
+            if not in_string and ch == "/" and idx + 1 < len(line) and line[idx + 1] == "/":
+                break
+            new_line.append(ch)
+        stripped = "".join(new_line).strip()
+        if stripped.startswith("//"):
+            continue
+        cleaned_lines.append("".join(new_line))
+    cleaned = "\n".join(cleaned_lines)
+    if not cleaned.strip():
+        return {}
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Invalid JSON in {path}: {exc}") from exc
+
+
+def save_jsonc(path, data, header=None):
+    """Save data as pretty-printed JSONC."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = json.dumps(data, indent=2, ensure_ascii=False)
+    if header:
+        content = header + "\n" + content
+    path.write_text(content + "\n", encoding="utf-8")
+
+
+def merge_mcp_config(existing, new_servers):
+    """Merge new MCP servers into existing config, preserving user values."""
+    result = dict(existing)
+    mcp = result.setdefault("mcp", {})
+    for name, config in new_servers.items():
+        if name in mcp:
+            info(f"MCP server [accent]{name}[/accent] already configured; skipping")
+            continue
+        mcp[name] = dict(config)
+        success(f"Added MCP server [accent]{name}[/accent]")
+    return result
+
+
+def configure_opencode_global():
+    """Write/update the global OpenCode config with MCP servers."""
+    step("Configuring global OpenCode")
+    config_path = get_global_config_path()
+    config_dir = config_path.parent
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    existing = load_jsonc(config_path) if config_path.exists() else {}
+    merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
+
+    header = "// OpenCode global configuration generated by evo setup opencode"
+    save_jsonc(config_path, merged, header=header)
+    success(f"Global config written to [accent]{config_path}[/accent]")
+    return config_path
+
+
+def configure_opencode_project(project_path):
+    """Write/update a project-level OpenCode config with MCP servers."""
+    step("Configuring project OpenCode")
+    project_dir = Path(project_path).resolve()
+    config_path = project_dir / "opencode.json"
+
+    existing = load_jsonc(config_path) if config_path.exists() else {}
+    merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
+
+    header = "// OpenCode project configuration generated by evo setup opencode"
+    save_jsonc(config_path, merged, header=header)
+    success(f"Project config written to [accent]{config_path}[/accent]")
+    return config_path
+
+
+def verify_mcp_servers():
+    """Run a basic JSON-RPC initialize check against installed MCP servers."""
+    step("Verifying MCP servers")
+    init_message = (
+        '{"jsonrpc":"2.0","id":1,"method":"initialize",'
+        '"params":{"protocolVersion":"2024-11-05","capabilities":{},'
+        '"clientInfo":{"name":"evo-cli","version":"1.0"}}}'
+    )
+    checks = [
+        ("playwright", ["npx", "-y", "@playwright/mcp@latest", "--headless"]),
+        ("google-search", ["npx", "-y", "@mcp-server/google-search-mcp@latest"]),
+    ]
+    for name, cmd in checks:
+        try:
+            result = subprocess.run(
+                cmd,
+                input=init_message,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0 and '"jsonrpc":"2.0"' in result.stdout:
+                success(f"MCP server [accent]{name}[/accent] responded to initialize")
+            else:
+                warning(f"MCP server [accent]{name}[/accent] did not respond as expected")
+        except Exception as exc:
+            warning(f"Could not verify MCP server [accent]{name}[/accent]: {exc}")
+
+
+def run_setup_opencode(global_only, project):
+    step("evo setup opencode")
+
+    try:
+        ensure_node_installed()
+    except Exception as exc:
+        error(str(exc))
+        return
+
+    install_mcp_servers()
+    install_playwright_browsers()
+
+    global_path = configure_opencode_global()
+    project_path = None
+    if not global_only:
+        target = project or Path.cwd()
+        project_path = configure_opencode_project(target)
+
+    verify_mcp_servers()
+
+    console.print()
+    paths_text = f"Global: [accent]{global_path}[/accent]"
+    if project_path:
+        paths_text += f"\nProject: [accent]{project_path}[/accent]"
+
+    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.",
+            title="setup opencode complete",
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+@click.command("opencode", epilog=EPILOG)
+@click.option(
+    "--global-only",
+    is_flag=True,
+    help="Only update the global OpenCode config; skip project-level 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.
+
+    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
+    (~/.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)

{evo_cli-0.7.0 → evo_cli-0.8.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.7.0
+Version: 0.8.0
 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.7.0 → evo_cli-0.8.0}/evo_cli.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ evo_cli/commands/gdrive.py
 evo_cli/commands/localproxy.py
 evo_cli/commands/miniconda.py
 evo_cli/commands/netcheck.py
+evo_cli/commands/opencode.py
 evo_cli/commands/plantuml.py
 evo_cli/commands/site2s.py
 evo_cli/commands/ssh.py
@@ -31,6 +32,7 @@ evo_cli/commands/wifi.py
 tests/__init__.py
 tests/test_cli.py
 tests/test_fix_claude.py
+tests/test_opencode.py
 tests/test_plantuml.py
 tests/test_sysmon.py
 tests/test_wifi.py

{evo_cli-0.7.0 → evo_cli-0.8.0}/tests/test_cli.py

@@ -4,10 +4,16 @@ from evo_cli.cli import cli
 
 
 def test_all_commands_are_registered():
-    for name in ("setupssh", "miniconda", "cfssh", "f-claude"):
+    for name in ("setup", "cfssh", "f-claude"):
         assert name in cli.commands
 
 
+def test_setup_subgroup_commands_are_registered():
+    setup_group = cli.commands["setup"]
+    for name in ("opencode", "miniconda", "setupssh"):
+        assert name in setup_group.commands
+
+
 def test_group_help_runs():
     result = CliRunner().invoke(cli, ["--help"])
     assert result.exit_code == 0
@@ -16,3 +22,8 @@ def test_group_help_runs():
 def test_fix_claude_help_runs():
     result = CliRunner().invoke(cli, ["f-claude", "--help"])
     assert result.exit_code == 0
+
+
+def test_setup_opencode_help_runs():
+    result = CliRunner().invoke(cli, ["setup", "opencode", "--help"])
+    assert result.exit_code == 0

evo_cli-0.8.0/tests/test_opencode.py

@@ -0,0 +1,117 @@
+import json
+
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands.opencode import (
+    DEFAULT_MCP_SERVERS,
+    configure_opencode_global,
+    configure_opencode_project,
+    load_jsonc,
+    merge_mcp_config,
+    save_jsonc,
+)
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def test_opencode_command_is_registered():
+    assert "setup" in cli.commands
+    assert "opencode" in cli.commands["setup"].commands
+
+
+def test_opencode_help_runs(runner):
+    result = runner.invoke(cli, ["setup", "opencode", "--help"])
+    assert result.exit_code == 0
+    assert "Install Node.js" in result.output or "OpenCode" in result.output
+
+
+def test_load_jsonc_ignores_comments(tmp_path):
+    path = tmp_path / "config.jsonc"
+    path.write_text("// header\n{\"a\": 1}\n// footer")
+    assert load_jsonc(path) == {"a": 1}
+
+
+def test_load_jsonc_missing_file(tmp_path):
+    assert load_jsonc(tmp_path / "nope.jsonc") == {}
+
+
+def test_save_and_load_jsonc(tmp_path):
+    path = tmp_path / "config.jsonc"
+    save_jsonc(path, {"foo": "bar"}, header="// test")
+    data = load_jsonc(path)
+    assert data == {"foo": "bar"}
+    assert path.read_text().startswith("// test")
+
+
+def test_merge_mcp_config_preserves_existing():
+    existing = {"mcp": {"playwright": {"enabled": False}}}
+    merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
+    assert merged["mcp"]["playwright"]["enabled"] is False
+    assert merged["mcp"]["google-search"]["enabled"] is True
+
+
+def test_configure_opencode_global(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.get_global_config_path",
+        lambda: tmp_path / "opencode" / "opencode.jsonc",
+    )
+    path = configure_opencode_global()
+    data = load_jsonc(path)
+    assert "mcp" in data
+    assert set(data["mcp"].keys()) == {"google-search", "playwright"}
+
+
+def test_configure_opencode_project(tmp_path):
+    path = configure_opencode_project(tmp_path)
+    data = load_jsonc(path)
+    assert "mcp" in data
+    assert set(data["mcp"].keys()) == {"google-search", "playwright"}
+
+
+def test_setup_opencode_writes_global_and_project(runner, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "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_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)])
+    assert result.exit_code == 0
+    assert (tmp_path / "opencode.json").exists()
+    project_data = json.loads((tmp_path / "opencode.json").read_text().split("\n", 1)[1])
+    assert "mcp" in project_data
+
+
+def test_setup_opencode_global_only(runner, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "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_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)
+
+    project = tmp_path / "project"
+    project.mkdir()
+    result = runner.invoke(cli, ["setup", "opencode", "--global-only", "--project", str(project)])
+    assert result.exit_code == 0
+    assert not (project / "opencode.json").exists()

evo_cli-0.7.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.7.0