claude-mpm 5.1.9__py3-none-any.whl → 5.4.48__py3-none-any.whl

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -551,38 +551,39 @@ class AsyncAgentDeploymentService:
             or ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
 
-        # Get model from capabilities.model in new format
+        # Get model from capabilities.model in new format (no default fallback)
         model = (
             agent_data.get("capabilities", {}).get("model")
             or agent_data.get("configuration_fields", {}).get("model")
-            or "sonnet"  # Default fallback
+            # No default fallback - preserve None if not set
         )
 
-        # Simplify model name for Claude Code
-        model_map = {
-            "claude-4-sonnet-20250514": "sonnet",
-            "claude-sonnet-4-20250514": "sonnet",
-            "claude-opus-4-20250514": "opus",
-            "claude-3-opus-20240229": "opus",
-            "claude-3-haiku-20240307": "haiku",
-            "claude-3.5-sonnet": "sonnet",
-            "claude-3-sonnet": "sonnet",
-        }
-        # Better fallback: extract the model type (opus/sonnet/haiku) from the string
-        if model not in model_map:
-            if "opus" in model.lower():
-                model = "opus"
-            elif "sonnet" in model.lower():
-                model = "sonnet"
-            elif "haiku" in model.lower():
-                model = "haiku"
+        # Simplify model name for Claude Code (only if model is specified)
+        if model is not None:
+            model_map = {
+                "claude-4-sonnet-20250514": "sonnet",
+                "claude-sonnet-4-20250514": "sonnet",
+                "claude-opus-4-20250514": "opus",
+                "claude-3-opus-20240229": "opus",
+                "claude-3-haiku-20240307": "haiku",
+                "claude-3.5-sonnet": "sonnet",
+                "claude-3-sonnet": "sonnet",
+            }
+            # Better fallback: extract the model type (opus/sonnet/haiku) from the string
+            if model not in model_map:
+                if "opus" in model.lower():
+                    model = "opus"
+                elif "sonnet" in model.lower():
+                    model = "sonnet"
+                elif "haiku" in model.lower():
+                    model = "haiku"
+                else:
+                    # Last resort: try to extract from hyphenated format
+                    model = model_map.get(
+                        model, model.split("-")[-1] if "-" in model else model
+                    )
             else:
-                # Last resort: try to extract from hyphenated format
-                model = model_map.get(
-                    model, model.split("-")[-1] if "-" in model else model
-                )
-        else:
-            model = model_map[model]
+                model = model_map[model]
 
         # Convert tools list to comma-separated string for Claude Code compatibility
         # IMPORTANT: No spaces after commas - Claude Code requires exact format
@@ -601,9 +602,12 @@ class AsyncAgentDeploymentService:
             f"base_version: {self._format_version_display(base_version)}",
             "author: claude-mpm",  # Identify as system agent for deployment
             f"tools: {tools_str}",
-            f"model: {model}",
         ]
 
+        # Only include model field if explicitly set
+        if model is not None:
+            frontmatter_lines.append(f"model: {model}")
+
         # Add optional fields if present
         # Check for color in metadata section (new format) or root (old format)
         color = agent_data.get("metadata", {}).get("color") or agent_data.get("color")

claude_mpm/services/agents/deployment/local_template_deployment.py

@@ -157,7 +157,9 @@ class LocalTemplateDeploymentService:
 
         # Add capabilities
         if template.capabilities:
-            frontmatter["model"] = template.capabilities.get("model", "sonnet")
+            # Only include model if explicitly set (no default)
+            if "model" in template.capabilities:
+                frontmatter["model"] = template.capabilities["model"]
             tools = template.capabilities.get("tools", "*")
             if tools == "*":
                 frontmatter["tools"] = "all"

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -16,6 +16,8 @@ import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+import yaml
+
 from claude_mpm.core.config import Config
 from claude_mpm.core.logging_config import get_logger
 
@@ -24,6 +26,18 @@ from .agent_version_manager import AgentVersionManager
 from .remote_agent_discovery_service import RemoteAgentDiscoveryService
 
 
+def _normalize_agent_name(name: str) -> str:
+    """Normalize agent name for consistent comparison.
+
+    Converts spaces, underscores to hyphens and lowercases.
+    Examples:
+        "Dart Engineer" -> "dart-engineer"
+        "dart_engineer" -> "dart-engineer"
+        "DART-ENGINEER" -> "dart-engineer"
+    """
+    return name.lower().replace(" ", "-").replace("_", "-")
+
+
 class MultiSourceAgentDeploymentService:
     """Service for deploying agents from multiple sources with version comparison.
 
@@ -51,6 +65,70 @@ class MultiSourceAgentDeploymentService:
         self.logger = get_logger(__name__)
         self.version_manager = AgentVersionManager()
 
+    def _read_template_version(self, template_path: Path) -> Optional[str]:
+        """Read version from template file (supports both .md and .json formats).
+
+        For .md files: Extract version from YAML frontmatter
+        For .json files: Extract version from JSON structure
+
+        Args:
+            template_path: Path to template file
+
+        Returns:
+            Version string or None if version cannot be extracted
+        """
+        try:
+            if template_path.suffix == ".md":
+                # Parse markdown with YAML frontmatter
+                content = template_path.read_text()
+
+                # Extract YAML frontmatter (between --- markers)
+                if not content.strip().startswith("---"):
+                    return None
+
+                parts = content.split("---", 2)
+                if len(parts) < 3:
+                    return None
+
+                # Parse YAML frontmatter
+                frontmatter = yaml.safe_load(parts[1])
+                if not frontmatter:
+                    return None
+
+                # Extract version from frontmatter
+                version = frontmatter.get("version")
+                return version if version else None
+
+            if template_path.suffix == ".json":
+                # Parse JSON template
+                template_data = json.loads(template_path.read_text())
+                metadata = template_data.get("metadata", {})
+                version = (
+                    template_data.get("agent_version")
+                    or template_data.get("version")
+                    or metadata.get("version")
+                )
+                return version if version else None
+
+            self.logger.warning(
+                f"Unknown template format: {template_path.suffix} for {template_path.name}"
+            )
+            return None
+
+        except yaml.YAMLError as e:
+            self.logger.warning(
+                f"Invalid YAML frontmatter in {template_path.name}: {e}"
+            )
+            return None
+        except json.JSONDecodeError as e:
+            self.logger.warning(f"Invalid JSON in {template_path.name}: {e}")
+            return None
+        except Exception as e:
+            self.logger.warning(
+                f"Error reading template version from {template_path.name}: {e}"
+            )
+            return None
+
     def _build_canonical_id_for_agent(self, agent_info: Dict[str, Any]) -> str:
         """Build or retrieve canonical_id for an agent.
 
@@ -113,14 +191,14 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
     ) -> Dict[str, List[Dict[str, Any]]]:
-        """Discover agents from all 4 tiers (system, user, remote, project).
+        """Discover agents from all 4 tiers (system, user, cache, project).
 
         Priority hierarchy (highest to lowest):
         4. Project agents - Highest priority, project-specific customizations
-        3. Remote agents - GitHub-synced agents from cache
+        3. Cached agents - GitHub-synced agents from cache
         2. User agents - DEPRECATED, user-level customizations
         1. System templates - Lowest priority, built-in agents
 
@@ -128,7 +206,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
             user_agents_dir: Directory containing user custom agents (DEPRECATED)
-            remote_agents_dir: Directory containing cached remote agents
+            agents_cache_dir: Directory containing cached agents from Git sources
             working_directory: Current working directory for finding project agents
 
         Returns:
@@ -159,12 +237,12 @@ class MultiSourceAgentDeploymentService:
             if not user_agents_dir.exists():
                 user_agents_dir = None
 
-        if not remote_agents_dir:
-            # Check for remote agents in cache directory
+        if not agents_cache_dir:
+            # Check for agents in cache directory
             cache_dir = Path.home() / ".claude-mpm" / "cache"
-            remote_agents_dir = cache_dir / "remote-agents"
-            if not remote_agents_dir.exists():
-                remote_agents_dir = None
+            agents_cache_dir = cache_dir / "agents"
+            if not agents_cache_dir.exists():
+                agents_cache_dir = None
 
         # Discover agents from each source in priority order
         # Note: We process in reverse priority order (system first) and build up the dictionary
@@ -172,7 +250,7 @@ class MultiSourceAgentDeploymentService:
         sources = [
             ("system", system_templates_dir),
             ("user", user_agents_dir),
-            ("remote", remote_agents_dir),
+            ("remote", agents_cache_dir),
             ("project", project_agents_dir),
         ]
 
@@ -257,7 +335,7 @@ class MultiSourceAgentDeploymentService:
     def get_agents_by_collection(
         self,
         collection_id: str,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
     ) -> List[Dict[str, Any]]:
         """Get all agents from a specific collection.
 
@@ -265,7 +343,7 @@ class MultiSourceAgentDeploymentService:
 
         Args:
             collection_id: Collection identifier (e.g., "bobmatnyc/claude-mpm-agents")
-            remote_agents_dir: Directory containing remote agents cache
+            agents_cache_dir: Directory containing agents cache
 
         Returns:
             List of agent dictionaries from the specified collection
@@ -276,18 +354,16 @@ class MultiSourceAgentDeploymentService:
             >>> len(agents)
             45
         """
