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

claude_mpm/VERSION

@@ -1 +1 @@
-4.4.6
+4.4.7

claude_mpm/agents/templates/local_ops_agent.json

@@ -0,0 +1,273 @@
+{
+  "name": "local-ops",
+  "display_name": "Local Operations Agent",
+  "description": "Specialized agent for managing local development deployments with authority over PM2, Docker, and native processes",
+  "version": "1.0.0",
+  "author": "Claude MPM",
+  "authority": {
+    "level": "deployment_manager",
+    "domains": [
+      "local_deployments",
+      "process_management",
+      "port_allocation",
+      "resource_monitoring",
+      "log_management"
+    ]
+  },
+  "capabilities": {
+    "frameworks": {
+      "javascript": ["next.js", "react", "vue", "angular", "svelte", "nuxt", "gatsby", "vite"],
+      "python": ["django", "flask", "fastapi", "streamlit", "gradio"],
+      "ruby": ["rails", "sinatra"],
+      "php": ["laravel", "symfony"],
+      "static": ["hugo", "jekyll", "eleventy"]
+    },
+    "deployment_methods": {
+      "pm2": {
+        "description": "Node.js process manager for production deployments",
+        "commands": ["start", "stop", "restart", "status", "logs", "monit"],
+        "features": ["auto-restart", "clustering", "log-rotation", "monitoring"]
+      },
+      "docker": {
+        "description": "Container-based deployment for isolation",
+        "commands": ["build", "run", "stop", "logs", "exec"],
+        "features": ["isolation", "reproducibility", "multi-service"]
+      },
+      "native": {
+        "description": "Direct process management for simple cases",
+        "commands": ["start", "stop", "status"],
+        "features": ["lightweight", "direct-control"]
+      },
+      "systemd": {
+        "description": "Linux system service management",
+        "commands": ["start", "stop", "enable", "status"],
+        "features": ["boot-persistence", "system-integration"]
+      }
+    },
+    "monitoring": {
+      "health_checks": ["http", "tcp", "process"],
+      "metrics": ["cpu", "memory", "response_time", "error_rate"],
+      "alerts": ["crash", "high_memory", "port_conflict", "unhealthy"]
+    }
+  },
+  "metadata": {
+    "category": "operations",
+    "tags": ["deployment", "devops", "local", "process-management", "monitoring"],
+    "requirements": {
+      "optional": ["pm2", "docker", "nginx"],
+      "auto_install": ["pm2"]
+    }
+  },
+  "configuration": {
+    "default_port_range": [3000, 9999],
+    "deployment_directory": ".claude-mpm/deployments",
+    "log_directory": ".claude-mpm/logs",
+    "state_file": ".claude-mpm/deployment-state.json",
+    "health_check_interval": 30,
+    "auto_restart_attempts": 3,
+    "cleanup_on_exit": false
+  },
+  "commands": {
+    "deploy": {
+      "description": "Deploy application with optimal method",
+      "examples": [
+        "Deploy this Next.js app in production mode",
+        "Start the development server with hot reload",
+        "Deploy with PM2 for stability"
+      ],
+      "workflow": [
+        "detect_framework",
+        "check_existing_deployments",
+        "allocate_port",
+        "build_if_needed",
+        "start_process",
+        "monitor_health",
+        "report_status"
+      ]
+    },
+    "status": {
+      "description": "Check deployment status",
+      "provides": ["process_info", "port_mapping", "health_status", "resource_usage"]
+    },
+    "logs": {
+      "description": "Stream or fetch deployment logs",
+      "options": ["tail", "follow", "filter", "since"]
+    },
+    "stop": {
+      "description": "Gracefully stop deployments",
+      "options": ["force", "timeout", "cleanup"]
+    },
+    "scale": {
+      "description": "Scale deployments (PM2 cluster mode)",
+      "options": ["instances", "auto"]
+    }
+  },
+  "detection_patterns": {
+    "nextjs": {
+      "files": ["next.config.js", "next.config.mjs", "next.config.ts"],
+      "package_json": ["next"],
+      "commands": {
+        "dev": "next dev",
+        "build": "next build",
+        "start": "next start",
+        "export": "next export"
+      }
+    },
+    "react": {
+      "files": ["react-scripts", "vite.config.js", "webpack.config.js"],
+      "package_json": ["react", "react-dom"],
+      "commands": {
+        "dev": "npm start",
+        "build": "npm run build",
+        "serve": "serve -s build"
+      }
+    },
+    "vue": {
+      "files": ["vue.config.js", "vite.config.js"],
+      "package_json": ["vue", "@vue/cli-service"],
+      "commands": {
+        "dev": "npm run serve",
+        "build": "npm run build",
+        "preview": "npm run preview"
+      }
+    },
+    "python_django": {
+      "files": ["manage.py", "wsgi.py"],
+      "requirements": ["django"],
+      "commands": {
+        "dev": "python manage.py runserver",
+        "prod": "gunicorn wsgi:application"
+      }
+    },
+    "python_flask": {
+      "files": ["app.py", "wsgi.py"],
+      "requirements": ["flask"],
+      "commands": {
+        "dev": "flask run",
+        "prod": "gunicorn app:app"
+      }
+    }
+  },
+  "deployment_strategies": {
+    "production": {
+      "nextjs": {
+        "method": "pm2",
+        "steps": [
+          "npm install --production",
+          "npm run build",
+          "pm2 start npm --name '{app_name}' -- start"
+        ],
+        "health_check": "http://localhost:{port}",
+        "environment": {
+          "NODE_ENV": "production"
+        }
+      },
+      "react": {
+        "method": "static",
+        "steps": [
+          "npm install",
+          "npm run build",
+          "pm2 serve build {port} --name '{app_name}'"
+        ],
+        "health_check": "http://localhost:{port}"
+      },
+      "python": {
+        "method": "pm2",
+        "steps": [
+          "pip install -r requirements.txt",
+          "pm2 start gunicorn --name '{app_name}' -- app:app --bind 0.0.0.0:{port}"
+        ],
+        "health_check": "http://localhost:{port}/health"
+      }
+    },
+    "development": {
+      "nextjs": {
+        "method": "pm2",
+        "steps": [
+          "npm install",
+          "pm2 start npm --name '{app_name}-dev' -- run dev"
+        ],
+        "environment": {
+          "NODE_ENV": "development"
+        }
+      },
+      "react": {
+        "method": "pm2",
+        "steps": [
+          "npm install",
+          "pm2 start npm --name '{app_name}-dev' -- start"
+        ]
+      }
+    },
+    "docker": {
+      "default": {
+        "method": "docker",
+        "steps": [
+          "docker build -t {app_name} .",
+          "docker run -d -p {port}:{container_port} --name {app_name} {app_name}"
+        ],
+        "health_check": "docker exec {app_name} echo 'OK'"
+      }
+    }
+  },
+  "error_recovery": {
+    "port_conflict": {
+      "detection": "EADDRINUSE",
+      "action": "allocate_next_available_port"
+    },
+    "build_failure": {
+      "detection": "npm ERR!|ERROR|Failed",
+      "action": "report_error_and_suggest_fixes"
+    },
+    "crash_loop": {
+      "detection": "restart_count > 5",
+      "action": "stop_and_investigate_logs"
+    },
+    "out_of_memory": {
+      "detection": "JavaScript heap out of memory",
+      "action": "increase_memory_limit"
+    }
+  },
+  "security": {
+    "port_exposure": "localhost_only",
+    "process_isolation": "user_level",
+    "log_sanitization": true,
+    "secrets_handling": "environment_variables"
+  },
+  "integration": {
+    "hooks": {
+      "pre_deploy": "validate_requirements",
+      "post_deploy": "notify_status",
+      "pre_stop": "graceful_shutdown",
+      "on_crash": "auto_restart_with_backoff"
+    },
+    "monitoring": {
+      "export_metrics": true,
+      "prometheus_endpoint": "/metrics",
+      "health_endpoint": "/health"
+    }
+  },
+  "tools": [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit"
+  ],
+  "examples": [
+    {
+      "user": "Deploy my Next.js app",
+      "response": "I'll deploy your Next.js application using PM2 for stability. Let me detect your configuration and set it up...",
+      "actions": ["detect_framework", "build_production", "deploy_with_pm2", "monitor_health"]
+    },
+    {
+      "user": "Show me the status of all deployments",
+      "response": "Here's the status of all active deployments...",
+      "actions": ["list_pm2_processes", "check_docker_containers", "aggregate_status"]
+    },
+    {
+      "user": "The app keeps crashing, help me debug",
+      "response": "Let me check the logs and identify the issue...",
+      "actions": ["fetch_error_logs", "analyze_crash_pattern", "suggest_fixes"]
+    }
+  ]
+}

claude_mpm/cli/__init__.py

@@ -234,6 +234,19 @@ def _verify_mcp_gateway_startup():
     DESIGN DECISION: This is non-blocking - failures are logged but don't prevent
     startup to ensure claude-mpm remains functional even if MCP gateway has issues.
     """
+    # Quick verification of MCP services installation
+    try:
+        from ..services.mcp_service_verifier import verify_mcp_services_on_startup
+        from ..core.logger import get_logger
+
+        logger = get_logger("mcp_verify")
+        all_ok, message = verify_mcp_services_on_startup()
+        if not all_ok:
+            logger.warning(message)
+    except Exception:
+        # Non-critical - continue with startup
+        pass
+
     try:
         import asyncio
         import time
@@ -449,6 +462,14 @@ def _execute_command(command: str, args) -> int:
         # Convert CommandResult to exit code
         return result.exit_code if result else 0
 
+    # Handle verify command with lazy import
+    if command == "verify":
+        # Lazy import to avoid loading unless needed
+        from .commands.verify import handle_verify
+
+        result = handle_verify(args)
+        return result if result is not None else 0
+
     # Map stable commands to their implementations
     command_map = {
         CLICommands.RUN.value: run_session,

claude_mpm/cli/commands/verify.py

@@ -0,0 +1,118 @@
+"""
+Verify command for MCP service health checks.
+"""
+
+import argparse
+import sys
+
+from ...core.logger import get_logger
+from ...services.mcp_service_verifier import MCPServiceVerifier, ServiceStatus
+
+
+def add_parser(subparsers) -> None:
+    """Add the verify command parser."""
+    parser = subparsers.add_parser(
+        "verify",
+        help="Verify MCP services installation and configuration",
+        description="Performs comprehensive health checks on MCP services",
+    )
+
+    parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Attempt to automatically fix detected issues",
+    )
+
+    parser.add_argument(
+        "--service",
+        type=str,
+        help="Verify a specific service only",
+        choices=["mcp-vector-search", "mcp-browser", "mcp-ticketer", "kuzu-memory"],
+    )
+
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results in JSON format",
+    )
+
+    parser.set_defaults(func=handle_verify)
+
+
+def handle_verify(args: argparse.Namespace) -> int:
+    """
+    Handle the verify command.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for issues found)
+    """
+    logger = get_logger(__name__)
+    verifier = MCPServiceVerifier()
+
+    try:
+        # Run verification
+        if args.service:
+            # Verify single service
+            logger.info(f"Verifying {args.service}...")
+            diagnostic = verifier._verify_service(args.service)
+            diagnostics = {args.service: diagnostic}
+
+            # Auto-fix if requested
+            if args.fix and diagnostic.fix_command and diagnostic.status != ServiceStatus.WORKING:
+                logger.info(f"Attempting to fix {args.service}...")
+                if verifier._attempt_auto_fix(args.service, diagnostic):
+                    # Re-verify after fix
+                    diagnostic = verifier._verify_service(args.service)
+                    diagnostics = {args.service: diagnostic}
+        else:
+            # Verify all services
+            logger.info("Verifying all MCP services...")
+            diagnostics = verifier.verify_all_services(auto_fix=args.fix)
+
+        # Output results
+        if args.json:
+            import json
+
+            # Convert to JSON-serializable format
+            json_output = {}
+            for name, diag in diagnostics.items():
+                json_output[name] = {
+                    "status": diag.status.value,
+                    "message": diag.message,
+                    "installed_path": diag.installed_path,
+                    "configured_command": diag.configured_command,
+                    "fix_command": diag.fix_command,
+                    "details": diag.details,
+                }
+            print(json.dumps(json_output, indent=2))
+        else:
+            verifier.print_diagnostics(diagnostics)
+
+        # Determine exit code
+        all_working = all(
+            d.status == ServiceStatus.WORKING
+            for d in diagnostics.values()
+        )
+
+        if all_working:
+            logger.info("✅ All verified services are fully operational")
+            return 0
+        else:
+            issues_count = sum(
+                1 for d in diagnostics.values()
+                if d.status != ServiceStatus.WORKING
+            )
+            logger.warning(f"⚠️ {issues_count} service(s) have issues")
+            return 1
+
+    except Exception as e:
+        logger.error(f"Verification failed: {e}")
+        if args.json:
+            import json
+            print(json.dumps({"error": str(e)}, indent=2))
+        else:
+            print(f"\n❌ Verification failed: {e}")
+        return 2

claude_mpm/cli/parsers/base_parser.py

@@ -422,6 +422,11 @@ def create_parser(
         from ..commands.doctor import add_doctor_parser
 
         add_doctor_parser(subparsers)
+
+        # Add verify command for MCP service verification
+        from ..commands.verify import add_parser as add_verify_parser
+
+        add_verify_parser(subparsers)
     except ImportError:
         # Commands module may not be available during testing or refactoring
         pass

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -369,12 +369,18 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                     else "single"
                 )
 
+                # When using multi-source deployment, we've already determined which
+                # agents need updates. Don't re-check versions in single_agent_deployer.
+                # This prevents the issue where multi-source says "deploying 9 agents"
+                # but then all get skipped due to redundant version checks.
+                skip_version_check = use_multi_source and not force_rebuild
+
                 self.single_agent_deployer.deploy_single_agent(
                     template_file=template_file_path,
                     agents_dir=agents_dir,
                     base_agent_data=base_agent_data,
                     base_agent_version=base_agent_version,
-                    force_rebuild=force_rebuild,
+                    force_rebuild=force_rebuild or skip_version_check,
                     deployment_mode=deployment_mode,
                     results=results,
                     source_info=source_info,
@@ -817,11 +823,9 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
 
                 agents_to_deploy = filtered_agents
 
-                if agents_to_deploy:
-                    self.logger.info(
-                        f"Deploying {len(agents_to_deploy)} agents that need updates"
-                    )
-                else:
+                # Don't log this redundant message - we already logged the upgrades above
+                # The "Deploying X agent upgrade(s)" message is sufficient
+                if not agents_to_deploy:
                     self.logger.debug(
                         f"All {len(comparison_results.get('up_to_date', []))} agents are up to date"
                     )

claude_mpm/services/mcp_service_verifier.py

@@ -0,0 +1,690 @@
+"""
+MCP Service Verifier
+====================
+
+Comprehensive verification system for MCP services that checks installation,
+configuration, and runtime functionality. Provides detailed diagnostics and
+automated fixes for common issues.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from ..core.logger import get_logger
+
+
+class ServiceStatus(Enum):
+    """MCP service health status levels."""
+
+    WORKING = "✅"  # Fully operational
+    MISCONFIGURED = "⚠️"  # Installed but configuration issues
+    NOT_INSTALLED = "❌"  # Not installed at all
+    PERMISSION_DENIED = "🔒"  # Permissions issue
+    VERSION_MISMATCH = "🔄"  # Needs upgrade
+    UNKNOWN = "❓"  # Unknown status
+
+
+@dataclass
+class ServiceDiagnostic:
+    """Detailed diagnostic information for a service."""
+
+    name: str
+    status: ServiceStatus
+    message: str
+    installed_path: Optional[str] = None
+    configured_command: Optional[str] = None
+    fix_command: Optional[str] = None
+    details: Optional[Dict] = None
+
+
+class MCPServiceVerifier:
+    """
+    Comprehensive MCP service verification and auto-fix system.
+
+    This verifier performs deep health checks on MCP services including:
+    - Installation verification (pipx, uvx, system)
+    - Configuration validation in ~/.claude.json
+    - Permission checks on executables
+    - Command format verification
+    - Runtime functionality testing
+    - Auto-fix capabilities for common issues
+    """
+
+    # Known MCP services and their requirements
+    SERVICE_REQUIREMENTS = {
+        "mcp-vector-search": {
+            "pipx_package": "mcp-vector-search",
+            "test_args": ["--version"],
+            "required_args": ["-m", "mcp_vector_search.mcp.server"],
+            "needs_project_path": True,
+        },
+        "mcp-browser": {
+            "pipx_package": "mcp-browser",
+            "test_args": ["--version"],
+            "required_args": ["mcp"],
+            "env_vars": {"MCP_BROWSER_HOME": "~/.mcp-browser"},
+        },
+        "mcp-ticketer": {
+            "pipx_package": "mcp-ticketer",
+            "test_args": ["--version"],
+            "required_args": ["mcp"],
+        },
+        "kuzu-memory": {
+            "pipx_package": "kuzu-memory",
+            "test_args": ["--help"],  # kuzu-memory uses --help not --version
+            "required_args": ["mcp", "serve"],  # Modern format
+            "min_version": "1.1.0",  # Minimum version for MCP support
+            "version_check_pattern": ["mcp", "serve", "claude"],  # Pattern to check in help
+        },
+    }
+
+    def __init__(self):
+        """Initialize the MCP service verifier."""
+        self.logger = get_logger(__name__)
+        self.project_root = Path.cwd()
+        self.claude_config_path = Path.home() / ".claude.json"
+        self.diagnostics: Dict[str, ServiceDiagnostic] = {}
+
+    def verify_all_services(self, auto_fix: bool = False) -> Dict[str, ServiceDiagnostic]:
+        """
+        Perform comprehensive verification of all MCP services.
+
+        Args:
+            auto_fix: Whether to attempt automatic fixes for issues
+
+        Returns:
+            Dictionary mapping service names to diagnostic results
+        """
+        self.logger.info("Starting MCP service verification...")
+
+        for service_name in self.SERVICE_REQUIREMENTS:
+            diagnostic = self._verify_service(service_name)
+            self.diagnostics[service_name] = diagnostic
+
+            # Attempt auto-fix if requested and fixable
+            if auto_fix and diagnostic.fix_command and diagnostic.status != ServiceStatus.WORKING:
+                self._attempt_auto_fix(service_name, diagnostic)
+                # Re-verify after fix
+                self.diagnostics[service_name] = self._verify_service(service_name)
+
+        return self.diagnostics
+
+    def _verify_service(self, service_name: str) -> ServiceDiagnostic:
+        """
+        Perform deep verification of a single MCP service.
+
+        Args:
+            service_name: Name of the service to verify
+
+        Returns:
+            Diagnostic result for the service
+        """
+        requirements = self.SERVICE_REQUIREMENTS[service_name]
+
+        # Step 1: Check if service is installed
+        installed_path = self._find_service_installation(service_name)
+
+        if not installed_path:
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.NOT_INSTALLED,
+                message=f"{service_name} is not installed",
+                fix_command=f"pipx install {requirements['pipx_package']}"
+            )
+
+        # Step 2: Check executable permissions
+        if not self._check_permissions(installed_path):
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.PERMISSION_DENIED,
+                message=f"Permission denied for {service_name}",
+                installed_path=installed_path,
+                fix_command=f"chmod +x {installed_path}"
+            )
+
+        # Step 3: Test basic functionality
+        if not self._test_service_functionality(service_name, installed_path):
+            # Check if it's a version issue for kuzu-memory
+            if service_name == "kuzu-memory":
+                version_info = self._check_kuzu_version(installed_path)
+                if not version_info["has_mcp_support"]:
+                    return ServiceDiagnostic(
+                        name=service_name,
+                        status=ServiceStatus.VERSION_MISMATCH,
+                        message=f"kuzu-memory needs upgrade to v1.1.0+ for MCP support",
+                        installed_path=installed_path,
+                        fix_command="pipx upgrade kuzu-memory",
+                        details=version_info
+                    )
+
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.MISCONFIGURED,
+                message=f"{service_name} installed but not functioning",
+                installed_path=installed_path,
+                fix_command=f"pipx reinstall {requirements['pipx_package']}"
+            )
+
+        # Step 4: Verify configuration in ~/.claude.json
+        config_status = self._verify_configuration(service_name, installed_path)
+
+        if not config_status["configured"]:
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.MISCONFIGURED,
+                message=f"{service_name} not configured in ~/.claude.json",
+                installed_path=installed_path,
+                configured_command=None,
+                fix_command="Run 'claude-mpm configure' to update configuration"
+            )
+
+        if not config_status["correct"]:
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.MISCONFIGURED,
+                message=f"{service_name} configuration needs update",
+                installed_path=installed_path,
+                configured_command=config_status.get("command"),
+                fix_command="Run 'claude-mpm configure' to fix configuration",
+                details={"config_issue": config_status.get("issue")}
+            )
+
+        # Step 5: Test actual MCP command execution
+        if not self._test_mcp_command(service_name, config_status.get("command"), config_status.get("args", [])):
+            return ServiceDiagnostic(
+                name=service_name,
+                status=ServiceStatus.MISCONFIGURED,
+                message=f"{service_name} command format issue",
+                installed_path=installed_path,
+                configured_command=config_status.get("command"),
+                fix_command="Run 'claude-mpm configure' to update command format",
+                details={"command": config_status.get("command"), "args": config_status.get("args")}
+            )
+
+        # All checks passed!
+        return ServiceDiagnostic(
+            name=service_name,
+            status=ServiceStatus.WORKING,
+            message=f"{service_name} is fully operational",
+            installed_path=installed_path,
+            configured_command=config_status.get("command")
+        )
+
+    def _find_service_installation(self, service_name: str) -> Optional[str]:
+        """
+        Find where a service is installed.
+
+        Checks in order:
+        1. pipx installation
+        2. uvx installation
+        3. System PATH
+        4. User pip installation
+
+        Args:
+            service_name: Name of the service
+
+        Returns:
+            Path to the service executable or None
+        """
+        # Check pipx
+        pipx_path = Path.home() / ".local" / "pipx" / "venvs" / service_name / "bin" / service_name
+        if pipx_path.exists():
+            return str(pipx_path)
+
+        # Special case for mcp-vector-search (uses Python interpreter)
+        if service_name == "mcp-vector-search":
+            pipx_python = pipx_path.parent / "python"
+            if pipx_python.exists():
+                return str(pipx_python)
+
+        # Check system PATH
+        system_path = shutil.which(service_name)
+        if system_path:
+            return system_path
+
+        # Check user pip installation
+        user_bin = Path.home() / ".local" / "bin" / service_name
+        if user_bin.exists():
+            return str(user_bin)
+
+        return None
+
+    def _check_permissions(self, path: str) -> bool:
+        """
+        Check if a file has execute permissions.
+
+        Args:
+            path: Path to the executable
+
+        Returns:
+            True if executable, False otherwise
+        """
+        try:
+            return os.access(path, os.X_OK)
+        except Exception as e:
+            self.logger.debug(f"Permission check failed for {path}: {e}")
+            return False
+
+    def _test_service_functionality(self, service_name: str, path: str) -> bool:
+        """
+        Test if a service can execute basic commands.
+
+        Args:
+            service_name: Name of the service
+            path: Path to the executable
+
+        Returns:
+            True if service is functional, False otherwise
+        """
+        requirements = self.SERVICE_REQUIREMENTS[service_name]
+        test_args = requirements.get("test_args", ["--help"])
+
+        try:
+            # First try direct execution
+            result = subprocess.run(
+                [path] + test_args,
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False
+            )
+
+            output = (result.stdout + result.stderr).lower()
+
+            # Check for success indicators
+            if result.returncode == 0:
+                return True
+
+            # Some tools return non-zero but still work
+            if any(word in output for word in ["version", "usage", "help", service_name.lower()]):
+                # Make sure it's not an error
+                if not any(error in output for error in ["error", "not found", "traceback", "no module"]):
+                    return True
+
+            # Try pipx run as fallback
+            if shutil.which("pipx"):
+                result = subprocess.run(
+                    ["pipx", "run", service_name] + test_args,
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                    check=False
+                )
+                if result.returncode == 0 or "version" in result.stdout.lower():
+                    return True
+
+        except subprocess.TimeoutExpired:
+            self.logger.warning(f"Service {service_name} timed out during functionality test")
+        except Exception as e:
+            self.logger.debug(f"Functionality test failed for {service_name}: {e}")
+
+        return False
+
+    def _check_kuzu_version(self, path: str) -> Dict:
+        """
+        Check kuzu-memory version and MCP support.
+
+        Args:
+            path: Path to kuzu-memory executable
+
+        Returns:
+            Dictionary with version information
+        """
+        version_info = {
+            "has_mcp_support": False,
+            "version": "unknown",
+            "command_format": None
+        }
+
+        try:
+            # Check help output for MCP support
+            result = subprocess.run(
+                [path, "--help"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False
+            )
+
+            help_text = (result.stdout + result.stderr).lower()
+
+            # Check for modern "mcp serve" command
+            if "mcp serve" in help_text or ("mcp" in help_text and "serve" in help_text):
+                version_info["has_mcp_support"] = True
+                version_info["command_format"] = "mcp serve"
+            # Check for legacy "serve" only
+            elif "serve" in help_text and "mcp" not in help_text:
+                version_info["has_mcp_support"] = False
+                version_info["command_format"] = "serve"
+
+            # Try to extract version
+            version_result = subprocess.run(
+                [path, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False
+            )
+            if version_result.returncode == 0:
+                version_info["version"] = version_result.stdout.strip()
+
+        except Exception as e:
+            self.logger.debug(f"Failed to check kuzu-memory version: {e}")
+
+        return version_info
+
+    def _verify_configuration(self, service_name: str, installed_path: str) -> Dict:
+        """
+        Verify service configuration in ~/.claude.json.
+
+        Args:
+            service_name: Name of the service
+            installed_path: Path where service is installed
+
+        Returns:
+            Dictionary with configuration status
+        """
+        project_key = str(self.project_root)
+
+        if not self.claude_config_path.exists():
+            return {"configured": False, "correct": False}
+
+        try:
+            with open(self.claude_config_path) as f:
+                config = json.load(f)
+
+            # Check if project is configured
+            if "projects" not in config or project_key not in config["projects"]:
+                return {"configured": False, "correct": False}
+
+            project_config = config["projects"][project_key]
+            mcp_servers = project_config.get("mcpServers", {})
+
+            # Check if service is configured
+            if service_name not in mcp_servers:
+                return {"configured": False, "correct": False}
+
+            service_config = mcp_servers[service_name]
+            command = service_config.get("command", "")
+            args = service_config.get("args", [])
+
+            # Validate command configuration
+            requirements = self.SERVICE_REQUIREMENTS[service_name]
+            required_args = requirements.get("required_args", [])
+
+            # Check if using pipx run or direct execution
+            if command == "pipx" and args and args[0] == "run":
+                # pipx run format
+                if service_name not in args:
+                    return {
+                        "configured": True,
+                        "correct": False,
+                        "command": command,
+                        "args": args,
+                        "issue": "Service name missing in pipx run command"
+                    }
+                # Check required args are present
+                for req_arg in required_args:
+                    if req_arg not in args[2:]:  # Skip "run" and service name
+                        return {
+                            "configured": True,
+                            "correct": False,
+                            "command": command,
+                            "args": args,
+                            "issue": f"Missing required argument: {req_arg}"
+                        }
+            elif command == "uvx" and args and args[0] == service_name:
+                # uvx format - similar validation
+                for req_arg in required_args:
+                    if req_arg not in args[1:]:
+                        return {
+                            "configured": True,
+                            "correct": False,
+                            "command": command,
+                            "args": args,
+                            "issue": f"Missing required argument: {req_arg}"
+                        }
+            else:
+                # Direct execution - command should be a valid path
+                if not Path(command).exists() and command != installed_path:
+                    # Allow for relative paths that might resolve differently
+                    if not shutil.which(command):
+                        return {
+                            "configured": True,
+                            "correct": False,
+                            "command": command,
+                            "args": args,
+                            "issue": f"Command path does not exist: {command}"
+                        }
+
+                # Check required args
+                for req_arg in required_args:
+                    if req_arg not in args:
+                        return {
+                            "configured": True,
+                            "correct": False,
+                            "command": command,
+                            "args": args,
+                            "issue": f"Missing required argument: {req_arg}"
+                        }
+
+            # Special validation for kuzu-memory command format
+            if service_name == "kuzu-memory":
+                # Should use "mcp serve" format for modern versions
+                if args and "serve" in args and "mcp" not in args:
+                    return {
+                        "configured": True,
+                        "correct": False,
+                        "command": command,
+                        "args": args,
+                        "issue": "Using legacy 'serve' format, should use 'mcp serve'"
+                    }
+
+            return {
+                "configured": True,
+                "correct": True,
+                "command": command,
+                "args": args
+            }
+
+        except Exception as e:
+            self.logger.error(f"Failed to verify configuration: {e}")
+            return {"configured": False, "correct": False, "error": str(e)}
+
+    def _test_mcp_command(self, service_name: str, command: str, args: List[str]) -> bool:
+        """
+        Test if the configured MCP command actually works.
+
+        Args:
+            service_name: Name of the service
+            command: Configured command
+            args: Configured arguments
+
+        Returns:
+            True if command executes successfully
+        """
+        if not command:
+            return False
+
+        try:
+            # Build test command - add --help to test without side effects
+            test_cmd = [command] + args[:2] if args else [command]  # Include base args
+            test_cmd.append("--help")
+
+            result = subprocess.run(
+                test_cmd,
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+                cwd=str(self.project_root)  # Run in project context
+            )
+
+            # Check for success or expected output
+            output = (result.stdout + result.stderr).lower()
+            if result.returncode == 0:
+                return True
+
+            # Check for expected patterns
+            if service_name == "kuzu-memory" and "mcp" in output and "serve" in output:
+                return True
+            if service_name in output or "usage" in output or "help" in output:
+                if not any(error in output for error in ["error", "not found", "traceback"]):
+                    return True
+
+        except subprocess.TimeoutExpired:
+            self.logger.warning(f"Command test timed out for {service_name}")
+        except Exception as e:
+            self.logger.debug(f"Command test failed for {service_name}: {e}")
+
+        return False
+
+    def _attempt_auto_fix(self, service_name: str, diagnostic: ServiceDiagnostic) -> bool:
+        """
+        Attempt to automatically fix a service issue.
+
+        Args:
+            service_name: Name of the service
+            diagnostic: Current diagnostic information
+
+        Returns:
+            True if fix was successful
+        """
+        if not diagnostic.fix_command:
+            return False
+
+        self.logger.info(f"Attempting auto-fix for {service_name}: {diagnostic.fix_command}")
+
+        try:
+            # Handle different types of fix commands
+            if diagnostic.fix_command.startswith("pipx "):
+                # Execute pipx command
+                cmd_parts = diagnostic.fix_command.split()
+                result = subprocess.run(
+                    cmd_parts,
+                    capture_output=True,
+                    text=True,
+                    timeout=120,
+                    check=False
+                )
+                return result.returncode == 0
+
+            elif diagnostic.fix_command.startswith("chmod "):
+                # Fix permissions
+                path = diagnostic.fix_command.replace("chmod +x ", "")
+                os.chmod(path, 0o755)
+                return True
+
+            elif "claude-mpm configure" in diagnostic.fix_command:
+                # Trigger configuration update
+                from .mcp_config_manager import MCPConfigManager
+                manager = MCPConfigManager()
+                success, _ = manager.ensure_mcp_services_configured()
+                return success
+
+        except Exception as e:
+            self.logger.error(f"Auto-fix failed for {service_name}: {e}")
+
+        return False
+
+    def print_diagnostics(self, diagnostics: Optional[Dict[str, ServiceDiagnostic]] = None) -> None:
+        """
+        Print formatted diagnostic results to console.
+
+        Args:
+            diagnostics: Diagnostic results to print (uses self.diagnostics if None)
+        """
+        if diagnostics is None:
+            diagnostics = self.diagnostics
+
+        if not diagnostics:
+            print("\n📋 No services verified yet")
+            return
+
+        print("\n" + "=" * 60)
+        print("📋 MCP Service Verification Report")
+        print("=" * 60)
+
+        # Group by status
+        working = []
+        issues = []
+
+        for name, diag in diagnostics.items():
+            if diag.status == ServiceStatus.WORKING:
+                working.append(diag)
+            else:
+                issues.append(diag)
+
+        # Print working services
+        if working:
+            print("\n✅ Fully Operational Services:")
+            for diag in working:
+                print(f"  • {diag.name}: {diag.message}")
+                if diag.configured_command:
+                    print(f"    Command: {diag.configured_command}")
+
+        # Print services with issues
+        if issues:
+            print("\n⚠️ Services Requiring Attention:")
+            for diag in issues:
+                print(f"\n  {diag.status.value} {diag.name}:")
+                print(f"    Issue: {diag.message}")
+                if diag.installed_path:
+                    print(f"    Path: {diag.installed_path}")
+                if diag.fix_command:
+                    print(f"    Fix: {diag.fix_command}")
+                if diag.details:
+                    print(f"    Details: {json.dumps(diag.details, indent=6)}")
+
+        # Summary
+        print("\n" + "=" * 60)
+        print(f"Summary: {len(working)}/{len(diagnostics)} services operational")
+
+        if issues:
+            print("\n💡 Quick Fix Commands:")
+            seen_fixes = set()
+            for diag in issues:
+                if diag.fix_command and diag.fix_command not in seen_fixes:
+                    print(f"  {diag.fix_command}")
+                    seen_fixes.add(diag.fix_command)
+
+            print("\nOr run: claude-mpm verify --fix")
+
+        print("=" * 60 + "\n")
+
+
+def verify_mcp_services_on_startup() -> Tuple[bool, str]:
+    """
+    Quick verification check for MCP services during startup.
+
+    This is a lightweight check that runs during CLI initialization
+    to warn users of potential issues without blocking startup.
+
+    Returns:
+        Tuple of (all_working, summary_message)
+    """
+    verifier = MCPServiceVerifier()
+    logger = get_logger(__name__)
+
+    # Do quick checks only (don't block startup)
+    issues = []
+    for service_name in MCPServiceVerifier.SERVICE_REQUIREMENTS:
+        path = verifier._find_service_installation(service_name)
+        if not path:
+            issues.append(f"{service_name} not installed")
+        elif not verifier._check_permissions(path):
+            issues.append(f"{service_name} permission issue")
+
+    if issues:
+        message = f"MCP service issues detected: {', '.join(issues)}. Run 'claude-mpm verify' for details."
+        return False, message
+
+    return True, "All MCP services appear operational"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.4.6
+Version: 4.4.7
 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
@@ -230,6 +230,18 @@ claude-mpm doctor --checks installation configuration agents mcp
 # Check MCP service status specifically
 claude-mpm doctor --checks mcp --verbose
 
+# Verify MCP services installation and configuration
+claude-mpm verify
+
+# Auto-fix MCP service issues
+claude-mpm verify --fix
+
+# Verify specific service
+claude-mpm verify --service kuzu-memory
+
+# Get JSON output for automation
+claude-mpm verify --json
+
 # Manage memory for large conversation histories
 claude-mpm cleanup-memory
 ```

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

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=toytnNjkIKPgQaGwDqQdC1rpNTAdSEc6Vja50d7Ovug,4
-claude_mpm/VERSION,sha256=M-cFSdn4NoMwZN-6G3jqIuaWG2LiBtAkXTZdmRNAyc8,6
+claude_mpm/VERSION,sha256=R8T1NAm61Ztbc_VglNJtvUE8VEkNwCNRHjh4rXfFP_M,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
@@ -38,6 +38,7 @@ claude_mpm/agents/templates/documentation.json,sha256=Hp9GADw0Wttmxe2pxTCg40DT1A
 claude_mpm/agents/templates/engineer.json,sha256=tAWKqt35OyL0RUQgTSeX9nVtcjF94ND-WbflXStAXHA,8222
 claude_mpm/agents/templates/gcp_ops_agent.json,sha256=v2exIGCzPLBDu5M4CCxZ1k3EQfrV0jc6T9C2ecPjScY,10812
 claude_mpm/agents/templates/imagemagick.json,sha256=6Zy4W_q6BYkJxd_KqDT2B3GBkwhn7VKT9ZVj-O_tj0Q,17747
+claude_mpm/agents/templates/local_ops_agent.json,sha256=50i0Ic2zkxR19VRw8kAadkdR3-sq03SASj1e8TgLIZo,8203
 claude_mpm/agents/templates/memory_manager.json,sha256=b6bTMLFShY4-884pgjc6wsfLICcVx17ZrRj7y-NH61w,12613
 claude_mpm/agents/templates/nextjs_engineer.json,sha256=Y2NUxJ3D6FFkDdk83kTqbJ70IZKAVJZkePbyEX_hESo,18786
 claude_mpm/agents/templates/ops.json,sha256=zp1uBfxdp7Atja0oLcNr8TAv-CQuK4mAnbfnLQMFIF4,10904
@@ -60,7 +61,7 @@ claude_mpm/agents/templates/.claude-mpm/memories/README.md,sha256=vEiG7cPjHRZfwX
 claude_mpm/agents/templates/.claude-mpm/memories/engineer_memories.md,sha256=KMZSJrQi-wHOwfl2C0m3A4PpC4QuBtDolAtVybGahKc,77
 claude_mpm/agents/templates/logs/prompts/agent_engineer_20250826_014258_728.md,sha256=UBm4BycXtdaa-_l1VCh0alTGGOUSsnCbpKwbFuI-mUY,2219
 claude_mpm/agents/templates/logs/prompts/agent_engineer_20250901_010124_142.md,sha256=oPvFSYFnmJ4TkbTe4AZnNHWaJMJ-xqZP2WM6scUKQKo,13089
-claude_mpm/cli/__init__.py,sha256=U_ZoiMocO4sOT1aBF2CH1OiB5-88PFKIUfnUPDaM0_c,18615
+claude_mpm/cli/__init__.py,sha256=TTtZNHx70miCIk-6ekKZiawOA9a0q1-HmVDecljZ3ZA,19317
 claude_mpm/cli/__main__.py,sha256=WnVGBwe10InxuZjJRFdwuMF6Gh16aXox6zFgxr0sRXk,847
 claude_mpm/cli/parser.py,sha256=Vqx9n-6Xo1uNhXR4rThmgWpZXTr0nOtkgDf3oMS9b0g,5855
 claude_mpm/cli/startup_logging.py,sha256=xtgAmTirhpk2B-dIS9YKcesPprXTukfu24gJSmGt8y8,29357
@@ -98,6 +99,7 @@ claude_mpm/cli/commands/run.py,sha256=_MpX-Eh4OVaUuS_cX8UZFGPbtMwZq0kFfstI6V4VA3
 claude_mpm/cli/commands/search.py,sha256=_0qbUnop8v758MHsB0fAop8FVxwygD59tec_-iN7pLE,9806
 claude_mpm/cli/commands/tickets.py,sha256=kl2dklTBnG3Y4jUUJ_PcEVsTx4CtVJfkGWboWBx_mQM,21234
 claude_mpm/cli/commands/uninstall.py,sha256=KGlVG6veEs1efLVjrZ3wSty7e1zVR9wpt-VXQA1RzWw,5945
+claude_mpm/cli/commands/verify.py,sha256=KhtykUj5hodz0vUQSMCFxe3rGQdqerMVH6J8WlCIWX4,3694
 claude_mpm/cli/interactive/__init__.py,sha256=vQqUCgPFvLYA1Vkq-5pnY7Ow3A-IgdM0SByfNL1ZLTk,433
 claude_mpm/cli/interactive/agent_wizard.py,sha256=PMSG6F3Jngb0Gm4nBA6X2PK9Iuuj-AuJd35-g4iE4tE,36202
 claude_mpm/cli/parsers/__init__.py,sha256=f0Fm1DDXorlVOZPLxUpjC-GIvLh01G-FZOK7TEV1L3I,1005
@@ -105,7 +107,7 @@ claude_mpm/cli/parsers/agent_manager_parser.py,sha256=TQEIm638ELM4X_AAGcn6WrJxlt
 claude_mpm/cli/parsers/agents_parser.py,sha256=R-9ESNXdjqr5iCEIcmbb2EPvcswW9UfJzMj5bAkgI4U,9042
 claude_mpm/cli/parsers/analyze_code_parser.py,sha256=cpJSMFbc3mqB4qrMBIEZiikzPekC2IQX-cjt9U2fHW4,5356
 claude_mpm/cli/parsers/analyze_parser.py,sha256=E00Ao0zwzbJPchs_AJt-aoQ7LQEtJPXRCNQ6Piivb4o,3908
-claude_mpm/cli/parsers/base_parser.py,sha256=0iz_EzdlUHya2peMdq_R0OifzAeEaEiV5JCBbUSjW1E,14001
+claude_mpm/cli/parsers/base_parser.py,sha256=Wejn4lAo-rMUQVP13PAehE6NoqmH2AD50HLKDf3QAKM,14169
 claude_mpm/cli/parsers/config_parser.py,sha256=wp6NbV8_p9txP28MXFcQrri0JDIfGFM7u4aJbYJXcYQ,2699
 claude_mpm/cli/parsers/configure_parser.py,sha256=xE77C9yMGGmXFuYmSrWBAeKl1xxBaYqrlI9NDSvrjmk,4244
 claude_mpm/cli/parsers/dashboard_parser.py,sha256=JBCM6v_iZhADr_Fwtk_d3up9AOod1avMab-vkNE61gE,3460
@@ -410,6 +412,7 @@ claude_mpm/services/exceptions.py,sha256=5lVZETr_6-xk0ItH7BTfYUiX5RlckS1e8ah_Ual
 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_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
 claude_mpm/services/port_manager.py,sha256=CYqLh8Ss_-aoYEXV3G6uZkGexpsRK_XTBL0bV4P3tSI,22838
@@ -431,7 +434,7 @@ claude_mpm/services/agents/deployment/__init__.py,sha256=iprW-Ww3LBtWu9pVFjAX45_
 claude_mpm/services/agents/deployment/agent_config_provider.py,sha256=gtQcbGr0GspZYplbeRkGXd3BAXl3_pWhKSsbfiSVTww,15234
 claude_mpm/services/agents/deployment/agent_configuration_manager.py,sha256=5nf69hfo7lUa3_55sDcU5WfpzBtOZCMSTPYGr2dlIdY,12173
 claude_mpm/services/agents/deployment/agent_definition_factory.py,sha256=DaJ__b3-ADinfd-qNnW6LKWfclOaZbkBBcfuHgqlUic,2697
-claude_mpm/services/agents/deployment/agent_deployment.py,sha256=6ntX6T66otpxR7zeKZDGnIzn1uB1Hb_zUxFq6Av3hSg,36423
+claude_mpm/services/agents/deployment/agent_deployment.py,sha256=wcicglXOv4tiJsDUSUJyEgJJryPmXbgGyK7kuiflq7Y,36860
 claude_mpm/services/agents/deployment/agent_discovery_service.py,sha256=-Iw_gIA6yTdt2eHGDLVJtz9wIQiSUH20WXTapqxd8_Q,18551
 claude_mpm/services/agents/deployment/agent_environment_manager.py,sha256=kjMiLyZYHs-s9pVdtj4av4hJW0gNXnD7lZz2CJpxmZI,9863
 claude_mpm/services/agents/deployment/agent_filesystem_manager.py,sha256=F58zMgJYISbi8eqcVlEq6Nd5Q4oLg4Zj4wll4gwRL64,12965
@@ -770,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.6.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.4.6.dist-info/METADATA,sha256=31bVYfdqk4nEHGwBEE4wdir7O7A2MVEjtKyJiNr-Sew,17264
-claude_mpm-4.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.4.6.dist-info/entry_points.txt,sha256=FDPZgz8JOvD-6iuXY2l9Zbo9zYVRuE4uz4Qr0vLeGOk,471
-claude_mpm-4.4.6.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.4.6.dist-info/RECORD,,
+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,,