claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/agents/deployment/agent_config_provider.py

@@ -90,8 +90,19 @@ class AgentConfigProvider:
             "engineer": {
                 **base_config,
                 "description": "Code implementation, development, and inline documentation",
-                "tags": '["engineer", "development", "coding", "implementation"]',
-                "tools": '["Read", "Write", "Edit", "MultiEdit", "Bash", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["engineer", "development", "coding", "implementation"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "MultiEdit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Code implementation needed",
@@ -109,14 +120,28 @@ class AgentConfigProvider:
                     "Refactor codebases",
                 ],
                 "primary_role": "Code implementation and development",
-                "specializations": '["coding", "debugging", "refactoring", "optimization"]',
+                "specializations": [
+                    "coding",
+                    "debugging",
+                    "refactoring",
+                    "optimization",
+                ],
                 "authority": "ALL code implementation decisions",
             },
             "qa": {
                 **base_config,
                 "description": "Quality assurance, testing, and validation",
-                "tags": '["qa", "testing", "quality", "validation"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["qa", "testing", "quality", "validation"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "TodoWrite",
+                ],
                 "temperature": 0.1,
                 "when_to_use": [
                     "Testing needed",
@@ -134,14 +159,29 @@ class AgentConfigProvider:
                     "Validate quality",
                 ],
                 "primary_role": "Testing and quality assurance",
-                "specializations": '["testing", "validation", "quality-assurance", "coverage"]',
+                "specializations": [
+                    "testing",
+                    "validation",
+                    "quality-assurance",
+                    "coverage",
+                ],
                 "authority": "ALL testing and quality decisions",
             },
             "documentation": {
                 **base_config,
                 "description": "Documentation creation, maintenance, and changelog generation",
-                "tags": '["documentation", "writing", "changelog", "docs"]',
-                "tools": '["Read", "Write", "Edit", "MultiEdit", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["documentation", "writing", "changelog", "docs"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "MultiEdit",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.3,
                 "when_to_use": [
                     "Documentation updates needed",
@@ -159,14 +199,27 @@ class AgentConfigProvider:
                     "Maintain docs",
                 ],
                 "primary_role": "Documentation and technical writing",
-                "specializations": '["technical-writing", "changelog", "api-docs", "guides"]',
+                "specializations": [
+                    "technical-writing",
+                    "changelog",
+                    "api-docs",
+                    "guides",
+                ],
                 "authority": "ALL documentation decisions",
             },
             "research": {
                 **base_config,
                 "description": "Technical research, analysis, and investigation",
-                "tags": '["research", "analysis", "investigation", "evaluation"]',
-                "tools": '["Read", "Grep", "Glob", "LS", "WebSearch", "WebFetch", "TodoWrite"]',
+                "tags": ["research", "analysis", "investigation", "evaluation"],
+                "tools": [
+                    "Read",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "WebFetch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.4,
                 "when_to_use": [
                     "Technical research needed",
@@ -184,14 +237,27 @@ class AgentConfigProvider:
                     "Evidence-based recommendations",
                 ],
                 "primary_role": "Research and technical analysis",
-                "specializations": '["investigation", "analysis", "evaluation", "recommendations"]',
+                "specializations": [
+                    "investigation",
+                    "analysis",
+                    "evaluation",
+                    "recommendations",
+                ],
                 "authority": "ALL research decisions",
             },
             "security": {
                 **base_config,
                 "description": "Security analysis, vulnerability assessment, and protection",
-                "tags": '["security", "vulnerability", "protection", "audit"]',
-                "tools": '["Read", "Grep", "Glob", "LS", "Bash", "WebSearch", "TodoWrite"]',
+                "tags": ["security", "vulnerability", "protection", "audit"],
+                "tools": [
+                    "Read",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "Bash",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.1,
                 "when_to_use": [
                     "Security review needed",
@@ -209,14 +275,28 @@ class AgentConfigProvider:
                     "Threat modeling",
                 ],
                 "primary_role": "Security analysis and protection",
-                "specializations": '["vulnerability-assessment", "security-audit", "threat-modeling", "protection"]',
+                "specializations": [
+                    "vulnerability-assessment",
+                    "security-audit",
+                    "threat-modeling",
+                    "protection",
+                ],
                 "authority": "ALL security decisions",
             },
             "ops": {
                 **base_config,
                 "description": "Deployment, operations, and infrastructure management",
-                "tags": '["ops", "deployment", "infrastructure", "devops"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["ops", "deployment", "infrastructure", "devops"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Deployment configuration",
@@ -234,14 +314,29 @@ class AgentConfigProvider:
                     "Automate operations",
                 ],
                 "primary_role": "Operations and deployment management",
-                "specializations": '["deployment", "infrastructure", "automation", "monitoring"]',
+                "specializations": [
+                    "deployment",
+                    "infrastructure",
+                    "automation",
+                    "monitoring",
+                ],
                 "authority": "ALL operations decisions",
             },
             "data_engineer": {
                 **base_config,
                 "description": "Data pipeline management and AI API integrations",
-                "tags": '["data", "pipeline", "etl", "ai-integration"]',
-                "tools": '["Read", "Write", "Edit", "Bash", "Grep", "Glob", "LS", "WebSearch", "TodoWrite"]',
+                "tags": ["data", "pipeline", "etl", "ai-integration"],
+                "tools": [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Bash",
+                    "Grep",
+                    "Glob",
+                    "LS",
+                    "WebSearch",
+                    "TodoWrite",
+                ],
                 "temperature": 0.2,
                 "when_to_use": [
                     "Data pipeline setup",
@@ -259,14 +354,19 @@ class AgentConfigProvider:
                     "Integrate AI services",
                 ],
                 "primary_role": "Data engineering and AI integration",
-                "specializations": '["data-pipelines", "etl", "database", "ai-integration"]',
+                "specializations": [
+                    "data-pipelines",
+                    "etl",
+                    "database",
+                    "ai-integration",
+                ],
                 "authority": "ALL data engineering decisions",
             },
             "version_control": {
                 **base_config,
                 "description": "Git operations, version management, and release coordination",
-                "tags": '["git", "version-control", "release", "branching"]',
-                "tools": '["Read", "Bash", "Grep", "Glob", "LS", "TodoWrite"]',
+                "tags": ["git", "version-control", "release", "branching"],
+                "tools": ["Read", "Bash", "Grep", "Glob", "LS", "TodoWrite"],
                 "temperature": 0.1,
                 "network_access": False,  # Git operations are local
                 "when_to_use": [
@@ -285,7 +385,7 @@ class AgentConfigProvider:
                     "Release coordination",
                 ],
                 "primary_role": "Version control and release management",
-                "specializations": '["git", "versioning", "branching", "releases"]',
+                "specializations": ["git", "versioning", "branching", "releases"],
                 "authority": "ALL version control decisions",
             },
         }
@@ -298,13 +398,13 @@ class AgentConfigProvider:
         return {
             **base_config,
             "description": f"{agent_name.title()} agent for specialized tasks",
-            "tags": f'["{agent_name}", "specialized", "mpm"]',
-            "tools": '["Read", "Write", "Edit", "Grep", "Glob", "LS", "TodoWrite"]',
+            "tags": [agent_name, "specialized", "mpm"],
+            "tools": ["Read", "Write", "Edit", "Grep", "Glob", "LS", "TodoWrite"],
             "temperature": 0.3,
             "when_to_use": [f"When {agent_name} expertise is needed"],
             "specialized_knowledge": [f"{agent_name.title()} domain knowledge"],
             "unique_capabilities": [f"{agent_name.title()} specialized operations"],
             "primary_role": f"{agent_name.title()} operations",
-            "specializations": f'["{agent_name}"]',
+            "specializations": [agent_name],
             "authority": f"ALL {agent_name} decisions",
         }

claude_mpm/services/agents/deployment/agent_configuration_manager.py

