second-opinion-mcp 0.3.0__tar.gz → 0.3.2__tar.gz

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/.gitignore

@@ -50,3 +50,4 @@ Thumbs.db
 
 # Distribution / packaging
 MANIFEST
+second_opinion.py

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: second-opinion-mcp
-Version: 0.3.0
+Version: 0.3.2
 Summary: Multi-model AI analysis for Claude - get second opinions from DeepSeek, Kimi, and OpenRouter
 Project-URL: Homepage, https://github.com/MarvinFS/second-opinion-mcp
 Project-URL: Repository, https://github.com/MarvinFS/second-opinion-mcp
@@ -279,6 +279,25 @@ Use code_review with focus_areas=["security", "error-handling", "performance"]
 Use code_review on directory="./src" with save_to="./docs/reviews"
 ```
 
+## Updating
+
+The server checks for updates on startup and notifies you if a new version is available.
+
+To update manually:
+
+```bash
+pipx upgrade second-opinion-mcp
+```
+
+Or reinstall:
+
+```bash
+pipx uninstall second-opinion-mcp
+pipx install second-opinion-mcp
+```
+
+Your API keys are preserved in the system keyring across updates.
+
 ## Uninstalling
 
 ```bash

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/README.md

@@ -241,6 +241,25 @@ Use code_review with focus_areas=["security", "error-handling", "performance"]
 Use code_review on directory="./src" with save_to="./docs/reviews"
 ```
 
+## Updating
+
+The server checks for updates on startup and notifies you if a new version is available.
+
+To update manually:
+
+```bash
+pipx upgrade second-opinion-mcp
+```
+
+Or reinstall:
+
+```bash
+pipx uninstall second-opinion-mcp
+pipx install second-opinion-mcp
+```
+
+Your API keys are preserved in the system keyring across updates.
+
 ## Uninstalling
 
 ```bash

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "second-opinion-mcp"
-version = "0.3.0"
+version = "0.3.2"
 description = "Multi-model AI analysis for Claude - get second opinions from DeepSeek, Kimi, and OpenRouter"
 requires-python = ">=3.10"
 readme = "README.md"

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/src/second_opinion_mcp/__init__.py

