evo-cli 0.13.0__tar.gz → 0.14.0__tar.gz

{evo_cli-0.13.0 → evo_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.13.0
+Version: 0.14.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -214,8 +214,19 @@ evo cred add vbee.token --from-stdin       # JWT from the same app page
 evo cred add openai_api_key --from-stdin
 ```
 
-`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set. `--provider auto`
-(the default) picks Vbee when its credentials exist, otherwise OpenAI.
+`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set.
+
+`--provider auto` (the default) resolves to `EVO_TTS_PROVIDER` when that is set, and otherwise to
+whichever provider has credentials. Pick a machine default once:
+
+```bash
+export EVO_TTS_PROVIDER=openai        # what `auto` means here
+export EVO_TTS_VOICE_OPENAI=nova      # default voice for that provider only
+```
+
+Prefer the provider-scoped `EVO_TTS_VOICE_OPENAI` / `EVO_TTS_VOICE_VBEE` over a bare
+`EVO_TTS_VOICE`: a shared value breaks as soon as you pass `--provider vbee`, because an OpenAI
+voice name is not a Vbee voice code.
 
 Playback uses whichever of `ffplay`, `mpv`, `cvlc`, `afplay`, or `paplay`/`aplay` is on PATH, and
 falls back to PowerShell's `MediaPlayer` on Windows. Without any of them the audio is still written

{evo_cli-0.13.0 → evo_cli-0.14.0}/README.md

@@ -186,8 +186,19 @@ evo cred add vbee.token --from-stdin       # JWT from the same app page
 evo cred add openai_api_key --from-stdin
 ```
 
-`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set. `--provider auto`
-(the default) picks Vbee when its credentials exist, otherwise OpenAI.
+`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set.
+
+`--provider auto` (the default) resolves to `EVO_TTS_PROVIDER` when that is set, and otherwise to
+whichever provider has credentials. Pick a machine default once:
+
+```bash
+export EVO_TTS_PROVIDER=openai        # what `auto` means here
+export EVO_TTS_VOICE_OPENAI=nova      # default voice for that provider only
+```
+
+Prefer the provider-scoped `EVO_TTS_VOICE_OPENAI` / `EVO_TTS_VOICE_VBEE` over a bare
+`EVO_TTS_VOICE`: a shared value breaks as soon as you pass `--provider vbee`, because an OpenAI
+voice name is not a Vbee voice code.
 
 Playback uses whichever of `ffplay`, `mpv`, `cvlc`, `afplay`, or `paplay`/`aplay` is on PATH, and
 falls back to PowerShell's `MediaPlayer` on Windows. Without any of them the audio is still written

evo_cli-0.14.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.14.0

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli/commands/mcp.py

@@ -38,7 +38,7 @@ def claude_has_server(name):
     return result.returncode == 0
 
 
-def add_to_claude(name, spec, scope):
+def add_to_claude(name, spec, scope, force=False):
     step("Adding to Claude Code")
     if not shutil.which("claude"):
         warning("`claude` CLI not found on PATH; skipping Claude Code")
@@ -46,16 +46,23 @@ def add_to_claude(name, spec, scope):
         return False
 
     if claude_has_server(name):
-        info(f"MCP server [accent]{name}[/accent] already in Claude Code; skipping")
-        return True
+        if not force:
+            info(f"MCP server [accent]{name}[/accent] already in Claude Code; skipping")
+            return True
+        info(f"Replacing existing [accent]{name}[/accent] in Claude Code")
+        run_command(["claude", "mcp", "remove", "--scope", scope, name], check=False)
 
     cmd = ["claude", "mcp", "add", "--scope", scope]
     if is_remote(spec):
         cmd += ["--transport", spec["transport"], name, spec["url"]]
     else:
+        # `claude mcp add` declares -e as variadic (`-e <env...>`), so any flag placed
+        # before the positional name swallows it as another KEY=value and the command
+        # dies with "Invalid environment variable format: <name>". Name first.
+        cmd += [name]
         for key, value in (spec.get("env") or {}).items():
             cmd += ["-e", f"{key}={value}"]
-        cmd += [name, "--", *spec["command"]]
+        cmd += ["--", *spec["command"]]
     if spec.get("headers"):
         for key, value in spec["headers"].items():
             cmd += ["--header", f"{key}: {value}"]
@@ -70,20 +77,24 @@ def add_to_claude(name, spec, scope):
     return True
 
 
-def add_to_opencode(name, spec, project):
+def add_to_opencode(name, spec, project, force=False):
     step("Adding to OpenCode")
     server_config = to_opencode_config(spec)
 
     config_path = get_global_config_path()
     existing = load_jsonc(config_path) if config_path.exists() else {}
     mcp = existing.setdefault("mcp", {})
-    if name in mcp:
+    if name in mcp and not force:
         info(f"MCP server [accent]{name}[/accent] already in OpenCode global; skipping")
+    elif name in mcp and mcp[name] == server_config:
+        info(f"MCP server [accent]{name}[/accent] already matches in OpenCode global; unchanged")
     else:
+        replacing = name in mcp
         mcp[name] = server_config
         header = "// OpenCode global configuration generated by evo"
         save_jsonc(config_path, existing, header=header)
-        success(f"Added [accent]{name}[/accent] to OpenCode global config")
+        verb = "Replaced" if replacing else "Added"
+        success(f"{verb} [accent]{name}[/accent] in OpenCode global config")
     info(f"Config: [accent]{config_path}[/accent]")
 
     if project:
@@ -91,7 +102,7 @@ def add_to_opencode(name, spec, project):
         proj_path = target / "opencode.json"
         proj_existing = load_jsonc(proj_path) if proj_path.exists() else {}
         proj_mcp = proj_existing.setdefault("mcp", {})
-        if name in proj_mcp:
+        if name in proj_mcp and not force:
             info(f"MCP server [accent]{name}[/accent] already in project config; skipping")
         else:
             proj_mcp[name] = server_config
@@ -179,12 +190,17 @@ def list_servers():
 )
 @click.option("--claude-only", is_flag=True, help="Only configure Claude Code.")
 @click.option("--opencode-only", is_flag=True, help="Only configure OpenCode.")
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Replace an existing entry instead of leaving it alone (use when --env or the command changed).",
+)
 @click.option(
     "--project",
     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, command, env, transport, scope, claude_only, opencode_only, project):
