claude-mpm 4.0.23__py3-none-any.whl → 4.0.28__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -45,6 +45,7 @@ from claude_mpm.core.logging_config import (
     log_operation,
     log_performance_context,
 )
+from claude_mpm.services.shared import ConfigServiceBase
 
 from .agent_configuration_manager import AgentConfigurationManager
 from .agent_discovery_service import AgentDiscoveryService
@@ -58,7 +59,7 @@ from .agent_version_manager import AgentVersionManager
 from .multi_source_deployment_service import MultiSourceAgentDeploymentService
 
 
-class AgentDeploymentService(AgentDeploymentInterface):
+class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
     """Service for deploying Claude Code native agents.
 
     METRICS COLLECTION OPPORTUNITIES:
@@ -94,6 +95,7 @@ class AgentDeploymentService(AgentDeploymentInterface):
         templates_dir: Optional[Path] = None,
         base_agent_path: Optional[Path] = None,
         working_directory: Optional[Path] = None,
+        config: Optional[Config] = None,
     ):
         """
         Initialize agent deployment service.
@@ -102,13 +104,15 @@ class AgentDeploymentService(AgentDeploymentInterface):
             templates_dir: Directory containing agent JSON files
             base_agent_path: Path to base_agent.md file
             working_directory: User's working directory (for project agents)
+            config: Configuration instance
 
         METRICS OPPORTUNITY: Track initialization performance:
         - Template directory scan time
         - Base agent loading time
         - Initial validation overhead
         """
-        self.logger = get_logger(__name__)
+        # Initialize base class with configuration
+        super().__init__("agent_deployment", config=config)
 
         # Initialize template builder service
         self.template_builder = AgentTemplateBuilder()
@@ -139,26 +143,22 @@ class AgentDeploymentService(AgentDeploymentInterface):
             "deployment_errors": {},
         }
 
-        # Determine the actual working directory
-        # For deployment, we need to track the working directory but NOT use it
-        # for determining where system agents go (they always go to ~/.claude/agents/)
-        # Priority: working_directory param > current directory
-        if working_directory:
-            self.working_directory = Path(working_directory)
-        else:
-            # Use current directory but don't let CLAUDE_MPM_USER_PWD affect system agent deployment
-            self.working_directory = Path.cwd()
-
+        # Determine the actual working directory using configuration
+        # Priority: param > config > environment > current directory
+        self.working_directory = self.get_config_value(
+            "working_directory",
+            default=working_directory or Path.cwd(),
+            config_type=Path
+        )
         self.logger.info(f"Working directory for deployment: {self.working_directory}")
 
-        # Find templates directory using centralized path management
-        if templates_dir:
-            self.templates_dir = Path(templates_dir)
-        else:
-            # Use centralized paths instead of fragile parent calculations
-            # For system agents, still use templates subdirectory
-            # For project/user agents, this should be overridden with actual agents dir
-            self.templates_dir = paths.agents_dir / "templates"
+        # Find templates directory using configuration
+        # Priority: param > config > default paths
+        self.templates_dir = self.get_config_value(
+            "templates_dir",
+            default=templates_dir or paths.agents_dir / "templates",
+            config_type=Path
+        )
 
         # Initialize discovery service (after templates_dir is set)
         self.discovery_service = AgentDiscoveryService(self.templates_dir)
@@ -166,9 +166,13 @@ class AgentDeploymentService(AgentDeploymentInterface):
         # Initialize multi-source deployment service for version comparison
         self.multi_source_service = MultiSourceAgentDeploymentService()
 
-        # Find base agent file with priority-based search
+        # Find base agent file using configuration
+        # Priority: param > config > search
+        configured_base_agent = self.get_config_value("base_agent_path", config_type=Path)
         if base_agent_path:
             self.base_agent_path = Path(base_agent_path)
+        elif configured_base_agent:
+            self.base_agent_path = configured_base_agent
         else:
             # Priority-based search for base_agent.json
             self.base_agent_path = self._find_base_agent_file()
@@ -382,7 +386,7 @@ class AgentDeploymentService(AgentDeploymentInterface):
             if use_multi_source:
                 # Use multi-source deployment to get highest version agents
                 template_files, agent_sources = self._get_multi_source_templates(
-                    excluded_agents, config, agents_dir
+                    excluded_agents, config, agents_dir, force_rebuild
                 )
                 results["total"] = len(template_files)
                 results["multi_source"] = True
@@ -1056,7 +1060,8 @@ class AgentDeploymentService(AgentDeploymentInterface):
         return False
     
     def _get_multi_source_templates(
-        self, excluded_agents: List[str], config: Config, agents_dir: Path
+        self, excluded_agents: List[str], config: Config, agents_dir: Path, 
+        force_rebuild: bool = False
     ) -> Tuple[List[Path], Dict[str, str]]:
         """Get agent templates from multiple sources with version comparison.
         
@@ -1113,6 +1118,27 @@ class AgentDeploymentService(AgentDeploymentInterface):
                 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
+                agents_needing_update = set(comparison_results.get("needs_update", []))
+                
+                # Extract agent names from new_agents list (which contains dicts)
+                new_agent_names = [
+                    agent["name"] if isinstance(agent, dict) else agent
+                    for agent in comparison_results.get("new_agents", [])
+                ]
+                agents_needing_update.update(new_agent_names)
+                
+                # Filter agents_to_deploy to only include those needing updates
+                filtered_agents = {
+                    name: path for name, path in agents_to_deploy.items()
+                    if name in agents_needing_update
+                }
+                agents_to_deploy = filtered_agents
+                
+                self.logger.info(f"Filtered to {len(agents_to_deploy)} agents needing deployment")
         
         # Convert to list of Path objects
         template_files = list(agents_to_deploy.values())

claude_mpm/services/agents/deployment/deployment_wrapper.py

@@ -0,0 +1,71 @@
+"""Temporary wrapper to provide backward compatibility for CLI commands."""
+
+from pathlib import Path
+from typing import Dict, Any
+
+from claude_mpm.services.agents.deployment import AgentDeploymentService
+
+
+class DeploymentServiceWrapper:
+    """Wrapper to provide backward-compatible methods for the CLI."""
+    
+    def __init__(self, deployment_service: AgentDeploymentService):
+        """Initialize wrapper with actual deployment service."""
+        self.service = deployment_service
+        # Pass through all attributes
+        for attr in dir(deployment_service):
+            if not attr.startswith('_') and not hasattr(self, attr):
+                setattr(self, attr, getattr(deployment_service, attr))
+    
+    def deploy_system_agents(self, force: bool = False) -> Dict[str, Any]:
+        """Deploy system agents only.
+        
+        Args:
+            force: Force rebuild even if agents are up to date
+            
+        Returns:
+            Deployment results
+        """
+        # Deploy agents with default target (system agents location)
+        result = self.service.deploy_agents(
+            force_rebuild=force,
+            deployment_mode="update"
+        )
+        
+        # Transform result to expected format
+        return {
+            "deployed_count": len(result.get("deployed", [])) + len(result.get("updated", [])),
+            "deployed": result.get("deployed", []),
+            "updated": result.get("updated", []),
+            "errors": result.get("errors", []),
+            "target_dir": result.get("target_dir", "")
+        }
+    
+    def deploy_project_agents(self, force: bool = False) -> Dict[str, Any]:
+        """Deploy project agents only.
+        
+        Args:
+            force: Force rebuild even if agents are up to date
+            
+        Returns:
+            Deployment results
+        """
+        # Check if project agents directory exists
+        project_dir = Path.cwd() / ".claude-mpm" / "agents"
+        if not project_dir.exists():
+            return {
+                "deployed_count": 0,
+                "deployed": [],
+                "updated": [],
+                "errors": [],
+                "target_dir": ""
+            }
+        
+        # For now, return empty result as project agents are handled differently
+        return {
+            "deployed_count": 0,
+            "deployed": [],
+            "updated": [],
+            "errors": [],
+            "target_dir": str(project_dir)
+        }

claude_mpm/services/agents/deployment/pipeline/pipeline_context.py

@@ -42,6 +42,7 @@ class PipelineContext:
     template_files: List[Path] = field(default_factory=list)
     base_agent_data: Optional[Dict[str, Any]] = None
     base_agent_version: Optional[tuple] = None
+    agent_sources: Dict[str, str] = field(default_factory=dict)  # Maps agent names to sources
 
     # Deployment results
     results: Dict[str, Any] = field(default_factory=dict)

claude_mpm/services/agents/deployment/pipeline/steps/agent_processing_step.py

@@ -2,6 +2,8 @@
 
 import time
 
+from pathlib import Path
+
 from claude_mpm.services.agents.deployment.processors import (
     AgentDeploymentContext,
     AgentDeploymentResult,
@@ -48,6 +50,14 @@ class AgentProcessingStep(BaseDeploymentStep):
             # Process each template file
             for template_file in context.template_files:
                 try:
+                    # Determine source for this agent
+                    agent_name = template_file.stem
+                    # Use source from context if available (multi-source deployment), otherwise determine it
+                    if context.agent_sources and agent_name in context.agent_sources:
+                        source_info = context.agent_sources[agent_name]
+                    else:
+                        source_info = self._determine_agent_source(template_file)
+                    
                     # Create agent deployment context
                     agent_context = AgentDeploymentContext.from_template_file(
                         template_file=template_file,
@@ -56,6 +66,7 @@ class AgentProcessingStep(BaseDeploymentStep):
                         base_agent_version=context.base_agent_version or (1, 0, 0),
                         force_rebuild=context.force_rebuild,
                         deployment_mode=context.deployment_mode,
+                        source_info=source_info,
                     )
 
                     # Validate agent if requested
@@ -193,3 +204,35 @@ class AgentProcessingStep(BaseDeploymentStep):
         from .target_directory_step import TargetDirectorySetupStep
 
         return [TargetDirectorySetupStep]
+
+    def _determine_agent_source(self, template_path: Path) -> str:
+        """Determine the source of an agent from its template path.
+        
+        Args:
+            template_path: Path to the agent template
+            
+        Returns:
+            Source string (system/project/user/unknown)
+        """
+        template_str = str(template_path.resolve())
+        
+        # Check if it's a system template
+        if "/claude_mpm/agents/templates/" in template_str or "/src/claude_mpm/agents/templates/" in template_str:
+            return "system"
+        
+        # Check if it's a project agent
+        if "/.claude-mpm/agents/" in template_str:
+            # Check if it's in the current working directory
+            try:
+                from pathlib import Path
+                cwd = Path.cwd()
+                if str(cwd) in template_str:
+                    return "project"
+            except:
+                pass
+        
+        # Check if it's a user agent
+        if "/.claude/agents/" in template_str:
+            return "user"
+            
+        return "unknown"

claude_mpm/services/agents/deployment/processors/agent_deployment_context.py

@@ -21,6 +21,7 @@ class AgentDeploymentContext:
     # Deployment configuration
     force_rebuild: bool = False
     deployment_mode: str = "update"
+    source_info: str = "unknown"  # Source of the agent (system/project/user)
 
     # Base agent data
     base_agent_data: Optional[Dict[str, Any]] = None
@@ -53,6 +54,7 @@ class AgentDeploymentContext:
         base_agent_version: tuple,
         force_rebuild: bool = False,
         deployment_mode: str = "update",
+        source_info: str = "unknown",
     ) -> "AgentDeploymentContext":
         """Create context from template file.
 
@@ -63,6 +65,7 @@ class AgentDeploymentContext:
             base_agent_version: Base agent version
             force_rebuild: Whether to force rebuild
             deployment_mode: Deployment mode
+            source_info: Source of the agent (system/project/user)
 
         Returns:
             AgentDeploymentContext instance
@@ -79,6 +82,7 @@ class AgentDeploymentContext:
             base_agent_data=base_agent_data,
             base_agent_version=base_agent_version,
             agents_dir=agents_dir,
+            source_info=source_info,
         )
 
     def is_update(self) -> bool:

claude_mpm/services/agents/deployment/processors/agent_processor.py

@@ -185,7 +185,7 @@ class AgentProcessor:
         """
         try:
             return self.template_builder.build_agent_markdown(
-                context.agent_name, context.template_file, context.base_agent_data
+                context.agent_name, context.template_file, context.base_agent_data, context.source_info
             )
         except Exception as e:
             raise AgentDeploymentError(

claude_mpm/services/agents/loading/base_agent_manager.py

@@ -16,6 +16,7 @@ from typing import Any, Dict, List, Optional
 
 from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
+from claude_mpm.services.shared import ConfigServiceBase
 
 logger = logging.getLogger(__name__)
 
@@ -63,12 +64,19 @@ class BaseAgentStructure:
     raw_sections: Dict[str, str] = field(default_factory=dict)
 
 
-class BaseAgentManager:
+class BaseAgentManager(ConfigServiceBase):
     """Manages base_agent.md with structured updates and validation."""
 
-    def __init__(self, agents_dir: Optional[Path] = None):
+    def __init__(self, agents_dir: Optional[Path] = None, config: Optional[Dict[str, Any]] = None):
         """Initialize BaseAgentManager."""
-        self.agents_dir = agents_dir or Path(__file__).parent.parent / "agents"
+        super().__init__("base_agent_manager", config=config)
+
+        # Initialize paths using configuration
+        self.agents_dir = self.get_config_value(
+            "agents_dir",
+            default=agents_dir or Path(__file__).parent.parent / "agents",
+            config_type=Path
+        )
         self.base_agent_path = self.agents_dir / "BASE_AGENT_TEMPLATE.md"
         self.cache = SharedPromptCache.get_instance()
 

claude_mpm/services/agents/registry/deployed_agent_discovery.py

@@ -7,26 +7,35 @@ handling both new standardized schema and legacy agent formats.
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.agent_registry import AgentRegistryAdapter
 from claude_mpm.core.unified_paths import get_path_manager
+from claude_mpm.services.shared import ConfigServiceBase
 
 logger = logging.getLogger(__name__)
 
 
-class DeployedAgentDiscovery:
+class DeployedAgentDiscovery(ConfigServiceBase):
     """Discovers and analyzes deployed agents in the project."""
 
-    def __init__(self, project_root: Path = None):
+    def __init__(self, project_root: Path = None, config: Optional[Dict[str, Any]] = None):
         """Initialize the discovery service.
 
         Args:
             project_root: Project root path. Defaults to auto-detected root.
+            config: Configuration dictionary
         """
-        self.project_root = project_root or get_path_manager().get_project_root()
+        super().__init__("deployed_agent_discovery", config=config)
+
+        # Initialize project root using configuration
+        self.project_root = self.get_config_value(
+            "project_root",
+            default=project_root or get_path_manager().project_root,
+            config_type=Path
+        )
         self.agent_registry = AgentRegistryAdapter()
-        logger.debug(
+        self.logger.debug(
             f"Initialized DeployedAgentDiscovery with root: {self.project_root}"
         )
 

claude_mpm/services/event_aggregator.py

@@ -60,10 +60,12 @@ class EventAggregator:
         self.port = port
         self.logger = get_logger("event_aggregator")
 
-        # Load configuration
+        # Load configuration using ConfigLoader
         from claude_mpm.core.config import Config
+        from claude_mpm.core.shared.config_loader import ConfigLoader
 
-        self.config = Config()
+        config_loader = ConfigLoader()
+        self.config = config_loader.load_main_config()
 
         # Session storage
         self.active_sessions: Dict[str, AgentSession] = {}

claude_mpm/services/mcp_gateway/config/config_loader.py

@@ -7,6 +7,8 @@ MCP Gateway Configuration Loader
 Handles loading and discovery of MCP configuration files.
 
 Part of ISS-0034: Infrastructure Setup - MCP Gateway Project Foundation
+
+UPDATED: Migrated to use shared ConfigLoader pattern (TSK-0141)
 """
 
 import os
@@ -15,6 +17,7 @@ from typing import List, Optional
 import yaml
 
 from claude_mpm.core.logger import get_logger
+from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
 
 
 class MCPConfigLoader:
@@ -27,25 +30,41 @@ class MCPConfigLoader:
     WHY: We separate configuration loading from the main configuration
     service to support multiple configuration sources and provide a clean
     abstraction for configuration discovery.
+
+    UPDATED: Now uses shared ConfigLoader pattern for consistency (TSK-0141)
     """
 
-    # Standard configuration file search paths
-    CONFIG_SEARCH_PATHS = [
-        # User-specific configurations
-        Path("~/.claude/mcp/config.yaml"),
-        Path("~/.claude/mcp_gateway.yaml"),
-        Path("~/.config/claude-mpm/mcp_gateway.yaml"),
-        # Project-specific configurations
-        Path("./mcp_gateway.yaml"),
-        Path("./config/mcp_gateway.yaml"),
-        Path("./.claude/mcp_gateway.yaml"),
-        # System-wide configurations
-        Path("/etc/claude-mpm/mcp_gateway.yaml"),
-    ]
+    # MCP Gateway configuration pattern
+    MCP_CONFIG_PATTERN = ConfigPattern(
+        filenames=[
+            "mcp_gateway.yaml",
+            "mcp_gateway.yml",
+            ".mcp_gateway.yaml",
+            ".mcp_gateway.yml",
+            "config.yaml",
+            "config.yml"
+        ],
+        search_paths=[
+            "~/.claude/mcp",
+            "~/.config/claude-mpm",
+            ".",
+            "./config",
+            "./.claude",
+            "/etc/claude-mpm"
+        ],
+        env_prefix="CLAUDE_MPM_MCP_",
+        defaults={
+            "host": "localhost",
+            "port": 3000,
+            "debug": False,
+            "timeout": 30
+        }
+    )
 
     def __init__(self):
         """Initialize configuration loader."""
         self.logger = get_logger("MCPConfigLoader")
+        self._shared_loader = ConfigLoader()
 
     def find_config_file(self) -> Optional[Path]:
         """
@@ -154,22 +173,64 @@ class MCPConfigLoader:
         """
         from .configuration import MCPConfiguration
 
-        # Start with defaults
-        config = MCPConfiguration.DEFAULT_CONFIG.copy()
-
-        # Load from file
-        file_path = config_path or self.find_config_file()
-        if file_path:
-            file_config = self.load_from_file(file_path)
-            if file_config:
-                config = self._merge_configs(config, file_config)
-
-        # Apply environment overrides
-        env_config = self.load_from_env()
-        if env_config:
-            config = self._merge_configs(config, env_config)
+        if config_path:
+            # Use specific config file with shared loader
+            pattern = ConfigPattern(
+                filenames=[config_path.name],
+                search_paths=[str(config_path.parent)],
+                env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
+                defaults=MCPConfiguration.DEFAULT_CONFIG.copy()
+            )
+            config_obj = self._shared_loader.load_config(pattern, cache_key=f"mcp_{config_path}")
+            return config_obj.to_dict()
+        else:
+            # Use standard MCP pattern with defaults
+            pattern = ConfigPattern(
+                filenames=self.MCP_CONFIG_PATTERN.filenames,
+                search_paths=self.MCP_CONFIG_PATTERN.search_paths,
+                env_prefix=self.MCP_CONFIG_PATTERN.env_prefix,
+                defaults=MCPConfiguration.DEFAULT_CONFIG.copy()
+            )
+            config_obj = self._shared_loader.load_config(pattern, cache_key="mcp_gateway")
+            return config_obj.to_dict()
+
+    # Backward compatibility methods (deprecated)
+    def find_config_file(self) -> Optional[Path]:
+        """Find configuration file using legacy method (deprecated)."""
+        import warnings
+        warnings.warn(
+            "find_config_file is deprecated. Use load() method instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        # Use shared loader to find config file
+        config_file = self._shared_loader._find_config_file(self.MCP_CONFIG_PATTERN)
+        return config_file
 
-        return config
+    def load_from_file(self, config_path: Path) -> Optional[dict]:
+        """Load from file using legacy method (deprecated)."""
+        import warnings
+        warnings.warn(
+            "load_from_file is deprecated. Use load() method instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        # Use shared loader
+        return self._shared_loader._load_config_file(config_path)
+
+    def load_from_env(self, prefix: str = "CLAUDE_MPM_MCP_") -> dict:
+        """Load from environment using legacy method (deprecated)."""
+        import warnings
+        warnings.warn(
+            "load_from_env is deprecated. Use load() method instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+
+        # Use shared loader
+        return self._shared_loader._load_env_config(prefix)
 
     def _merge_configs(self, base: dict, overlay: dict) -> dict:
         """

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -17,6 +17,7 @@ import yaml
 from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
 from claude_mpm.services.mcp_gateway.core.exceptions import MCPConfigurationError
 from claude_mpm.services.mcp_gateway.core.interfaces import IMCPConfiguration
+from claude_mpm.services.shared import ConfigServiceBase
 
 
 class MCPConfiguration(BaseMCPService, IMCPConfiguration):
@@ -88,6 +89,12 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
         self._config_data: Dict[str, Any] = {}
         self._is_loaded = False
 
+        # Initialize shared configuration utilities
+        self._config_helper = ConfigServiceBase("mcp_configuration")
+
+        # Merge environment configuration
+        self._config_helper.merge_env_config("CLAUDE_MPM_MCP_")
+
     async def _do_initialize(self) -> bool:
         """
         Initialize the configuration service.
@@ -376,3 +383,25 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
 
         # Revalidate
         return self.validate()
+
+    def get_config_with_validation(self, key: str, default: Any = None, config_type: type = None) -> Any:
+        """
+        Get configuration value with validation using shared utilities.
+
+        Args:
+            key: Configuration key (supports dot notation)
+            default: Default value if not found
+            config_type: Expected type for validation
+
+        Returns:
+            Configuration value
+        """
+        try:
+            return self._config_helper.get_config_value(key, default, config_type=config_type)
+        except ValueError:
+            # Fall back to standard get method
+            return self.get(key, default)
+
+    def get_config_summary(self) -> Dict[str, Any]:
+        """Get configuration summary using shared utilities."""
+        return self._config_helper.get_config_summary()