@@ -71,7 +71,7 @@ class AgentConfigurationManager:
             # Cache the result
             self._base_agent_cache = (base_agent_data, base_agent_version)
 
-            self.logger.info(f"Loaded base agent from {self.base_agent_path}")
+            self.logger.debug(f"Loaded base agent from {self.base_agent_path}")
             return self._base_agent_cache
 
         except Exception as e:

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,
@@ -683,7 +689,10 @@ class AgentDeploymentService(ConfigServiceBase, AgentDeploymentInterface):
 
     def _get_filtered_templates(self, excluded_agents: list, config: Config) -> list:
         """Get and filter template files based on exclusion rules."""
-        return self.discovery_service.get_filtered_templates(excluded_agents, config)
+        filter_non_mpm = config.get("agent_deployment.filter_non_mpm_agents", True)
+        return self.discovery_service.get_filtered_templates(
+            excluded_agents, config, filter_non_mpm
+        )
 
     def _validate_and_repair_existing_agents(self, agents_dir: Path) -> Dict[str, Any]:
         """Validate and repair broken frontmatter in existing agent files."""
@@ -773,16 +782,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
@@ -801,11 +800,35 @@ 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"
-                )
+                # 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"
+                    )
 
         # Convert to list of Path objects
         template_files = list(agents_to_deploy.values())

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -85,7 +85,10 @@ class AgentDiscoveryService:
         return agents
 
     def get_filtered_templates(
-        self, excluded_agents: List[str], config: Optional[Config] = None
+        self,
+        excluded_agents: List[str],
+        config: Optional[Config] = None,
+        filter_non_mpm: bool = False,
     ) -> List[Path]:
         """
         Get filtered list of template files based on configuration.
@@ -93,6 +96,7 @@ class AgentDiscoveryService:
         Args:
             excluded_agents: List of agent names to exclude
             config: Configuration object for additional filtering
+            filter_non_mpm: Whether to filter out non-MPM agents
 
         Returns:
             List of template file paths to deploy
@@ -111,6 +115,7 @@ class AgentDiscoveryService:
         # Apply exclusion filtering
         filtered_files = []
         excluded_count = 0
+        non_mpm_count = 0
 
         for template_file in template_files:
             agent_name = template_file.stem
@@ -121,14 +126,24 @@ class AgentDiscoveryService:
                 self.logger.debug(f"Excluding agent: {agent_name}")
                 continue
 
+            # Check if we should filter non-MPM agents
+            if filter_non_mpm and not self._is_mpm_agent(template_file):
+                non_mpm_count += 1
+                self.logger.debug(f"Filtering non-MPM agent: {agent_name}")
+                continue
+
             # Validate template file
             if self._validate_template_file(template_file):
                 filtered_files.append(template_file)
             else:
                 self.logger.warning(f"Invalid template file: {template_file.name}")
 
+        # Log filtering results
+        if filter_non_mpm and non_mpm_count > 0:
+            self.logger.info(f"Filtered out {non_mpm_count} non-MPM agents")
+
         self.logger.info(
-            f"Found {len(template_files)} templates, excluded {excluded_count}, deploying {len(filtered_files)}"
+            f"Found {len(template_files)} templates, excluded {excluded_count}, filtered {non_mpm_count} non-MPM, deploying {len(filtered_files)}"
         )
         return filtered_files
 
@@ -201,22 +216,41 @@ 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", 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"),
             }
 
@@ -236,6 +270,46 @@ class AgentDiscoveryService:
             )
             return None
 
+    def _is_mpm_agent(self, template_file: Path) -> bool:
+        """Check if agent is authored by Claude MPM team.
+
+        MPM agents must have:
+        - An author field containing 'claude mpm', 'claude-mpm', or 'anthropic'
+        - A valid agent_version field
+
+        Args:
+            template_file: Path to the agent template JSON file
+
+        Returns:
+            True if this is an MPM agent, False otherwise
+        """
+        try:
+            template_data = json.loads(template_file.read_text())
+            metadata = template_data.get("metadata", {})
+
+            # Check for author field
+            author = metadata.get("author", "").lower()
+            has_valid_author = any(
+                pattern in author
+                for pattern in ["claude mpm", "claude-mpm", "anthropic"]
+            )
+
+            # Check for version field
+            has_version = bool(template_data.get("agent_version"))
+
+            if not has_valid_author or not has_version:
+                self.logger.debug(
+                    f"Filtered non-MPM agent {template_file.name}: "
+                    f"author='{metadata.get('author', 'missing')}', "
+                    f"version={'present' if has_version else 'missing'}"
+                )
+
+            return has_valid_author and has_version
+
+        except Exception as e:
+            self.logger.debug(f"Error checking if {template_file} is MPM agent: {e}")
+            return False  # Treat invalid templates as non-MPM
+
     def _is_agent_excluded(
         self,
         agent_name: str,
@@ -357,6 +431,50 @@ class AgentDiscoveryService:
 
         return bool(re.match(pattern, agent_name))
 
+    def _is_mpm_agent(
+        self, template_file: Path, config: Optional[Config] = None
+    ) -> bool:
+        """Check if agent is authored by Claude MPM team.
+
+        MPM agents must have:
+        - An author field containing configurable MPM patterns (default: 'claude mpm', 'claude-mpm', 'anthropic')
+        - A valid agent_version field
+
+        Args:
+            template_file: Path to the agent template JSON file
+            config: Configuration object for MPM patterns
+
+        Returns:
+            True if this is an MPM agent, False otherwise
+        """
+        try:
+            template_data = json.loads(template_file.read_text())
+            metadata = template_data.get("metadata", {})
+
+            # Get MPM author patterns from config
+            if config:
+                mpm_patterns = config.get(
+                    "agent_deployment.mpm_author_patterns",
+                    ["claude mpm", "claude-mpm", "anthropic"],
+                )
+            else:
+                mpm_patterns = ["claude mpm", "claude-mpm", "anthropic"]
+
+            # Check for author field
+            author = metadata.get("author", "").lower()
+            has_valid_author = any(
+                pattern.lower() in author for pattern in mpm_patterns
+            )
+
+            # Check for version field
+            has_version = bool(template_data.get("agent_version"))
+
+            return has_valid_author and has_version
+
+        except Exception as e:
+            self.logger.debug(f"Error checking if {template_file} is MPM agent: {e}")
+            return False  # Treat invalid templates as non-MPM
+
     def get_discovery_stats(self) -> Dict[str, Any]:
         """
         Get statistics about agent discovery.

