claude-mpm 4.4.8__py3-none-any.whl → 4.4.10__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.4.8
+4.4.10

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -5,8 +5,10 @@ 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
 
@@ -35,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",
@@ -43,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",
@@ -51,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",
@@ -59,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
         },
     }
 
@@ -77,6 +84,33 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             sub_results = []
             services_status = {}
 
+            # Use MCPConfigManager to detect and fix corrupted installations
+            from claude_mpm.services.mcp_config_manager import MCPConfigManager
+            mcp_manager = MCPConfigManager()
+
+            # Run comprehensive fix for all MCP service issues
+            fix_success, fix_message = mcp_manager.fix_mcp_service_issues()
+            if fix_message and fix_message != "All MCP services are functioning correctly":
+                # Create diagnostic result for the fixes
+                fix_result = DiagnosticResult(
+                    category="MCP Service Fixes",
+                    status=DiagnosticStatus.OK if fix_success else DiagnosticStatus.WARNING,
+                    message=fix_message,
+                    details={"auto_fix_applied": True}
+                )
+                sub_results.append(fix_result)
+
+            # Also ensure configurations are updated for all projects
+            config_success, config_message = mcp_manager.ensure_mcp_services_configured()
+            if config_message and config_message != "All MCP services already configured correctly":
+                config_result = DiagnosticResult(
+                    category="MCP Configuration Update",
+                    status=DiagnosticStatus.OK if config_success else DiagnosticStatus.WARNING,
+                    message=config_message,
+                    details={"auto_config_applied": True}
+                )
+                sub_results.append(config_result)
+
             # Check for kuzu-memory configuration issues and offer auto-fix
             kuzu_config_result = self._check_and_fix_kuzu_memory_config()
             if kuzu_config_result:
@@ -86,11 +120,20 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             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
@@ -102,12 +145,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
@@ -120,6 +169,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"
@@ -127,8 +182,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,
@@ -146,6 +201,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}
@@ -156,6 +390,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
@@ -197,6 +437,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(
@@ -211,10 +509,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(
@@ -226,10 +533,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,
         )
 
@@ -423,40 +746,42 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             args = kuzu_config.get("args", [])
             needs_fix = False
             fix_reason = ""
-            new_args = None
+            # The correct args for kuzu-memory v1.1.0+ are ["mcp", "serve"]
+            correct_args = ["mcp", "serve"]
 
-            # Check for outdated configurations
-            if args == ["claude", "mcp-server"]:
+            # Check for any configuration that is NOT the correct one
+            if args != correct_args:
                 needs_fix = True
-                fix_reason = "Outdated 'claude mcp-server' format"
-                new_args = ["mcp", "serve"]
-            elif args == ["serve"]:
-                needs_fix = True
-                fix_reason = "Legacy 'serve' format"
-                new_args = ["mcp", "serve"]
-            elif args == ["mcp-server"]:
-                needs_fix = True
-                fix_reason = "Incorrect 'mcp-server' format"
-                new_args = ["mcp", "serve"]
+                # 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:
-                # Offer to auto-fix
+                # Log the issue for debugging
                 self.logger.warning(
                     f"Found incorrect kuzu-memory configuration: {fix_reason}. "
-                    f"Current args: {args}"
+                    f"Current args: {args}, should be: {correct_args}"
                 )
 
                 # Auto-fix the configuration
-                fixed = self._fix_kuzu_memory_args(claude_config_path, config, new_args)
+                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="Fixed kuzu-memory configuration",
+                        message=f"Fixed kuzu-memory configuration to use correct args",
                         details={
                             "old_args": args,
-                            "new_args": new_args,
+                            "new_args": correct_args,
                             "reason": fix_reason,
                             "auto_fixed": True,
                         },
@@ -468,7 +793,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                         message="kuzu-memory has incorrect configuration",
                         details={
                             "current_args": args,
-                            "correct_args": new_args,
+                            "correct_args": correct_args,
                             "reason": fix_reason,
                             "auto_fix_failed": True,
                         },
@@ -476,7 +801,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                         fix_description="Fix kuzu-memory configuration manually",
                     )
 
-            # Configuration is correct
+            # Configuration is correct - args match ["mcp", "serve"]
             return None
 
         except (json.JSONDecodeError, Exception) as e:
@@ -489,18 +814,48 @@ class MCPServicesCheck(BaseDiagnosticCheck):
             # 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
+            # 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"
@@ -594,3 +949,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