claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/commands/mcp.py

@@ -34,9 +34,10 @@ def manage_mcp(args):
     logger = get_logger("cli.mcp")
 
     # First check if MCP package is installed for any command
-    try:
-        import mcp
-    except ImportError:
+    import importlib.util
+
+    mcp_spec = importlib.util.find_spec("mcp")
+    if not mcp_spec:
         if args.mcp_command != MCPCommands.INSTALL.value:
             print("\nMCP package is not installed.", file=sys.stderr)
             print("Please install it first:", file=sys.stderr)
@@ -114,7 +115,12 @@ def manage_mcp(args):
 
 
 def _show_status(
-    args, logger, MCPConfiguration, MCPServiceRegistry, ToolRegistry, MCPGateway
+    args,
+    logger,
+    MCPConfiguration,
+    MCPServiceRegistry,
+    ToolRegistry,
+    MCPGateway,
 ):
     """
     Show MCP Gateway status when no subcommand is provided.
@@ -129,11 +135,12 @@ def _show_status(
     print("=" * 50)
 
     # Check if MCP package is installed
-    try:
-        import mcp
+    import importlib.util
 
+    mcp_spec = importlib.util.find_spec("mcp")
+    if mcp_spec:
         print("✅ MCP package installed")
-    except ImportError:
+    else:
         print("❌ MCP package not installed")
         print("   Run: claude-mpm mcp install")
         return 1
@@ -144,7 +151,7 @@ def _show_status(
     if config_path.exists():
         print(f"   Config file: {config_path}")
         try:
-            with open(config_path) as f:
+            with config_path.open() as f:
                 config = json.load(f)
                 if "servers" in config:
                     print(f"   Configured servers: {len(config.get('servers', {}))}")
@@ -164,7 +171,7 @@ def _show_status(
     if claude_config.exists():
         print(f"\n🖥️  Claude Code Config: {claude_config}")
         try:
-            with open(claude_config) as f:
+            with claude_config.open() as f:
                 config = json.load(f)
                 mcp_servers = config.get("mcpServers", {})
                 if "claude-mpm" in mcp_servers:
@@ -184,7 +191,7 @@ def _show_status(
             ToolRegistry()
             # Don't initialize fully, just check
             print("\n🔧 Tools: Check with 'claude-mpm mcp tools'")
-        except:
+        except Exception:
             print("\n🔧 Tools: Registry not available")
 
     print("\n💡 Available Commands:")

claude_mpm/cli/commands/mcp_command_router.py

@@ -45,6 +45,9 @@ class MCPCommandRouter:
         if args.mcp_command == MCPCommands.SERVER.value:
             return self._run_server(args)
 
+        if args.mcp_command == MCPCommands.EXTERNAL.value:
+            return self._manage_external(args)
+
         if args.mcp_command == "cleanup":
             return self._cleanup_locks(args)
 
@@ -124,6 +127,13 @@ class MCPCommandRouter:
         handler = MCPServerCommands(self.logger)
         return asyncio.run(handler.start_server(args))
 
+    def _manage_external(self, args) -> int:
+        """Manage external MCP services command handler."""
+        from .mcp_external_commands import MCPExternalCommands
+
+        handler = MCPExternalCommands(self.logger)
+        return handler.manage_external(args)
+
     def _show_help(self):
         """Show available MCP commands."""
         print("\nAvailable MCP commands:")
@@ -136,6 +146,7 @@ class MCPCommandRouter:
         print("  register - Register a new tool")
         print("  test     - Test tool invocation")
         print("  config   - View and manage configuration")
+        print("  external - Manage external MCP services")
         print("  cleanup  - Clean up legacy files")
         print("\nFor help with a specific command:")
         print("  claude-mpm mcp <command> --help")

claude_mpm/cli/commands/mcp_config.py

@@ -0,0 +1,154 @@
+"""
+MCP Configuration Command
+=========================
+
+Command for managing MCP service configurations with pipx preference.
+"""
+
+import json
+from pathlib import Path
+
+from ...services.mcp_config_manager import MCPConfigManager
+from ..shared import BaseCommand, CommandResult
+
+
+class MCPConfigCommand(BaseCommand):
+    """Manage MCP service configurations."""
+
+    def __init__(self):
+        super().__init__("mcp-config")
+
+    def run(self, args) -> CommandResult:
+        """Execute the MCP configuration command."""
+        manager = MCPConfigManager()
+
+        # Handle different sub-commands
+        if hasattr(args, "mcp_config_command"):
+            command = args.mcp_config_command
+
+            if command == "detect":
+                return self._detect_services(manager)
+            if command == "update":
+                return self._update_config(manager, args)
+            if command == "validate":
+                return self._validate_config(manager)
+            if command == "install":
+                return self._install_services(manager)
+            return self._show_status(manager)
+        return self._show_status(manager)
+
+    def _detect_services(self, manager: MCPConfigManager) -> CommandResult:
+        """Detect available MCP services."""
+        results = {}
+        for service in manager.PIPX_SERVICES:
+            path = manager.detect_service_path(service)
+            results[service] = {
+                "found": path is not None,
+                "path": path or "Not found",
+            }
+
+        return CommandResult(
+            success=True,
+            message="MCP service detection complete",
+            data=results,
+        )
+
+    def _update_config(self, manager: MCPConfigManager, args) -> CommandResult:
+        """Update MCP configuration."""
+        force_pipx = getattr(args, "force_pipx", True)
+        success, message = manager.update_mcp_config(force_pipx=force_pipx)
+
+        if success:
+            # Show the updated configuration
+            config_path = Path.cwd() / ".mcp.json"
+            if config_path.exists():
+                with config_path.open() as f:
+                    config = json.load(f)
+                return CommandResult(
+                    success=True,
+                    message=message,
+                    data=config,
+                )
+
+        return CommandResult(
+            success=success,
+            message=message,
+        )
+
+    def _validate_config(self, manager: MCPConfigManager) -> CommandResult:
+        """Validate current MCP configuration."""
+        results = manager.validate_configuration()
+
+        all_valid = all(results.values()) if results else False
+        message = (
+            "All MCP services are properly configured"
+            if all_valid
+            else "Some MCP services are not accessible"
+        )
+
+        return CommandResult(
+            success=all_valid,
+            message=message,
+            data=results,
+        )
+
+    def _install_services(self, manager: MCPConfigManager) -> CommandResult:
+        """Install missing MCP services."""
+        success, message = manager.install_missing_services()
+        return CommandResult(
+            success=success,
+            message=message,
+        )
+
+    def _show_status(self, manager: MCPConfigManager) -> CommandResult:
+        """Show current MCP configuration status."""
+        # Detect services
+        detected = {}
+        for service in manager.PIPX_SERVICES:
+            path = manager.detect_service_path(service)
+            detected[service] = {
+                "installed": path is not None,
+                "path": path or "Not installed",
+                "via_pipx": path and "pipx" in path if path else False,
+            }
+
+        # Validate configuration
+        config_valid = manager.validate_configuration()
+
+        # Read current config
+        config_path = Path.cwd() / ".mcp.json"
+        current_config = {}
+        if config_path.exists():
+            try:
+                with config_path.open() as f:
+                    current_config = json.load(f)
+            except Exception:
+                pass
+
+        status_data = {
+            "services": detected,
+            "configuration_valid": config_valid,
+            "config_file_exists": config_path.exists(),
+            "configured_services": list(current_config.get("mcpServers", {}).keys()),
+        }
+
+        return CommandResult(
+            success=True,
+            message="MCP configuration status",
+            data=status_data,
+        )
+
+
+def manage_mcp_config(args):
+    """
+    Entry point for MCP configuration command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code
+    """
+    command = MCPConfigCommand()
+    result = command.execute(args)
+    return result.exit_code

claude_mpm/cli/commands/mcp_external_commands.py

@@ -0,0 +1,249 @@
+"""MCP external services command implementations.
+
+This module provides commands for managing external MCP services
+like mcp-vector-search and mcp-browser.
+"""
+
+
+class MCPExternalCommands:
+    """Handles MCP external service commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP external commands handler."""
+        self.logger = logger
+
+    def manage_external(self, args):
+        """Manage external MCP services.
+
+        Args:
+            args: Parsed command line arguments
+
+        Returns:
+            int: Exit code (0 for success, non-zero for failure)
+        """
+        # Get the external subcommand if it exists
+        external_action = getattr(args, "external_action", None)
+
+        if not external_action:
+            # No subcommand provided, show help
+            self._show_help()
+            return 0
+
+        # Route to appropriate handler
+        if external_action == "setup":
+            return self._setup_external(args)
+        if external_action == "list":
+            return self._list_external(args)
+        if external_action == "check":
+            return self._check_external(args)
+        if external_action == "fix-browser":
+            return self._fix_browser(args)
+        if external_action == "detect":
+            return self._detect_and_update(args)
+        print(f"Unknown external subcommand: {external_action}")
+        self._show_help()
+        return 1
+
+    def _setup_external(self, args):
+        """Setup external MCP services in Claude Code.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        print("📦 Setting up External MCP Services")
+        print("=" * 50)
+
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+
+        # First install Python packages
+        print("\n1️⃣  Installing Python packages...")
+        if not setup.check_and_install_pip_packages():
+            print("⚠️ Some Python packages could not be installed")
+            print("   You may need to install them manually:")
+            print("   pip install mcp-vector-search mcp-browser")
+
+        # Then configure in Claude Code
+        print("\n2️⃣  Configuring Claude Code...")
+        force = getattr(args, "force", False)
+        if setup.setup_external_services(force=force):
+            print("\n✅ External services setup completed successfully!")
+            print("\nNext steps:")
+            print("1. Restart Claude Code to load the new services")
+            print("2. Check status with: claude-mpm mcp external list")
+            print("3. The services will be available in Claude as separate MCP servers")
+            return 0
+        print("\n❌ Failed to setup external services")
+        print("Please check the error messages above and try again")
+        return 1
+
+    def _list_external(self, args):
+        """List external MCP services and their status.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        setup.list_external_services()
+        return 0
+
+    def _check_external(self, args):
+        """Check if external services are properly configured.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        print("🔍 Checking External MCP Services Configuration")
+        print("=" * 50)
+
+        import json
+        from pathlib import Path
+
+        # Check Claude Code configuration
+        config_paths = [
+            Path.home()
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "claude_desktop_config.json",  # macOS
+            Path.home() / ".config" / "Claude" / "claude_desktop_config.json",  # Linux
+            Path.home()
+            / "AppData"
+            / "Roaming"
+            / "Claude"
+            / "claude_desktop_config.json",  # Windows
+            Path.home() / ".claude" / "claude_desktop_config.json",  # Alternative
+            Path.home() / ".claude.json",  # Legacy
+        ]
+
+        config_found = False
+        for config_path in config_paths:
+            if config_path.exists():
+                config_found = True
+                print(f"\n📄 Found config: {config_path}")
+
+                try:
+                    with config_path.open() as f:
+                        config = json.load(f)
+
+                    mcp_servers = config.get("mcpServers", {})
+
+                    # Check for external services
+                    external_services = ["mcp-vector-search", "mcp-browser"]
+                    for service in external_services:
+                        if service in mcp_servers:
+                            print(f"  ✅ {service} is configured")
+                            server_config = mcp_servers[service]
+                            print(f"     Command: {server_config.get('command')}")
+                            print(f"     Args: {server_config.get('args')}")
+                        else:
+                            print(f"  ❌ {service} is NOT configured")
+
+                except Exception as e:
+                    print(f"  ❌ Error reading config: {e}")
+
+                break
+
+        if not config_found:
+            print("❌ No Claude Code configuration found")
+            print("   Please run: claude-mpm mcp install")
+
+        # Check Python packages
+        print("\n🐍 Python Package Status:")
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+
+        packages = [
+            ("mcp-vector-search", "mcp_vector_search"),
+            ("mcp-browser", "mcp_browser"),
+        ]
+
+        for package_name, module_name in packages:
+            if setup._check_python_package(module_name):
+                print(f"  ✅ {package_name} is installed")
+            else:
+                print(f"  ❌ {package_name} is NOT installed")
+
+        return 0
+
+    def _fix_browser(self, args):
+        """Fix mcp-browser configuration to use pipx installation.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        if setup.fix_browser_configuration():
+            return 0
+        return 1
+
+    def _detect_and_update(self, args):
+        """Auto-detect MCP service installations and update configuration.
+
+        Prioritizes local development installations over pipx/system.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            int: Exit code
+        """
+        from .mcp_setup_external import MCPExternalServicesSetup
+
+        setup = MCPExternalServicesSetup(self.logger)
+        force = getattr(args, "force", False)
+
+        if setup.update_mcp_json_with_detected(force=force):
+            print("\n✅ Configuration updated successfully!")
+            print("\nNext steps:")
+            print("1. Review the .mcp.json file to verify the configuration")
+            print("2. Restart Claude Code to load the updated services")
+            return 0
+        print("\n❌ Failed to update configuration")
+        return 1
+
+    def _show_help(self):
+        """Show help for external commands."""
+        print("\nMCP External Services Management")
+        print("=" * 40)
+        print("\nAvailable commands:")
+        print(
+            "  setup       - Setup external MCP services (mcp-vector-search, mcp-browser)"
+        )
+        print("  list        - List available external services and their status")
+        print("  check       - Check configuration and installation status")
+        print(
+            "  detect      - Auto-detect installations and update .mcp.json (prioritizes local dev)"
+        )
+        print("  fix-browser - Fix mcp-browser configuration to use pipx installation")
+        print("\nUsage:")
+        print("  claude-mpm mcp external setup         # Interactive setup")
+        print("  claude-mpm mcp external setup --force # Force reconfiguration")
+        print("  claude-mpm mcp external detect        # Auto-detect and update config")
+        print(
+            "  claude-mpm mcp external detect --force # Force update even if configured"
+        )
+        print("  claude-mpm mcp external list          # Show service status")
+        print("  claude-mpm mcp external check         # Detailed configuration check")
+        print("  claude-mpm mcp external fix-browser   # Fix mcp-browser to use pipx")
+        print("\nExternal services provide additional capabilities:")
+        print("  - mcp-vector-search: Semantic code search with embeddings")
+        print("  - mcp-browser: Web browsing and content extraction")