bingo-light 2.0.0

package/bingo_core/setup.py

@@ -0,0 +1,549 @@
+"""
+bingo_core.setup — Interactive setup wizard for configuring MCP across AI tools.
+
+Detects installed AI coding tools, presents a multi-select menu, and writes
+the correct MCP server configuration for each selected tool.
+
+Python 3.8+ stdlib only. Uses termios for raw input on Unix.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+
+# ─── AI Tool Definitions ────────────────────────────────────────────────────
+
+
+@dataclass
+class AITool:
+    """Describes one AI coding tool that supports MCP."""
+
+    id: str
+    name: str
+    config_path: str  # with ~ or env vars, expanded at runtime
+    top_key: str  # JSON key wrapping the server entry
+    detect_dirs: List[str] = field(default_factory=list)
+    detect_cmds: List[str] = field(default_factory=list)
+    extra_fields: Dict[str, Any] = field(default_factory=dict)
+    note: str = ""
+
+    def expand_path(self) -> str:
+        return os.path.expandvars(os.path.expanduser(self.config_path))
+
+    def is_detected(self) -> bool:
+        for d in self.detect_dirs:
+            if os.path.isdir(os.path.expanduser(d)):
+                return True
+        for c in self.detect_cmds:
+            if shutil.which(c):
+                return True
+        return False
+
+
+def _get_tools() -> List[AITool]:
+    """Return the list of all supported AI tools."""
+    is_mac = platform.system() == "Darwin"
+    is_win = platform.system() == "Windows"
+
+    tools = [
+        AITool(
+            id="claude-code",
+            name="Claude Code",
+            config_path="~/.claude/settings.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.claude"],
+            detect_cmds=["claude"],
+        ),
+        AITool(
+            id="claude-desktop",
+            name="Claude Desktop",
+            config_path=(
+                "~/Library/Application Support/Claude/claude_desktop_config.json"
+                if is_mac
+                else "%APPDATA%\\Claude\\claude_desktop_config.json"
+                if is_win
+                else ""
+            ),
+            top_key="mcpServers",
+            detect_dirs=(
+                ["~/Library/Application Support/Claude"] if is_mac
+                else ["%APPDATA%\\Claude"] if is_win
+                else []
+            ),
+        ),
+        AITool(
+            id="cursor",
+            name="Cursor",
+            config_path="~/.cursor/mcp.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.cursor"],
+            detect_cmds=["cursor"],
+        ),
+        AITool(
+            id="windsurf",
+            name="Windsurf",
+            config_path="~/.codeium/windsurf/mcp_config.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.codeium/windsurf"],
+        ),
+        AITool(
+            id="vscode-copilot",
+            name="VS Code / Copilot",
+            config_path="~/.vscode/mcp.json",
+            top_key="servers",
+            detect_dirs=["~/.vscode"],
+            detect_cmds=["code"],
+            extra_fields={"type": "stdio"},
+            note="Also supports .vscode/mcp.json per project",
+        ),
+        AITool(
+            id="cline",
+            name="Cline",
+            config_path="~/.vscode/cline_mcp_settings.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.vscode"],
+            note="Managed by Cline extension; edit via MCP Servers panel",
+        ),
+        AITool(
+            id="roo-code",
+            name="Roo Code",
+            config_path="~/.vscode/roo_mcp_settings.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.vscode"],
+            note="Managed by Roo Code extension; edit via settings",
+        ),
+        AITool(
+            id="zed",
+            name="Zed",
+            config_path="~/.config/zed/settings.json",
+            top_key="context_servers",
+            detect_dirs=["~/.config/zed"],
+            detect_cmds=["zed"],
+        ),
+        AITool(
+            id="gemini-cli",
+            name="Gemini CLI",
+            config_path="~/.gemini/settings.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.gemini"],
+            detect_cmds=["gemini"],
+        ),
+        AITool(
+            id="amazon-q",
+            name="Amazon Q Developer",
+            config_path="~/.aws/amazonq/mcp.json",
+            top_key="mcpServers",
+            detect_dirs=["~/.aws/amazonq"],
+        ),
+    ]
+
+    # Filter out tools with empty config paths (e.g. Claude Desktop on Linux)
+    return [t for t in tools if t.config_path]
+
+
+# ─── MCP Server Path Detection ──────────────────────────────────────────────
+
+
+def find_mcp_server() -> Tuple[str, List[str]]:
+    """Find the MCP server command and args.
+
+    Returns (command, args) tuple. Tries:
+    1. Installed `bingo-light-mcp` on PATH
+    2. mcp-server.py next to the running script
+    3. mcp-server.py next to bingo_core package
+    """
+    # 1. Installed binary on PATH
+    for name in ("bingo-light-mcp", "mcp-server.py"):
+        mcp_bin = shutil.which(name)
+        if mcp_bin:
+            return ("python3", [mcp_bin])
+
+    # 2. Relative to running script
+    script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+    candidate = os.path.join(script_dir, "mcp-server.py")
+    if os.path.isfile(candidate):
+        return ("python3", [candidate])
+
+    # 3. Relative to bingo_core package
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    candidate = os.path.join(os.path.dirname(pkg_dir), "mcp-server.py")
+    if os.path.isfile(candidate):
+        return ("python3", [candidate])
+
+    # Fallback
+    return ("python3", ["bingo-light-mcp"])
+
+
+# ─── Config Writer ───────────────────────────────────────────────────────────
+
+
+def write_mcp_config(
+    tool: AITool,
+    command: str,
+    args: List[str],
+    server_name: str = "bingo-light",
+) -> Dict[str, Any]:
+    """Write MCP server config for one AI tool.
+
+    Returns dict with ok, tool, config_path, action (created|updated|error).
+    """
+    config_path = tool.expand_path()
+    config_dir = os.path.dirname(config_path)
+
+    try:
+        os.makedirs(config_dir, exist_ok=True)
+    except OSError as e:
+        return {"ok": False, "tool": tool.id, "error": str(e)}
+
+    # Read existing config
+    data: Dict[str, Any] = {}
+    if os.path.isfile(config_path):
+        try:
+            with open(config_path) as f:
+                data = json.load(f)
+            action = "updated"
+        except (json.JSONDecodeError, OSError):
+            data = {}
+            action = "created"
+    else:
+        action = "created"
+
+    # Build the server entry
+    entry: Dict[str, Any] = {"command": command, "args": args}
+    entry.update(tool.extra_fields)
+
+    # Write under the correct top-level key
+    servers = data.setdefault(tool.top_key, {})
+    already = server_name in servers
+    servers[server_name] = entry
+
+    try:
+        with open(config_path, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+    except OSError as e:
+        return {"ok": False, "tool": tool.id, "error": str(e)}
+
+    return {
+        "ok": True,
+        "tool": tool.id,
+        "name": tool.name,
+        "config_path": config_path,
+        "action": "unchanged" if already else action,
+    }
+
+
+# ─── Interactive Multi-Select ────────────────────────────────────────────────
+
+
+def _tildify(path: str) -> str:
+    home = os.path.expanduser("~")
+    if path.startswith(home + os.sep):
+        return "~" + path[len(home):]
+    if path == home:
+        return "~"
+    return path
+
+
+def _read_key() -> str:
+    """Read a single keypress (including escape sequences) from /dev/tty."""
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        ch = sys.stdin.read(1)
+        if ch == "\x1b":
+            ch2 = sys.stdin.read(1)
+            if ch2 == "[":
+                ch3 = sys.stdin.read(1)
+                return f"\x1b[{ch3}"
+            return ch + ch2
+        return ch
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+def _read_key_tty() -> str:
+    """Read a keypress from /dev/tty (works even when stdin is piped)."""
+    import termios
+    import tty
+
+    try:
+        fd = os.open("/dev/tty", os.O_RDONLY)
+    except OSError:
+        return _read_key()
+
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        ch = os.read(fd, 1).decode("utf-8", errors="replace")
+        if ch == "\x1b":
+            ch2 = os.read(fd, 1).decode("utf-8", errors="replace")
+            if ch2 == "[":
+                ch3 = os.read(fd, 1).decode("utf-8", errors="replace")
+                return f"\x1b[{ch3}"
+            return ch + ch2
+        return ch
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        os.close(fd)
+
+
+def multiselect(
+    items: List[Dict[str, Any]],
+    pre_selected: Optional[List[int]] = None,
+) -> List[int]:
+    """Interactive multi-select with arrow keys and spacebar.
+
+    items: list of {"label": str, "hint": str, "detected": bool}
+    pre_selected: indices that start checked
+
+    Returns list of selected indices.
+    """
+    out = sys.stderr
+    selected = set(pre_selected or [])
+    cursor = 0
+    n = len(items)
+
+    def render():
+        for i, item in enumerate(items):
+            prefix = " >" if i == cursor else "  "
+            check = "\033[32m[x]\033[0m" if i in selected else "[ ]"
+            label = item["label"]
+            hint = item.get("hint", "")
+            detected = item.get("detected", False)
+
+            if i == cursor:
+                label = f"\033[1m{label}\033[0m"
+
+            if hint:
+                if detected:
+                    hint_str = f"  \033[2m{hint}\033[0m"
+                else:
+                    hint_str = "  \033[2m(not detected)\033[0m"
+            else:
+                hint_str = ""
+
+            out.write(f"{prefix} {check} {label}{hint_str}\n")
+
+    def clear():
+        for _ in range(n):
+            out.write("\033[1A\033[2K")
+
+    # Hide cursor
+    out.write("\033[?25l")
+    out.flush()
+
+    try:
+        render()
+        out.flush()
+
+        while True:
+            key = _read_key_tty()
+
+            if key == "\x1b[A":  # Up
+                cursor = (cursor - 1) % n
+            elif key == "\x1b[B":  # Down
+                cursor = (cursor + 1) % n
+            elif key == " ":  # Space = toggle
+                if cursor in selected:
+                    selected.discard(cursor)
+                else:
+                    selected.add(cursor)
+            elif key == "a":  # Toggle all
+                if len(selected) == n:
+                    selected.clear()
+                else:
+                    selected = set(range(n))
+            elif key in ("\r", "\n"):  # Enter = confirm
+                clear()
+                # Show final state (non-interactive)
+                for i, item in enumerate(items):
+                    check = "\033[32m[x]\033[0m" if i in selected else "\033[2m[ ]\033[0m"
+                    label = item["label"]
+                    out.write(f"   {check} {label}\n")
+                out.flush()
+                return sorted(selected)
+            elif key in ("\x03", "\x04"):  # Ctrl-C / Ctrl-D
+                clear()
+                out.write("\033[?25h")
+                out.flush()
+                raise KeyboardInterrupt
+
+            clear()
+            render()
+            out.flush()
+    finally:
+        out.write("\033[?25h")
+        out.flush()
+
+
+# ─── Shell Completions ───────────────────────────────────────────────────────
+
+
+def detect_shell() -> str:
+    """Detect the user's shell."""
+    return os.path.basename(os.environ.get("SHELL", "sh"))
+
+
+def install_completions(shell: str, source_dir: str) -> Dict[str, Any]:
+    """Install shell completions. Returns result dict."""
+    home = os.path.expanduser("~")
+
+    if shell == "bash":
+        xdg = os.environ.get("XDG_DATA_HOME", os.path.join(home, ".local", "share"))
+        comp_dir = os.environ.get(
+            "BASH_COMPLETION_USER_DIR",
+            os.path.join(xdg, "bash-completion", "completions"),
+        )
+        src = os.path.join(source_dir, "completions", "bingo-light.bash")
+        dst = os.path.join(comp_dir, "bingo-light")
+    elif shell == "zsh":
+        comp_dir = os.path.join(home, ".zfunc")
+        src = os.path.join(source_dir, "completions", "bingo-light.zsh")
+        dst = os.path.join(comp_dir, "_bingo-light")
+    elif shell == "fish":
+        comp_dir = os.path.join(home, ".config", "fish", "completions")
+        src = os.path.join(source_dir, "completions", "bingo-light.fish")
+        dst = os.path.join(comp_dir, "bingo-light.fish")
+    else:
+        return {"ok": False, "shell": shell, "error": f"Unsupported shell: {shell}"}
+
+    if not os.path.isfile(src):
+        return {"ok": False, "shell": shell, "error": f"Completion file not found: {src}"}
+
+    try:
+        os.makedirs(comp_dir, exist_ok=True)
+        shutil.copy2(src, dst)
+    except OSError as e:
+        return {"ok": False, "shell": shell, "error": str(e)}
+
+    # For zsh, ensure fpath is set in .zshrc
+    if shell == "zsh":
+        zshrc = os.path.join(home, ".zshrc")
+        if os.path.isfile(zshrc):
+            with open(zshrc) as f:
+                content = f.read()
+            if ".zfunc" not in content:
+                with open(zshrc, "a") as f:
+                    f.write("\nfpath=(~/.zfunc $fpath)\nautoload -Uz compinit && compinit\n")
+
+    return {"ok": True, "shell": shell, "path": dst}
+
+
+# ─── Main Setup Flow ────────────────────────────────────────────────────────
+
+
+def run_setup(
+    yes: bool = False,
+    json_mode: bool = False,
+    no_completions: bool = False,
+) -> Dict[str, Any]:
+    """Run the interactive setup wizard.
+
+    Returns a result dict summarizing what was configured.
+    """
+    out = sys.stderr
+    tools = _get_tools()
+    command, args = find_mcp_server()
+    results: List[Dict[str, Any]] = []
+    is_tty = hasattr(sys.stderr, "isatty") and sys.stderr.isatty()
+
+    # ── Header ──
+    if not json_mode and is_tty:
+        out.write("\n  \033[1mbingo-light setup\033[0m\n")
+        out.write("  \033[2mConfigure MCP server for your AI tools\033[0m\n\n")
+        out.write(f"  MCP server: \033[2m{command} {' '.join(args)}\033[0m\n\n")
+
+    # ── Detect tools ──
+    items = []
+    detected_indices = []
+    for i, tool in enumerate(tools):
+        detected = tool.is_detected()
+        items.append({
+            "label": tool.name,
+            "hint": _tildify(tool.expand_path()),
+            "detected": detected,
+        })
+        if detected:
+            detected_indices.append(i)
+
+    # ── Select tools ──
+    if yes:
+        # Non-interactive: configure all detected tools
+        selected = detected_indices
+        if not json_mode and is_tty:
+            out.write("  Auto-configuring detected tools:\n")
+            for i in selected:
+                out.write(f"   \033[32m[x]\033[0m {tools[i].name}\n")
+            out.write("\n")
+    elif is_tty:
+        # Interactive multi-select
+        out.write("  Select tools to configure:\n")
+        out.write("  \033[2m↑/↓ navigate  SPACE select  a toggle all  ENTER confirm\033[0m\n\n")
+        selected = multiselect(items, pre_selected=detected_indices)
+        out.write("\n")
+    else:
+        # Non-TTY fallback: configure detected tools
+        selected = detected_indices
+
+    if not selected:
+        if not json_mode and is_tty:
+            out.write("  No tools selected.\n\n")
+        return {"ok": True, "configured": [], "skipped": True}
+
+    # ── Configure each selected tool ──
+    for idx in selected:
+        tool = tools[idx]
+        result = write_mcp_config(tool, command, args)
+        results.append(result)
+
+        if not json_mode and is_tty:
+            if result["ok"]:
+                path = _tildify(result["config_path"])
+                out.write(f"  \033[32m✓\033[0m {tool.name} → {path}\n")
+            else:
+                out.write(f"  \033[31mx\033[0m {tool.name}: {result.get('error', 'unknown error')}\n")
+
+    # ── Shell completions ──
+    if not no_completions:
+        shell = detect_shell()
+        # Find source dir (completions/ alongside bingo-light script)
+        script_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+        pkg_dir = os.path.dirname(os.path.abspath(__file__))
+        source_dir = script_dir if os.path.isdir(os.path.join(script_dir, "completions")) else os.path.dirname(pkg_dir)
+
+        if os.path.isdir(os.path.join(source_dir, "completions")):
+            comp_result = install_completions(shell, source_dir)
+            if not json_mode and is_tty:
+                if comp_result["ok"]:
+                    out.write(f"  \033[32m✓\033[0m {shell} completions installed\n")
+                else:
+                    out.write(f"  \033[2m⊘ {shell} completions: {comp_result.get('error', 'skipped')}\033[0m\n")
+
+    # ── Summary ──
+    configured = [r for r in results if r["ok"]]
+    failed = [r for r in results if not r["ok"]]
+
+    if not json_mode and is_tty:
+        out.write(f"\n  \033[1m\033[32m✓ {len(configured)} tool(s) configured\033[0m")
+        if failed:
+            out.write(f", \033[31m{len(failed)} failed\033[0m")
+        out.write("\n\n")
+
+    return {
+        "ok": len(failed) == 0,
+        "configured": [r["tool"] for r in configured],
+        "failed": [r["tool"] for r in failed],
+        "results": results,
+    }