claude-mpm 3.5.6__py3-none-any.whl → 3.6.0__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_deployment.py

@@ -37,6 +37,7 @@ from typing import Optional, List, Dict, Any
 from claude_mpm.core.logger import get_logger
 from claude_mpm.constants import EnvironmentVars, Paths, AgentMetadata
 from claude_mpm.config.paths import paths
+from claude_mpm.core.config import Config
 
 
 class AgentDeploymentService:
@@ -131,7 +132,7 @@ class AgentDeploymentService:
         self.logger.info(f"Templates directory: {self.templates_dir}")
         self.logger.info(f"Base agent path: {self.base_agent_path}")
         
-    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False, deployment_mode: str = "update") -> Dict[str, Any]:
+    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False, deployment_mode: str = "update", config: Optional[Config] = None, use_async: bool = True) -> Dict[str, Any]:
         """
         Build and deploy agents by combining base_agent.md with templates.
         Also deploys system instructions for PM framework.
@@ -140,6 +141,12 @@ class AgentDeploymentService:
         - "update": Normal update mode - skip agents with matching versions (default)
         - "project": Project deployment mode - always deploy all agents regardless of version
         
+        CONFIGURATION:
+        The config parameter or default configuration is used to determine:
+        - Which agents to exclude from deployment
+        - Case sensitivity for agent name matching
+        - Whether to exclude agent dependencies
+        
         METRICS COLLECTED:
         - Deployment start/end timestamps
         - Individual agent deployment durations
@@ -181,6 +188,8 @@ class AgentDeploymentService:
             target_dir: Target directory for agents (default: .claude/agents/)
             force_rebuild: Force rebuild even if agents exist (useful for troubleshooting)
             deployment_mode: "update" for version-aware updates, "project" for always deploy
+            config: Optional configuration object (loads default if not provided)
+            use_async: Use async operations for 50-70% faster deployment (default: True)
             
         Returns:
             Dictionary with deployment results:
@@ -196,6 +205,64 @@ class AgentDeploymentService:
         # METRICS: Record deployment start time for performance tracking
         deployment_start_time = time.time()
         
+        # Try async deployment for better performance if requested
+        if use_async:
+            try:
+                from .async_agent_deployment import deploy_agents_async_wrapper
+                self.logger.info("Using async deployment for improved performance")
+                
+                # Run async deployment
+                results = deploy_agents_async_wrapper(
+                    templates_dir=self.templates_dir,
+                    base_agent_path=self.base_agent_path,
+                    working_directory=self.working_directory,
+                    target_dir=target_dir,
+                    force_rebuild=force_rebuild,
+                    config=config
+                )
+                
+                # Add metrics about async vs sync
+                if 'metrics' in results:
+                    results['metrics']['deployment_method'] = 'async'
+                    duration_ms = results['metrics'].get('duration_ms', 0)
+                    self.logger.info(f"Async deployment completed in {duration_ms:.1f}ms")
+                    
+                    # Update internal metrics
+                    self._deployment_metrics['total_deployments'] += 1
+                    if not results.get('errors'):
+                        self._deployment_metrics['successful_deployments'] += 1
+                    else:
+                        self._deployment_metrics['failed_deployments'] += 1
+                
+                return results
+                
+            except ImportError:
+                self.logger.warning("Async deployment not available, falling back to sync")
+            except Exception as e:
+                self.logger.warning(f"Async deployment failed, falling back to sync: {e}")
+        
+        # Continue with synchronous deployment
+        self.logger.info("Using synchronous deployment")
+        
+        # Load configuration if not provided
+        if config is None:
+            config = Config()
+        
+        # Get agent exclusion configuration
+        excluded_agents = config.get('agent_deployment.excluded_agents', [])
+        case_sensitive = config.get('agent_deployment.case_sensitive', False)
+        exclude_dependencies = config.get('agent_deployment.exclude_dependencies', False)
+        
+        # Normalize excluded agents list for comparison
+        if not case_sensitive:
+            excluded_agents = [agent.lower() for agent in excluded_agents]
+        
+        # Log exclusion configuration if agents are being excluded
+        if excluded_agents:
+            self.logger.info(f"Excluding agents from deployment: {excluded_agents}")
+            self.logger.debug(f"Case sensitive matching: {case_sensitive}")
+            self.logger.debug(f"Exclude dependencies: {exclude_dependencies}")
+        
         if not target_dir:
             # Default to working directory's .claude/agents directory (not home)
             # This ensures we deploy to the user's project directory, not the framework directory
@@ -294,17 +361,54 @@ class AgentDeploymentService:
             
             # Get all template files
             template_files = list(self.templates_dir.glob("*.json"))
-            # Filter out non-agent files - exclude system files and uppercase special files
-            # CRITICAL: PM (Project Manager) must NEVER be deployed as it's the main Claude instance
-            excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
-            template_files = [
-                f for f in template_files 
-                if f.stem not in excluded_names 
-                and not f.stem.startswith(".")
-                and not f.stem.endswith(".backup")
-            ]
+            
+            # Build the combined exclusion set
+            # Start with hardcoded exclusions (these are ALWAYS excluded)
+            hardcoded_exclusions = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
+            
+            # Add user-configured exclusions
+            user_exclusions = set()
+            for agent in excluded_agents:
+                if case_sensitive:
+                    user_exclusions.add(agent)
+                else:
+                    # For case-insensitive, we'll check during filtering
+                    user_exclusions.add(agent.lower())
+            
+            # Filter out excluded agents
+            filtered_files = []
+            excluded_count = 0
+            for f in template_files:
+                agent_name = f.stem
+                
+                # Check hardcoded exclusions (always case-sensitive)
+                if agent_name in hardcoded_exclusions:
+                    self.logger.debug(f"Excluding {agent_name}: hardcoded system exclusion")
+                    excluded_count += 1
+                    continue
+                
+                # Check file patterns
+                if agent_name.startswith(".") or agent_name.endswith(".backup"):
+                    self.logger.debug(f"Excluding {agent_name}: file pattern exclusion")
+                    excluded_count += 1
+                    continue
+                
+                # Check user-configured exclusions
+                compare_name = agent_name.lower() if not case_sensitive else agent_name
+                if compare_name in user_exclusions:
+                    self.logger.info(f"Excluding {agent_name}: user-configured exclusion")
+                    excluded_count += 1
+                    continue
+                
+                # Agent is not excluded, add to filtered list
+                filtered_files.append(f)
+            
+            template_files = filtered_files
             results["total"] = len(template_files)
             
+            if excluded_count > 0:
+                self.logger.info(f"Excluded {excluded_count} agents from deployment")
+            
             for template_file in template_files:
                 try:
                     # METRICS: Track individual agent deployment time
@@ -983,6 +1087,17 @@ temperature: {temperature}"""
         
         # List deployed agents
         agent_files = list(agents_dir.glob("*.md"))
