claude-mpm 4.3.11__py3-none-any.whl → 4.3.12__py3-none-any.whl

claude_mpm/core/unified_agent_registry.py

@@ -460,6 +460,13 @@ class UnifiedAgentRegistry:
             if agent_format == AgentFormat.JSON:
                 data = json.loads(content)
 
+                # Ensure data is a dictionary, not a list
+                if not isinstance(data, dict):
+                    logger.warning(
+                        f"Invalid JSON structure in {file_path}: expected object, got {type(data).__name__}"
+                    )
+                    return "", []
+
                 # Handle local agent JSON templates with metadata structure
                 if "metadata" in data:
                     metadata = data["metadata"]

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -776,16 +776,6 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                 agent_sources=agent_sources,
             )
 
-            # Log version upgrades and source changes
-            if comparison_results.get("version_upgrades"):
-                self.logger.info(
-                    f"Version upgrades available for {len(comparison_results['version_upgrades'])} agents"
-                )
-            if comparison_results.get("source_changes"):
-                self.logger.info(
-                    f"Source changes for {len(comparison_results['source_changes'])} agents"
-                )
-
             # Filter agents based on comparison results (unless force_rebuild is set)
             if not force_rebuild:
                 # Only deploy agents that need updates or are new
@@ -804,11 +794,36 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
                     for name, path in agents_to_deploy.items()
                     if name in agents_needing_update
                 }
+
+                # Only log upgrade messages if we're actually going to deploy them
+                if filtered_agents and comparison_results.get("version_upgrades"):
+                    # Filter upgrades to only those actually being deployed
+                    deployed_upgrades = [
+                        upgrade for upgrade in comparison_results["version_upgrades"]
+                        if upgrade["name"] in filtered_agents
+                    ]
+
+                    if deployed_upgrades:
+                        self.logger.info(
+                            f"Deploying {len(deployed_upgrades)} agent upgrade(s):"
+                        )
+                        for upgrade in deployed_upgrades:
+                            self.logger.info(
+                                f"  Upgrading: {upgrade['name']} "
+                                f"{upgrade['deployed_version']} -> {upgrade['new_version']} "
+                                f"(from {upgrade['source']})"
+                            )
+
                 agents_to_deploy = filtered_agents
 
-                self.logger.info(
-                    f"Filtered to {len(agents_to_deploy)} agents needing deployment"
-                )
+                if agents_to_deploy:
+                    self.logger.info(
+                        f"Deploying {len(agents_to_deploy)} agents that need updates"
+                    )
+                else:
+                    self.logger.debug(
+                        f"All {len(comparison_results.get('up_to_date', []))} agents are up to date"
+                    )
 
         # Convert to list of Path objects
         template_files = list(agents_to_deploy.values())

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -216,25 +216,35 @@ class AgentDiscoveryService:
             metadata = template_data.get("metadata", {})
             capabilities = template_data.get("capabilities", {})
 
+            # Handle capabilities as either dict or list
+            if isinstance(capabilities, list):
+                # If capabilities is a list (like in php-engineer.json), treat it as capabilities list
+                tools_list = template_data.get("tools", [])  # Look for tools at root level
+                model_value = template_data.get("model", "sonnet")
+            else:
+                # If capabilities is a dict, extract tools and model from it
+                tools_list = capabilities.get("tools", [])
+                model_value = capabilities.get("model", "sonnet")
+
             agent_info = {
                 "name": metadata.get("name", template_file.stem),
-                "description": metadata.get("description", "No description available"),
+                "description": metadata.get("description", template_data.get("description", "No description available")),
                 "type": template_data.get(
-                    "agent_type", metadata.get("category", "agent")
+                    "agent_type", metadata.get("category", template_data.get("category", "agent"))
                 ),  # Extract agent type
                 "version": template_data.get(
                     "agent_version",
                     template_data.get("version", metadata.get("version", "1.0.0")),
                 ),
-                "tools": capabilities.get("tools", []),
+                "tools": tools_list,
                 "specializations": metadata.get(
-                    "tags", []
-                ),  # Use tags as specializations
+                    "tags", template_data.get("tags", [])
+                ),  # Use tags as specializations, fallback to root-level tags
                 "file": template_file.name,
                 "path": str(template_file),
                 "file_path": str(template_file),  # Keep for backward compatibility
                 "size": template_file.stat().st_size,
-                "model": capabilities.get("model", "sonnet"),
+                "model": model_value,
                 "author": metadata.get("author", "unknown"),
             }
 

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -742,18 +742,20 @@ class MultiSourceAgentDeploymentService:
 
         self.logger.info(f"Version comparison complete: {', '.join(summary_parts)}")
 
+        # Don't log upgrades here - let the caller decide when to log
+        # This prevents repeated upgrade messages on every startup
         if comparison_results["version_upgrades"]:
             for upgrade in comparison_results["version_upgrades"]:
-                self.logger.info(
-                    f"  Upgrade: {upgrade['name']} "
+                self.logger.debug(
+                    f"  Upgrade available: {upgrade['name']} "
                     f"{upgrade['deployed_version']} -> {upgrade['new_version']} "
                     f"(from {upgrade['source']})"
                 )
 
         if comparison_results["source_changes"]:
             for change in comparison_results["source_changes"]:
-                self.logger.info(
-                    f"  Source change: {change['name']} "
+                self.logger.debug(
+                    f"  Source change available: {change['name']} "
                     f"from {change['from_source']} to {change['to_source']}"
                 )
 

claude_mpm/services/cli/agent_cleanup_service.py

@@ -138,6 +138,11 @@ class AgentCleanupService(IAgentCleanupService):
                 if not isinstance(result, dict):
                     result = {"success": bool(result)}
 
+                # Add success flag based on whether there were errors
+                if "success" not in result:
+                    # Consider it successful if no errors occurred
+                    result["success"] = not bool(result.get("errors"))
+
                 # Add cleaned_count for backward compatibility
                 if "cleaned_count" not in result:
                     removed_count = len(result.get("removed", []))

claude_mpm/services/mcp_config_manager.py

@@ -0,0 +1,294 @@
+"""
+MCP Configuration Manager
+========================
+
+Manages MCP service configurations, preferring pipx installations
+over local virtual environments for better isolation and management.
+
+This module provides utilities to detect, configure, and validate
+MCP service installations.
+"""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from ..core.logger import get_logger
+
+
+class MCPConfigManager:
+    """Manages MCP service configurations with pipx preference."""
+
+    # Standard MCP services that should use pipx
+    PIPX_SERVICES = {
+        "mcp-vector-search",
+        "mcp-browser",
+        "mcp-ticketer",
+    }
+
+    def __init__(self):
+        """Initialize the MCP configuration manager."""
+        self.logger = get_logger(__name__)
+        self.pipx_base = Path.home() / ".local" / "pipx" / "venvs"
+        self.project_root = Path.cwd()
+
+    def detect_service_path(self, service_name: str) -> Optional[str]:
+        """
+        Detect the best path for an MCP service.
+
+        Priority order:
+        1. Pipx installation (preferred)
+        2. System PATH (likely from pipx)
+        3. Local venv (fallback)
+
+        Args:
+            service_name: Name of the MCP service
+
+        Returns:
+            Path to the service executable or None if not found
+        """
+        # Check pipx installation first
+        pipx_path = self._check_pipx_installation(service_name)
+        if pipx_path:
+            self.logger.debug(f"Found {service_name} via pipx: {pipx_path}")
+            return pipx_path
+
+        # Check system PATH
+        system_path = self._check_system_path(service_name)
+        if system_path:
+            self.logger.debug(f"Found {service_name} in PATH: {system_path}")
+            return system_path
+
+        # Fallback to local venv
+        local_path = self._check_local_venv(service_name)
+        if local_path:
+            self.logger.warning(
+                f"Using local venv for {service_name} (consider installing via pipx)"
+            )
+            return local_path
+
+        self.logger.warning(f"Service {service_name} not found")
+        return None
+
+    def _check_pipx_installation(self, service_name: str) -> Optional[str]:
+        """Check if service is installed via pipx."""
+        pipx_venv = self.pipx_base / service_name
+
+        if not pipx_venv.exists():
+            return None
+
+        # Special handling for mcp-vector-search (needs Python interpreter)
+        if service_name == "mcp-vector-search":
+            python_bin = pipx_venv / "bin" / "python"
+            if python_bin.exists() and python_bin.is_file():
+                return str(python_bin)
+        else:
+            # Other services use direct binary
+            service_bin = pipx_venv / "bin" / service_name
+            if service_bin.exists() and service_bin.is_file():
+                return str(service_bin)
+
+        return None
+
+    def _check_system_path(self, service_name: str) -> Optional[str]:
+        """Check if service is available in system PATH."""
+        try:
+            result = subprocess.run(
+                ["which", service_name],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0:
+                path = result.stdout.strip()
+                # Verify it's from pipx
+                if "/.local/bin/" in path or "/pipx/" in path:
+                    return path
+        except Exception as e:
+            self.logger.debug(f"Error checking system PATH: {e}")
+
+        return None
+
+    def _check_local_venv(self, service_name: str) -> Optional[str]:
+        """Check for local virtual environment installation (fallback)."""
+        # Common local development paths
+        possible_paths = [
+            Path.home() / "Projects" / "managed" / service_name / ".venv" / "bin",
+            self.project_root / ".venv" / "bin",
+            self.project_root / "venv" / "bin",
+        ]
+
+        for base_path in possible_paths:
+            if service_name == "mcp-vector-search":
+                python_bin = base_path / "python"
+                if python_bin.exists():
+                    return str(python_bin)
+            else:
+                service_bin = base_path / service_name
+                if service_bin.exists():
+                    return str(service_bin)
+
+        return None
+
+    def generate_service_config(self, service_name: str) -> Optional[Dict]:
+        """
+        Generate configuration for a specific MCP service.
+
+        Args:
+            service_name: Name of the MCP service
+
+        Returns:
+            Service configuration dict or None if service not found
+        """
+        service_path = self.detect_service_path(service_name)
+        if not service_path:
+            return None
+
+        config = {
+            "type": "stdio",
+            "command": service_path,
+        }
+
+        # Service-specific configurations
+        if service_name == "mcp-vector-search":
+            config["args"] = [
+                "-m",
+                "mcp_vector_search.mcp.server",
+                str(self.project_root),
+            ]
+            config["env"] = {}
+        elif service_name == "mcp-browser":
+            config["args"] = ["mcp"]
+            config["env"] = {
+                "MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")
+            }
+        elif service_name == "mcp-ticketer":
+            config["args"] = ["mcp"]
+        else:
+            # Generic config for unknown services
+            config["args"] = []
+
+        return config
+
+    def update_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
+        """
+        Update the .mcp.json configuration file.
+
+        Args:
+            force_pipx: If True, only use pipx installations
+
+        Returns:
+            Tuple of (success, message)
+        """
+        mcp_config_path = self.project_root / ".mcp.json"
+
+        # Load existing config if it exists
+        existing_config = {}
+        if mcp_config_path.exists():
+            try:
+                with open(mcp_config_path, "r") as f:
+                    existing_config = json.load(f)
+            except Exception as e:
+                self.logger.error(f"Error reading existing config: {e}")
+
+        # Generate new configurations
+        new_config = {"mcpServers": {}}
+        missing_services = []
+
+        for service_name in self.PIPX_SERVICES:
+            config = self.generate_service_config(service_name)
+            if config:
+                new_config["mcpServers"][service_name] = config
+            elif force_pipx:
+                missing_services.append(service_name)
+            else:
+                # Keep existing config if not forcing pipx
+                if service_name in existing_config.get("mcpServers", {}):
+                    new_config["mcpServers"][service_name] = existing_config[
+                        "mcpServers"
+                    ][service_name]
+
+        # Add any additional services from existing config
+        for service_name, config in existing_config.get("mcpServers", {}).items():
+            if service_name not in new_config["mcpServers"]:
+                new_config["mcpServers"][service_name] = config
+
+        # Write the updated configuration
+        try:
+            with open(mcp_config_path, "w") as f:
+                json.dump(new_config, f, indent=2)
+
+            if missing_services:
+                message = f"Updated .mcp.json. Missing services (install via pipx): {', '.join(missing_services)}"
+                return True, message
+            else:
+                return True, "Successfully updated .mcp.json with pipx paths"
+        except Exception as e:
+            return False, f"Failed to update .mcp.json: {e}"
+
+    def validate_configuration(self) -> Dict[str, bool]:
+        """
+        Validate that all configured MCP services are accessible.
+
+        Returns:
+            Dict mapping service names to availability status
+        """
+        mcp_config_path = self.project_root / ".mcp.json"
+        if not mcp_config_path.exists():
+            return {}
+
+        try:
+            with open(mcp_config_path, "r") as f:
+                config = json.load(f)
+        except Exception as e:
+            self.logger.error(f"Error reading config: {e}")
+            return {}
+
+        results = {}
+        for service_name, service_config in config.get("mcpServers", {}).items():
+            command_path = service_config.get("command", "")
+            results[service_name] = Path(command_path).exists()
+
+        return results
+
+    def install_missing_services(self) -> Tuple[bool, str]:
+        """
+        Install missing MCP services via pipx.
+
+        Returns:
+            Tuple of (success, message)
+        """
+        missing = []
+        for service_name in self.PIPX_SERVICES:
+            if not self.detect_service_path(service_name):
+                missing.append(service_name)
+
+        if not missing:
+            return True, "All MCP services are already installed"
+
+        installed = []
+        failed = []
+
+        for service_name in missing:
+            try:
+                self.logger.info(f"Installing {service_name} via pipx...")
+                result = subprocess.run(
+                    ["pipx", "install", service_name],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                installed.append(service_name)
+                self.logger.info(f"Successfully installed {service_name}")
+            except subprocess.CalledProcessError as e:
+                failed.append(service_name)
+                self.logger.error(f"Failed to install {service_name}: {e.stderr}")
+
+        if failed:
+            return False, f"Failed to install: {', '.join(failed)}"
+        elif installed:
+            return True, f"Successfully installed: {', '.join(installed)}"
+        else:
+            return True, "No services needed installation"

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -60,6 +60,23 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                 "timeout_default": 30,  # seconds
                 "max_concurrent": 10,
             },
+            "external_services": {
+                "enabled": True,
+                "auto_install": True,
+                "services": [
+                    {
+                        "name": "mcp-vector-search",
+                        "package": "mcp-vector-search",
+                        "enabled": True,
+                        "auto_index": True,
+                    },
+                    {
+                        "name": "mcp-browser",
+                        "package": "mcp-browser",
+                        "enabled": True,
+                    },
+                ],
+            },
             "logging": {
                 "level": "INFO",
                 "file": "~/.claude/logs/mcp_gateway.log",

claude_mpm/services/mcp_gateway/main.py

@@ -115,6 +115,14 @@ except ImportError:
     # Unified ticket tool is optional
     UnifiedTicketTool = None
 
+try:
+    from claude_mpm.services.mcp_gateway.tools.external_mcp_services import (
+        ExternalMCPServiceManager,
+    )
+except ImportError:
+    # External MCP services are optional
+    ExternalMCPServiceManager = None
+
 # Manager module removed - using simplified architecture
 
 
@@ -148,6 +156,7 @@ class MCPGatewayOrchestrator:
         self.registry: Optional[ToolRegistry] = None
         self.communication: Optional[StdioHandler] = None
         self.configuration: Optional[MCPConfiguration] = None
+        self.external_services: Optional[ExternalMCPServiceManager] = None
 
         # Shutdown handling
         self._shutdown_event = asyncio.Event()
@@ -199,6 +208,28 @@ class MCPGatewayOrchestrator:
                     self.logger.warning(f"Failed to register some tools: {e}")
                     # Continue - server can run with partial tools
 
+            # Initialize external MCP services if available
+            if ExternalMCPServiceManager is not None:
+                try:
+                    self.logger.info("Initializing external MCP services...")
+                    self.external_services = ExternalMCPServiceManager()
+                    external_services = await self.external_services.initialize_services()
+
+                    if external_services and self.registry:
+                        for service in external_services:
+                            try:
+                                if self.registry.register_tool(service, category="external"):
+                                    self.logger.info(f"Registered external service: {service.service_name}")
+                                else:
+                                    self.logger.warning(f"Failed to register external service: {service.service_name}")
+                            except Exception as e:
+                                self.logger.warning(f"Error registering {service.service_name}: {e}")
+
+                    self.logger.info(f"Initialized {len(external_services)} external MCP services")
+                except Exception as e:
+                    self.logger.warning(f"Failed to initialize external MCP services: {e}")
+                    self.external_services = None
+
             # Initialize communication handler with fallback
             try:
                 self.communication = StdioHandler()
@@ -371,6 +402,13 @@ class MCPGatewayOrchestrator:
                 except Exception as e:
                     self.logger.warning(f"Error during communication shutdown: {e}")
 
+            # Shutdown external services
+            if self.external_services:
+                try:
+                    await self.external_services.shutdown()
+                except Exception as e:
+                    self.logger.warning(f"Error during external services shutdown: {e}")
+
             self.logger.info("MCP Gateway shutdown complete")
 
         except Exception as e: