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

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"

claude_mpm/services/agents/deployment/agent_format_converter.py

@@ -8,7 +8,6 @@ maintainability and testability.
 """
 
 import re
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -130,13 +129,13 @@ class AgentFormatConverter:
         if isinstance(tools_line, str):
             if tools_line.startswith("[") and tools_line.endswith("]"):
                 # Already in list format
-                tools_list = tools_line
+                pass
             else:
                 # Convert comma-separated to list
                 tools = [tool.strip() for tool in tools_line.split(",")]
-                tools_list = str(tools).replace("'", '"')
+                str(tools).replace("'", '"')
         else:
-            tools_list = '["Read", "Write", "Edit"]'
+            pass
 
         # Extract additional fields
         model = self.extract_yaml_field(yaml_content, "model") or "sonnet"
@@ -148,19 +147,38 @@ class AgentFormatConverter:
         # Extract instructions from YAML content
         instructions = self._extract_instructions_from_yaml(yaml_content, agent_name)
 
-        # Build new YAML frontmatter
-        current_time = datetime.now().isoformat() + "Z"
+        # Map model names to Claude Code format
+        model_map = {
+            "claude-3-5-sonnet-20241022": "sonnet",
+            "claude-3-5-sonnet": "sonnet",
+            "claude-3-sonnet": "sonnet",
+            "claude-3-haiku": "haiku",
+            "claude-3-opus": "opus",
+            "sonnet": "sonnet",
+            "haiku": "haiku",
+            "opus": "opus",
+        }
+
+        mapped_model = model_map.get(model, "sonnet")
+
+        # Create multiline description with example (Claude Code format)
+        multiline_description = f"""{description}
+
+<example>
+Context: When you need specialized assistance from the {name} agent.
+user: "I need help with {agent_name.replace('_', ' ').replace('-', ' ')} tasks"
+assistant: "I'll use the {name} agent to provide specialized assistance."
+</example>"""
 
+        # Build new YAML frontmatter - Claude Code compatible format
+        # NOTE: Removed tags field and other non-essential fields for Claude Code compatibility
         new_frontmatter = f"""---
 name: {name}
-description: "{description}"
+description: |
+  {self._indent_text(multiline_description, 2)}
+model: {mapped_model}
 version: "{version}"
 author: "{author}"
-created: "{current_time}"
-updated: "{current_time}"
-tags: ["{agent_name}", "mpm-framework"]
-tools: {tools_list}
-model: "{model}"
 ---
 
 """
@@ -447,3 +465,29 @@ model: "{model}"
         except Exception as e:
             self.logger.error(f"Failed to convert MD to JSON: {e}")
             return json.dumps({"error": str(e)})
+
+    def _indent_text(self, text: str, spaces: int) -> str:
+        """
+        Indent multiline text with specified number of spaces.
+
+        Args:
+            text: Text to indent
+            spaces: Number of spaces for indentation
+
+        Returns:
+            Indented text
+        """
+        if not text:
+            return ""
+
+        indent = " " * spaces
+        lines = text.split("\n")
+        indented_lines = []
+
+        for line in lines:
+            if line.strip():  # Non-empty lines get indented
+                indented_lines.append(indent + line)
+            else:  # Empty lines stay empty
+                indented_lines.append("")
+
+        return "\n".join(indented_lines)

claude_mpm/services/agents/deployment/agent_lifecycle_manager.py

@@ -32,10 +32,12 @@ Created for ISS-0118: Agent Registry and Hierarchical Discovery System
 
 import asyncio
 import time
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.models.agent_definition import AgentDefinition
 from claude_mpm.services.agents.management import AgentManager
 from claude_mpm.services.agents.memory import (
@@ -270,7 +272,7 @@ class AgentLifecycleManager(BaseService):
             # First convert to JSON string with custom encoder, then save
             json_str = json.dumps(data, indent=2, default=str)
             records_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(records_file, "w", encoding="utf-8") as f:
+            with records_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(self.agent_records)} agent records")
@@ -758,7 +760,7 @@ class AgentLifecycleManager(BaseService):
             backup_dir = get_path_manager().get_tracking_dir() / "backups"
             path_ops.ensure_dir(backup_dir)
 
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_filename = f"{agent_name}_deleted_{timestamp}{source_path.suffix}"
             backup_path = backup_dir / backup_filename
 

claude_mpm/services/agents/deployment/agent_operation_service.py

@@ -479,9 +479,9 @@ class AgentOperationService(BaseService):
             backup_dir = get_path_manager().get_tracking_dir() / "backups"
             path_ops.ensure_dir(backup_dir)
 
-            from datetime import datetime
+            from datetime import datetime, timezone
 
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_filename = f"{agent_name}_deleted_{timestamp}{source_path.suffix}"
             backup_path = backup_dir / backup_filename
 

claude_mpm/services/agents/deployment/agent_record_service.py

@@ -80,7 +80,7 @@ class AgentRecordService(BaseService):
             json_str = json.dumps(data, indent=2, default=str)
             self.records_file.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(self.records_file, "w", encoding="utf-8") as f:
+            with self.records_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(records)} agent records")
@@ -107,7 +107,7 @@ class AgentRecordService(BaseService):
                     record = self._deserialize_record(record_data)
                     records[agent_name] = record
 
-                self.logger.info(f"Loaded {len(records)} agent records")
+                self.logger.debug(f"Loaded {len(records)} agent records")
             else:
                 self.logger.debug("No existing records file found")
 
@@ -149,7 +149,7 @@ class AgentRecordService(BaseService):
             json_str = json.dumps(data, indent=2, default=str)
             self.history_file.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(self.history_file, "w", encoding="utf-8") as f:
+            with self.history_file.open("w", encoding="utf-8") as f:
                 f.write(json_str)
 
             self.logger.debug(f"Saved {len(history)} operation history entries")
@@ -255,7 +255,7 @@ class AgentRecordService(BaseService):
 
                 # Write to output path
                 json_str = json.dumps(data, indent=2, default=str)
-                with open(output_path, "w", encoding="utf-8") as f:
+                with output_path.open("w", encoding="utf-8") as f:
                     f.write(json_str)
 
             elif format == "csv":

claude_mpm/services/agents/deployment/agent_state_service.py

@@ -59,9 +59,9 @@ class AgentLifecycleRecord:
     @property
     def last_modified_datetime(self):
         """Get last modified as datetime."""
-        from datetime import datetime
+        from datetime import datetime, timezone
 
-        return datetime.fromtimestamp(self.last_modified)
+        return datetime.fromtimestamp(self.last_modified, tz=timezone.utc)
 
 
 @dataclass