@@ -1,6 +1,6 @@
 """Second Opinion MCP Server - Multi-model AI analysis for Claude."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 __author__ = "MarvinFS"
 
 from second_opinion_mcp.server import mcp, second_opinion, challenge, code_review, consensus, review_synthesis

second_opinion_mcp-0.3.2/src/second_opinion_mcp/cli.py

@@ -0,0 +1,465 @@
+#!/usr/bin/env python3
+"""Interactive setup wizard for second-opinion-mcp."""
+import sys
+import platform
+
+try:
+    import questionary
+    from questionary import Style
+except ImportError:
+    print("Error: questionary not installed. Run: pip install questionary")
+    sys.exit(1)
+
+import keyring
+from keyring.errors import NoKeyringError
+
+# Provider configurations
+PROVIDERS = {
+    "deepseek": {
+        "name": "DeepSeek V3.2",
+        "description": "DeepSeek Reasoner with chain-of-thought reasoning",
+        "keyring_service": "second-opinion",
+        "keyring_name": "deepseek",
+        "key_hint": "https://platform.deepseek.com",
+        "key_prefix": "sk-",
+    },
+    "moonshot": {
+        "name": "Kimi K2.5 (Moonshot)",
+        "description": "Moonshot AI's Kimi with thinking mode",
+        "keyring_service": "second-opinion",
+        "keyring_name": "moonshot",
+        "key_hint": "https://platform.moonshot.cn",
+        "key_prefix": None,
+    },
+    "openrouter": {
+        "name": "OpenRouter",
+        "description": "Access 300+ models via unified API",
+        "keyring_service": "second-opinion",
+        "keyring_name": "openrouter",
+        "key_hint": "https://openrouter.ai/keys",
+        "key_prefix": "sk-or-",
+    },
+}
+
+# Custom style for questionary
+custom_style = Style([
+    ("qmark", "fg:cyan bold"),
+    ("question", "bold"),
+    ("answer", "fg:cyan"),
+    ("pointer", "fg:cyan bold"),
+    ("highlighted", "fg:cyan bold"),
+    ("selected", "fg:green"),
+])
+
+
+def check_keyring_available() -> tuple[bool, str]:
+    """Check if keyring backend is available and working."""
+    try:
+        # Try to access keyring - this will fail if no backend
+        backend = keyring.get_keyring()
+        backend_name = str(type(backend).__name__)
+
+        # Check for null/fail backends
+        if "Null" in backend_name or "Fail" in backend_name:
+            return False, backend_name
+
+        # Try a test write/read/delete to verify it works
+        test_service = "second-opinion-test"
+        test_key = "connectivity-check"
+        try:
+            keyring.set_password(test_service, test_key, "test")
+            result = keyring.get_password(test_service, test_key)
+            keyring.delete_password(test_service, test_key)
+            if result != "test":
+                return False, backend_name
+        except Exception:
+            return False, backend_name
+
+        return True, backend_name
+    except NoKeyringError:
+        return False, "NoKeyringError"
+    except Exception as e:
+        return False, str(e)
+
+
+def print_keyring_setup_instructions():
+    """Print instructions for setting up keyring on different platforms."""
+    print()
+    print("=" * 60)
+    print("  Keyring Backend Required")
+    print("=" * 60)
+    print()
+    print("second-opinion-mcp stores API keys securely in your system keyring.")
+    print("A keyring backend must be installed and configured first.")
+    print()
+
+    system = platform.system()
+
+    if system == "Linux":
+        print("For Linux, install one of these backends:")
+        print()
+        print("  Option 1 - Secret Service (GNOME/KDE desktop):")
+        print("    sudo apt install gnome-keyring  # or kde-wallet")
+        print("    pip install secretstorage")
+        print()
+        print("  Option 2 - Encrypted file (headless/server):")
+        print("    pip install keyrings.alt")
+        print("    mkdir -p ~/.local/share/python_keyring")
+        print("    cat > ~/.local/share/python_keyring/keyringrc.cfg << 'EOF'")
+        print("    [backend]")
+        print("    default-keyring=keyrings.alt.file.EncryptedKeyring")
+        print("    EOF")
+        print()
+        print("  Then run 'second-opinion-mcp setup' again.")
+
+    elif system == "Darwin":
+        print("For macOS, keyring should work automatically with Keychain.")
+        print("If you see this error, try:")
+        print()
+        print("  pip install keyring --upgrade")
+        print()
+        print("Then run 'second-opinion-mcp setup' again.")
+
+    else:
+        print("For Windows, keyring should work automatically with Credential Manager.")
+        print("If you see this error, try:")
+        print()
+        print("  pip install keyring --upgrade")
+        print()
+        print("Then run 'second-opinion-mcp setup' again.")
+
+    print()
+
+
+def print_manual_setup_instructions(providers: list[str] | None = None):
+    """Print instructions for manual keyring setup."""
+    print()
+    print("=" * 60)
+    print("  Manual API Key Setup")
+    print("=" * 60)
+    print()
+    print("IMPORTANT: You must configure at least 2 providers for the")
+    print("'consensus' tool to work. Single-provider mode is limited.")
+    print()
+    print("Run these commands to store your API keys:")
+    print()
+
+    target_providers = providers if providers else list(PROVIDERS.keys())
+
+    for provider in target_providers:
+        config = PROVIDERS[provider]
+        print(f"  # {config['name']} - Get key at {config['key_hint']}")
+        print(f"  python -c \"import keyring; keyring.set_password('{config['keyring_service']}', '{config['keyring_name']}', 'YOUR_API_KEY')\"")
+        print()
+
+    print("To verify your keys are stored:")
+    print()
+    print("  python -c \"import keyring; print('deepseek:', bool(keyring.get_password('second-opinion', 'deepseek'))); print('moonshot:', bool(keyring.get_password('second-opinion', 'moonshot')))\"")
+    print()
+    print("After configuring keys, register with Claude Code:")
+    print()
+
+    if providers and len(providers) >= 1:
+        providers_str = ",".join(providers)
+    else:
+        providers_str = "deepseek,moonshot"
+
+    print(f"  claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS=\"{providers_str}\" -- second-opinion-mcp")
+    print()
+
+
+def check_existing_keys() -> dict[str, bool]:
+    """Check which providers already have API keys configured."""
+    existing = {}
+    for provider, config in PROVIDERS.items():
+        try:
+            key = keyring.get_password(config["keyring_service"], config["keyring_name"])
+            existing[provider] = bool(key)
+        except Exception:
+            existing[provider] = False
+    return existing
+
+
+def count_configured_providers() -> int:
+    """Count how many providers have API keys configured."""
+    return sum(1 for v in check_existing_keys().values() if v)
+
+
+def store_api_key(provider: str, key: str) -> tuple[bool, str]:
+    """Store API key in system keyring. Returns (success, error_message)."""
+    config = PROVIDERS[provider]
+    try:
+        keyring.set_password(config["keyring_service"], config["keyring_name"], key)
+        return True, ""
+    except Exception as e:
+        return False, str(e)
+
+
+def validate_api_key(provider: str, key: str) -> tuple[bool, str]:
+    """Basic validation of API key format."""
+    if not key or not key.strip():
+        return False, "API key cannot be empty"
+
+    config = PROVIDERS[provider]
+    key = key.strip()
+
+    if config["key_prefix"] and not key.startswith(config["key_prefix"]):
+        return False, f"Key should start with '{config['key_prefix']}'"
+
+    if len(key) < 20:
+        return False, "Key seems too short"
+
+    return True, ""
+
+
+def get_registration_command(selected_providers: list[str]) -> str:
+    """Generate the registration command for Claude Code CLI."""
+    providers_env = ",".join(selected_providers)
+    return f'claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'
+
+
+def get_desktop_config(selected_providers: list[str]) -> str:
+    """Generate Claude Desktop configuration JSON."""
+    providers_env = ",".join(selected_providers)
+
+    return f'''{{
+  "mcpServers": {{
+    "second-opinion": {{
+      "command": "second-opinion-mcp",
+      "env": {{
+        "SECOND_OPINION_PROVIDERS": "{providers_env}"
+      }}
+    }}
+  }}
+}}'''
+
+
+def setup_wizard():
+    """Interactive setup wizard for second-opinion-mcp."""
+    print()
+    print("=" * 60)
+    print("  Second Opinion MCP - Setup Wizard")
+    print("=" * 60)
+    print()
+
+    # Check keyring availability first
+    keyring_ok, backend_info = check_keyring_available()
+
+    if not keyring_ok:
+        print(f"Keyring backend not available: {backend_info}")
+        print_keyring_setup_instructions()
+        print()
+        print("Alternatively, choose 'Manual setup' to get CLI commands.")
+        print()
+
+        choice = questionary.select(
+            "How would you like to proceed?",
+            choices=[
+                questionary.Choice("Manual setup (show CLI commands)", value="manual"),
+                questionary.Choice("Exit and fix keyring first", value="exit"),
+            ],
+            style=custom_style,
+        ).ask()
+
+        if choice == "manual" or choice is None:
+            print_manual_setup_instructions()
+        return
+
+    print("This wizard will help you configure API keys for AI providers.")
+    print("Keys are stored securely in your system keyring.")
+    print()
+
+    # Check existing configuration
+    existing = check_existing_keys()
+    configured_count = sum(1 for v in existing.values() if v)
+
+    if configured_count > 0:
+        configured = [p for p, has_key in existing.items() if has_key]
+        print(f"Already configured: {', '.join(configured)}")
+        if configured_count < 2:
+            print("Note: At least 2 providers required for 'consensus' tool.")
+        print()
+
+    # Setup method selection
+    setup_method = questionary.select(
+        "Setup method:",
+        choices=[
+            questionary.Choice("Interactive (enter keys now)", value="interactive"),
+            questionary.Choice("Manual (show CLI commands)", value="manual"),
+        ],
+        style=custom_style,
+    ).ask()
+
+    if setup_method is None:
+        print("Setup cancelled.")
+        return
+
+    if setup_method == "manual":
+        # Ask which providers they want to configure
+        choices = [
+            questionary.Choice(
+                f"{config['name']}" + (" (configured)" if existing.get(provider) else ""),
+                value=provider,
+                checked=not existing.get(provider)  # Pre-check unconfigured ones
+            )
+            for provider, config in PROVIDERS.items()
+        ]
+
+        selected = questionary.checkbox(
+            "Select providers to configure:",
+            choices=choices,
+            style=custom_style,
+        ).ask()
+
+        if not selected:
+            selected = list(PROVIDERS.keys())
+
+        print_manual_setup_instructions(selected)
+        return
+
+    # Interactive setup
+    choices = []
+    for provider, config in PROVIDERS.items():
+        label = config["name"]
+        if existing.get(provider):
+            label += " (configured)"
+        choices.append(questionary.Choice(label, value=provider, checked=not existing.get(provider)))
+
+    selected = questionary.checkbox(
+        "Select providers to configure (at least 2 required for consensus):",
+        choices=choices,
+        style=custom_style,
+        validate=lambda x: len(x) >= 1 or "Select at least one provider",
+    ).ask()
+
+    if not selected:
+        print("Setup cancelled.")
+        return
+
+    # Warn about single provider
+    total_will_have = len([p for p in selected if not existing.get(p)]) + configured_count
+    if total_will_have < 2 and len(selected) < 2:
+        print()
+        print("WARNING: You need at least 2 providers for the 'consensus' tool.")
+        print("With only 1 provider, only basic tools will be available.")
+        proceed = questionary.confirm(
+            "Continue anyway?",
+            default=False,
+            style=custom_style,
+        ).ask()
+        if not proceed:
+            return setup_wizard()
+
+    print()
+
+    # Configure API keys
+    keyring_error_shown = False
+    for provider in selected:
+        config = PROVIDERS[provider]
+
+        if existing.get(provider):
+            update = questionary.confirm(
+                f"{config['name']} already configured. Update API key?",
+                default=False,
+                style=custom_style,
+            ).ask()
+            if not update:
+                continue
+
+        print(f"\n{config['name']}")
+        print(f"  Get your key at: {config['key_hint']}")
+
+        while True:
+            key = questionary.password(
+                "  Enter API key:",
+                style=custom_style,
+            ).ask()
+
+            if key is None:
+                print("  Skipped.")
+                break
+
+            valid, error = validate_api_key(provider, key)
+            if not valid:
+                print(f"  {error}")
+                retry = questionary.confirm("Try again?", default=True, style=custom_style).ask()
+                if not retry:
+                    break
+                continue
+
+            success, store_error = store_api_key(provider, key.strip())
+            if success:
+                print("  Key stored successfully.")
+                break
+            else:
+                print(f"  Error storing key: {store_error}")
+                if not keyring_error_shown:
+                    keyring_error_shown = True
+                    print()
+                    print("  Keyring storage failed. You may need to configure a backend.")
+                    show_manual = questionary.confirm(
+                        "  Show manual setup instructions?",
+                        default=True,
+                        style=custom_style,
+                    ).ask()
+                    if show_manual:
+                        print_manual_setup_instructions(selected)
+                        return
+                break
+
+    # Check final configuration
+    final_existing = check_existing_keys()
+    configured = [p for p, has_key in final_existing.items() if has_key]
+
+    print()
+    print("=" * 60)
+    print("  Setup Complete!")
+    print("=" * 60)
+    print()
+
+    if not configured:
+        print("No API keys were configured.")
+        print("Run 'second-opinion-mcp setup' to try again.")
+        return
+
+    print(f"Configured providers: {', '.join(configured)}")
+
+    if len(configured) < 2:
+        print()
+        print("WARNING: Only 1 provider configured. The 'consensus' tool requires 2+.")
+        print("Run 'second-opinion-mcp setup' to add more providers.")
+
+    print()
+    print("Register with Claude Code CLI:")
+    print()
+    print(f"  {get_registration_command(configured)}")
+    print()
+
+    # Show desktop config option
+    show_desktop = questionary.confirm(
+        "Show Claude Desktop configuration?",
+        default=False,
+        style=custom_style,
+    ).ask()
+
+    if show_desktop:
+        print()
+        print("Add this to your claude_desktop_config.json:")
+        print()
+        print(get_desktop_config(configured))
+        print()
+        if platform.system() == "Windows":
+            print("Location: %APPDATA%\\Claude\\claude_desktop_config.json")
+        elif platform.system() == "Darwin":
+            print("Location: ~/Library/Application Support/Claude/claude_desktop_config.json")
+        else:
+            print("Location: ~/.config/Claude/claude_desktop_config.json")
+
+    print()
+    print("Test the server with:")
+    print("  second-opinion-mcp")
+    print()
+
+
+if __name__ == "__main__":
+    setup_wizard()

{second_opinion_mcp-0.3.0 → second_opinion_mcp-0.3.2}/src/second_opinion_mcp/server.py

@@ -1523,13 +1523,121 @@ def _sync_cleanup():
 atexit.register(_sync_cleanup)
 
 
+def _check_provider_keys() -> tuple[list[str], list[str]]:
+    """Check which enabled providers have API keys configured.
+
+    Returns:
+        (configured_providers, missing_providers) tuple
+    """
+    configured = []
+    missing = []
+
+    for provider, config in MODELS.items():
+        if not config.get("enabled"):
+            continue
+
+        try:
+            key = keyring.get_password(config["keyring_service"], config["keyring_name"])
+            if key:
+                configured.append(provider)
+            else:
+                missing.append(provider)
+        except Exception:
+            missing.append(provider)
+
+    return configured, missing
+
+
+def _validate_startup_requirements() -> tuple[bool, str]:
+    """Validate that minimum requirements are met to run the server.
+
+    Returns:
+        (ok, error_message) tuple. If ok is False, server should not start.
+    """
+    configured, missing = _check_provider_keys()
+
+    if len(configured) == 0:
+        return False, (
+            "No API keys configured. Run 'second-opinion-mcp setup' to configure providers.\n\n"
+            "Or manually configure keys:\n"
+            "  python -c \"import keyring; keyring.set_password('second-opinion', 'deepseek', 'YOUR_KEY')\"\n"
+            "  python -c \"import keyring; keyring.set_password('second-opinion', 'moonshot', 'YOUR_KEY')\"\n"
+        )
+
+    if len(configured) == 1:
+        return False, (
+            f"Only 1 provider configured ({configured[0]}). At least 2 providers required.\n\n"
+            "The 'consensus' tool requires multiple models to debate.\n"
+            "Run 'second-opinion-mcp setup' to add another provider.\n\n"
+            f"Missing: {', '.join(missing) if missing else 'none enabled'}\n"
+        )
+
+    return True, ""
+
+
+def _check_for_updates() -> tuple[str | None, str | None]:
+    """Check PyPI for newer version of second-opinion-mcp.
+
+    Returns:
+        (latest_version, current_version) if update available, (None, None) otherwise.
+    """
+    import urllib.request
+    import json
+
+    try:
+        from second_opinion_mcp import __version__ as current_version
+    except ImportError:
+        current_version = "0.0.0"
+
+    try:
+        # Quick timeout to not delay startup
+        url = "https://pypi.org/pypi/second-opinion-mcp/json"
+        req = urllib.request.Request(url, headers={"User-Agent": "second-opinion-mcp"})
+        with urllib.request.urlopen(req, timeout=3) as response:
+            data = json.loads(response.read().decode())
+            latest_version = data.get("info", {}).get("version", "0.0.0")
+
+            # Simple version comparison (works for semver)
+            def parse_version(v: str) -> tuple[int, ...]:
+                return tuple(int(x) for x in v.split(".")[:3] if x.isdigit())
+
+            if parse_version(latest_version) > parse_version(current_version):
+                return latest_version, current_version
+
+    except Exception:
+        # Don't fail startup on update check errors
+        pass
+
+    return None, None
+
+
 def main():
     """Run the MCP server with stdio transport."""
+    import sys
+
     # Configure logging when run directly (not when imported as library)
     logging.basicConfig(
         level=logging.INFO,
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
     )
+
+    # Check for updates (non-blocking, quick timeout)
+    latest, current = _check_for_updates()
+    if latest:
+        print(f"Update available: {current} -> {latest}", file=sys.stderr)
+        print("Run: pipx upgrade second-opinion-mcp", file=sys.stderr)
+        print(file=sys.stderr)
+
+    # Validate minimum requirements
+    ok, error = _validate_startup_requirements()
+    if not ok:
+        print(f"Error: {error}", file=sys.stderr)
+        sys.exit(1)
+
+    # Log configured providers
+    configured, _ = _check_provider_keys()
+    logger.info("Starting with providers: %s", ", ".join(configured))
+
     mcp.run(transport="stdio")
 
 

second_opinion_mcp-0.3.0/src/second_opinion_mcp/cli.py

@@ -1,272 +0,0 @@
-#!/usr/bin/env python3
-"""Interactive setup wizard for second-opinion-mcp."""
-import sys
-import platform
-
-try:
-    import questionary
-    from questionary import Style
-except ImportError:
-    print("Error: questionary not installed. Run: pip install questionary")
-    sys.exit(1)
-
-import keyring
-
-# Provider configurations
-PROVIDERS = {
-    "deepseek": {
-        "name": "DeepSeek V3.2",
-        "description": "DeepSeek Reasoner with chain-of-thought reasoning",
-        "keyring_service": "second-opinion",
-        "keyring_name": "deepseek",
-        "key_hint": "Get your key at https://platform.deepseek.com",
-        "key_prefix": "sk-",
-    },
-    "moonshot": {
-        "name": "Kimi K2.5 (Moonshot)",
-        "description": "Moonshot AI's Kimi with thinking mode",
-        "keyring_service": "second-opinion",
-        "keyring_name": "moonshot",
-        "key_hint": "Get your key at https://platform.moonshot.cn",
-        "key_prefix": None,
-    },
-    "openrouter": {
-        "name": "OpenRouter",
-        "description": "Access 300+ models via unified API",
-        "keyring_service": "second-opinion",
-        "keyring_name": "openrouter",
-        "key_hint": "Get your key at https://openrouter.ai/keys",
-        "key_prefix": "sk-or-",
-    },
-}
-
-# Custom style for questionary
-custom_style = Style([
-    ("qmark", "fg:cyan bold"),
-    ("question", "bold"),
-    ("answer", "fg:cyan"),
-    ("pointer", "fg:cyan bold"),
-    ("highlighted", "fg:cyan bold"),
-    ("selected", "fg:green"),
-])
-
-
-def check_existing_keys() -> dict[str, bool]:
-    """Check which providers already have API keys configured."""
-    existing = {}
-    for provider, config in PROVIDERS.items():
-        try:
-            key = keyring.get_password(config["keyring_service"], config["keyring_name"])
-            existing[provider] = bool(key)
-        except Exception:
-            existing[provider] = False
-    return existing
-
-
-def store_api_key(provider: str, key: str) -> bool:
-    """Store API key in system keyring."""
-    config = PROVIDERS[provider]
-    try:
-        keyring.set_password(config["keyring_service"], config["keyring_name"], key)
-        return True
-    except Exception as e:
-        print(f"Error storing key: {e}")
-        return False
-
-
-def validate_api_key(provider: str, key: str) -> tuple[bool, str]:
-    """Basic validation of API key format."""
-    if not key or not key.strip():
-        return False, "API key cannot be empty"
-
-    config = PROVIDERS[provider]
-    key = key.strip()
-
-    if config["key_prefix"] and not key.startswith(config["key_prefix"]):
-        return False, f"Key should start with '{config['key_prefix']}'"
-
-    if len(key) < 20:
-        return False, "Key seems too short"
-
-    return True, ""
-
-
-def get_registration_command(selected_providers: list[str]) -> str:
-    """Generate the registration command for Claude Code CLI."""
-    providers_env = ",".join(selected_providers)
-
-    if platform.system() == "Windows":
-        return f'''claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'''
-    else:
-        return f'''claude mcp add -s user second-opinion -e SECOND_OPINION_PROVIDERS="{providers_env}" -- second-opinion-mcp'''
-
-
-def get_desktop_config(selected_providers: list[str]) -> str:
-    """Generate Claude Desktop configuration JSON."""
-    providers_env = ",".join(selected_providers)
-
-    return f'''{{
-  "mcpServers": {{
-    "second-opinion": {{
-      "command": "second-opinion-mcp",
-      "env": {{
-        "SECOND_OPINION_PROVIDERS": "{providers_env}"
-      }}
-    }}
-  }}
-}}'''
-
-
-def setup_wizard():
-    """Interactive setup wizard for second-opinion-mcp."""
-    print()
-    print("=" * 60)
-    print("  Second Opinion MCP - Setup Wizard")
-    print("=" * 60)
-    print()
-    print("This wizard will help you configure API keys for AI providers.")
-    print("Keys are stored securely in your system keyring.")
-    print()
-
-    # Check existing configuration
-    existing = check_existing_keys()
-    has_existing = any(existing.values())
-
-    if has_existing:
-        configured = [p for p, has_key in existing.items() if has_key]
-        print(f"Already configured: {', '.join(configured)}")
-        print()
-
-    # Provider selection
-    choices = []
-    for provider, config in PROVIDERS.items():
-        label = config["name"]
-        if existing.get(provider):
-            label += " (configured)"
-        choices.append(questionary.Choice(label, value=provider, checked=existing.get(provider, False)))
-
-    selected = questionary.checkbox(
-        "Select providers to configure (at least 2 recommended):",
-        choices=choices,
-        style=custom_style,
-        validate=lambda x: len(x) >= 1 or "Select at least one provider",
-    ).ask()
-
-    if not selected:
-        print("Setup cancelled.")
-        return
-
-    if len(selected) < 2:
-        print()
-        print("Note: Using 2+ providers enables the 'consensus' tool for multi-model debates.")
-        proceed = questionary.confirm(
-            "Continue with single provider?",
-            default=True,
-            style=custom_style,
-        ).ask()
-        if not proceed:
-            return setup_wizard()  # Restart
-
-    print()
-
-    # Configure API keys
-    for provider in selected:
-        config = PROVIDERS[provider]
-
-        if existing.get(provider):
-            update = questionary.confirm(
-                f"{config['name']} already configured. Update API key?",
-                default=False,
-                style=custom_style,
-            ).ask()
-            if not update:
-                continue
-
-        print(f"\n{config['name']}")
-        print(f"  {config['key_hint']}")
-
-        while True:
-            key = questionary.password(
-                f"  Enter API key:",
-                style=custom_style,
-            ).ask()
-
-            if key is None:  # User cancelled
-                print("  Skipped.")
-                break
-
-            valid, error = validate_api_key(provider, key)
-            if not valid:
-                print(f"  {error}")
-                retry = questionary.confirm("Try again?", default=True, style=custom_style).ask()
-                if not retry:
-                    break
-                continue
-
-            if store_api_key(provider, key.strip()):
-                print("  Key stored successfully.")
-            break
-
-    # Generate registration commands
-    print()
-    print("=" * 60)
-    print("  Setup Complete!")
-    print("=" * 60)
-    print()
-
-    # Filter to providers that now have keys
-    configured = []
-    for provider in selected:
-        try:
-            key = keyring.get_password(
-                PROVIDERS[provider]["keyring_service"],
-                PROVIDERS[provider]["keyring_name"]
-            )
-            if key:
-                configured.append(provider)
-        except Exception:
-            pass
-
-    if not configured:
-        print("No API keys were configured. Run 'second-opinion-mcp setup' to try again.")
-        return
-
-    print(f"Configured providers: {', '.join(configured)}")
-    print()
-
-    # Show registration command
-    print("For Claude Code CLI, run:")
-    print()
-    print(f"  {get_registration_command(configured)}")
-    print()
-
-    # Show desktop config
-    show_desktop = questionary.confirm(
-        "Show Claude Desktop configuration?",
-        default=False,
-        style=custom_style,
-    ).ask()
-
-    if show_desktop:
-        print()
-        print("Add this to your claude_desktop_config.json:")
-        print()
-        print(get_desktop_config(configured))
-        print()
-        if platform.system() == "Windows":
-            print("Location: %APPDATA%\\Claude\\claude_desktop_config.json")
-        elif platform.system() == "Darwin":
-            print("Location: ~/Library/Application Support/Claude/claude_desktop_config.json")
-        else:
-            print("Location: ~/.config/Claude/claude_desktop_config.json")
-
-    print()
-    print("Test the server with:")
-    print("  second-opinion-mcp")
-    print()
-    print("The server will start and wait for input. Press Ctrl+C to stop.")
-    print()
-
-
-if __name__ == "__main__":
-    setup_wizard()