+def add_server(name, url, command, env, transport, scope, claude_only, opencode_only, force, project):
     """Add an MCP server to Claude Code and OpenCode.
 
     NAME is a key from the library (`evo mcp list`), or any label when paired
@@ -218,9 +234,9 @@ def add_server(name, url, command, env, transport, scope, claude_only, opencode_
 
     did_claude = did_opencode = False
     if not opencode_only:
-        did_claude = add_to_claude(name, spec, scope)
+        did_claude = add_to_claude(name, spec, scope, force=force)
     if not claude_only:
-        did_opencode = add_to_opencode(name, spec, project)
+        did_opencode = add_to_opencode(name, spec, project, force=force)
 
     console.print()
     targets = []

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli/commands/opencode.py

@@ -42,14 +42,19 @@ def is_windows():
 
 
 def get_global_config_dir():
-    home = Path.home()
-    if is_windows():
-        return home / "AppData" / "Roaming" / "opencode"
-    return home / ".config" / "opencode"
+    # OpenCode reads ~/.config/opencode on every platform, Windows included - it does
+    # not follow the %APPDATA% convention. Writing to AppData produced a file that
+    # `opencode mcp list` never saw, so every server evo "added" was silently inert.
+    return Path.home() / ".config" / "opencode"
 
 
 def get_global_config_path():
-    return get_global_config_dir() / "opencode.jsonc"
+    directory = get_global_config_dir()
+    for name in ("opencode.jsonc", "opencode.json"):
+        candidate = directory / name
+        if candidate.exists():
+            return candidate
+    return directory / "opencode.jsonc"
 
 
 def ensure_node_installed():

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli/commands/tts.py

@@ -168,7 +168,7 @@ def speak(
         if not quiet and not to_stdout:
             info(
                 f"Provider [accent]{resolved}[/accent], voice "
-                f"[accent]{voice or core.default_voice(resolved)}[/accent], "
+                f"[accent]{voice or core.default_voice_for(resolved)}[/accent], "
                 f"{len(body.strip())} characters (limit {chunks}/request)"
             )
 

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli/tts/__init__.py

@@ -3,6 +3,7 @@ from evo_cli.tts.core import (
     PROVIDERS,
     chunk_limit,
     default_voice,
+    default_voice_for,
     list_voices,
     resolve_provider,
     supported_formats,
@@ -18,6 +19,7 @@ __all__ = [
     "TtsError",
     "chunk_limit",
     "default_voice",
+    "default_voice_for",
     "list_voices",
     "play",
     "player_hint",

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli/tts/core.py

@@ -1,3 +1,4 @@
+import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from evo_cli.tts import openai as openai_tts
@@ -15,6 +16,11 @@ def resolve_provider(provider):
     if provider in PROVIDERS:
         return provider
     if provider in (None, "", "auto"):
+        preferred = (os.environ.get("EVO_TTS_PROVIDER") or "").strip().lower()
+        if preferred in PROVIDERS:
+            return preferred
+        if preferred and preferred != "auto":
+            raise TtsError(f"EVO_TTS_PROVIDER is set to '{preferred}', which is not one of: {', '.join(PROVIDERS)}")
         if has_vbee_credentials():
             return "vbee"
         if has_openai_credentials():
@@ -27,6 +33,14 @@ def resolve_provider(provider):
     raise TtsError(f"unknown provider '{provider}' (expected one of: {', '.join(PROVIDERS)}, auto)")
 
 
+def default_voice_for(provider):
+    # Provider-scoped first, so a machine configured for both does not hand a Vbee
+    # voice code to OpenAI the moment EVO_TTS_PROVIDER flips.
+    scoped = (os.environ.get(f"EVO_TTS_VOICE_{provider.upper()}") or "").strip()
+    shared = (os.environ.get("EVO_TTS_VOICE") or "").strip()
+    return scoped or shared or default_voice(provider)
+
+
 def default_voice(provider):
     return vbee.DEFAULT_VOICE if provider == "vbee" else openai_tts.DEFAULT_VOICE
 
@@ -81,6 +95,7 @@ def synthesize(
     on_poll=None,
 ):
     provider = resolve_provider(provider)
+    voice = voice or default_voice_for(provider)
     if mode not in MODES:
         raise TtsError(f"unknown mode '{mode}' (expected one of: {', '.join(MODES)})")
     text = (text or "").strip()

{evo_cli-0.13.0 → evo_cli-0.14.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.13.0
+Version: 0.14.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -214,8 +214,19 @@ evo cred add vbee.token --from-stdin       # JWT from the same app page
 evo cred add openai_api_key --from-stdin
 ```
 
-`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set. `--provider auto`
-(the default) picks Vbee when its credentials exist, otherwise OpenAI.
+`VBEE_APP_ID`, `VBEE_TOKEN`, and `OPENAI_API_KEY` override the store when set.
+
+`--provider auto` (the default) resolves to `EVO_TTS_PROVIDER` when that is set, and otherwise to
+whichever provider has credentials. Pick a machine default once:
+
+```bash
+export EVO_TTS_PROVIDER=openai        # what `auto` means here
+export EVO_TTS_VOICE_OPENAI=nova      # default voice for that provider only
+```
+
+Prefer the provider-scoped `EVO_TTS_VOICE_OPENAI` / `EVO_TTS_VOICE_VBEE` over a bare
+`EVO_TTS_VOICE`: a shared value breaks as soon as you pass `--provider vbee`, because an OpenAI
+voice name is not a Vbee voice code.
 
 Playback uses whichever of `ffplay`, `mpv`, `cvlc`, `afplay`, or `paplay`/`aplay` is on PATH, and
 falls back to PowerShell's `MediaPlayer` on Windows. Without any of them the audio is still written

{evo_cli-0.13.0 → evo_cli-0.14.0}/tests/test_mcp.py

@@ -2,7 +2,7 @@ import pytest
 from click.testing import CliRunner
 
 from evo_cli.cli import cli
-from evo_cli.commands.mcp import resolve_spec, to_opencode_config
+from evo_cli.commands.mcp import add_to_claude, resolve_spec, to_opencode_config
 from evo_cli.commands.opencode import load_jsonc
 
 
@@ -128,3 +128,47 @@ def test_add_rejects_both_only_flags(runner, tmp_path, monkeypatch):
     )
     assert result.exit_code == 0
     assert "mutually exclusive" in result.output
+
+
+def test_claude_add_puts_the_name_before_the_variadic_env_flag(monkeypatch):
+    captured = []
+    monkeypatch.setattr("evo_cli.commands.mcp.shutil.which", lambda name: f"/usr/bin/{name}")
+    monkeypatch.setattr("evo_cli.commands.mcp.claude_has_server", lambda name: False)
+    monkeypatch.setattr("evo_cli.commands.mcp.run_command", lambda cmd, **kw: captured.append(cmd))
+
+    spec = {"transport": "stdio", "command": ["uv", "run", "server.py"], "env": {"A": "1", "B": "2"}}
+    add_to_claude("evo-tts", spec, "user")
+
+    cmd = captured[0]
+    # `claude mcp add` declares -e as variadic, so a name after it is swallowed as
+    # another KEY=value and the real CLI errors out.
+    assert cmd.index("evo-tts") < cmd.index("-e")
+    assert cmd[cmd.index("--") + 1 :] == ["uv", "run", "server.py"]
+    assert "A=1" in cmd and "B=2" in cmd
+
+
+def test_opencode_add_leaves_an_existing_entry_alone_without_force(runner, tmp_path, monkeypatch):
+    global_path = tmp_path / "global.jsonc"
+    monkeypatch.setattr("evo_cli.commands.mcp.get_global_config_path", lambda: global_path)
+
+    runner.invoke(cli, ["mcp", "add", "srv", "--opencode-only", "--command", "old cmd"])
+    result = runner.invoke(cli, ["mcp", "add", "srv", "--opencode-only", "--command", "new cmd"])
+
+    assert result.exit_code == 0
+    assert load_jsonc(global_path)["mcp"]["srv"]["command"] == ["old", "cmd"]
+
+
+def test_opencode_add_force_replaces_the_entry(runner, tmp_path, monkeypatch):
+    global_path = tmp_path / "global.jsonc"
+    monkeypatch.setattr("evo_cli.commands.mcp.get_global_config_path", lambda: global_path)
+
+    runner.invoke(cli, ["mcp", "add", "srv", "--opencode-only", "--command", "old cmd"])
+    result = runner.invoke(
+        cli,
+        ["mcp", "add", "srv", "--opencode-only", "--force", "--env", "K=v", "--command", "new cmd"],
+    )
+
+    assert result.exit_code == 0
+    entry = load_jsonc(global_path)["mcp"]["srv"]
+    assert entry["command"] == ["new", "cmd"]
+    assert entry["environment"] == {"K": "v"}

{evo_cli-0.13.0 → evo_cli-0.14.0}/tests/test_opencode.py

@@ -5,6 +5,7 @@ import pytest
 from click.testing import CliRunner
 
 from evo_cli.cli import cli
+from evo_cli.commands import opencode
 from evo_cli.commands.opencode import (
     DEFAULT_MCP_SERVERS,
     EXA_ENV_VAR,
@@ -209,3 +210,34 @@ def test_setup_opencode_global_only(runner, tmp_path, monkeypatch):
     result = runner.invoke(cli, ["setup", "opencode", "--global-only", "--project", str(project)])
     assert result.exit_code == 0
     assert not (project / "opencode.json").exists()
+
+
+def test_global_config_dir_is_xdg_style_on_every_platform(monkeypatch, tmp_path):
+    monkeypatch.setattr(opencode.Path, "home", classmethod(lambda cls: tmp_path))
+    for system in ("Windows", "Linux", "Darwin"):
+        monkeypatch.setattr(opencode.platform, "system", lambda system=system: system)
+        assert opencode.get_global_config_dir() == tmp_path / ".config" / "opencode"
+
+
+def test_global_config_path_reuses_an_existing_json_file(monkeypatch, tmp_path):
+    monkeypatch.setattr(opencode.Path, "home", classmethod(lambda cls: tmp_path))
+    directory = tmp_path / ".config" / "opencode"
+    directory.mkdir(parents=True)
+    existing = directory / "opencode.json"
+    existing.write_text("{}", encoding="utf-8")
+    assert opencode.get_global_config_path() == existing
+
+
+def test_global_config_path_prefers_jsonc_when_both_exist(monkeypatch, tmp_path):
+    monkeypatch.setattr(opencode.Path, "home", classmethod(lambda cls: tmp_path))
+    directory = tmp_path / ".config" / "opencode"
+    directory.mkdir(parents=True)
+    (directory / "opencode.json").write_text("{}", encoding="utf-8")
+    (directory / "opencode.jsonc").write_text("{}", encoding="utf-8")
+    assert opencode.get_global_config_path() == directory / "opencode.jsonc"
+
+
+def test_global_config_path_defaults_to_jsonc_when_nothing_exists(monkeypatch, tmp_path):
+    monkeypatch.setattr(opencode.Path, "home", classmethod(lambda cls: tmp_path))
+    expected = tmp_path / ".config" / "opencode" / "opencode.jsonc"
+    assert opencode.get_global_config_path() == expected

{evo_cli-0.13.0 → evo_cli-0.14.0}/tests/test_tts.py

@@ -9,6 +9,24 @@ from evo_cli.tts import core, vbee
 from evo_cli.tts.chunking import join_audio, split_text
 from evo_cli.tts.errors import TtsError
 
+EVO_TTS_ENV_VARS = (
+    "EVO_TTS_PROVIDER",
+    "EVO_TTS_VOICE",
+    "EVO_TTS_VOICE_OPENAI",
+    "EVO_TTS_VOICE_VBEE",
+    "EVO_TTS_SPEED",
+    "EVO_TTS_DIR",
+)
+
+
+@pytest.fixture(autouse=True)
+def clean_tts_env(monkeypatch):
+    # These are set for real on machines that picked a default provider, and they
+    # would otherwise decide the outcome of the auto-detection tests. CI has none of
+    # them set, so without this the suite passes there and fails on a real desktop.
+    for name in EVO_TTS_ENV_VARS:
+        monkeypatch.delenv(name, raising=False)
+
 
 @pytest.fixture
 def runner():
@@ -258,3 +276,54 @@ def test_batch_exits_nonzero_when_an_item_fails(runner, monkeypatch, tmp_path):
     result = runner.invoke(cli, ["tts", "batch", "-t", "xin chào", "-o", str(tmp_path / "out")])
     assert result.exit_code == 1
     assert "nope" in result.output
+
+
+def test_resolve_provider_auto_follows_the_env_override(monkeypatch):
+    monkeypatch.setenv("EVO_TTS_PROVIDER", "openai")
+    monkeypatch.setattr(core, "has_vbee_credentials", lambda: True)
+    assert core.resolve_provider("auto") == "openai"
+
+
+def test_env_override_does_not_beat_an_explicit_provider(monkeypatch):
+    monkeypatch.setenv("EVO_TTS_PROVIDER", "openai")
+    assert core.resolve_provider("vbee") == "vbee"
+
+
+def test_resolve_provider_rejects_a_bogus_env_override(monkeypatch):
+    monkeypatch.setenv("EVO_TTS_PROVIDER", "elevenlabs")
+    with pytest.raises(TtsError, match="EVO_TTS_PROVIDER"):
+        core.resolve_provider("auto")
+
+
+def test_default_voice_for_falls_back_to_the_provider_default(monkeypatch):
+    monkeypatch.delenv("EVO_TTS_VOICE", raising=False)
+    monkeypatch.delenv("EVO_TTS_VOICE_OPENAI", raising=False)
+    assert core.default_voice_for("openai") == core.openai_tts.DEFAULT_VOICE
+    assert core.default_voice_for("vbee") == vbee.DEFAULT_VOICE
+
+
+def test_scoped_voice_env_wins_over_the_shared_one(monkeypatch):
+    monkeypatch.setenv("EVO_TTS_VOICE", "shared")
+    monkeypatch.setenv("EVO_TTS_VOICE_OPENAI", "nova")
+    assert core.default_voice_for("openai") == "nova"
+    assert core.default_voice_for("vbee") == "shared"
+
+
+def test_scoped_voice_does_not_leak_across_providers(monkeypatch):
+    monkeypatch.delenv("EVO_TTS_VOICE", raising=False)
+    monkeypatch.setenv("EVO_TTS_VOICE_OPENAI", "nova")
+    assert core.default_voice_for("vbee") == vbee.DEFAULT_VOICE
+
+
+def test_synthesize_applies_the_env_voice(monkeypatch):
+    monkeypatch.delenv("EVO_TTS_VOICE", raising=False)
+    monkeypatch.setenv("EVO_TTS_VOICE_OPENAI", "nova")
+    seen = {}
+
+    def fake_synthesize(text, **kwargs):
+        seen["voice"] = kwargs["voice"]
+        return b"x"
+
+    monkeypatch.setattr(core.openai_tts, "synthesize", fake_synthesize)
+    core.synthesize("xin chào", provider="openai")
+    assert seen["voice"] == "nova"

evo_cli-0.13.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.13.0