evo-cli 0.10.3__tar.gz → 0.11.0__tar.gz

{evo_cli-0.10.3 → evo_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.10.3
+Version: 0.11.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.11.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.11.0

{evo_cli-0.10.3 → evo_cli-0.11.0}/evo_cli/cli.py

@@ -1,9 +1,11 @@
 import rich_click as click
 
 from evo_cli import __version__
+from evo_cli.commands.claude_code import setup_claude
 from evo_cli.commands.cloudflare import cfssh
 from evo_cli.commands.fix_claude import f_claude
 from evo_cli.commands.gdrive import gdrive
+from evo_cli.commands.gh import setup_gh
 from evo_cli.commands.localproxy import localproxy
 from evo_cli.commands.mcp import mcp_group
 from evo_cli.commands.miniconda import miniconda
@@ -20,6 +22,7 @@ from evo_cli.commands.wifi import wifi
 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"
@@ -41,6 +44,8 @@ def cli():
     """
 
 
+setup_group.add_command(setup_claude)
+setup_group.add_command(setup_gh)
 setup_group.add_command(setup_opencode)
 setup_group.add_command(miniconda)
 setup_group.add_command(setupssh)

evo_cli-0.11.0/evo_cli/commands/claude_code.py

@@ -0,0 +1,309 @@
+"""Install Claude Code and register its default MCP servers."""
+
+import os
+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.commands.fix_claude import is_affected, probe_version, version_str
+from evo_cli.commands.gh import check_gh_auth, install_gh
+from evo_cli.commands.mcp import add_to_claude
+from evo_cli.console import CommandError, console, error, info, run_command, step, success, warning
+from evo_cli.mcp_registry import MCP_REGISTRY
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo setup claude[/cyan]                        install Claude Code + gh + the default MCP servers\n"
+    "  [cyan]evo setup claude --skip-install[/cyan]         only register MCP servers\n"
+    "  [cyan]evo setup claude --no-mcp --no-gh[/cyan]       only install the CLI\n"
+    "  [cyan]evo setup claude --mcp playwright --mcp github[/cyan]\n"
+    "  [cyan]evo setup claude --method npm[/cyan]           install via npm instead of the native installer\n"
+    "  [cyan]evo setup claude --install-version 2.1.153[/cyan]\n"
+    "  [cyan]evo setup claude --reinstall[/cyan]            reinstall even if already present"
+)
+
+INSTALL_SH = "https://claude.ai/install.sh"
+INSTALL_PS1 = "https://claude.ai/install.ps1"
+NPM_PACKAGE = "@anthropic-ai/claude-code"
+
+# Claude Code already ships web search, file editing and shell tools, so the
+# defaults only cover what it cannot do on its own: drive a real browser
+# (playwright) and pull current library docs (context7). Add any other server
+# from the library later with `evo mcp add <name>`.
+DEFAULT_MCP_SERVERS = ("playwright", "context7")
+
+# The native installer drops the binary in one of these; neither is on PATH until
+# a new shell is started.
+LOCAL_BIN_DIRS = (
+    Path.home() / ".local" / "bin",
+    Path.home() / ".claude" / "local",
+)
+
+
+def is_windows():
+    return platform.system() == "Windows"
+
+
+def ensure_claude_on_path():
+    """Return the `claude` binary, making a fresh install visible to this process.
+
+    The native installer writes to ~/.local/bin, which the shell that launched
+    evo has not picked up yet, so `claude` stays invisible until the user opens a
+    new terminal. Prepend the install dir to PATH so the MCP and doctor steps can
+    still run in this same invocation.
+    """
+    found = shutil.which("claude")
+    if found:
+        return found
+
+    binary = "claude.exe" if is_windows() else "claude"
+    for directory in LOCAL_BIN_DIRS:
+        candidate = directory / binary
+        if candidate.exists():
+            os.environ["PATH"] = f"{directory}{os.pathsep}{os.environ.get('PATH', '')}"
+            return str(candidate)
+    return None
+
+
+def native_install_command(version=None):
+    """Build the official installer command for this platform."""
+    if is_windows():
+        return ["powershell", "-NoProfile", "-Command", f"irm {INSTALL_PS1} | iex"]
+    script = f"curl -fsSL {INSTALL_SH} | bash"
+    if version:
+        script += f" -s {version}"
+    return ["bash", "-c", script]
+
+
+def npm_install_command(version=None):
+    package = f"{NPM_PACKAGE}@{version}" if version else NPM_PACKAGE
+    return ["npm", "install", "-g", package]
+
+
+def native_install_available(version=None):
+    """Whether the native installer can run here.
+
+    install.ps1 takes no version argument, so a pinned version on Windows has to
+    go through npm instead.
+    """
+    if is_windows():
+        return bool(shutil.which("powershell")) and not version
+    return bool(shutil.which("curl") and shutil.which("bash"))
+
+
+def install_attempts(method, version):
+    """Ordered (label, command) install attempts for the requested method."""
+    attempts = []
+    if method in ("auto", "native") and native_install_available(version):
+        attempts.append(("native installer", native_install_command(version)))
+    if method in ("auto", "npm") and shutil.which("npm"):
+        attempts.append(("npm", npm_install_command(version)))
+    return attempts
+
+
+def install_claude(method="auto", version=None, reinstall=False):
+    """Install the Claude Code CLI. Returns True when `claude` ends up runnable."""
+    step("Installing Claude Code")
+
+    if ensure_claude_on_path() and not reinstall:
+        info(f"Claude Code already installed ({version_str(probe_version())}); skipping install")
+        info("Pass --reinstall to install it again, or run `claude update` to update.")
+        return True
+
+    attempts = install_attempts(method, version)
+    if not attempts:
+        error(f"No usable install method for --method {method} on {platform.system()}.")
+        if is_windows():
+            info(f"Install manually: [accent]irm {INSTALL_PS1} | iex[/accent] (PowerShell)")
+        else:
+            info(f"Install manually: [accent]curl -fsSL {INSTALL_SH} | bash[/accent]")
+        return False
+
+    for label, command in attempts:
+        info(f"Installing via {label}")
+        try:
+            run_command(command, status=f"Installing Claude Code via {label}", timeout=600)
+        except CommandError as exc:
+            warning(f"Install via {label} failed: {exc}")
+            continue
+
+        if ensure_claude_on_path():
+            success(f"Claude Code installed ({version_str(probe_version())})")
+            return True
+        warning(f"Install via {label} finished but `claude` is not on PATH")
+
+    error("Could not install Claude Code.")
+    info("Open a new shell and retry, or add the install directory (~/.local/bin) to PATH.")
+    return False
+
+
+def configure_mcp_servers(names, scope):
+    """Register the named library MCP servers with Claude Code."""
+    added = []
+    for name in names:
+        if add_to_claude(name, MCP_REGISTRY[name], scope):
+            added.append(name)
+    return added
+
+
+def run_doctor():
+    """Run Claude Code's own diagnostic. Never fatal: it is a report, not a gate."""
+    step("Verifying installation")
+    result = run_command(
+        ["claude", "doctor"],
+        status="Running claude doctor",
+        stdin=subprocess.DEVNULL,
+        timeout=120,
+        check=False,
+    )
+    if getattr(result, "returncode", None) == 0:
+        success("`claude doctor` reported no problems")
+    else:
+        warning("`claude doctor` reported problems; see its output above")
+
+
+def setup_github_cli():
+    """Install gh and report its auth state. Returns one of: ready, unauthenticated, missing.
+
+    Claude Code shells out to `gh` for PRs, issues and the GitHub API, so a fresh
+    machine wants it too. A failure here is not fatal: Claude Code still works,
+    it just cannot touch GitHub until gh is installed and signed in.
+    """
+    if not install_gh():
+        return "missing"
+    return "ready" if check_gh_auth() else "unauthenticated"
+
+
+def print_summary(installed, added, scope, gh_state=None):
+    console.print()
+    if not installed:
+        console.print(
+            Panel(
+                "Claude Code is not installed, so nothing was configured.\n\n"
+                f"Install it with [accent]curl -fsSL {INSTALL_SH} | bash[/accent] "
+                "(or [accent]evo setup claude --method npm[/accent]), then re-run this command.",
+                title="setup claude incomplete",
+                border_style="warning",
+                expand=False,
+            )
+        )
+        return
+
+    version = probe_version()
+    lines = [f"Claude Code [accent]{version_str(version)}[/accent] is ready."]
+    if added:
+        lines.append(f"MCP servers registered ({scope} scope): [accent]{', '.join(added)}[/accent]")
+        lines.append("Run [accent]/mcp[/accent] inside Claude Code to authenticate any server that needs OAuth.")
+    lines.append("")
+    lines.append("Run [accent]claude[/accent] to start; the first run opens a browser to sign in.")
+    lines.append(
+        "Add more MCP servers anytime with [accent]evo mcp add <name>[/accent] ([accent]evo mcp list[/accent])."
+    )
+    if gh_state == "unauthenticated":
+        lines.append("Sign in to GitHub with [accent]gh auth login[/accent] so Claude Code can open PRs.")
+    elif gh_state == "missing":
+        lines.append("[warning]GitHub CLI is missing; retry with [accent]evo setup gh[/accent].[/warning]")
+    if is_affected(version):
+        lines.append("")
+        lines.append(
+            "[warning]This build has the tool-result bug; run [accent]evo f-claude[/accent] to fix it.[/warning]"
+        )
+
+    console.print(
+        Panel(
+            Text.from_markup("\n".join(lines)),
+            title="setup claude complete",
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+def run_setup_claude(skip_install, reinstall, method, install_version, mcp_names, no_mcp, scope, no_gh):
+    step("evo setup claude")
+
+    if skip_install:
+        info("Skipping install as requested")
+        installed = bool(ensure_claude_on_path())
+        if not installed:
+            error("`claude` was not found on PATH; nothing to configure.")
+    else:
+        installed = install_claude(method, install_version, reinstall)
+
+    gh_state = None
+    if no_gh:
+        info("Skipping the GitHub CLI as requested")
+    else:
+        gh_state = setup_github_cli()
+
+    added = []
+    if not installed:
+        pass
+    elif no_mcp:
+        info("Skipping MCP registration as requested")
+    else:
+        added = configure_mcp_servers(mcp_names or DEFAULT_MCP_SERVERS, scope)
+
+    if installed:
+        run_doctor()
+
+    print_summary(installed, added, scope, gh_state)
+
+
+@click.command("claude", epilog=EPILOG)
+@click.option("--skip-install", is_flag=True, help="Skip installing the CLI; only register MCP servers.")
+@click.option("--reinstall", is_flag=True, help="Install even if Claude Code is already present.")
+@click.option(
+    "--method",
+    type=click.Choice(["auto", "native", "npm"]),
+    default="auto",
+    show_default=True,
+    help="Install method. `auto` tries the native installer, then falls back to npm.",
+)
+@click.option(
+    "--install-version",
+    metavar="VERSION",
+    help="Install a specific version instead of the latest, e.g. 2.1.153.",
+)
+@click.option(
+    "--mcp",
+    "mcp_names",
+    multiple=True,
+    metavar="NAME",
+    help=f"MCP server from the library to register (repeatable). Default: {', '.join(DEFAULT_MCP_SERVERS)}.",
+)
+@click.option("--no-mcp", is_flag=True, help="Skip MCP server registration.")
+@click.option("--no-gh", is_flag=True, help="Skip installing the GitHub CLI (gh).")
+@click.option(
+    "--scope",
+    type=click.Choice(["local", "user", "project"]),
+    default="user",
+    show_default=True,
+    help="Claude Code config scope for the MCP servers.",
+)
+def setup_claude(skip_install, reinstall, method, install_version, mcp_names, no_mcp, no_gh, scope):
+    """Install Claude Code, the GitHub CLI, and the default MCP servers.
+
+    Installs the CLI with Anthropic's native installer (falling back to npm),
+    installs the GitHub CLI that Claude Code shells out to for PRs and issues,
+    registers the MCP servers Claude Code lacks natively - playwright for browser
+    automation and context7 for up-to-date library docs - and runs `claude doctor`
+    to verify the result. Everything is idempotent: existing installs are left
+    alone unless --reinstall is passed, and servers already registered are skipped.
+
+    Pick your own servers with --mcp (repeatable, from `evo mcp list`), or skip
+    them with --no-mcp; skip the GitHub CLI with --no-gh (`evo setup gh` installs
+    it on its own). No credentials are written: `gh auth login` and OAuth MCP
+    servers (/mcp inside Claude Code) stay in your hands.
+    """
+    unknown = [name for name in mcp_names if name not in MCP_REGISTRY]
+    if unknown:
+        error(f"Unknown MCP server(s): {', '.join(unknown)}. Run `evo mcp list` to see the library.")
+        return
+
+    run_setup_claude(skip_install, reinstall, method, install_version, mcp_names, no_mcp, scope, no_gh)

evo_cli-0.11.0/evo_cli/commands/gh.py

@@ -0,0 +1,246 @@
+"""Install the GitHub CLI (gh) and report whether it is authenticated."""
+
+import platform
+import re
+import shutil
+import subprocess
+
+import rich_click as click
+from rich.panel import Panel
+from rich.text import Text
+
+from evo_cli.console import CommandError, console, error, info, resolve_executable, run_command, step, success, warning
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo setup gh[/cyan]                    install gh, then check its auth status\n"
+    "  [cyan]evo setup gh --reinstall[/cyan]        install again even if gh is present\n"
+    "  [cyan]evo setup gh --skip-auth-check[/cyan]  install only; do not run `gh auth status`"
+)
+
+RELEASES_URL = "https://github.com/cli/cli/releases/latest"
+
+# gh is not in the default Debian/Ubuntu repositories, so the official
+# instructions add GitHub's keyring and apt source first. Kept close to upstream:
+# https://github.com/cli/cli/blob/trunk/docs/install_linux.md
+APT_SCRIPT = (
+    "set -e\n"
+    "(type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y))\n"
+    "sudo mkdir -p -m 755 /etc/apt/keyrings\n"
+    "out=$(mktemp)\n"
+    "wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg\n"
+    "cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null\n"
+    "sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg\n"
+    "sudo mkdir -p -m 755 /etc/apt/sources.list.d\n"
+    'echo "deb [arch=$(dpkg --print-architecture) '
+    "signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] "
+    'https://cli.github.com/packages stable main" '
+    "| sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null\n"
+    "sudo apt update\n"
+    "sudo apt install gh -y\n"
+)
+
+# Fedora ships gh in its own repositories; only fall back to GitHub's rpm repo
+# when the distro does not carry the package.
+DNF_SCRIPT = (
+    "sudo dnf install -y gh || {\n"
+    "  sudo dnf install -y dnf5-plugins\n"
+    "  sudo dnf config-manager addrepo --from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo\n"
+    "  sudo dnf install -y gh\n"
+    "}\n"
+)
+
+ZYPPER_SCRIPT = (
+    "set -e\n"
+    "sudo zypper addrepo https://cli.github.com/packages/rpm/gh-cli.repo\n"
+    "sudo zypper ref\n"
+    "sudo zypper install -y gh\n"
+)
+
+
+def gh_version():
+    """Return the installed gh version string, or None if gh is not on PATH."""
+    if not shutil.which("gh"):
+        return None
+    try:
+        result = subprocess.run(
+            resolve_executable(["gh", "--version"]),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "unknown"
+    match = re.search(r"\d+\.\d+\.\d+", result.stdout or "")
+    return match.group(0) if match else "unknown"
+
+
+def linux_install_command():
+    if shutil.which("apt-get"):
+        return ["bash", "-c", APT_SCRIPT]
+    if shutil.which("dnf"):
+        return ["bash", "-c", DNF_SCRIPT]
+    if shutil.which("pacman"):
+        return ["sudo", "pacman", "-S", "--noconfirm", "github-cli"]
+    if shutil.which("apk"):
+        return ["sudo", "apk", "add", "github-cli"]
+    if shutil.which("zypper"):
+        return ["bash", "-c", ZYPPER_SCRIPT]
+    return None
+
+
+def windows_install_command():
+    if shutil.which("winget"):
+        # The accept flags keep winget from stopping on an interactive agreement prompt.
+        return [
+            "winget",
+            "install",
+            "--id",
+            "GitHub.cli",
+            "--source",
+            "winget",
+            "--accept-package-agreements",
+            "--accept-source-agreements",
+        ]
+    if shutil.which("scoop"):
+        return ["scoop", "install", "gh"]
+    if shutil.which("choco"):
+        return ["choco", "install", "gh", "-y"]
+    return None
+
+
+def install_command():
+    """The gh install command for this platform, or None if none is usable."""
+    system = platform.system()
+    if system == "Darwin":
+        return ["brew", "install", "gh"] if shutil.which("brew") else None
+    if system == "Linux":
+        return linux_install_command()
+    if system == "Windows":
+        return windows_install_command()
+    return None
+
+
+def missing_package_manager_hint():
+    system = platform.system()
+    if system == "Darwin":
+        info("Homebrew not found. Install it from https://brew.sh, then re-run.")
+    elif system == "Linux":
+        info("No supported package manager found (apt-get, dnf, pacman, apk, zypper).")
+    elif system == "Windows":
+        info("No supported package manager found (winget, scoop, choco).")
+    else:
+        info(f"Unsupported platform: {system}")
+    info(f"You can also grab a binary from [accent]{RELEASES_URL}[/accent]")
+
+
+def install_gh(reinstall=False):
+    """Install the GitHub CLI. Returns True when `gh` ends up runnable."""
+    step("Installing GitHub CLI")
+
+    version = gh_version()
+    if version and not reinstall:
+        info(f"gh already installed ({version}); skipping install")
+        return True
+
+    command = install_command()
+    if command is None:
+        error("Could not install gh automatically.")
+        missing_package_manager_hint()
+        return False
+
+    try:
+        run_command(command, status="Installing gh", stdin=subprocess.DEVNULL, timeout=900)
+    except CommandError as exc:
+        error(f"Installing gh failed: {exc}")
+        info(f"Install it manually from [accent]{RELEASES_URL}[/accent]")
+        return False
+
+    version = gh_version()
+    if not version:
+        warning("gh installed but it is not on PATH yet")
+        info("Open a new terminal, then run `gh --version` to confirm.")
+        return False
+
+    success(f"gh installed ({version})")
+    return True
+
+
+def check_gh_auth():
+    """Report whether gh holds GitHub credentials.
+
+    `gh auth status` is read-only and exits non-zero when logged out, so it is
+    safe here. `gh auth login` is not: it needs a TTY and a browser, so leave it
+    to the user rather than blocking the run on it.
+    """
+    step("Checking GitHub authentication")
+    result = run_command(
+        ["gh", "auth", "status"],
+        status="Running gh auth status",
+        stdin=subprocess.DEVNULL,
+        timeout=60,
+        check=False,
+    )
+    if getattr(result, "returncode", None) == 0:
+        success("gh is authenticated")
+        return True
+
+    warning("gh is not authenticated")
+    info("Run [accent]gh auth login[/accent] in your terminal; it opens a browser to sign in.")
+    return False
+
+
+def print_summary(installed, authenticated, auth_checked):
+    console.print()
+    if not installed:
+        console.print(
+            Panel(
+                f"gh was not installed. Install it manually from [accent]{RELEASES_URL}[/accent], then re-run.",
+                title="setup gh incomplete",
+                border_style="warning",
+                expand=False,
+            )
+        )
+        return
+
+    lines = [f"GitHub CLI [accent]{gh_version()}[/accent] is ready."]
+    if not auth_checked:
+        lines.append("Auth check skipped; run [accent]gh auth status[/accent] to see if you are signed in.")
+    elif authenticated:
+        lines.append("You are signed in; `gh pr`, `gh issue` and Claude Code's GitHub workflows will work.")
+    else:
+        lines.append("Sign in with [accent]gh auth login[/accent] to finish setting it up.")
+
+    console.print(
+        Panel(
+            "\n".join(lines),
+            title="setup gh complete",
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+@click.command("gh", epilog=EPILOG)
+@click.option("--reinstall", is_flag=True, help="Install even if gh is already present.")
+@click.option("--skip-auth-check", is_flag=True, help="Skip the `gh auth status` check afterwards.")
+def setup_gh(reinstall, skip_auth_check):
+    """Install the GitHub CLI (gh) and check whether it is signed in.
+
+    Uses the package manager for your platform - Homebrew on macOS, apt/dnf/
+    pacman/apk/zypper on Linux, winget/scoop/choco on Windows - following
+    GitHub's official instructions (on Debian/Ubuntu that means adding GitHub's
+    keyring and apt source, since gh is not in the default repos).
+
+    An existing install is left alone unless --reinstall is passed. Signing in is
+    left to you: `gh auth login` needs an interactive terminal and a browser, so
+    this command only reports whether credentials are already present.
+    """
+    step("evo setup gh")
+    installed = install_gh(reinstall)
+    authenticated = False
+    if installed and not skip_auth_check:
+        authenticated = check_gh_auth()
+    print_summary(installed, authenticated, auth_checked=not skip_auth_check)

{evo_cli-0.10.3 → evo_cli-0.11.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.10.3
+Version: 0.11.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.10.3 → evo_cli-0.11.0}/evo_cli.egg-info/SOURCES.txt

@@ -18,9 +18,11 @@ evo_cli.egg-info/entry_points.txt
 evo_cli.egg-info/requires.txt
 evo_cli.egg-info/top_level.txt
 evo_cli/commands/__init__.py
+evo_cli/commands/claude_code.py
 evo_cli/commands/cloudflare.py
 evo_cli/commands/fix_claude.py
 evo_cli/commands/gdrive.py
+evo_cli/commands/gh.py
 evo_cli/commands/localproxy.py
 evo_cli/commands/mcp.py
 evo_cli/commands/miniconda.py
@@ -32,9 +34,11 @@ evo_cli/commands/ssh.py
 evo_cli/commands/sysmon.py
 evo_cli/commands/wifi.py
 tests/__init__.py
+tests/test_claude_code.py
 tests/test_cli.py
 tests/test_console.py
 tests/test_fix_claude.py
+tests/test_gh.py
 tests/test_mcp.py
 tests/test_opencode.py
 tests/test_plantuml.py

evo_cli-0.11.0/tests/test_claude_code.py

@@ -0,0 +1,228 @@
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands import claude_code
+from evo_cli.commands.claude_code import (
+    DEFAULT_MCP_SERVERS,
+    configure_mcp_servers,
+    install_attempts,
+    install_claude,
+    native_install_command,
+    npm_install_command,
+)
+from evo_cli.mcp_registry import MCP_REGISTRY
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def test_claude_command_is_registered():
+    assert "setup" in cli.commands
+    assert "claude" in cli.commands["setup"].commands
+
+
+def test_claude_help_runs(runner):
+    result = runner.invoke(cli, ["setup", "claude", "--help"])
+    assert result.exit_code == 0
+    assert "Claude Code" in result.output
+
+
+def test_default_mcp_servers_are_in_the_library():
+    for name in DEFAULT_MCP_SERVERS:
+        assert name in MCP_REGISTRY
+
+
+def test_native_install_command_posix(monkeypatch):
+    monkeypatch.setattr(claude_code, "is_windows", lambda: False)
+    assert native_install_command() == ["bash", "-c", "curl -fsSL https://claude.ai/install.sh | bash"]
+
+
+def test_native_install_command_pins_version(monkeypatch):
+    monkeypatch.setattr(claude_code, "is_windows", lambda: False)
+    assert native_install_command("2.1.153")[-1].endswith("| bash -s 2.1.153")
+
+
+def test_native_install_command_windows(monkeypatch):
+    monkeypatch.setattr(claude_code, "is_windows", lambda: True)
+    command = native_install_command()
+    assert command[0] == "powershell"
+    assert "install.ps1" in command[-1]
+
+
+def test_npm_install_command():
+    assert npm_install_command() == ["npm", "install", "-g", "@anthropic-ai/claude-code"]
+    assert npm_install_command("2.1.153")[-1] == "@anthropic-ai/claude-code@2.1.153"
+
+
+def test_install_attempts_auto_falls_back_to_npm(monkeypatch):
+    """With the native installer unusable, `auto` still has npm to fall back on."""
+    monkeypatch.setattr(claude_code, "native_install_available", lambda version=None: False)
+    monkeypatch.setattr(claude_code.shutil, "which", lambda name: "/usr/bin/npm")
+    labels = [label for label, _ in install_attempts("auto", None)]
+    assert labels == ["npm"]
+
+
+def test_install_attempts_native_only_skips_npm(monkeypatch):
+    monkeypatch.setattr(claude_code, "native_install_available", lambda version=None: True)
+    monkeypatch.setattr(claude_code, "is_windows", lambda: False)
+    labels = [label for label, _ in install_attempts("native", None)]
+    assert labels == ["native installer"]
+
+
+def test_native_install_unavailable_when_pinning_on_windows(monkeypatch):
+    """install.ps1 takes no version argument, so a pinned version must go via npm."""
+    monkeypatch.setattr(claude_code, "is_windows", lambda: True)
+    monkeypatch.setattr(claude_code.shutil, "which", lambda name: "/usr/bin/powershell")
+    assert claude_code.native_install_available() is True
+    assert claude_code.native_install_available("2.1.153") is False
+
+
+def test_install_claude_skips_when_already_present(monkeypatch):
+    calls = []
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 153))
+    monkeypatch.setattr(claude_code, "run_command", lambda *a, **kw: calls.append(a))
+
+    assert install_claude() is True
+    assert calls == []
+
+
+def test_install_claude_reinstall_runs_the_installer(monkeypatch):
+    calls = []
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 153))
+    monkeypatch.setattr(claude_code, "install_attempts", lambda m, v: [("npm", ["npm", "install"])])
+    monkeypatch.setattr(claude_code, "run_command", lambda cmd, **kw: calls.append(cmd))
+
+    assert install_claude(reinstall=True) is True
+    assert calls == [["npm", "install"]]
+
+
+def test_install_claude_falls_back_after_a_failure(monkeypatch):
+    """A failing native install must not abort the run; npm is still tried."""
+    calls = []
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: None if not calls else "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 153))
+    monkeypatch.setattr(
+        claude_code,
+        "install_attempts",
+        lambda m, v: [("native installer", ["bash", "-c", "boom"]), ("npm", ["npm", "install"])],
+    )
+
+    def fake_run(cmd, **kwargs):
+        calls.append(cmd)
+        if cmd[0] == "bash":
+            raise claude_code.CommandError("native failed")
+
+    monkeypatch.setattr(claude_code, "run_command", fake_run)
+
+    assert install_claude() is True
+    assert calls == [["bash", "-c", "boom"], ["npm", "install"]]
+
+
+def test_install_claude_reports_failure_when_nothing_works(monkeypatch):
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: None)
+    monkeypatch.setattr(claude_code, "install_attempts", lambda m, v: [])
+    assert install_claude() is False
+
+
+def test_configure_mcp_servers_passes_registry_specs(monkeypatch):
+    seen = []
+
+    def fake_add(name, spec, scope):
+        seen.append((name, spec, scope))
+        return True
+
+    monkeypatch.setattr(claude_code, "add_to_claude", fake_add)
+    added = configure_mcp_servers(["playwright"], "user")
+
+    assert added == ["playwright"]
+    assert seen == [("playwright", MCP_REGISTRY["playwright"], "user")]
+
+
+def test_configure_mcp_servers_omits_failures(monkeypatch):
+    monkeypatch.setattr(claude_code, "add_to_claude", lambda name, spec, scope: name != "context7")
+    assert configure_mcp_servers(["playwright", "context7"], "user") == ["playwright"]
+
+
+def test_unknown_mcp_server_is_rejected(runner, monkeypatch):
+    monkeypatch.setattr(claude_code, "run_setup_claude", lambda *a, **kw: pytest.fail("must not run"))
+    result = runner.invoke(cli, ["setup", "claude", "--mcp", "nope"])
+    assert result.exit_code == 0
+    assert "Unknown MCP server" in result.output
+
+
+def test_skip_install_without_claude_does_nothing(runner, monkeypatch):
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: None)
+    monkeypatch.setattr(claude_code, "configure_mcp_servers", lambda *a: pytest.fail("must not configure"))
+    monkeypatch.setattr(claude_code, "run_doctor", lambda: pytest.fail("must not run doctor"))
+
+    result = runner.invoke(cli, ["setup", "claude", "--skip-install", "--no-gh"])
+    assert result.exit_code == 0
+    assert "not found on PATH" in result.output
+
+
+def test_no_mcp_skips_registration(runner, monkeypatch):
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 200))
+    monkeypatch.setattr(claude_code, "configure_mcp_servers", lambda *a: pytest.fail("must not configure"))
+    monkeypatch.setattr(claude_code, "run_doctor", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "claude", "--skip-install", "--no-mcp", "--no-gh"])
+    assert result.exit_code == 0
+    assert "Skipping MCP registration" in result.output
+
+
+def test_setup_installs_gh_by_default(runner, monkeypatch):
+    """Claude Code shells out to gh for PRs, so a plain run must set it up too."""
+    calls = []
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 200))
+    monkeypatch.setattr(claude_code, "install_gh", lambda: calls.append("install") or True)
+    monkeypatch.setattr(claude_code, "check_gh_auth", lambda: calls.append("auth") or True)
+    monkeypatch.setattr(claude_code, "run_doctor", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "claude", "--skip-install", "--no-mcp"])
+    assert result.exit_code == 0
+    assert calls == ["install", "auth"]
+
+
+def test_no_gh_skips_the_github_cli(runner, monkeypatch):
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 200))
+    monkeypatch.setattr(claude_code, "install_gh", lambda: pytest.fail("must not install gh"))
+    monkeypatch.setattr(claude_code, "run_doctor", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "claude", "--skip-install", "--no-mcp", "--no-gh"])
+    assert result.exit_code == 0
+    assert "Skipping the GitHub CLI" in result.output
+
+
+def test_setup_github_cli_states(monkeypatch):
+    monkeypatch.setattr(claude_code, "install_gh", lambda: False)
+    monkeypatch.setattr(claude_code, "check_gh_auth", lambda: pytest.fail("must not check a missing gh"))
+    assert claude_code.setup_github_cli() == "missing"
+
+    monkeypatch.setattr(claude_code, "install_gh", lambda: True)
+    monkeypatch.setattr(claude_code, "check_gh_auth", lambda: False)
+    assert claude_code.setup_github_cli() == "unauthenticated"
+
+    monkeypatch.setattr(claude_code, "check_gh_auth", lambda: True)
+    assert claude_code.setup_github_cli() == "ready"
+
+
+def test_failed_gh_install_does_not_block_claude_setup(runner, monkeypatch):
+    """gh is a companion tool: losing it must not fail the Claude Code setup."""
+    monkeypatch.setattr(claude_code, "ensure_claude_on_path", lambda: "/usr/bin/claude")
+    monkeypatch.setattr(claude_code, "probe_version", lambda: (2, 1, 200))
+    monkeypatch.setattr(claude_code, "install_gh", lambda: False)
+    monkeypatch.setattr(claude_code, "configure_mcp_servers", lambda *a: ["playwright"])
+    monkeypatch.setattr(claude_code, "run_doctor", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "claude", "--skip-install"])
+    assert result.exit_code == 0
+    assert "setup claude complete" in result.output
+    assert "evo setup gh" in result.output

evo_cli-0.11.0/tests/test_gh.py

@@ -0,0 +1,146 @@
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands import gh as gh_mod
+from evo_cli.commands.gh import check_gh_auth, gh_version, install_command, install_gh
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def only_which(*available):
+    """A shutil.which stub that finds only the named binaries."""
+    return lambda name: f"/usr/bin/{name}" if name in available else None
+
+
+def test_gh_command_is_registered():
+    assert "gh" in cli.commands["setup"].commands
+
+
+def test_gh_help_runs(runner):
+    result = runner.invoke(cli, ["setup", "gh", "--help"])
+    assert result.exit_code == 0
+    assert "GitHub CLI" in result.output
+
+
+def test_install_command_macos_uses_brew(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("brew"))
+    assert install_command() == ["brew", "install", "gh"]
+
+
+def test_install_command_macos_without_brew(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
+    assert install_command() is None
+
+
+def test_install_command_apt_adds_github_repo(monkeypatch):
+    """gh is not in the default Debian/Ubuntu repos, so the keyring must be set up."""
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("apt-get"))
+    command = install_command()
+    assert command[:2] == ["bash", "-c"]
+    assert "githubcli-archive-keyring.gpg" in command[2]
+    assert "sudo apt install gh -y" in command[2]
+
+
+def test_install_command_pacman(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("pacman"))
+    assert install_command() == ["sudo", "pacman", "-S", "--noconfirm", "github-cli"]
+
+
+def test_install_command_linux_without_package_manager(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
+    assert install_command() is None
+
+
+def test_install_command_windows_winget_is_non_interactive(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("winget"))
+    command = install_command()
+    assert command[:4] == ["winget", "install", "--id", "GitHub.cli"]
+    assert "--accept-package-agreements" in command
+
+
+def test_install_command_windows_falls_back_to_scoop(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("scoop"))
+    assert install_command() == ["scoop", "install", "gh"]
+
+
+def test_gh_version_none_when_missing(monkeypatch):
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
+    assert gh_version() is None
+
+
+def test_install_gh_skips_when_present(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
+    assert install_gh() is True
+
+
+def test_install_gh_reinstall_runs_the_installer(monkeypatch):
+    calls = []
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: calls.append(cmd))
+    assert install_gh(reinstall=True) is True
+    assert calls == [["brew", "install", "gh"]]
+
+
+def test_install_gh_fails_without_package_manager(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: None)
+    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
+    assert install_gh() is False
+
+
+def test_install_gh_reports_failed_install(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
+
+    def boom(cmd, **kwargs):
+        raise gh_mod.CommandError("brew exploded")
+
+    monkeypatch.setattr(gh_mod, "run_command", boom)
+    assert install_gh() is False
+
+
+def test_install_gh_detects_binary_not_on_path(monkeypatch):
+    """A package manager can succeed while the binary is still not reachable."""
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: None)
+    assert install_gh() is False
+
+
+class FakeResult:
+    def __init__(self, returncode):
+        self.returncode = returncode
+
+
+def test_check_gh_auth_signed_in(monkeypatch):
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(0))
+    assert check_gh_auth() is True
+
+
+def test_check_gh_auth_signed_out(monkeypatch):
+    """`gh auth status` exits non-zero when logged out; that must not be fatal."""
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(1))
+    assert check_gh_auth() is False
+
+
+def test_setup_gh_skip_auth_check(runner, monkeypatch):
+    monkeypatch.setattr(gh_mod, "install_gh", lambda reinstall: True)
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "check_gh_auth", lambda: pytest.fail("must not check auth"))
+
+    result = runner.invoke(cli, ["setup", "gh", "--skip-auth-check"])
+    assert result.exit_code == 0
+    assert "Auth check skipped" in result.output

evo_cli-0.10.3/evo_cli/VERSION

@@ -1 +0,0 @@
-0.10.3