mcp-vector-search 0.12.6__py3-none-any.whl → 1.1.22__py3-none-any.whl

mcp_vector_search/cli/commands/install.py

@@ -2,27 +2,39 @@
 
 This module provides installation commands for:
 1. Project initialization (main command)
-2. Platform-specific MCP integrations (subcommands)
+2. Platform-specific MCP integrations using py-mcp-installer library
 
 Examples:
     # Install in current project
     $ mcp-vector-search install
 
-    # Install Claude Code integration
-    $ mcp-vector-search install claude-code
+    # Install MCP integration (auto-detect platforms)
+    $ mcp-vector-search install mcp
 
-    # Install all available integrations
-    $ mcp-vector-search install --all
+    # Install to specific platform
+    $ mcp-vector-search install mcp --platform cursor
+
+    # Install to all detected platforms
+    $ mcp-vector-search install mcp --all
 """
 
 import asyncio
-import json
-import shutil
 from pathlib import Path
-from typing import Any
 
 import typer
 from loguru import logger
+
+# Import from py-mcp-installer library
+from py_mcp_installer import (
+    InstallationError,
+    InstallationResult,
+    MCPInspector,
+    MCPInstaller,
+    MCPServerConfig,
+    Platform,
+    PlatformDetector,
+    PlatformInfo,
+)
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -53,23 +65,25 @@ install_app = create_enhanced_typer(
      [code]$ mcp-vector-search install[/code]
 
   [green]2. MCP Platform Integration[/green]
-     Add MCP integration for specific platforms:
-     [code]$ mcp-vector-search install claude-code[/code]
-     [code]$ mcp-vector-search install cursor[/code]
-     [code]$ mcp-vector-search install windsurf[/code]
+     Add MCP integration with auto-detection:
+     [code]$ mcp-vector-search install mcp[/code]
+     [code]$ mcp-vector-search install mcp --platform cursor[/code]
+     [code]$ mcp-vector-search install mcp --all[/code]
 
   [green]3. Complete Setup[/green]
      Install project + all MCP integrations:
      [code]$ mcp-vector-search install --with-mcp[/code]
 
 [bold cyan]Supported Platforms:[/bold cyan]
-  • [green]claude-code[/green]     - Claude Code (project-scoped .mcp.json)
-  • [green]claude-desktop[/green]  - Claude Desktop (~/.claude/config.json)
-  • [green]cursor[/green]          - Cursor IDE (~/.cursor/mcp.json)
-  • [green]windsurf[/green]        - Windsurf IDE (~/.codeium/windsurf/mcp_config.json)
-  • [green]vscode[/green]          - VS Code (~/.vscode/mcp.json)
-
-[dim]💡 Use 'mcp-vector-search uninstall <platform>' to remove integrations[/dim]
+  • [green]claude-code[/green]     - Claude Code
+  • [green]claude-desktop[/green]  - Claude Desktop
+  • [green]cursor[/green]          - Cursor IDE
+  • [green]auggie[/green]          - Auggie
+  • [green]codex[/green]           - Codex
+  • [green]windsurf[/green]        - Windsurf IDE
+  • [green]gemini-cli[/green]      - Gemini CLI
+
+[dim]💡 Use 'mcp-vector-search uninstall mcp' to remove integrations[/dim]
 """,
     invoke_without_command=True,
     no_args_is_help=False,
@@ -77,190 +91,184 @@ install_app = create_enhanced_typer(
 
 
 # ==============================================================================
-# Platform Configuration
+# Helper Functions
 # ==============================================================================
 
-SUPPORTED_PLATFORMS = {
-    "claude-code": {
-        "name": "Claude Code",
-        "config_path": ".mcp.json",  # Project-scoped
-        "description": "Claude Code with project-scoped configuration",
-        "scope": "project",
-    },
-    "claude-desktop": {
-        "name": "Claude Desktop",
-        "config_path": "~/Library/Application Support/Claude/claude_desktop_config.json",
-        "description": "Claude Desktop application",
-        "scope": "global",
-    },
-    "cursor": {
-        "name": "Cursor",
-        "config_path": "~/.cursor/mcp.json",
-        "description": "Cursor IDE",
-        "scope": "global",
-    },
-    "windsurf": {
-        "name": "Windsurf",
-        "config_path": "~/.codeium/windsurf/mcp_config.json",
-        "description": "Windsurf IDE",
-        "scope": "global",
-    },
-    "vscode": {
-        "name": "VS Code",
-        "config_path": "~/.vscode/mcp.json",
-        "description": "Visual Studio Code",
-        "scope": "global",
-    },
-}
-
-
-def get_platform_config_path(platform: str, project_root: Path) -> Path:
-    """Get the configuration file path for a platform.
+
+def detect_project_root(start_path: Path | None = None) -> Path:
+    """Auto-detect project root directory.
+
+    Detection priority:
+    1. Directory with .mcp-vector-search/ (project initialized)
+    2. Git repository root
+    3. Current working directory (fallback)
 
     Args:
-        platform: Platform name (e.g., "claude-code", "cursor")
-        project_root: Project root directory (for project-scoped configs)
+        start_path: Starting path for detection (default: current directory)
 
     Returns:
-        Path to the configuration file
+        Path to detected project root
     """
-    if platform not in SUPPORTED_PLATFORMS:
-        raise ValueError(f"Unsupported platform: {platform}")
+    current = start_path or Path.cwd()
 
-    config_info = SUPPORTED_PLATFORMS[platform]
-    config_path_str = config_info["config_path"]
+    # Check for .mcp-vector-search directory (initialized project)
+    if (current / ".mcp-vector-search").exists():
+        logger.debug(f"Detected project root via .mcp-vector-search: {current}")
+        return current
 
-    # Resolve project-scoped vs global paths
-    if config_info["scope"] == "project":
-        return project_root / config_path_str
-    else:
-        return Path(config_path_str).expanduser()
+    # Check if we're in a git repository
+    git_root = find_git_root(current)
+    if git_root and (git_root / ".mcp-vector-search").exists():
+        logger.debug(f"Detected project root via git + .mcp-vector-search: {git_root}")
+        return git_root
+
+    # Fallback to current directory
+    logger.debug(f"Using current directory as project root: {current}")
+    return current
 
 
-def get_mcp_server_config(
-    project_root: Path,
-    platform: str,
-    enable_watch: bool = True,
-) -> dict[str, Any]:
-    """Generate MCP server configuration for a platform.
+def find_git_root(path: Path) -> Path | None:
+    """Find git repository root by walking up directory tree.
 
     Args:
-        project_root: Project root directory
-        platform: Platform name
-        enable_watch: Whether to enable file watching
+        path: Starting path
 
     Returns:
-        Dictionary containing MCP server configuration
+        Path to git root or None if not in a git repo
     """
-    # Base configuration using uv for compatibility
-    config: dict[str, Any] = {
-        "command": "uv",
-        "args": ["run", "mcp-vector-search", "mcp"],
-        "env": {
-            "MCP_ENABLE_FILE_WATCHING": "true" if enable_watch else "false",
-        },
-    }
+    current = path.resolve()
+    while current != current.parent:
+        if (current / ".git").exists():
+            logger.debug(f"Found git root: {current}")
+            return current
+        current = current.parent
+    return None
+
 
-    # Platform-specific adjustments
-    if platform in ("claude-code", "cursor", "windsurf", "vscode"):
-        # These platforms require "type": "stdio"
-        config["type"] = "stdio"
+def _get_claude_desktop_config_path() -> Path | None:
+    """Get the default config path for Claude Desktop based on OS.
 
-    # Only add cwd for global-scope platforms (not project-scoped)
-    if SUPPORTED_PLATFORMS[platform]["scope"] == "global":
-        config["cwd"] = str(project_root.absolute())
+    Returns:
+        Path to Claude Desktop config or None if unknown OS
+    """
+    import sys
+
+    if sys.platform == "darwin":
+        # macOS
+        return (
+            Path.home()
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "claude_desktop_config.json"
+        )
+    elif sys.platform == "win32":
+        # Windows
+        import os
 
-    return config
+        appdata = os.environ.get("APPDATA", "")
+        if appdata:
+            return Path(appdata) / "Claude" / "claude_desktop_config.json"
+    else:
+        # Linux
+        return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+    return None
 
 
-def detect_installed_platforms() -> dict[str, Path]:
-    """Detect which MCP platforms are installed on the system.
+def detect_all_platforms() -> list[PlatformInfo]:
+    """Detect all available platforms on the system.
 
     Returns:
-        Dictionary mapping platform names to their config paths
+        List of detected platforms with confidence scores
     """
-    detected = {}
+    detector = PlatformDetector()
+    detected_platforms = []
+
+    # Try to detect each platform
+    platform_detectors = {
+        Platform.CLAUDE_CODE: detector.detect_claude_code,
+        Platform.CLAUDE_DESKTOP: detector.detect_claude_desktop,
+        Platform.CURSOR: detector.detect_cursor,
+        Platform.AUGGIE: detector.detect_auggie,
+        Platform.CODEX: detector.detect_codex,
+        Platform.WINDSURF: detector.detect_windsurf,
+        Platform.GEMINI_CLI: detector.detect_gemini_cli,
+    }
 
-    for platform, info in SUPPORTED_PLATFORMS.items():
-        # For project-scoped platforms, always include them
-        if info["scope"] == "project":
-            detected[platform] = Path(info["config_path"])
+    for platform_enum, detector_func in platform_detectors.items():
+        try:
+            confidence, config_path = detector_func()
+
+            # Determine CLI availability
+            cli_available = False
+            from py_mcp_installer.utils import resolve_command_path
+
+            if platform_enum in (Platform.CLAUDE_CODE, Platform.CLAUDE_DESKTOP):
+                cli_available = resolve_command_path("claude") is not None
+            elif platform_enum == Platform.CURSOR:
+                cli_available = resolve_command_path("cursor") is not None
+
+            # Include platform if:
+            # 1. Has config file with confidence > 0, OR
+            # 2. Has CLI available (can create config)
+            # For CLI-based platforms, we can configure even without existing config
+            if confidence > 0.0 and config_path:
+                # Has existing config file
+                platform_info = PlatformInfo(
+                    platform=platform_enum,
+                    confidence=confidence,
+                    config_path=config_path,
+                    cli_available=cli_available,
+                )
+                detected_platforms.append(platform_info)
+            elif cli_available and platform_enum in (
+                Platform.CLAUDE_CODE,
+                Platform.CLAUDE_DESKTOP,
+                Platform.CURSOR,
+            ):
+                # CLI available but no config yet - we can still configure it
+                # Use default config path for the platform
+                default_config_paths = {
+                    Platform.CLAUDE_CODE: Path.home()
+                    / ".config"
+                    / "claude"
+                    / "mcp.json",
+                    Platform.CLAUDE_DESKTOP: _get_claude_desktop_config_path(),
+                    Platform.CURSOR: Path.home() / ".cursor" / "mcp.json",
+                }
+                platform_info = PlatformInfo(
+                    platform=platform_enum,
+                    confidence=0.2,  # Low confidence since no config exists yet
+                    config_path=default_config_paths.get(platform_enum),
+                    cli_available=cli_available,
+                )
+                detected_platforms.append(platform_info)
+        except Exception as e:
+            logger.debug(f"Failed to detect {platform_enum.value}: {e}")
             continue
 
-        # For global platforms, check if config directory exists
-        config_path = Path(info["config_path"]).expanduser()
-        if config_path.parent.exists():
-            detected[platform] = config_path
-
-    return detected
+    return detected_platforms
 
 
-def configure_platform(
-    platform: str,
-    project_root: Path,
-    server_name: str = "mcp-vector-search",
-    enable_watch: bool = True,
-    force: bool = False,
-) -> bool:
-    """Configure MCP integration for a specific platform.
+def platform_name_to_enum(name: str) -> Platform | None:
+    """Convert platform name to enum.
 
     Args:
-        platform: Platform name (e.g., "claude-code", "cursor")
-        project_root: Project root directory
-        server_name: Name for the MCP server entry
-        enable_watch: Whether to enable file watching
-        force: Whether to overwrite existing configuration
+        name: Platform name (e.g., "cursor", "claude-code")
 
     Returns:
-        True if configuration was successful, False otherwise
+        Platform enum or None if not found
     """
-    try:
-        config_path = get_platform_config_path(platform, project_root)
-
-        # Create backup if file exists
-        if config_path.exists():
-            backup_path = config_path.with_suffix(config_path.suffix + ".backup")
-            shutil.copy2(config_path, backup_path)
-
-            # Load existing config
-            with open(config_path) as f:
-                config = json.load(f)
-
-            # Check if server already exists
-            if "mcpServers" in config and server_name in config["mcpServers"]:
-                if not force:
-                    print_warning(
-                        f"  ⚠️  Server '{server_name}' already exists in {platform} config"
-                    )
-                    print_info("  Use --force to overwrite")
-                    return False
-        else:
-            # Create new config
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-            config = {}
-
-        # Ensure mcpServers section exists
-        if "mcpServers" not in config:
-            config["mcpServers"] = {}
-
-        # Add server configuration
-        server_config = get_mcp_server_config(project_root, platform, enable_watch)
-        config["mcpServers"][server_name] = server_config
-
-        # Write configuration
-        with open(config_path, "w") as f:
-            json.dump(config, f, indent=2)
-
-        platform_name = SUPPORTED_PLATFORMS[platform]["name"]
-        print_success(f"  ✅ Configured {platform_name}")
-        print_info(f"     Config: {config_path}")
-
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to configure {platform}: {e}")
-        print_error(f"  ❌ Failed to configure {platform}: {e}")
-        return False
+    name_map = {
+        "claude-code": Platform.CLAUDE_CODE,
+        "claude-desktop": Platform.CLAUDE_DESKTOP,
+        "cursor": Platform.CURSOR,
+        "auggie": Platform.AUGGIE,
+        "codex": Platform.CODEX,
+        "windsurf": Platform.WINDSURF,
+        "gemini-cli": Platform.GEMINI_CLI,
+    }
+    return name_map.get(name.lower())
 
 
 # ==============================================================================
@@ -409,15 +417,15 @@ def main(
         # Install MCP integrations if requested
         if with_mcp:
             console.print("\n[bold blue]🔗 Installing MCP integrations...[/bold blue]")
-            detected = detect_installed_platforms()
+            detected = detect_all_platforms()
 
             if detected:
-                for platform in detected:
-                    configure_platform(platform, project_root, enable_watch=True)
+                for platform_info in detected:
+                    _install_to_platform(platform_info, project_root)
             else:
                 print_warning("No MCP platforms detected")
                 print_info("Install platforms manually using:")
-                print_info("  mcp-vector-search install <platform>")
+                print_info("  mcp-vector-search install mcp --platform <platform>")
 
         # Success message
         console.print("\n[bold green]🎉 Installation Complete![/bold green]")
@@ -429,11 +437,14 @@ def main(
 
         if not with_mcp:
             next_steps.append(
-                "[cyan]mcp-vector-search install claude-code[/cyan] - Add MCP integration"
+                "[cyan]mcp-vector-search install mcp[/cyan] - Add MCP integration"
             )
 
         print_next_steps(next_steps, title="Ready to Use")
 
+    except typer.Exit:
+        # Re-raise typer.Exit to allow proper exit handling
+        raise
     except ProjectInitializationError as e:
         print_error(f"Installation failed: {e}")
         raise typer.Exit(1)
@@ -444,231 +455,482 @@ def main(
 
 
 # ==============================================================================
-# Platform-Specific Installation Commands
+# MCP Installation Command
 # ==============================================================================
 
 
-@install_app.command("claude-code")
-def install_claude_code(
+def _install_to_platform(
+    platform_info: PlatformInfo, project_root: Path, force: bool = True
+) -> bool:
+    """Install to a specific platform.
+
+    Args:
+        platform_info: Platform information
+        project_root: Project root directory
+        force: If True, overwrite existing installation (default: True)
+
+    Returns:
+        True if installation succeeded
+    """
+    import io
+    import sys
+
+    try:
+        # Create installer for this platform
+        installer = MCPInstaller(platform=platform_info.platform)
+
+        # Detect installation method (uv vs direct command)
+        import shutil
+
+        use_uv = shutil.which("uv") is not None
+        mcp_cmd = shutil.which("mcp-vector-search")
+
+        if use_uv:
+            # Development mode with uv
+            command = "uv"
+            args = ["run", "--directory", str(project_root), "mcp-vector-search", "mcp"]
+        elif mcp_cmd:
+            # Production mode with installed package
+            command = "mcp-vector-search"
+            args = ["mcp"]
+        else:
+            # Fallback to uv (will fail if not available)
+            command = "uv"
+            args = ["run", "mcp-vector-search", "mcp"]
+
+        # Create server configuration
+        server_config = MCPServerConfig(
+            name="mcp-vector-search",
+            command=command,
+            args=args,
+            env={
+                "PROJECT_ROOT": str(project_root.resolve()),
+                "MCP_PROJECT_ROOT": str(project_root.resolve()),
+            },
+            description=f"Semantic code search for {project_root.name}",
+        )
+
+        def do_install() -> InstallationResult:
+            """Execute the installation."""
+            return installer.install_server(
+                name=server_config.name,
+                command=server_config.command,
+                args=server_config.args,
+                env=server_config.env,
+                description=server_config.description,
+            )
+
+        # Try to install, suppressing verbose stderr output from py-mcp-installer
+        try:
+            # Capture stderr to suppress verbose traceback output
+            old_stderr = sys.stderr
+            sys.stderr = io.StringIO()
+            try:
+                result = do_install()
+            finally:
+                captured_stderr = sys.stderr.getvalue()
+                sys.stderr = old_stderr
+                # Log captured output at debug level for troubleshooting
+                if captured_stderr.strip():
+                    logger.debug(f"Installation stderr: {captured_stderr[:500]}")
+        except InstallationError as e:
+            # Restore stderr before handling error
+            if sys.stderr != old_stderr:
+                sys.stderr = old_stderr
+
+            # Check if it's an "already exists" error
+            error_msg = str(e).lower()
+            if "already exists" in error_msg and force:
+                # Silently uninstall first, then reinstall
+                logger.debug(
+                    f"Server already exists on {platform_info.platform.value}, "
+                    "removing and reinstalling..."
+                )
+                try:
+                    # Suppress stderr during uninstall too
+                    old_stderr = sys.stderr
+                    sys.stderr = io.StringIO()
+                    try:
+                        installer.uninstall_server(server_config.name)
+                        result = do_install()
+                    finally:
+                        sys.stderr = old_stderr
+                except Exception as uninstall_err:
+                    logger.debug(
+                        f"Failed to uninstall existing server: {uninstall_err}"
+                    )
+                    # Server already exists is not a failure - it's already configured
+                    print_success(f"  ✅ Installed to {platform_info.platform.value}")
+                    if platform_info.config_path:
+                        print_info(f"     Config: {platform_info.config_path}")
+                    return True
+            else:
+                raise
+
+        if result.success:
+            print_success(f"  ✅ Installed to {platform_info.platform.value}")
+            if result.config_path:
+                print_info(f"     Config: {result.config_path}")
+
+            # Validate installation
+            inspector = MCPInspector(platform_info)
+            report = inspector.inspect()
+
+            if report.has_errors():
+                print_warning("  ⚠️  Configuration has issues:")
+                for issue in report.issues:
+                    if issue.severity == "error":
+                        print_warning(f"      • {issue.message}")
+
+            return True
+        else:
+            print_error(
+                f"  ❌ Failed to install to {platform_info.platform.value}: {result.message}"
+            )
+            return False
+
+    except Exception as e:
+        logger.debug(f"Installation to {platform_info.platform.value} failed: {e}")
+        # Don't print full exception - just a clean error message
+        error_str = str(e)
+        # Extract just the main error message, not the full traceback
+        if "already exists" in error_str.lower():
+            # Already exists is a success case - server is configured
+            print_success(f"  ✅ Installed to {platform_info.platform.value}")
+            if platform_info.config_path:
+                print_info(f"     Config: {platform_info.config_path}")
+            return True
+        else:
+            # Extract first line of error for clean output
+            short_error = error_str.split("\n")[0][:100]
+            print_error(f"  ❌ Failed: {platform_info.platform.value} - {short_error}")
+            return False
+
+
+@install_app.command(name="mcp")
+def install_mcp(
     ctx: typer.Context,
-    enable_watch: bool = typer.Option(
+    platform: str | None = typer.Option(
+        None,
+        "--platform",
+        "-p",
+        help="Specific platform to install to (e.g., cursor, claude-code)",
+    ),
+    all_platforms: bool = typer.Option(
+        False,
+        "--all",
+        "-a",
+        help="Install to all detected platforms",
+    ),
+    auto: bool = typer.Option(
         True,
-        "--watch/--no-watch",
-        help="Enable file watching for auto-reindex",
+        "--auto/--no-auto",
+        help="Auto-detect project root (default: enabled)",
     ),
-    force: bool = typer.Option(
+    dry_run: bool = typer.Option(
         False,
-        "--force",
-        "-f",
-        help="Force overwrite existing configuration",
+        "--dry-run",
+        help="Preview changes without applying them",
     ),
 ) -> None:
-    """Install Claude Code MCP integration (project-scoped).
+    """Install MCP integration to platforms.
+
+    Auto-detects available platforms and installs mcp-vector-search as an MCP server.
+    Automatically detects project root from current directory or git repository.
+
+    [bold cyan]Examples:[/bold cyan]
+
+      [green]Auto-detect and install (recommended):[/green]
+        $ mcp-vector-search install mcp
+        $ mcp-vector-search install mcp --auto
 
-    Creates .mcp.json in the project root for team sharing.
-    This file should be committed to version control.
+      [green]Install to specific platform:[/green]
+        $ mcp-vector-search install mcp --platform cursor
+
+      [green]Install to all detected platforms:[/green]
+        $ mcp-vector-search install mcp --all
+
+      [green]Preview changes (dry run):[/green]
+        $ mcp-vector-search install mcp --dry-run
+
+      [green]Use current directory as project root (no auto-detection):[/green]
+        $ mcp-vector-search install mcp --no-auto
     """
-    project_root = ctx.obj.get("project_root") or Path.cwd()
+    # Auto-detect project root if enabled
+    if auto:
+        project_root = detect_project_root()
+        console.print(f"[dim]🔍 Auto-detected project root: {project_root}[/dim]\n")
+    else:
+        project_root = ctx.obj.get("project_root") or Path.cwd()
+        console.print(f"[dim]📁 Using project root: {project_root}[/dim]\n")
 
     console.print(
         Panel.fit(
-            "[bold cyan]Installing Claude Code Integration[/bold cyan]\n"
-            "📁 Project-scoped configuration",
+            "[bold cyan]Installing MCP Integration[/bold cyan]\n"
+            f"📁 Project: {project_root}",
             border_style="cyan",
         )
     )
 
-    success = configure_platform(
-        "claude-code", project_root, enable_watch=enable_watch, force=force
-    )
+    try:
+        # Detect available platforms
+        print_info("🔍 Detecting available MCP platforms...")
+        detected = detect_all_platforms()
+
+        if not detected:
+            print_warning("No MCP platforms detected.")
+            print_info(
+                "Supported platforms: claude-code, claude-desktop, cursor, auggie, codex, windsurf, gemini-cli"
+            )
+            raise typer.Exit(0)
+
+        # Display detected platforms
+        table = Table(title="Detected MCP Platforms")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Config Path", style="green")
+        table.add_column("Confidence", style="yellow")
+        table.add_column("CLI", style="magenta")
+
+        for p in detected:
+            table.add_row(
+                p.platform.value,
+                str(p.config_path) if p.config_path else "N/A",
+                f"{p.confidence:.2f}",
+                "✅" if p.cli_available else "❌",
+            )
+
+        console.print(table)
+
+        # Filter platforms
+        target_platforms = detected
+
+        if platform:
+            # Install to specific platform
+            platform_enum = platform_name_to_enum(platform)
+            if not platform_enum:
+                print_error(f"Unknown platform: {platform}")
+                print_info(
+                    "Supported: claude-code, claude-desktop, cursor, auggie, codex, windsurf, gemini-cli"
+                )
+                raise typer.Exit(1)
+
+            target_platforms = [p for p in detected if p.platform == platform_enum]
+
+            if not target_platforms:
+                print_error(f"Platform '{platform}' not detected on this system")
+                raise typer.Exit(1)
+
+        elif not all_platforms:
+            # By default, install to highest confidence platform only
+            if detected:
+                max_confidence_platform = max(detected, key=lambda p: p.confidence)
+                target_platforms = [max_confidence_platform]
+                print_info(
+                    f"Installing to highest confidence platform: {max_confidence_platform.platform.value}"
+                )
+                print_info("Use --all to install to all detected platforms")
+
+        # Show what will be installed
+        console.print("\n[bold]Target platforms:[/bold]")
+        for p in target_platforms:
+            console.print(f"  • {p.platform.value}")
+
+        if dry_run:
+            console.print("\n[bold yellow]🔍 DRY RUN MODE[/bold yellow]")
+            print_info("No changes will be applied")
+            return
+
+        # Install to each platform
+        console.print("\n[bold]Installing...[/bold]")
+        successful = 0
+        failed = 0
+
+        for platform_info in target_platforms:
+            if _install_to_platform(platform_info, project_root):
+                successful += 1
+            else:
+                failed += 1
+
+        # Summary
+        console.print("\n[bold green]✨ Installation Summary[/bold green]")
+        console.print(f"  ✅ Successful: {successful}")
+        if failed > 0:
+            console.print(f"  ❌ Failed: {failed}")
 
-    if success:
-        console.print(
-            "\n[bold green]✨ Claude Code Integration Installed![/bold green]"
-        )
         console.print("\n[bold blue]Next Steps:[/bold blue]")
-        console.print("  1. Open Claude Code in this project directory")
+        console.print("  1. Restart your AI coding tool")
         console.print("  2. The MCP server will be available automatically")
         console.print("  3. Try: 'Search my code for authentication functions'")
-        console.print("\n[dim]💡 Commit .mcp.json to share with your team[/dim]")
-    else:
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.exception("MCP installation failed")
+        print_error(f"Installation failed: {e}")
         raise typer.Exit(1)
 
 
-@install_app.command("cursor")
-def install_cursor(
-    ctx: typer.Context,
-    enable_watch: bool = typer.Option(True, "--watch/--no-watch"),
-    force: bool = typer.Option(False, "--force", "-f"),
-) -> None:
-    """Install Cursor IDE MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
+# ==============================================================================
+# MCP Status Command
+# ==============================================================================
 
-    console.print(
-        Panel.fit(
-            "[bold cyan]Installing Cursor Integration[/bold cyan]\n"
-            "🌐 Global configuration (~/.cursor/mcp.json)",
-            border_style="cyan",
-        )
-    )
 
-    success = configure_platform(
-        "cursor", project_root, enable_watch=enable_watch, force=force
-    )
+@install_app.command("mcp-status")
+def mcp_status(ctx: typer.Context) -> None:
+    """Show MCP integration status for all platforms.
 
-    if success:
-        console.print("\n[bold green]✨ Cursor Integration Installed![/bold green]")
-        console.print("\n[bold blue]Next Steps:[/bold blue]")
-        console.print("  1. Restart Cursor IDE")
-        console.print("  2. Open this project in Cursor")
-        console.print("  3. MCP tools should be available")
-    else:
-        raise typer.Exit(1)
+    Displays which platforms have mcp-vector-search configured,
+    the detected project root, and configuration details.
 
+    [bold cyan]Examples:[/bold cyan]
 
-@install_app.command("windsurf")
-def install_windsurf(
-    ctx: typer.Context,
-    enable_watch: bool = typer.Option(True, "--watch/--no-watch"),
-    force: bool = typer.Option(False, "--force", "-f"),
-) -> None:
-    """Install Windsurf IDE MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
+      [green]Check status:[/green]
+        $ mcp-vector-search install mcp-status
+    """
+    # Auto-detect project root
+    project_root = detect_project_root()
 
     console.print(
         Panel.fit(
-            "[bold cyan]Installing Windsurf Integration[/bold cyan]\n"
-            "🌐 Global configuration (~/.codeium/windsurf/mcp_config.json)",
+            f"[bold cyan]MCP Integration Status[/bold cyan]\n"
+            f"📁 Detected Project: {project_root}",
             border_style="cyan",
         )
     )
 
-    success = configure_platform(
-        "windsurf", project_root, enable_watch=enable_watch, force=force
-    )
+    try:
+        # Detect all platforms
+        detected = detect_all_platforms()
 
-    if success:
-        console.print("\n[bold green]✨ Windsurf Integration Installed![/bold green]")
-        console.print("\n[bold blue]Next Steps:[/bold blue]")
-        console.print("  1. Restart Windsurf IDE")
-        console.print("  2. Open this project in Windsurf")
-        console.print("  3. MCP tools should be available")
-    else:
-        raise typer.Exit(1)
+        if not detected:
+            print_warning("No MCP platforms detected")
+            return
 
+        # Create status table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Config Path")
+        table.add_column("Project Root")
 
-@install_app.command("claude-desktop")
-def install_claude_desktop(
-    ctx: typer.Context,
-    enable_watch: bool = typer.Option(True, "--watch/--no-watch"),
-    force: bool = typer.Option(False, "--force", "-f"),
-) -> None:
-    """Install Claude Desktop MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
+        for platform_info in detected:
+            try:
+                # Check if mcp-vector-search is configured
+                installer = MCPInstaller(platform=platform_info.platform)
+                server = installer.get_server("mcp-vector-search")
+
+                if server:
+                    status = "✅ Configured"
+                    # Extract project root from env
+                    env = server.get("env", {})
+                    configured_root = env.get("MCP_PROJECT_ROOT") or env.get(
+                        "PROJECT_ROOT", "N/A"
+                    )
 
-    console.print(
-        Panel.fit(
-            "[bold cyan]Installing Claude Desktop Integration[/bold cyan]\n"
-            "🌐 Global configuration (~/.claude/config.json)",
-            border_style="cyan",
-        )
-    )
+                    # Check if it matches current project
+                    if configured_root != "N/A":
+                        configured_path = Path(configured_root)
+                        if configured_path == project_root:
+                            status = "✅ Configured (current project)"
+                        else:
+                            status = "⚠️ Configured (different project)"
+                else:
+                    status = "❌ Not configured"
+                    configured_root = "N/A"
 
-    success = configure_platform(
-        "claude-desktop", project_root, enable_watch=enable_watch, force=force
-    )
+            except Exception as e:
+                logger.debug(f"Failed to check {platform_info.platform.value}: {e}")
+                status = "❓ Unknown"
+                configured_root = "N/A"
+
+            table.add_row(
+                platform_info.platform.value,
+                status,
+                str(platform_info.config_path) if platform_info.config_path else "N/A",
+                configured_root,
+            )
+
+        console.print(table)
 
-    if success:
+        # Show next steps
+        console.print("\n[bold blue]Quick Actions:[/bold blue]")
         console.print(
-            "\n[bold green]✨ Claude Desktop Integration Installed![/bold green]"
+            "  mcp-vector-search install mcp                    # Install to auto-detected platform"
         )
-        console.print("\n[bold blue]Next Steps:[/bold blue]")
-        console.print("  1. Restart Claude Desktop")
-        console.print("  2. The mcp-vector-search server will be available")
-        console.print("  3. Open conversations in the project directory")
-    else:
-        raise typer.Exit(1)
-
-
-@install_app.command("vscode")
-def install_vscode(
-    ctx: typer.Context,
-    enable_watch: bool = typer.Option(True, "--watch/--no-watch"),
-    force: bool = typer.Option(False, "--force", "-f"),
-) -> None:
-    """Install VS Code MCP integration (global)."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
-
-    console.print(
-        Panel.fit(
-            "[bold cyan]Installing VS Code Integration[/bold cyan]\n"
-            "🌐 Global configuration (~/.vscode/mcp.json)",
-            border_style="cyan",
+        console.print(
+            "  mcp-vector-search install mcp --all              # Install to all platforms"
+        )
+        console.print(
+            "  mcp-vector-search install mcp --platform <name>  # Install to specific platform"
         )
-    )
-
-    success = configure_platform(
-        "vscode", project_root, enable_watch=enable_watch, force=force
-    )
 
-    if success:
-        console.print("\n[bold green]✨ VS Code Integration Installed![/bold green]")
-        console.print("\n[bold blue]Next Steps:[/bold blue]")
-        console.print("  1. Restart VS Code")
-        console.print("  2. Open this project in VS Code")
-        console.print("  3. MCP tools should be available")
-    else:
+    except Exception as e:
+        logger.exception("Failed to check MCP status")
+        print_error(f"Status check failed: {e}")
         raise typer.Exit(1)
 
 
-@install_app.command("list")
-def list_platforms(ctx: typer.Context) -> None:
-    """List all supported MCP platforms and their installation status."""
-    project_root = ctx.obj.get("project_root") or Path.cwd()
+# ==============================================================================
+# List Platforms Command
+# ==============================================================================
 
+
+@install_app.command("list-platforms")
+def list_platforms(ctx: typer.Context) -> None:
+    """List all detected MCP platforms and their status."""
     console.print(
         Panel.fit("[bold cyan]MCP Platform Status[/bold cyan]", border_style="cyan")
     )
 
-    table = Table(show_header=True, header_style="bold cyan")
-    table.add_column("Platform", style="cyan")
-    table.add_column("Name")
-    table.add_column("Status")
-    table.add_column("Config Location")
+    try:
+        detected = detect_all_platforms()
 
-    detected = detect_installed_platforms()
+        if not detected:
+            print_warning("No MCP platforms detected")
+            print_info(
+                "Supported platforms: claude-code, claude-desktop, cursor, auggie, codex, windsurf, gemini-cli"
+            )
+            return
 
-    for platform, info in SUPPORTED_PLATFORMS.items():
-        config_path = get_platform_config_path(platform, project_root)
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Platform", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Config Path")
+        table.add_column("Confidence", style="yellow")
 
-        # Check if configured
-        is_configured = False
-        if config_path.exists():
+        for platform_info in detected:
+            # Check if mcp-vector-search is configured
             try:
-                with open(config_path) as f:
-                    config = json.load(f)
-                is_configured = "mcp-vector-search" in config.get("mcpServers", {})
+                installer = MCPInstaller(platform=platform_info.platform)
+                server = installer.get_server("mcp-vector-search")
+                status = "✅ Configured" if server else "⚠️ Available"
             except Exception:
-                pass
+                status = "⚠️ Available"
 
-        status = (
-            "✅ Configured"
-            if is_configured
-            else ("⚠️ Available" if platform in detected else "❌ Not Found")
-        )
+            table.add_row(
+                platform_info.platform.value,
+                status,
+                str(platform_info.config_path) if platform_info.config_path else "N/A",
+                f"{platform_info.confidence:.2f}",
+            )
 
-        table.add_row(
-            platform,
-            info["name"],
-            status,
-            str(config_path) if info["scope"] == "project" else info["config_path"],
-        )
+        console.print(table)
 
-    console.print(table)
+        console.print("\n[bold blue]Installation Commands:[/bold blue]")
+        console.print(
+            "  mcp-vector-search install mcp                    # Auto-detect"
+        )
+        console.print(
+            "  mcp-vector-search install mcp --platform <name>  # Specific platform"
+        )
+        console.print(
+            "  mcp-vector-search install mcp --all              # All platforms"
+        )
 
-    console.print("\n[bold blue]Installation Commands:[/bold blue]")
-    for platform in SUPPORTED_PLATFORMS:
-        console.print(f"  mcp-vector-search install {platform}")
+    except Exception as e:
+        logger.exception("Failed to list platforms")
+        print_error(f"Failed to list platforms: {e}")
+        raise typer.Exit(1)
 
 
 if __name__ == "__main__":