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

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")

claude_mpm/cli/commands/mcp_install_commands.py

@@ -31,11 +31,12 @@ class MCPInstallCommands:
 
         # Step 1: Install MCP package if needed
         print("\n1️⃣  Checking MCP package installation...")
-        try:
-            import mcp
+        import importlib.util
 
+        mcp_spec = importlib.util.find_spec("mcp")
+        if mcp_spec:
             print("✅ MCP package already installed")
-        except ImportError:
+        else:
             print("📦 Installing MCP package...")
             try:
                 subprocess.check_call([sys.executable, "-m", "pip", "install", "mcp"])
@@ -46,19 +47,50 @@ class MCPInstallCommands:
                 return 1
 
         # Step 2: Configure Claude Code with the new CLI command
-        print("\n2️⃣  Configuring Claude Code (~/.claude.json)...")
+        print("\n2️⃣  Configuring Claude Code...")
         try:
             success = self._configure_claude_desktop(args.force)
-            if success:
-                print("✅ Configuration completed successfully")
-                print("\n🎉 MCP Gateway is ready to use!")
-                print("\nNext steps:")
-                print("1. Restart Claude Code (if running)")
-                print("2. Test the server: claude-mpm mcp server --test")
-                print("3. Check status: claude-mpm mcp status")
-                return 0
-            print("❌ Configuration failed")
-            return 1
+            if not success:
+                print("❌ Main gateway configuration failed")
+                return 1
+
+            # Step 3: Setup external MCP services
+            print("\n3️⃣  Setting up External MCP Services...")
+            from .mcp_setup_external import MCPExternalServicesSetup
+
+            external_setup = MCPExternalServicesSetup(self.logger)
+
+            # Check if user wants to set up external services
+            response = (
+                input(
+                    "\nDo you want to set up external MCP services (mcp-vector-search, mcp-browser)? (Y/n): "
+                )
+                .strip()
+                .lower()
+            )
+            if response in ["", "y", "yes"]:
+                # Install Python packages for external services
+                external_setup.check_and_install_pip_packages()
+
+                # Setup external services in Claude Code config
+                if external_setup.setup_external_services(force=args.force):
+                    print("✅ External services configured successfully")
+                else:
+                    print("⚠️ Some external services may not have been configured")
+            else:
+                print("⏭️ Skipping external services setup")
+                print(
+                    "   You can set them up later with: claude-mpm mcp external setup"
+                )
+
+            print("\n✅ Configuration completed successfully")
+            print("\n🎉 MCP Gateway is ready to use!")
+            print("\nNext steps:")
+            print("1. Restart Claude Code (if running)")
+            print("2. Test the server: claude-mpm mcp server --test")
+            print("3. Check status: claude-mpm mcp status")
+            print("4. List external services: claude-mpm mcp external list")
+            return 0
 
         except Exception as e:
             print(f"❌ Error during configuration: {e}")
@@ -67,9 +99,9 @@ class MCPInstallCommands:
     def _configure_claude_desktop(self, force=False):
         """Configure Claude Code to use the MCP gateway via CLI command.
 
-        WHY: Claude Code reads MCP server configurations from ~/.claude.json
-        (not ~/.claude/settings.local.json). This method updates that file
-        to include the claude-mpm-gateway server configuration.
+        WHY: Claude Code reads MCP server configurations from a platform-specific
+        configuration file. This method updates that file to include the claude-mpm-gateway
+        server configuration.
 
         Args:
             force: Whether to overwrite existing configuration
@@ -139,11 +171,49 @@ class MCPInstallCommands:
         Returns:
             Path or None: Path to Claude Code config file
         """
-
-        # Claude Code reads MCP server configurations from ~/.claude.json
-        # This is the actual file that Claude Code uses for MCP servers
-        # NOT ~/.claude/settings.local.json
-        return Path.home() / ".claude.json"
+        import platform
+
+        # Try multiple possible locations for Claude Code config
+        possible_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
+        ]
+
+        for path in possible_paths:
+            if path.exists():
+                return path
+
+        # If none exist, return the platform-appropriate default
+        system = platform.system()
+        if system == "Darwin":  # macOS
+            return (
+                Path.home()
+                / "Library"
+                / "Application Support"
+                / "Claude"
+                / "claude_desktop_config.json"
+            )
+        if system == "Windows":
+            return (
+                Path.home()
+                / "AppData"
+                / "Roaming"
+                / "Claude"
+                / "claude_desktop_config.json"
+            )
+        # Linux and others
+        return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
 
     def _find_claude_mpm_executable(self):
         """Find the claude-mpm executable path.
@@ -172,13 +242,12 @@ class MCPInstallCommands:
             return str(executable_path)
 
         # Fallback: Use Python module invocation if no executable found
-        try:
-            import claude_mpm
+        import importlib.util
 
+        claude_mpm_spec = importlib.util.find_spec("claude_mpm")
+        if claude_mpm_spec:
             print(f"   Using Python module: {sys.executable} -m claude_mpm")
             return sys.executable
-        except ImportError:
-            pass
 
         return None
 
@@ -193,7 +262,7 @@ class MCPInstallCommands:
             dict or None: Configuration dictionary
         """
         import json
-        from datetime import datetime
+        from datetime import datetime, timezone
 
         config = {}
 
@@ -201,7 +270,7 @@ class MCPInstallCommands:
             if not force:
                 # Check if claude-mpm-gateway already exists
                 try:
-                    with open(config_path) as f:
+                    with config_path.open() as f:
                         existing_config = json.load(f)
 
                     if (
@@ -226,7 +295,7 @@ class MCPInstallCommands:
 
                     # Create backup
                     backup_path = config_path.with_suffix(
-                        f'.backup.{datetime.now().strftime("%Y%m%d_%H%M%S")}.json'
+                        f'.backup.{datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")}.json'
                     )
                     try:
                         config_path.rename(backup_path)
@@ -236,11 +305,11 @@ class MCPInstallCommands:
             else:
                 # Force mode - create backup but proceed
                 try:
-                    with open(config_path) as f:
+                    with config_path.open() as f:
                         existing_config = json.load(f)
                     config = existing_config
                     print("   Force mode: Overwriting existing configuration")
-                except:
+                except Exception:
                     pass  # File doesn't exist or is invalid, start fresh
 
         # Ensure mcpServers section exists
@@ -266,7 +335,7 @@ class MCPInstallCommands:
             config_path.parent.mkdir(parents=True, exist_ok=True)
 
             # Write configuration with nice formatting
-            with open(config_path, "w") as f:
+            with config_path.open("w") as f:
                 json.dump(config, f, indent=2)
 
             print(f"\n✅ Configuration saved to {config_path}")

claude_mpm/cli/commands/mcp_pipx_config.py

@@ -110,7 +110,7 @@ def configure_mcp_for_pipx(args) -> int:
     existing_config = {}
     if config_path.exists():
         try:
-            with open(config_path) as f:
+            with config_path.open() as f:
                 existing_config = json.load(f)
             print("✅ Existing config loaded")
         except json.JSONDecodeError:
@@ -145,7 +145,7 @@ def configure_mcp_for_pipx(args) -> int:
     # Write config
     if not args.dry_run:
         try:
-            with open(config_path, "w") as f:
+            with config_path.open("w") as f:
                 json.dump(existing_config, f, indent=2)
             print(f"\n✅ Configuration written to: {config_path}")
         except Exception as e: