claude-mpm 4.1.0__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/agent_capabilities_service.py

@@ -11,11 +11,8 @@ This service handles:
 Extracted from ClaudeRunner to follow Single Responsibility Principle.
 """
 
-import logging
-from typing import Dict, Optional
 
 from claude_mpm.core.base_service import BaseService
-from claude_mpm.core.logging_config import get_logger
 from claude_mpm.services.core.interfaces import AgentCapabilitiesInterface
 
 
@@ -28,11 +25,9 @@ class AgentCapabilitiesService(BaseService, AgentCapabilitiesInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def generate_agent_capabilities(self, agent_type: str = "general") -> str:
         """Generate formatted agent capabilities for Claude.
@@ -108,7 +103,7 @@ class AgentCapabilitiesService(BaseService, AgentCapabilitiesInterface):
 
             # Group agents by category
             agents_by_category = {}
-            for agent_id, agent_info in discovered_agents.items():
+            for _agent_id, agent_info in discovered_agents.items():
                 category = agent_info["category"]
                 if category not in agents_by_category:
                     agents_by_category[category] = []
@@ -155,9 +150,9 @@ class AgentCapabilitiesService(BaseService, AgentCapabilitiesInterface):
 
             self.logger.info(
                 f"Generated capabilities for {len(discovered_agents)} agents "
-                + f"(project: {tier_counts.get('project', 0)}, "
-                + f"user: {tier_counts.get('user', 0)}, "
-                + f"system: {tier_counts.get('system', 0)})"
+                f"(project: {tier_counts.get('project', 0)}, "
+                f"user: {tier_counts.get('user', 0)}, "
+                f"system: {tier_counts.get('system', 0)})"
             )
             return section
 
@@ -227,30 +222,29 @@ class AgentCapabilitiesService(BaseService, AgentCapabilitiesInterface):
 
         if "engineer" in agent_id_lower or "engineering" in content_lower:
             return "Development"
-        elif "research" in agent_id_lower or "research" in content_lower:
+        if "research" in agent_id_lower or "research" in content_lower:
             return "Research"
-        elif (
+        if (
             "qa" in agent_id_lower
             or "test" in agent_id_lower
             or "quality" in content_lower
         ):
             return "Quality Assurance"
-        elif "doc" in agent_id_lower or "documentation" in content_lower:
+        if "doc" in agent_id_lower or "documentation" in content_lower:
             return "Documentation"
-        elif "security" in agent_id_lower or "security" in content_lower:
+        if "security" in agent_id_lower or "security" in content_lower:
             return "Security"
-        elif "data" in agent_id_lower or "database" in content_lower:
+        if "data" in agent_id_lower or "database" in content_lower:
             return "Data"
-        elif (
+        if (
             "ops" in agent_id_lower
             or "deploy" in agent_id_lower
             or "operations" in content_lower
         ):
             return "Operations"
-        elif "git" in agent_id_lower or "version" in content_lower:
+        if "git" in agent_id_lower or "version" in content_lower:
             return "Version Control"
-        else:
-            return "General"
+        return "General"
 
     def _get_fallback_capabilities(self) -> str:
         """Return fallback agent capabilities when deployed agents can't be read."""

claude_mpm/services/agents/__init__.py

@@ -40,37 +40,37 @@ from .registry.modification_tracker import (
 )
 
 __all__ = [
+    "AgentCapabilitiesGenerator",
+    # Deployment
+    "AgentDeploymentService",
+    "AgentLifecycleManager",
+    "AgentLifecycleRecord",
+    # Management
+    "AgentManager",
+    # Memory
+    "AgentMemoryManager",
+    "AgentMetadata",
+    "AgentModification",
+    "AgentModificationTracker",
+    "AgentPersistenceService",
+    "AgentProfileLoader",
     # Registry
     "AgentRegistry",
-    "AgentMetadata",
     "AgentTier",
     "AgentType",
+    "AgentVersionManager",
+    "BaseAgentManager",
     "DeployedAgentDiscovery",
-    "AgentModificationTracker",
-    "ModificationType",
-    "ModificationTier",
-    "AgentModification",
-    "ModificationHistory",
     # Loading
     "FrameworkAgentLoader",
-    "AgentProfileLoader",
-    "BaseAgentManager",
-    # Deployment
-    "AgentDeploymentService",
-    "AgentLifecycleManager",
-    "LifecycleState",
     "LifecycleOperation",
-    "AgentLifecycleRecord",
     "LifecycleOperationResult",
-    "AgentVersionManager",
-    # Memory
-    "AgentMemoryManager",
-    "get_memory_manager",
-    "AgentPersistenceService",
-    "PersistenceStrategy",
+    "LifecycleState",
+    "ModificationHistory",
+    "ModificationTier",
+    "ModificationType",
     "PersistenceOperation",
     "PersistenceRecord",
-    # Management
-    "AgentManager",
-    "AgentCapabilitiesGenerator",
+    "PersistenceStrategy",
+    "get_memory_manager",
 ]

claude_mpm/services/agents/agent_builder.py

@@ -9,7 +9,6 @@ This service provides comprehensive agent lifecycle management including:
 """
 
 import json
-import logging
 import re
 from datetime import datetime
 from pathlib import Path
@@ -21,29 +20,38 @@ from claude_mpm.core.logging_config import get_logger
 
 class AgentBuilderService:
     """Service for building and managing agent configurations."""
-    
+
     # Valid agent models
     VALID_MODELS = ["sonnet", "opus", "haiku"]
-    
+
     # Valid tool choices
     VALID_TOOL_CHOICES = ["auto", "required", "any", "none"]
-    
+
     # Agent categories
     AGENT_CATEGORIES = [
-        "engineering", "qa", "documentation", "ops", 
-        "research", "security", "system", "utility"
+        "engineering",
+        "qa",
+        "documentation",
+        "ops",
+        "research",
+        "security",
+        "system",
+        "utility",
     ]
-    
+
     def __init__(self, templates_dir: Optional[Path] = None):
         """Initialize the Agent Builder Service.
-        
+
         Args:
             templates_dir: Path to agent templates directory
         """
         self.logger = get_logger(__name__)
-        self.templates_dir = templates_dir or Path(__file__).parent.parent.parent / "agents" / "templates"
+        self.templates_dir = (
+            templates_dir
+            or Path(__file__).parent.parent.parent / "agents" / "templates"
+        )
         self._template_cache = {}
-        
+
     def create_agent(
         self,
         agent_id: str,
@@ -53,10 +61,10 @@ class AgentBuilderService:
         tool_choice: str = "auto",
         instructions: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        base_template: Optional[str] = None
+        base_template: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Create a new agent configuration.
-        
+
         Args:
             agent_id: Unique identifier for the agent
             name: Display name for the agent
@@ -66,10 +74,10 @@ class AgentBuilderService:
             instructions: Markdown instructions content
             metadata: Additional agent metadata
             base_template: Optional base template to extend
-            
+
         Returns:
             Complete agent configuration dictionary
-            
+
         Raises:
             AgentDeploymentError: If validation fails
         """
@@ -77,79 +85,83 @@ class AgentBuilderService:
         self._validate_agent_id(agent_id)
         self._validate_model(model)
         self._validate_tool_choice(tool_choice)
-        
+
         # Start with base template if provided
         if base_template:
             config = self._load_template(base_template)
             config["id"] = agent_id  # Override ID
         else:
             config = {}
-            
+
         # Build agent configuration
-        config.update({
-            "id": agent_id,
-            "name": name,
-            "prompt": f"{agent_id}.md",
-            "model": model,
-            "tool_choice": tool_choice
-        })
-        
+        config.update(
+            {
+                "id": agent_id,
+                "name": name,
+                "prompt": f"{agent_id}.md",
+                "model": model,
+                "tool_choice": tool_choice,
+            }
+        )
+
         # Build metadata
         agent_metadata = {
             "description": description,
             "version": "1.0.0",
             "created": datetime.now().isoformat(),
             "author": "Agent Manager",
-            "category": "custom"
+            "category": "custom",
         }
-        
+
         if metadata:
             agent_metadata.update(metadata)
-            
+
         config["metadata"] = agent_metadata
-        
+
         # Generate instructions if not provided
         if instructions is None:
-            instructions = self._generate_default_instructions(agent_id, name, description)
-            
+            instructions = self._generate_default_instructions(
+                agent_id, name, description
+            )
+
         return config, instructions
-        
+
     def create_variant(
         self,
         base_agent_id: str,
         variant_id: str,
         variant_name: str,
         modifications: Dict[str, Any],
-        instructions_append: Optional[str] = None
+        instructions_append: Optional[str] = None,
     ) -> Tuple[Dict[str, Any], str]:
         """Create an agent variant based on an existing agent.
-        
+
         Args:
             base_agent_id: ID of the base agent to extend
             variant_id: Unique ID for the variant
             variant_name: Display name for the variant
             modifications: Configuration changes for the variant
             instructions_append: Additional instructions to append
-            
+
         Returns:
             Tuple of (variant configuration, variant instructions)
-            
+
         Raises:
             AgentDeploymentError: If base agent not found or validation fails
         """
         # Load base agent
         base_config = self._load_template(base_agent_id)
         base_instructions = self._load_instructions(base_agent_id)
-        
+
         # Validate variant ID
         self._validate_agent_id(variant_id)
-        
+
         # Create variant configuration
         variant_config = base_config.copy()
         variant_config["id"] = variant_id
         variant_config["name"] = variant_name
         variant_config["prompt"] = f"{variant_id}.md"
-        
+
         # Apply modifications
         for key, value in modifications.items():
             if key in ["model", "tool_choice"]:
@@ -158,165 +170,170 @@ class AgentBuilderService:
                 elif key == "tool_choice":
                     self._validate_tool_choice(value)
             variant_config[key] = value
-            
+
         # Update metadata
         if "metadata" not in variant_config:
             variant_config["metadata"] = {}
-            
-        variant_config["metadata"].update({
-            "base_agent": base_agent_id,
-            "variant": True,
-            "variant_created": datetime.now().isoformat()
-        })
-        
+
+        variant_config["metadata"].update(
+            {
+                "base_agent": base_agent_id,
+                "variant": True,
+                "variant_created": datetime.now().isoformat(),
+            }
+        )
+
         # Build variant instructions
         variant_instructions = f"# {variant_name} (Variant of {base_config.get('name', base_agent_id)})\n\n"
         variant_instructions += base_instructions
-        
+
         if instructions_append:
-            variant_instructions += f"\n\n## Variant-Specific Instructions\n\n{instructions_append}"
-            
+            variant_instructions += (
+                f"\n\n## Variant-Specific Instructions\n\n{instructions_append}"
+            )
+
         return variant_config, variant_instructions
-        
+
     def validate_configuration(self, config: Dict[str, Any]) -> List[str]:
         """Validate an agent configuration.
-        
+
         Args:
             config: Agent configuration to validate
-            
+
         Returns:
             List of validation errors (empty if valid)
         """
         errors = []
-        
+
         # Required fields
         required_fields = ["id", "name", "prompt", "model"]
         for field in required_fields:
             if field not in config:
                 errors.append(f"Missing required field: {field}")
-                
+
         # Validate ID
         if "id" in config:
             try:
                 self._validate_agent_id(config["id"])
             except AgentDeploymentError as e:
                 errors.append(str(e))
-                
+
         # Validate model
         if "model" in config:
             try:
                 self._validate_model(config["model"])
             except AgentDeploymentError as e:
                 errors.append(str(e))
-                
+
         # Validate tool_choice
         if "tool_choice" in config:
             try:
                 self._validate_tool_choice(config["tool_choice"])
             except AgentDeploymentError as e:
                 errors.append(str(e))
-                
+
         # Validate metadata
-        if "metadata" in config:
-            if not isinstance(config["metadata"], dict):
-                errors.append("Metadata must be a dictionary")
-                
+        if "metadata" in config and not isinstance(config["metadata"], dict):
+            errors.append("Metadata must be a dictionary")
+
         return errors
-        
+
     def generate_pm_instructions(
         self,
         delegation_patterns: Optional[List[str]] = None,
         workflow_overrides: Optional[Dict[str, str]] = None,
-        custom_rules: Optional[List[str]] = None
+        custom_rules: Optional[List[str]] = None,
     ) -> str:
         """Generate customized PM instructions.
-        
+
         Args:
             delegation_patterns: Custom delegation patterns
             workflow_overrides: Workflow sequence modifications
             custom_rules: Additional PM rules
-            
+
         Returns:
             Customized PM instructions markdown
         """
         instructions = "# Custom PM Instructions\n\n"
-        
+
         if delegation_patterns:
             instructions += "## Custom Delegation Patterns\n\n"
             for pattern in delegation_patterns:
                 instructions += f"- {pattern}\n"
             instructions += "\n"
-            
+
         if workflow_overrides:
             instructions += "## Workflow Overrides\n\n"
             for workflow, override in workflow_overrides.items():
                 instructions += f"### {workflow}\n{override}\n\n"
-                
+
         if custom_rules:
             instructions += "## Additional Rules\n\n"
             for rule in custom_rules:
                 instructions += f"- {rule}\n"
-                
+
         return instructions
-        
+
     def list_available_templates(self) -> List[Dict[str, Any]]:
         """List all available agent templates.
-        
+
         Returns:
             List of template metadata dictionaries
         """
         templates = []
-        
+
         if not self.templates_dir.exists():
             return templates
-            
+
         for template_file in self.templates_dir.glob("*.json"):
             try:
-                with open(template_file, 'r') as f:
+                with open(template_file) as f:
                     config = json.load(f)
-                    
+
                 # Use filename stem as ID if not specified in config
                 template_id = config.get("id") or template_file.stem
-                    
-                templates.append({
-                    "id": template_id,
-                    "name": config.get("name", template_id),
-                    "description": config.get("metadata", {}).get("description"),
-                    "category": config.get("metadata", {}).get("category"),
-                    "version": config.get("metadata", {}).get("version"),
-                    "file": str(template_file)
-                })
+
+                templates.append(
+                    {
+                        "id": template_id,
+                        "name": config.get("name", template_id),
+                        "description": config.get("metadata", {}).get("description"),
+                        "category": config.get("metadata", {}).get("category"),
+                        "version": config.get("metadata", {}).get("version"),
+                        "file": str(template_file),
+                    }
+                )
             except Exception as e:
                 self.logger.warning(f"Failed to load template {template_file}: {e}")
-                
+
         return templates
-        
+
     def _validate_agent_id(self, agent_id: str) -> None:
         """Validate agent ID format.
-        
+
         Args:
             agent_id: Agent ID to validate
-            
+
         Raises:
             AgentDeploymentError: If ID is invalid
         """
         if not agent_id:
             raise AgentDeploymentError("Agent ID cannot be empty")
-            
+
         if len(agent_id) > 50:
             raise AgentDeploymentError("Agent ID must be 50 characters or less")
-            
-        if not re.match(r'^[a-z0-9-]+$', agent_id):
+
+        if not re.match(r"^[a-z0-9-]+$", agent_id):
             raise AgentDeploymentError(
                 "Agent ID must contain only lowercase letters, numbers, and hyphens"
             )
-            
+
     def _validate_model(self, model: str) -> None:
         """Validate model selection.
-        
+
         Args:
             model: Model to validate
-            
+
         Raises:
             AgentDeploymentError: If model is invalid
         """
@@ -324,13 +341,13 @@ class AgentBuilderService:
             raise AgentDeploymentError(
                 f"Invalid model '{model}'. Must be one of: {', '.join(self.VALID_MODELS)}"
             )
-            
+
     def _validate_tool_choice(self, tool_choice: str) -> None:
         """Validate tool choice setting.
-        
+
         Args:
             tool_choice: Tool choice to validate
-            
+
         Raises:
             AgentDeploymentError: If tool choice is invalid
         """
@@ -338,44 +355,44 @@ class AgentBuilderService:
             raise AgentDeploymentError(
                 f"Invalid tool_choice '{tool_choice}'. Must be one of: {', '.join(self.VALID_TOOL_CHOICES)}"
             )
-            
+
     def _load_template(self, template_id: str) -> Dict[str, Any]:
         """Load an agent template.
-        
+
         Args:
             template_id: Template ID to load
-            
+
         Returns:
             Template configuration dictionary
-            
+
         Raises:
             AgentDeploymentError: If template not found
         """
         if template_id in self._template_cache:
             return self._template_cache[template_id].copy()
-            
+
         template_file = self.templates_dir / f"{template_id}.json"
-        
+
         if not template_file.exists():
             raise AgentDeploymentError(f"Template '{template_id}' not found")
-            
+
         try:
-            with open(template_file, 'r') as f:
+            with open(template_file) as f:
                 config = json.load(f)
                 self._template_cache[template_id] = config
                 return config.copy()
         except Exception as e:
             raise AgentDeploymentError(f"Failed to load template '{template_id}': {e}")
-            
+
     def _load_instructions(self, agent_id: str) -> str:
         """Load agent instructions.
-        
+
         Args:
             agent_id: Agent ID to load instructions for
-            
+
         Returns:
             Instructions markdown content
-            
+
         Raises:
             AgentDeploymentError: If instructions not found
         """
@@ -383,28 +400,32 @@ class AgentBuilderService:
         possible_files = [
             self.templates_dir / f"{agent_id}.md",
             self.templates_dir / f"{agent_id}_instructions.md",
-            self.templates_dir / f"{agent_id}-instructions.md"
+            self.templates_dir / f"{agent_id}-instructions.md",
         ]
-        
+
         for instructions_file in possible_files:
             if instructions_file.exists():
                 try:
-                    with open(instructions_file, 'r') as f:
+                    with open(instructions_file) as f:
                         return f.read()
                 except Exception as e:
-                    self.logger.warning(f"Failed to read instructions from {instructions_file}: {e}")
-                    
+                    self.logger.warning(
+                        f"Failed to read instructions from {instructions_file}: {e}"
+                    )
+
         # If no instructions found, return empty
         return ""
-        
-    def _generate_default_instructions(self, agent_id: str, name: str, description: str) -> str:
+
+    def _generate_default_instructions(
+        self, agent_id: str, name: str, description: str
+    ) -> str:
         """Generate default agent instructions.
-        
+
         Args:
             agent_id: Agent identifier
             name: Agent display name
             description: Agent description
-            
+
         Returns:
             Default instructions markdown
         """
@@ -452,4 +473,4 @@ Provide structured responses with:
 
 *Agent ID: {agent_id}*
 *Generated by Agent Manager*
-"""
+"""