-        if not remote_agents_dir:
+        if not agents_cache_dir:
             cache_dir = Path.home() / ".claude-mpm" / "cache"
-            remote_agents_dir = cache_dir / "remote-agents"
+            agents_cache_dir = cache_dir / "agents"
 
-        if not remote_agents_dir.exists():
-            self.logger.warning(
-                f"Remote agents directory not found: {remote_agents_dir}"
-            )
+        if not agents_cache_dir.exists():
+            self.logger.warning(f"Agents cache directory not found: {agents_cache_dir}")
             return []
 
         # Use RemoteAgentDiscoveryService to get collection agents
-        remote_service = RemoteAgentDiscoveryService(remote_agents_dir)
+        remote_service = RemoteAgentDiscoveryService(agents_cache_dir)
         collection_agents = remote_service.get_agents_by_collection(collection_id)
 
         self.logger.info(
@@ -404,7 +480,7 @@ class MultiSourceAgentDeploymentService:
         system_templates_dir: Optional[Path] = None,
         project_agents_dir: Optional[Path] = None,
         user_agents_dir: Optional[Path] = None,
-        remote_agents_dir: Optional[Path] = None,
+        agents_cache_dir: Optional[Path] = None,
         working_directory: Optional[Path] = None,
         excluded_agents: Optional[List[str]] = None,
         config: Optional[Config] = None,
@@ -416,7 +492,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir: Directory containing system agent templates
             project_agents_dir: Directory containing project-specific agents
             user_agents_dir: Directory containing user custom agents (DEPRECATED)
-            remote_agents_dir: Directory containing cached remote agents
+            agents_cache_dir: Directory containing cached agents from Git sources
             working_directory: Current working directory for finding project agents
             excluded_agents: List of agent names to exclude from deployment
             config: Configuration object for additional filtering
@@ -433,7 +509,7 @@ class MultiSourceAgentDeploymentService:
             system_templates_dir=system_templates_dir,
             project_agents_dir=project_agents_dir,
             user_agents_dir=user_agents_dir,
-            remote_agents_dir=remote_agents_dir,
+            agents_cache_dir=agents_cache_dir,
             working_directory=working_directory,
         )
 
@@ -467,10 +543,44 @@ class MultiSourceAgentDeploymentService:
 
         # Apply exclusion filters
         if excluded_agents:
-            for agent_name in excluded_agents:
-                if agent_name in selected_agents:
-                    self.logger.info(f"Excluding agent '{agent_name}' from deployment")
-                    del selected_agents[agent_name]
+            # Find agents to remove by matching normalized names
+            # Normalization handles: "Dart Engineer", "dart_engineer", "dart-engineer"
+            agents_to_remove = []
+            excluded_set = {_normalize_agent_name(name) for name in excluded_agents}
+
+            for canonical_id, agent_info in list(selected_agents.items()):
+                # Check agent name field (normalized)
+                agent_name = _normalize_agent_name(agent_info.get("name", ""))
+
+                # Also check the agent_id portion of canonical_id (after the colon)
+                # Example: "bobmatnyc/claude-mpm-agents:pm" -> "pm"
+                raw_agent_id = (
+                    canonical_id.split(":")[-1]
+                    if ":" in canonical_id
+                    else canonical_id
+                )
+                agent_id = _normalize_agent_name(raw_agent_id)
+
+                # Check file stem from path (most reliable match)
+                file_stem = ""
+                path_str = agent_info.get("path") or agent_info.get("file_path")
+                if path_str:
+                    file_stem = _normalize_agent_name(Path(path_str).stem)
+
+                if (
+                    agent_name in excluded_set
+                    or agent_id in excluded_set
+                    or file_stem in excluded_set
+                ):
+                    agents_to_remove.append(canonical_id)
+                    self.logger.info(
+                        f"Excluding agent '{agent_info.get('name', raw_agent_id)}' "
+                        f"(canonical_id: {canonical_id}) from deployment"
+                    )
+
+            # Remove matched agents
+            for canonical_id in agents_to_remove:
+                del selected_agents[canonical_id]
 
         # Apply config-based filtering if provided
         if config:
@@ -519,6 +629,105 @@ class MultiSourceAgentDeploymentService:
 
         return agents_to_deploy, agent_sources, cleanup_results
 
+    def cleanup_excluded_agents(
+        self,
+        deployed_agents_dir: Path,
+        agents_to_deploy: Dict[str, Path],
+    ) -> Dict[str, Any]:
+        """Remove agents from deployed directory that aren't in the deployment list.
+
+        Similar to skill cleanup logic, this removes agents that were previously
+        deployed but are no longer in the enabled agents list (e.g., filtered out
+        by profile configuration).
+
+        Args:
+            deployed_agents_dir: Directory containing deployed agents (~/.claude/agents)
+            agents_to_deploy: Dictionary mapping agent file stems to template paths
+
+        Returns:
+            Dictionary with cleanup results:
+            - removed: List of removed agent names
+            - errors: List of errors during cleanup
+        """
+        cleanup_results = {"removed": [], "errors": []}
+
+        # Safety check - only operate on deployed agents directory
+        if not deployed_agents_dir.exists():
+            self.logger.debug("Deployed agents directory does not exist, no cleanup needed")
+            return cleanup_results
+
+        # Build set of agent names that should exist (file stems without .md extension)
+        expected_agents = set(agents_to_deploy.keys())
+
+        try:
+            # Check each file in deployed_agents_dir
+            for item in deployed_agents_dir.iterdir():
+                # Only process .md files
+                if not item.is_file() or item.suffix != ".md":
+                    continue
+
+                # Skip hidden files
+                if item.name.startswith("."):
+                    continue
+
+                # Get agent name (file stem)
+                agent_name = item.stem
+
+                # Check if this agent should be kept
+                if agent_name not in expected_agents:
+                    try:
+                        # Security: Validate path is within deployed_agents_dir
+                        resolved_item = item.resolve()
+                        resolved_target = deployed_agents_dir.resolve()
+
+                        if not str(resolved_item).startswith(str(resolved_target)):
+                            self.logger.error(
+                                f"Refusing to remove path outside target directory: {item}"
+                            )
+                            cleanup_results["errors"].append(
+                                {
+                                    "agent": agent_name,
+                                    "error": "Path outside target directory",
+                                }
+                            )
+                            continue
+
+                        # Remove the agent file
+                        item.unlink()
+                        cleanup_results["removed"].append(agent_name)
+                        self.logger.info(f"Removed excluded agent: {agent_name}")
+
+                    except PermissionError as e:
+                        error_msg = f"Permission denied removing {agent_name}: {e}"
+                        self.logger.error(error_msg)
+                        cleanup_results["errors"].append(
+                            {"agent": agent_name, "error": error_msg}
+                        )
+                    except Exception as e:
+                        error_msg = f"Error removing {agent_name}: {e}"
+                        self.logger.error(error_msg)
+                        cleanup_results["errors"].append(
+                            {"agent": agent_name, "error": error_msg}
+                        )
+
+        except Exception as e:
+            self.logger.error(f"Error during agent cleanup: {e}")
+            cleanup_results["errors"].append(
+                {"agent": "cleanup_process", "error": str(e)}
+            )
+
+        # Log cleanup summary
+        if cleanup_results["removed"]:
+            self.logger.info(
+                f"Cleanup complete: removed {len(cleanup_results['removed'])} excluded agents"
+            )
+        if cleanup_results["errors"]:
+            self.logger.warning(
+                f"Encountered {len(cleanup_results['errors'])} errors during cleanup"
+            )
+
+        return cleanup_results
+
     def cleanup_outdated_user_agents(
         self,
         agents_by_name: Dict[str, List[Dict[str, Any]]],
@@ -827,17 +1036,20 @@ class MultiSourceAgentDeploymentService:
                 comparison_results["needs_update"].append(agent_name)
                 continue
 
-            # Read template version
-            try:
-                template_data = json.loads(template_path.read_text())
-                metadata = template_data.get("metadata", {})
-                template_version = self.version_manager.parse_version(
-                    template_data.get("agent_version")
-                    or template_data.get("version")
-                    or metadata.get("version", "0.0.0")
+            # Read template version using format-aware helper
+            version_string = self._read_template_version(template_path)
+            if not version_string:
+                self.logger.warning(
+                    f"Could not extract version from template for '{agent_name}', skipping"
                 )
+                continue
+
+            try:
+                template_version = self.version_manager.parse_version(version_string)
             except Exception as e:
-                self.logger.warning(f"Error reading template for '{agent_name}': {e}")
+                self.logger.warning(
+                    f"Error parsing version '{version_string}' for '{agent_name}': {e}"
+                )
                 continue
 
             # Read deployed version