claude_mpm/services/agents/deployment/agent_filesystem_manager.py

@@ -183,9 +183,9 @@ class AgentFileSystemManager:
         try:
             # Generate backup directory name if not provided
             if not backup_dir:
-                import datetime
+                from datetime import datetime, timezone
 
-                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
                 backup_dir = agents_dir.parent / f"agents_backup_{timestamp}"
 
             # Create backup
@@ -324,7 +324,7 @@ class AgentFileSystemManager:
 
     def _convert_yaml_to_markdown(self, yaml_content: str, agent_name: str) -> str:
         """Convert YAML agent content to Markdown format with frontmatter."""
-        from datetime import datetime
+        from datetime import datetime, timezone
 
         # Extract YAML fields (simplified parsing)
         name = self._extract_yaml_field(yaml_content, "name") or agent_name
@@ -356,8 +356,8 @@ name: {name}
 description: "{description}"
 version: "{version}"
 author: "claude-mpm@anthropic.com"
-created: "{datetime.now().isoformat()}Z"
-updated: "{datetime.now().isoformat()}Z"
+created: "{datetime.now(timezone.utc).isoformat()}Z"
+updated: "{datetime.now(timezone.utc).isoformat()}Z"
 tags: ["{agent_name}", "mpm-framework"]
 tools: {tools_list}
 model: "sonnet"