claude-mpm 4.4.7__py3-none-any.whl → 4.4.9__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.4.7
+4.4.9

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -5,11 +5,14 @@ WHY: Verify that MCP services (mcp-vector-search, mcp-browser, mcp-ticketer, kuz
 are properly installed and accessible for enhanced Claude Code capabilities.
 """
 
+import asyncio
 import json
 import subprocess
+import time
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+from claude_mpm.core.logger import get_logger
 from ..models import DiagnosticResult, DiagnosticStatus
 from .base_check import BaseDiagnosticCheck
 
@@ -17,6 +20,11 @@ from .base_check import BaseDiagnosticCheck
 class MCPServicesCheck(BaseDiagnosticCheck):
     """Check MCP external services installation and health."""
 
+    def __init__(self, verbose: bool = False):
+        """Initialize the MCP services check."""
+        super().__init__(verbose)
+        self.logger = get_logger(self.__class__.__name__)
+
     # Define MCP services to check
     MCP_SERVICES = {
         "mcp-vector-search": {
@@ -29,6 +37,8 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             "check_health": True,
             "health_command": ["mcp-vector-search", "--version"],
             "pipx_run_command": ["pipx", "run", "mcp-vector-search", "--version"],
+            "mcp_command": ["python", "-m", "mcp_vector_search.mcp.server"],  # Command to run as MCP server
+            "pipx_mcp_command": ["pipx", "run", "--spec", "mcp-vector-search", "python", "-m", "mcp_vector_search.mcp.server"],
         },
         "mcp-browser": {
             "package": "mcp-browser",
@@ -37,6 +47,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             "check_health": True,
             "health_command": ["mcp-browser", "--version"],
             "pipx_run_command": ["pipx", "run", "mcp-browser", "--version"],
+            "mcp_command": ["mcp-browser", "mcp"],  # Command to run as MCP server
         },
         "mcp-ticketer": {
             "package": "mcp-ticketer",
@@ -45,6 +56,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             "check_health": True,
             "health_command": ["mcp-ticketer", "--version"],
             "pipx_run_command": ["pipx", "run", "mcp-ticketer", "--version"],
+            "mcp_command": ["mcp-ticketer", "mcp"],  # Command to run as MCP server
         },
         "kuzu-memory": {
             "package": "kuzu-memory",
@@ -53,6 +65,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             "check_health": True,  # v1.1.0+ has version command
             "health_command": ["kuzu-memory", "--version"],
             "pipx_run_command": ["pipx", "run", "kuzu-memory", "--version"],
+            "mcp_command": ["kuzu-memory", "mcp", "serve"],  # v1.1.0+ uses 'mcp serve' args
         },
     }
 
@@ -71,15 +84,29 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             sub_results = []
             services_status = {}
 
+            # Check for kuzu-memory configuration issues and offer auto-fix
+            kuzu_config_result = self._check_and_fix_kuzu_memory_config()
+            if kuzu_config_result:
+                sub_results.append(kuzu_config_result)
+
             # Check each MCP service
             for service_name, service_config in self.MCP_SERVICES.items():
                 service_result = self._check_service(service_name, service_config)
                 sub_results.append(service_result)
+
+                # Extract connection test info if available
+                connection_test = service_result.details.get("connection_test", {})
+
                 services_status[service_name] = {
                     "status": service_result.status.value,
                     "installed": service_result.details.get("installed", False),
                     "accessible": service_result.details.get("accessible", False),
                     "version": service_result.details.get("version"),
+                    "connection_tested": bool(connection_test),
+                    "connected": connection_test.get("connected", False),
+                    "response_time_ms": connection_test.get("response_time_ms"),
+                    "tools_discovered": connection_test.get("tools_discovered", 0),
+                    "connection_error": connection_test.get("error"),
                 }
 
             # Check MCP gateway configuration for services
@@ -91,12 +118,18 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             accessible_count = sum(
                 1 for s in services_status.values() if s["accessible"]
             )
+            connected_count = sum(1 for s in services_status.values() if s["connected"])
             total_services = len(self.MCP_SERVICES)
 
+            # Calculate total tools discovered
+            total_tools = sum(s.get("tools_discovered", 0) for s in services_status.values())
+
             details["services"] = services_status
             details["installed_count"] = installed_count
             details["accessible_count"] = accessible_count
+            details["connected_count"] = connected_count
             details["total_services"] = total_services
+            details["total_tools_discovered"] = total_tools
             details["gateway_configured"] = gateway_result.status == DiagnosticStatus.OK
 
             # Determine overall status
@@ -109,6 +142,12 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             elif installed_count == 0:
                 status = DiagnosticStatus.WARNING
                 message = "No MCP services installed"
+            elif connected_count == total_services:
+                status = DiagnosticStatus.OK
+                message = f"All {total_services} MCP services connected ({total_tools} tools available)"
+            elif connected_count > 0:
+                status = DiagnosticStatus.WARNING
+                message = f"{connected_count}/{total_services} MCP services connected, {installed_count} installed"
             elif accessible_count < installed_count:
                 status = DiagnosticStatus.WARNING
                 message = f"{installed_count}/{total_services} services installed, {accessible_count} accessible"
@@ -116,8 +155,8 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                 status = DiagnosticStatus.WARNING
                 message = f"{installed_count}/{total_services} MCP services installed"
             else:
-                status = DiagnosticStatus.OK
-                message = f"All {total_services} MCP services installed and accessible"
+                status = DiagnosticStatus.WARNING
+                message = f"All {total_services} MCP services installed but connections not tested"
 
             return DiagnosticResult(
                 category=self.category,
@@ -135,6 +174,185 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                 details={"error": str(e)},
             )
 
+    async def _test_mcp_connection(
+        self, service_name: str, command: List[str]
+    ) -> Dict:
+        """Test MCP server connection by sending JSON-RPC requests."""
+        result = {
+            "connected": False,
+            "response_time": None,
+            "tools_count": 0,
+            "tools": [],
+            "error": None,
+        }
+
+        process = None
+        try:
+            # Start the MCP server process
+            start_time = time.time()
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            # Give the server a moment to initialize
+            await asyncio.sleep(0.1)
+
+            # Prepare initialize request
+            init_request = {
+                "jsonrpc": "2.0",
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {},
+                    "clientInfo": {
+                        "name": "mpm-doctor",
+                        "version": "1.0.0"
+                    }
+                },
+                "id": 1
+            }
+
+            # Send initialize request
+            request_line = json.dumps(init_request) + "\n"
+            process.stdin.write(request_line.encode())
+            await process.stdin.drain()
+
+            # Read response with timeout
+            try:
+                response_line = await asyncio.wait_for(
+                    process.stdout.readline(), timeout=5.0
+                )
+                response_time = time.time() - start_time
+
+                if response_line:
+                    # Some MCP servers may output non-JSON before the actual response
+                    # Try to find JSON in the response
+                    response_text = response_line.decode().strip()
+
+                    # Skip empty lines or non-JSON lines
+                    while response_text and not response_text.startswith('{'):
+                        # Try to read the next line
+                        try:
+                            response_line = await asyncio.wait_for(
+                                process.stdout.readline(), timeout=1.0
+                            )
+                            if response_line:
+                                response_text = response_line.decode().strip()
+                            else:
+                                break
+                        except asyncio.TimeoutError:
+                            break
+
+                    if not response_text or not response_text.startswith('{'):
+                        result["error"] = "No valid JSON response received"
+                        return result
+
+                    response = json.loads(response_text)
+
+                    # Check for valid JSON-RPC response
+                    if "result" in response and response.get("id") == 1:
+                        result["connected"] = True
+                        result["response_time"] = round(response_time * 1000, 2)  # ms
+
+                        # Send tools/list request
+                        tools_request = {
+                            "jsonrpc": "2.0",
+                            "method": "tools/list",
+                            "params": {},
+                            "id": 2
+                        }
+
+                        request_line = json.dumps(tools_request) + "\n"
+                        process.stdin.write(request_line.encode())
+                        await process.stdin.drain()
+
+                        # Read tools response
+                        try:
+                            tools_response_line = await asyncio.wait_for(
+                                process.stdout.readline(), timeout=3.0
+                            )
+
+                            if tools_response_line:
+                                tools_response = json.loads(tools_response_line.decode())
+                                if "result" in tools_response:
+                                    tools = tools_response["result"].get("tools", [])
+                                    result["tools_count"] = len(tools)
+                                    # Store first 5 tool names for display
+                                    result["tools"] = [
+                                        tool.get("name", "unknown")
+                                        for tool in tools[:5]
+                                    ]
+                        except asyncio.TimeoutError:
+                            # Connection successful but tools query timed out
+                            pass
+                        except (json.JSONDecodeError, KeyError):
+                            # Connection successful but tools response invalid
+                            pass
+
+                    elif "error" in response:
+                        result["error"] = f"MCP error: {response['error'].get('message', 'Unknown error')}"
+                    else:
+                        result["error"] = "Invalid JSON-RPC response format"
+
+            except asyncio.TimeoutError:
+                # Try to get any error output from stderr
+                stderr_output = ""
+                if process and process.stderr:
+                    try:
+                        stderr_data = await asyncio.wait_for(
+                            process.stderr.read(1000), timeout=0.5
+                        )
+                        if stderr_data:
+                            stderr_output = stderr_data.decode('utf-8', errors='ignore')[:200]
+                    except:
+                        pass
+
+                if stderr_output:
+                    result["error"] = f"Connection timeout (5s). Server output: {stderr_output}"
+                else:
+                    result["error"] = "Connection timeout (5s)"
+
+            except json.JSONDecodeError as e:
+                # Try to get stderr for more context
+                stderr_output = ""
+                if process and process.stderr:
+                    try:
+                        stderr_data = await asyncio.wait_for(
+                            process.stderr.read(1000), timeout=0.5
+                        )
+                        if stderr_data:
+                            stderr_output = stderr_data.decode('utf-8', errors='ignore')[:200]
+                    except:
+                        pass
+
+                if stderr_output:
+                    result["error"] = f"Invalid JSON response: {str(e)}. Server error: {stderr_output}"
+                else:
+                    result["error"] = f"Invalid JSON response: {str(e)}"
+
+        except FileNotFoundError:
+            result["error"] = f"Command not found: {command[0]}"
+        except PermissionError:
+            result["error"] = f"Permission denied: {command[0]}"
+        except Exception as e:
+            result["error"] = f"Connection failed: {str(e)}"
+        finally:
+            # Clean up process
+            if process:
+                try:
+                    process.terminate()
+                    await asyncio.wait_for(process.wait(), timeout=2.0)
+                except asyncio.TimeoutError:
+                    process.kill()
+                    await process.wait()
+                except Exception:
+                    pass
+
+        return result
+
     def _check_service(self, service_name: str, config: Dict) -> DiagnosticResult:
         """Check a specific MCP service."""
         details = {"service": service_name}
@@ -145,6 +363,12 @@ class MCPServicesCheck(BaseDiagnosticCheck):
         if pipx_path:
             details["pipx_path"] = pipx_path
 
+        # Special check for mcp-ticketer: ensure gql dependency
+        if service_name == "mcp-ticketer" and pipx_installed:
+            gql_fixed = self._ensure_mcp_ticketer_gql_dependency()
+            if gql_fixed:
+                details["gql_dependency_fixed"] = True
+
         # Check if accessible in PATH
         accessible, command_path = self._check_command_accessible(config["command"])
         details["accessible"] = accessible
@@ -186,6 +410,64 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                     details["version"] = version
                     break
 
+        # Test MCP connection if installed (accessible or pipx) and has mcp_command
+        if (accessible or pipx_installed) and "mcp_command" in config:
+            # Determine which command to use for MCP connection test
+            mcp_command = None
+            if pipx_installed and not accessible:
+                # Service is installed via pipx but not in PATH
+                if "pipx_mcp_command" in config:
+                    # Use special pipx MCP command if available (e.g., for mcp-vector-search)
+                    mcp_command = config["pipx_mcp_command"]
+                else:
+                    # Build pipx run command based on package
+                    base_cmd = config["mcp_command"]
+                    if len(base_cmd) > 0 and base_cmd[0] == config["package"]:
+                        # Simple case where first command is the package name
+                        mcp_command = ["pipx", "run", config["package"]] + base_cmd[1:]
+                    else:
+                        # Complex case - just try running the package with mcp arg
+                        mcp_command = ["pipx", "run", config["package"], "mcp"]
+            elif details.get("accessible_via_pipx_run"):
+                # Use pipx run for the MCP command
+                if "pipx_mcp_command" in config:
+                    # Use special pipx MCP command if available (e.g., for mcp-vector-search)
+                    mcp_command = config["pipx_mcp_command"]
+                else:
+                    # Build pipx run command
+                    base_cmd = config["mcp_command"]
+                    if service_name == "kuzu-memory":
+                        # Special case for kuzu-memory with args
+                        mcp_command = ["pipx", "run", base_cmd[0]] + base_cmd[1:]
+                    else:
+                        mcp_command = ["pipx", "run"] + base_cmd
+            else:
+                mcp_command = config["mcp_command"]
+
+            if mcp_command:
+                # Run async connection test
+                try:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    connection_result = loop.run_until_complete(
+                        self._test_mcp_connection(service_name, mcp_command)
+                    )
+                    loop.close()
+
+                    # Add connection test results to details
+                    details["connection_test"] = {
+                        "connected": connection_result["connected"],
+                        "response_time_ms": connection_result["response_time"],
+                        "tools_discovered": connection_result["tools_count"],
+                        "tools_sample": connection_result["tools"],
+                        "error": connection_result["error"]
+                    }
+                except Exception as e:
+                    details["connection_test"] = {
+                        "connected": False,
+                        "error": f"Test failed: {str(e)}"
+                    }
+
         # Determine status
         if not (pipx_installed or accessible):
             return DiagnosticResult(
@@ -200,10 +482,19 @@ class MCPServicesCheck(BaseDiagnosticCheck):
         if pipx_installed and not accessible:
             # Check if pipx run works
             if details.get("pipx_run_available"):
+                # Include connection test info if available
+                connection_info = details.get("connection_test", {})
+                if connection_info.get("connected"):
+                    message = f"Installed via pipx, connection OK ({connection_info.get('tools_discovered', 0)} tools)"
+                elif connection_info.get("error"):
+                    message = f"Installed via pipx, connection failed: {connection_info['error']}"
+                else:
+                    message = "Installed via pipx (use 'pipx run' to execute)"
+
                 return DiagnosticResult(
                     category=f"MCP Service: {service_name}",
-                    status=DiagnosticStatus.OK,
-                    message="Installed via pipx (use 'pipx run' to execute)",
+                    status=DiagnosticStatus.OK if connection_info.get("connected") else DiagnosticStatus.WARNING,
+                    message=message,
                     details=details,
                 )
             return DiagnosticResult(
@@ -215,10 +506,26 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                 fix_description="Ensure pipx bin directory is in PATH",
             )
 
+        # Service is accessible - check connection test results
+        connection_info = details.get("connection_test", {})
+        if connection_info:
+            if connection_info.get("connected"):
+                response_time = connection_info.get("response_time_ms")
+                tools_count = connection_info.get("tools_discovered", 0)
+                message = f"Installed, accessible, connection OK ({tools_count} tools, {response_time}ms)"
+                status = DiagnosticStatus.OK
+            else:
+                error = connection_info.get("error", "Unknown error")
+                message = f"Installed but connection failed: {error}"
+                status = DiagnosticStatus.WARNING
+        else:
+            message = "Installed and accessible"
+            status = DiagnosticStatus.OK
+
         return DiagnosticResult(
             category=f"MCP Service: {service_name}",
-            status=DiagnosticStatus.OK,
-            message="Installed and accessible",
+            status=status,
+            message=message,
             details=details,
         )
 
@@ -391,6 +698,149 @@ class MCPServicesCheck(BaseDiagnosticCheck):
 
         return None
 
+    def _check_and_fix_kuzu_memory_config(self) -> Optional[DiagnosticResult]:
+        """Check for incorrect kuzu-memory configuration in .claude.json and offer auto-fix."""
+        claude_config_path = Path.home() / ".claude.json"
+
+        if not claude_config_path.exists():
+            return None
+
+        try:
+            with open(claude_config_path) as f:
+                config = json.load(f)
+
+            mcp_servers = config.get("mcpServers", {})
+            kuzu_config = mcp_servers.get("kuzu-memory")
+
+            if not kuzu_config:
+                return None
+
+            # Check if kuzu-memory has incorrect args
+            args = kuzu_config.get("args", [])
+            needs_fix = False
+            fix_reason = ""
+            # The correct args for kuzu-memory v1.1.0+ are ["mcp", "serve"]
+            correct_args = ["mcp", "serve"]
+
+            # Check for any configuration that is NOT the correct one
+            if args != correct_args:
+                needs_fix = True
+                # Identify the specific issue
+                if args == ["claude", "mcp-server"]:
+                    fix_reason = "Outdated 'claude mcp-server' format (pre-v1.1.0)"
+                elif args == ["serve"]:
+                    fix_reason = "Legacy 'serve' format"
+                elif args == ["mcp-server"]:
+                    fix_reason = "Incorrect 'mcp-server' format"
+                elif args == []:
+                    fix_reason = "Empty args list"
+                else:
+                    fix_reason = f"Incorrect args format: {args}"
+
+            if needs_fix:
+                # Log the issue for debugging
+                self.logger.warning(
+                    f"Found incorrect kuzu-memory configuration: {fix_reason}. "
+                    f"Current args: {args}, should be: {correct_args}"
+                )
+
+                # Auto-fix the configuration
+                fixed = self._fix_kuzu_memory_args(claude_config_path, config, correct_args)
+
+                if fixed:
+                    return DiagnosticResult(
+                        category="kuzu-memory Configuration Fix",
+                        status=DiagnosticStatus.OK,
+                        message=f"Fixed kuzu-memory configuration to use correct args",
+                        details={
+                            "old_args": args,
+                            "new_args": correct_args,
+                            "reason": fix_reason,
+                            "auto_fixed": True,
+                        },
+                    )
+                else:
+                    return DiagnosticResult(
+                        category="kuzu-memory Configuration",
+                        status=DiagnosticStatus.WARNING,
+                        message="kuzu-memory has incorrect configuration",
+                        details={
+                            "current_args": args,
+                            "correct_args": correct_args,
+                            "reason": fix_reason,
+                            "auto_fix_failed": True,
+                        },
+                        fix_command="claude-mpm configure --mcp --fix-kuzu",
+                        fix_description="Fix kuzu-memory configuration manually",
+                    )
+
+            # Configuration is correct - args match ["mcp", "serve"]
+            return None
+
+        except (json.JSONDecodeError, Exception) as e:
+            self.logger.debug(f"Could not check kuzu-memory config: {e}")
+            return None
+
+    def _fix_kuzu_memory_args(self, config_path: Path, config: Dict, new_args: List[str]) -> bool:
+        """Fix kuzu-memory args in the configuration."""
+        try:
+            # Save old args before updating
+            old_args = config["mcpServers"]["kuzu-memory"].get("args", [])
+
+            # Log the exact change we're about to make
+            self.logger.debug(
+                f"Fixing kuzu-memory args: old={old_args}, new={new_args}"
+            )
+
+            # Create backup
+            backup_path = config_path.with_suffix(".json.backup")
+            with open(backup_path, "w") as f:
+                json.dump(config, f, indent=2)
+
+            # Update the configuration - ensure we're setting the exact new_args
+            config["mcpServers"]["kuzu-memory"]["args"] = new_args
+
+            # Verify the update in memory before writing
+            if config["mcpServers"]["kuzu-memory"]["args"] != new_args:
+                self.logger.error(
+                    f"Failed to update args in memory! "
+                    f"Expected {new_args}, got {config['mcpServers']['kuzu-memory']['args']}"
+                )
+                return False
+
+            # Write updated configuration
+            with open(config_path, "w") as f:
+                json.dump(config, f, indent=2)
+
+            # Verify the file was written correctly
+            with open(config_path) as f:
+                verify_config = json.load(f)
+                verify_args = verify_config.get("mcpServers", {}).get("kuzu-memory", {}).get("args", [])
+
+                if verify_args != new_args:
+                    self.logger.error(
+                        f"Configuration write verification failed! "
+                        f"Expected {new_args}, got {verify_args}"
+                    )
+                    # Restore backup
+                    with open(backup_path) as bf:
+                        backup_config = json.load(bf)
+                    with open(config_path, "w") as f:
+                        json.dump(backup_config, f, indent=2)
+                    return False
+
+            self.logger.info(
+                f"✅ Fixed kuzu-memory configuration in {config_path}\n"
+                f"   Changed args from {old_args} to {new_args}\n"
+                f"   Backup saved to {backup_path}"
+            )
+
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to fix kuzu-memory configuration: {e}")
+            return False
+
     def _check_gateway_configuration(self) -> DiagnosticResult:
         """Check if MCP services are configured in the gateway."""
         try:
@@ -472,3 +922,41 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                 message=f"Could not check configuration: {e!s}",
                 details={"error": str(e)},
             )
+
+    def _ensure_mcp_ticketer_gql_dependency(self) -> bool:
+        """Ensure mcp-ticketer has the gql dependency injected."""
+        try:
+            # First check if mcp-ticketer can import gql
+            result = subprocess.run(
+                ["pipx", "run", "--spec", "mcp-ticketer", "python", "-c", "import gql"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            # If import fails, inject the dependency
+            if result.returncode != 0:
+                self.logger.info("🔧 mcp-ticketer missing gql dependency, fixing...")
+
+                inject_result = subprocess.run(
+                    ["pipx", "inject", "mcp-ticketer", "gql"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    check=False,
+                )
+
+                if inject_result.returncode == 0:
+                    self.logger.info("✅ Successfully injected gql dependency into mcp-ticketer")
+                    return True
+                else:
+                    self.logger.warning(f"Failed to inject gql dependency: {inject_result.stderr}")
+                    return False
+
+            # Dependency already present
+            return False
+
+        except Exception as e:
+            self.logger.debug(f"Could not check/fix mcp-ticketer gql dependency: {e}")
+            return False

claude_mpm/services/diagnostics/diagnostic_runner.py

@@ -214,6 +214,9 @@ class DiagnosticRunner:
             "agents": AgentCheck,
             "agent": AgentCheck,
             "mcp": MCPCheck,
+            "mcp_services": MCPServicesCheck,
+            "mcp-services": MCPServicesCheck,
+            "external": MCPServicesCheck,
             "monitor": MonitorCheck,
             "monitoring": MonitorCheck,
             "common": CommonIssuesCheck,

claude_mpm/services/mcp_config_manager.py

@@ -41,6 +41,33 @@ class MCPConfigManager:
         "kuzu-memory",
     }
 
+    # Static known-good MCP service configurations
+    # These are the correct, tested configurations that work reliably
+    STATIC_MCP_CONFIGS = {
+        "kuzu-memory": {
+            "type": "stdio",
+            "command": "pipx",
+            "args": ["run", "kuzu-memory", "mcp", "serve"]
+        },
+        "mcp-ticketer": {
+            "type": "stdio",
+            "command": "pipx",
+            "args": ["run", "mcp-ticketer", "mcp"]
+        },
+        "mcp-browser": {
+            "type": "stdio",
+            "command": "pipx",
+            "args": ["run", "mcp-browser", "mcp"],
+            "env": {"MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")}
+        },
+        "mcp-vector-search": {
+            "type": "stdio",
+            "command": "pipx",
+            "args": ["run", "mcp-vector-search", "-m", "mcp_vector_search.mcp.server", "{project_root}"],
+            "env": {}
+        }
+    }
+
     def __init__(self):
         """Initialize the MCP configuration manager."""
         self.logger = get_logger(__name__)
@@ -195,11 +222,36 @@ class MCPConfigManager:
 
         return None
 
+    def get_static_service_config(self, service_name: str) -> Optional[Dict]:
+        """
+        Get the static, known-good configuration for an MCP service.
+
+        Args:
+            service_name: Name of the MCP service
+
+        Returns:
+            Static service configuration dict or None if service not known
+        """
+        if service_name not in self.STATIC_MCP_CONFIGS:
+            return None
+
+        config = self.STATIC_MCP_CONFIGS[service_name].copy()
+
+        # Special handling for mcp-vector-search: replace {project_root} placeholder
+        if service_name == "mcp-vector-search":
+            config["args"] = [
+                arg.replace("{project_root}", str(self.project_root)) if "{project_root}" in arg else arg
+                for arg in config["args"]
+            ]
+
+        return config
+
     def generate_service_config(self, service_name: str) -> Optional[Dict]:
         """
         Generate configuration for a specific MCP service.
 
-        Prefers 'pipx run' or 'uvx' commands over direct execution for better isolation.
+        Prefers static configurations over detection. Falls back to detection
+        only for unknown services.
 
         Args:
             service_name: Name of the MCP service
@@ -207,6 +259,12 @@ class MCPConfigManager:
         Returns:
             Service configuration dict or None if service not found
         """
+        # First try to get static configuration
+        static_config = self.get_static_service_config(service_name)
+        if static_config:
+            return static_config
+
+        # Fall back to detection-based configuration for unknown services
         import shutil
 
         # Check for pipx run first (preferred for isolation)
@@ -308,7 +366,7 @@ class MCPConfigManager:
 
         elif service_name == "kuzu-memory":
             # Determine kuzu-memory command version
-            kuzu_args = ["mcp", "serve"]  # Default to the correct modern format
+            kuzu_args = ["mcp", "serve"]  # Default to the standard v1.1.0+ format
             test_cmd = None
 
             if use_pipx_run:
@@ -330,20 +388,21 @@ class MCPConfigManager:
                     # Check for MCP support in help output
                     help_output = result.stdout.lower() + result.stderr.lower()
 
-                    # Modern version detection - look for "mcp serve" command
+                    # Standard version detection - look for "mcp serve" command (v1.1.0+)
+                    # This is the correct format for kuzu-memory v1.1.0 and later
                     if "mcp serve" in help_output or ("mcp" in help_output and "serve" in help_output):
-                        # Modern version with mcp serve command
+                        # Standard v1.1.0+ version with mcp serve command
                         kuzu_args = ["mcp", "serve"]
                     # Legacy version detection - only "serve" without "mcp"
                     elif "serve" in help_output and "mcp" not in help_output:
                         # Very old version that only has serve command
                         kuzu_args = ["serve"]
-                    # Note: "claude mcp-server" format is deprecated and not used
                     else:
-                        # Default to the correct modern format
+                        # Default to the standard mcp serve format (v1.1.0+)
+                        # Note: "claude mcp-server" format is deprecated and does not work
                         kuzu_args = ["mcp", "serve"]
                 except Exception:
-                    # Default to the correct mcp serve command on any error
+                    # Default to the standard mcp serve command on any error
                     kuzu_args = ["mcp", "serve"]
 
             if use_pipx_run:
@@ -371,17 +430,20 @@ class MCPConfigManager:
 
     def ensure_mcp_services_configured(self) -> Tuple[bool, str]:
         """
-        Ensure MCP services are configured in ~/.claude.json on startup.
+        Ensure MCP services are configured correctly in ~/.claude.json on startup.
 
-        This method checks if the core MCP services are configured in the
-        current project's mcpServers section and automatically adds them if missing.
+        This method checks ALL projects in ~/.claude.json and ensures each has
+        the correct, static MCP service configurations. It will:
+        1. Add missing services
+        2. Fix incorrect configurations
+        3. Update all projects, not just the current one
 
         Returns:
             Tuple of (success, message)
         """
         updated = False
+        fixed_services = []
         added_services = []
-        project_key = str(self.project_root)
 
         # Load existing Claude config or create minimal structure
         claude_config = {}
@@ -396,9 +458,23 @@ class MCPConfigManager:
         # Ensure projects structure exists
         if "projects" not in claude_config:
             claude_config["projects"] = {}
+            updated = True
 
-        if project_key not in claude_config["projects"]:
-            claude_config["projects"][project_key] = {
+        # Check and fix mcp-ticketer dependencies ONCE before processing projects
+        # This avoids running the same pipx inject command 100+ times
+        mcp_ticketer_fixed = False
+        if "mcp-ticketer" in self.PIPX_SERVICES:
+            mcp_ticketer_fixed = self._check_and_fix_mcp_ticketer_dependencies()
+
+        # Process ALL projects in the config, not just current one
+        projects_to_update = list(claude_config.get("projects", {}).keys())
+
+        # Also add the current project if not in list
+        current_project_key = str(self.project_root)
+        if current_project_key not in projects_to_update:
+            projects_to_update.append(current_project_key)
+            # Initialize new project structure
+            claude_config["projects"][current_project_key] = {
                 "allowedTools": [],
                 "history": [],
                 "mcpContextUris": [],
@@ -412,29 +488,51 @@ class MCPConfigManager:
             }
             updated = True
 
-        # Get the project's mcpServers section
-        project_config = claude_config["projects"][project_key]
-        if "mcpServers" not in project_config:
-            project_config["mcpServers"] = {}
-            updated = True
-
-        # Check each service and add if missing
-        for service_name in self.PIPX_SERVICES:
-            if service_name not in project_config["mcpServers"]:
-                # Try to detect and configure the service
-                service_path = self.detect_service_path(service_name)
-                if service_path:
-                    config = self.generate_service_config(service_name)
-                    if config:
-                        project_config["mcpServers"][service_name] = config
-                        added_services.append(service_name)
-                        updated = True
-                        self.logger.debug(
-                            f"Added MCP service to config: {service_name}"
-                        )
+        # Update each project's MCP configurations
+        for project_key in projects_to_update:
+            project_config = claude_config["projects"][project_key]
+
+            # Ensure mcpServers section exists
+            if "mcpServers" not in project_config:
+                project_config["mcpServers"] = {}
+                updated = True
+
+            # Check and fix each service configuration
+            for service_name in self.PIPX_SERVICES:
+                # Get the correct static configuration
+                correct_config = self.STATIC_MCP_CONFIGS[service_name].copy()
+
+                # Special handling for mcp-vector-search: replace {project_root} placeholder
+                if service_name == "mcp-vector-search":
+                    # Use the project key as the project root for each project
+                    correct_config["args"] = [
+                        arg.replace("{project_root}", project_key) if "{project_root}" in arg else arg
+                        for arg in correct_config["args"]
+                    ]
+
+                # Check if service exists and has correct configuration
+                existing_config = project_config["mcpServers"].get(service_name)
+
+                # Determine if we need to update
+                needs_update = False
+                if not existing_config:
+                    # Service is missing
+                    needs_update = True
+                    added_services.append(f"{service_name} in {Path(project_key).name}")
                 else:
+                    # Service exists, check if configuration is correct
+                    # Compare command and args (the most critical parts)
+                    if (existing_config.get("command") != correct_config.get("command") or
+                        existing_config.get("args") != correct_config.get("args")):
+                        needs_update = True
+                        fixed_services.append(f"{service_name} in {Path(project_key).name}")
+
+                # Update configuration if needed
+                if needs_update:
+                    project_config["mcpServers"][service_name] = correct_config
+                    updated = True
                     self.logger.debug(
-                        f"MCP service {service_name} not found for auto-configuration"
+                        f"Updated MCP service config for {service_name} in project {Path(project_key).name}"
                     )
 
         # Write updated config if changes were made
@@ -448,7 +546,6 @@ class MCPConfigManager:
                             f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
                         )
                         import shutil
-
                         shutil.copy2(self.claude_config_path, backup_path)
                         self.logger.debug(f"Created backup: {backup_path}")
 
@@ -456,18 +553,20 @@ class MCPConfigManager:
                 with open(self.claude_config_path, "w") as f:
                     json.dump(claude_config, f, indent=2)
 
+                messages = []
                 if added_services:
-                    message = (
-                        f"Auto-configured MCP services: {', '.join(added_services)}"
-                    )
-                    # Don't log here - let the caller handle logging to avoid duplicates
-                    return True, message
-                return True, "All MCP services already configured"
+                    messages.append(f"Added MCP services: {', '.join(added_services[:3])}")
+                if fixed_services:
+                    messages.append(f"Fixed MCP services: {', '.join(fixed_services[:3])}")
+
+                if messages:
+                    return True, "; ".join(messages)
+                return True, "All MCP services already configured correctly"
             except Exception as e:
                 self.logger.error(f"Failed to write Claude config: {e}")
                 return False, f"Failed to write configuration: {e}"
 
-        return True, "All MCP services already configured"
+        return True, "All MCP services already configured correctly"
 
     def update_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
         """
@@ -695,6 +794,49 @@ class MCPConfigManager:
 
         return False, "none"
 
+    def _check_and_fix_mcp_ticketer_dependencies(self) -> bool:
+        """Check and fix mcp-ticketer missing gql dependency.
+
+        Note: This is a workaround for mcp-ticketer <= 0.1.8 which is missing
+        the gql dependency in its package metadata. Future versions (> 0.1.8)
+        should include 'gql[httpx]>=3.0.0' as a dependency, making this fix
+        unnecessary. We keep this for backward compatibility with older versions.
+        """
+        try:
+            # Test if gql is available in mcp-ticketer's environment
+            test_result = subprocess.run(
+                ["pipx", "run", "--spec", "mcp-ticketer", "python", "-c", "import gql"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            # If import fails, inject the dependency
+            if test_result.returncode != 0:
+                self.logger.info("🔧 mcp-ticketer missing gql dependency, fixing...")
+
+                inject_result = subprocess.run(
+                    ["pipx", "inject", "mcp-ticketer", "gql"],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    check=False,
+                )
+
+                if inject_result.returncode == 0:
+                    self.logger.info("✅ Successfully injected gql dependency into mcp-ticketer")
+                    return True
+                else:
+                    self.logger.warning(f"Failed to inject gql: {inject_result.stderr}")
+                    return False
+
+            return False
+
+        except Exception as e:
+            self.logger.debug(f"Could not check/fix mcp-ticketer dependencies: {e}")
+            return False
+
     def _verify_service_installed(self, service_name: str, method: str) -> bool:
         """
         Verify that a service was successfully installed and is functional.
@@ -711,6 +853,9 @@ class MCPConfigManager:
         # Give the installation a moment to settle
         time.sleep(1)
 
+        # Note: mcp-ticketer dependency fix is now handled once in ensure_mcp_services_configured()
+        # to avoid running the same pipx inject command multiple times
+
         # Check if we can find the service
         service_path = self.detect_service_path(service_name)
         if not service_path:

{claude_mpm-4.4.7.dist-info → claude_mpm-4.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.4.7
+Version: 4.4.9
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.4.7.dist-info → claude_mpm-4.4.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=R8T1NAm61Ztbc_VglNJtvUE8VEkNwCNRHjh4rXfFP_M,6
+claude_mpm/VERSION,sha256=k8-5xMoy2UlbzZa4MVGVy1j0Ym4rIg_47OvMJE5eNKg,6
 claude_mpm/__init__.py,sha256=lyTZAYGH4DTaFGLRNWJKk5Q5oTjzN5I6AXmfVX-Jff0,1512
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=cChN3myrAcF3jC-6DvHnBFTEnwlDk-TAsIXPvUZr_yw,5953
@@ -411,7 +411,7 @@ claude_mpm/services/event_aggregator.py,sha256=DDcehIZVpiEDzs9o18gDZyvjMBHCq2H8H
 claude_mpm/services/exceptions.py,sha256=5lVZETr_6-xk0ItH7BTfYUiX5RlckS1e8ah_UalYG9c,26475
 claude_mpm/services/hook_installer_service.py,sha256=z3kKeriEY1Y9bFesuGlHBxhCtc0Wzd3Zv02k2_rEyGo,19727
 claude_mpm/services/hook_service.py,sha256=rZnMn_4qxX5g9KAn0IQdoG50WmySNfsTmfG0XHuRHXk,15737
-claude_mpm/services/mcp_config_manager.py,sha256=bMV3vkDahRjH94Ht91sUg1Ha8H1Sz63Q1AM9SddfvBY,28957
+claude_mpm/services/mcp_config_manager.py,sha256=iEBnl9rPFR-PccOol8ZdufyCvhZvVN47wYtTteQVpBY,35112
 claude_mpm/services/mcp_service_verifier.py,sha256=ngiegCngX18AFehfyJdvqQAvscoIBvFN_DeOoGTjxj0,25164
 claude_mpm/services/memory_hook_service.py,sha256=pRlTClkRcw30Jhwbha4BC8IMdzKZxF8aWqf52JlntgY,11600
 claude_mpm/services/monitor_build_service.py,sha256=8gWR9CaqgXdG6-OjOFXGpk28GCcJTlHhojkUYnMCebI,12160
@@ -547,7 +547,7 @@ claude_mpm/services/core/interfaces/communication.py,sha256=evwtLbYCFa3Zb8kEfL10
 claude_mpm/services/core/interfaces/infrastructure.py,sha256=eLtr_dFhA3Ux3mPOV_4DbWhGjHpfpGnj6xOhfQcgZGk,10037
 claude_mpm/services/core/interfaces/service.py,sha256=hNfHXe45LcPCp_dToOmZCfnUZBF5axMf_TdxqCSm2-I,11536
 claude_mpm/services/diagnostics/__init__.py,sha256=WTRucANR9EwNi53rotjkeE4k75s18RjHJ8s1BfBj7ic,614
-claude_mpm/services/diagnostics/diagnostic_runner.py,sha256=bfF3QQfaJPv2fyo61AstHZ139nHvY0fcjXXbXFcNdZo,9336
+claude_mpm/services/diagnostics/diagnostic_runner.py,sha256=PJje2C3_20JAeDBf2LpZ_rfi3rwSWk73EXJmZEkDcvs,9470
 claude_mpm/services/diagnostics/doctor_reporter.py,sha256=WhlHBWy-KI8OhAWujOu77VAgSvkBvtF3sDrjacYZhvg,19649
 claude_mpm/services/diagnostics/models.py,sha256=nqOQLllZyZmw3Zt5eFJfE1Al7C3Vrn3REgFlARtT3jQ,3831
 claude_mpm/services/diagnostics/checks/__init__.py,sha256=aNdOeJHZVIpEqqzr6xWUOiyZCIrN4vckfRxkW70cqeo,987
@@ -560,7 +560,7 @@ claude_mpm/services/diagnostics/checks/filesystem_check.py,sha256=V5HoHDYlSuoK2l
 claude_mpm/services/diagnostics/checks/installation_check.py,sha256=WoTt15R8Wg-6k2JZFAtmffFuih1AIyCX71QOHEFH-Ro,19562
 claude_mpm/services/diagnostics/checks/instructions_check.py,sha256=VbgBorl0RpFvxKQ_SC1gibTmGSiXaKSp-vVZt6hbH1g,16290
 claude_mpm/services/diagnostics/checks/mcp_check.py,sha256=SftuhP70abopyMD8GlLA_K3XHEYnBAeITggUQI0cYP4,12173
-claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=aH1YgyAAj3rj5H02adWUjM00KdZuOz4Qm9oyY4bgELc,19007
+claude_mpm/services/diagnostics/checks/mcp_services_check.py,sha256=SrHdpRbEc62e7mkfC_m8aGFtQIkhNOmiiCQZ78MME98,40800
 claude_mpm/services/diagnostics/checks/monitor_check.py,sha256=NUx5G1yjHWlukZmwhUz4o8STRWgsQEx01YjIMReNC0A,10096
 claude_mpm/services/diagnostics/checks/startup_log_check.py,sha256=DrXdml2rHvmhFBdb_sntE3xmwaP_DZIKjdVbCn8Dy7E,12258
 claude_mpm/services/event_bus/__init__.py,sha256=ETCo4a6puIeyVWAv55uCDjjhzNyUwbVAHEcAVkVapx8,688
@@ -773,9 +773,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalN
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=Nm2WmcbCb0EwOG4nFcikc3wVdiiAfjGBBI3YoR6ainQ,20915
 claude_mpm/validation/frontmatter_validator.py,sha256=IDBOCBweO6umydSnUJjBh81sKk3cy9hRFYm61DCiXbI,7020
-claude_mpm-4.4.7.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.4.7.dist-info/METADATA,sha256=dxh7pWMT-QL9jjSQ4oI4tYrYfjuYfJAMucrSK30Jn70,17517
-claude_mpm-4.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.4.7.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.4.7.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.4.7.dist-info/RECORD,,
+claude_mpm-4.4.9.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.4.9.dist-info/METADATA,sha256=RSN3ddmTCsiu9uTUoaSFYFeB7O56BR7awyIOpLkSVsA,17517
+claude_mpm-4.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.4.9.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
+claude_mpm-4.4.9.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.4.9.dist-info/RECORD,,