+        
+        # Get exclusion configuration for logging purposes
+        try:
+            from claude_mpm.core.config import Config
+            config = Config()
+            excluded_agents = config.get('agent_deployment.excluded_agents', [])
+            if excluded_agents:
+                self.logger.debug(f"Note: The following agents are configured for exclusion: {excluded_agents}")
+        except Exception:
+            pass  # Ignore config loading errors in verification
+        
         for agent_file in agent_files:
             try:
                 # Read first few lines to get agent name from YAML
@@ -1123,15 +1238,46 @@ temperature: {temperature}"""
             return agents
         
         template_files = sorted(self.templates_dir.glob("*.json"))
-        # Filter out non-agent files - exclude system files and uppercase special files
-        # CRITICAL: PM (Project Manager) must NEVER be deployed as it's the main Claude instance
-        excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
-        template_files = [
-            f for f in template_files 
-            if f.stem not in excluded_names 
-            and not f.stem.startswith(".")
-            and not f.stem.endswith(".backup")
-        ]
+        
+        # Load configuration for exclusions
+        try:
+            from claude_mpm.core.config import Config
+            config = Config()
+            excluded_agents = config.get('agent_deployment.excluded_agents', [])
+            case_sensitive = config.get('agent_deployment.case_sensitive', False)
+            
+            # Normalize excluded agents for comparison
+            if not case_sensitive:
+                excluded_agents = [agent.lower() for agent in excluded_agents]
+        except Exception:
+            # If config loading fails, use empty exclusion list
+            excluded_agents = []
+            case_sensitive = False
+        
+        # Build combined exclusion set
+        hardcoded_exclusions = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README", "pm", "PM", "project_manager"}
+        
+        # Filter out excluded agents
+        filtered_files = []
+        for f in template_files:
+            agent_name = f.stem
+            
+            # Check hardcoded exclusions
+            if agent_name in hardcoded_exclusions:
+                continue
+            
+            # Check file patterns
+            if agent_name.startswith(".") or agent_name.endswith(".backup"):
+                continue
+            
+            # Check user-configured exclusions
+            compare_name = agent_name.lower() if not case_sensitive else agent_name
+            if compare_name in excluded_agents:
+                continue
+            
+            filtered_files.append(f)
+        
+        template_files = filtered_files
         
         for template_file in template_files:
             try: