claude-mpm 1.1.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

claude_mpm/schemas/agent_schema.json

@@ -0,0 +1,328 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Claude MPM Agent Schema",
+  "description": "Schema definition for Claude MPM agent templates",
+  "type": "object",
+  "required": ["id", "version", "metadata", "capabilities", "instructions"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_]*$",
+      "description": "Unique agent identifier (lowercase, alphanumeric with underscores)",
+      "examples": ["research", "engineer", "qa", "security"]
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$",
+      "description": "Semantic version of the agent template",
+      "examples": ["1.0.0", "2.1.3"]
+    },
+    "metadata": {
+      "type": "object",
+      "required": ["name", "description", "category", "tags"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 3,
+          "maxLength": 50,
+          "description": "Human-readable agent name"
+        },
+        "description": {
+          "type": "string",
+          "minLength": 10,
+          "maxLength": 200,
+          "description": "Brief description of agent purpose"
+        },
+        "category": {
+          "type": "string",
+          "enum": ["engineering", "research", "quality", "operations", "specialized"],
+          "description": "Agent category for organization"
+        },
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "pattern": "^[a-z][a-z0-9-]*$"
+          },
+          "minItems": 1,
+          "maxItems": 10,
+          "uniqueItems": true,
+          "description": "Tags for agent discovery"
+        },
+        "author": {
+          "type": "string",
+          "description": "Agent template author"
+        },
+        "created_at": {
+          "type": "string",
+          "format": "date-time",
+          "description": "Creation timestamp"
+        },
+        "updated_at": {
+          "type": "string",
+          "format": "date-time",
+          "description": "Last update timestamp"
+        }
+      }
+    },
+    "capabilities": {
+      "type": "object",
+      "required": ["model", "tools", "resource_tier"],
+      "properties": {
+        "model": {
+          "type": "string",
+          "enum": [
+            "claude-3-haiku-20240307",
+            "claude-3-5-haiku-20241022",
+            "claude-3-sonnet-20240229",
+            "claude-3-5-sonnet-20241022",
+            "claude-3-opus-20240229",
+            "claude-3-5-sonnet-20240620",
+            "claude-sonnet-4-20250514",
+            "claude-4-sonnet-20250514",
+            "claude-opus-4-20250514",
+            "claude-4-opus-20250514"
+          ],
+          "description": "Claude model to use for this agent"
+        },
+        "tools": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "Read", "Write", "Edit", "MultiEdit",
+              "Grep", "Glob", "LS", "Bash",
+              "WebSearch", "WebFetch",
+              "NotebookRead", "NotebookEdit",
+              "TodoWrite", "ExitPlanMode",
+              "git", "docker", "kubectl", "terraform",
+              "aws", "gcloud", "azure"
+            ]
+          },
+          "uniqueItems": true,
+          "description": "Available tools for the agent"
+        },
+        "resource_tier": {
+          "type": "string",
+          "enum": ["intensive", "standard", "lightweight"],
+          "description": "Resource allocation tier"
+        },
+        "max_tokens": {
+          "type": "integer",
+          "minimum": 1000,
+          "maximum": 200000,
+          "default": 8192,
+          "description": "Maximum tokens for response"
+        },
+        "temperature": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "default": 0.7,
+          "description": "Model temperature setting"
+        },
+        "timeout": {
+          "type": "integer",
+          "minimum": 30,
+          "maximum": 3600,
+          "default": 300,
+          "description": "Operation timeout in seconds"
+        },
+        "memory_limit": {
+          "type": "integer",
+          "minimum": 512,
+          "maximum": 8192,
+          "description": "Memory limit in MB (for resource tier)"
+        },
+        "cpu_limit": {
+          "type": "integer",
+          "minimum": 10,
+          "maximum": 100,
+          "description": "CPU limit percentage (for resource tier)"
+        },
+        "network_access": {
+          "type": "boolean",
+          "default": false,
+          "description": "Whether agent needs network access"
+        },
+        "file_access": {
+          "type": "object",
+          "properties": {
+            "read_paths": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Allowed read paths"
+            },
+            "write_paths": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Allowed write paths"
+            }
+          }
+        }
+      }
+    },
+    "instructions": {
+      "type": "string",
+      "minLength": 100,
+      "maxLength": 8000,
+      "description": "Agent system instructions (8000 character limit)"
+    },
+    "knowledge": {
+      "type": "object",
+      "description": "Agent-specific knowledge and context",
+      "properties": {
+        "domain_expertise": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Areas of expertise"
+        },
+        "best_practices": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Best practices the agent follows"
+        },
+        "constraints": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Operating constraints"
+        },
+        "examples": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "scenario": {"type": "string"},
+              "approach": {"type": "string"}
+            }
+          },
+          "description": "Example scenarios and approaches"
+        }
+      }
+    },
+    "interactions": {
+      "type": "object",
+      "description": "Agent interaction patterns",
+      "properties": {
+        "input_format": {
+          "type": "object",
+          "properties": {
+            "required_fields": {
+              "type": "array",
+              "items": {"type": "string"}
+            },
+            "optional_fields": {
+              "type": "array",
+              "items": {"type": "string"}
+            }
+          }
+        },
+        "output_format": {
+          "type": "object",
+          "properties": {
+            "structure": {
+              "type": "string",
+              "enum": ["markdown", "json", "structured", "free-form"]
+            },
+            "includes": {
+              "type": "array",
+              "items": {"type": "string"}
+            }
+          }
+        },
+        "handoff_agents": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Agents this agent can hand off to"
+        },
+        "triggers": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "condition": {"type": "string"},
+              "action": {"type": "string"}
+            }
+          },
+          "description": "Conditions that trigger specific actions"
+        }
+      }
+    },
+    "testing": {
+      "type": "object",
+      "description": "Testing configuration for the agent",
+      "properties": {
+        "test_cases": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["input", "expected_behavior"],
+            "properties": {
+              "name": {"type": "string"},
+              "input": {"type": "string"},
+              "expected_behavior": {"type": "string"},
+              "validation_criteria": {
+                "type": "array",
+                "items": {"type": "string"}
+              }
+            }
+          }
+        },
+        "performance_benchmarks": {
+          "type": "object",
+          "properties": {
+            "response_time": {"type": "integer"},
+            "token_usage": {"type": "integer"},
+            "success_rate": {"type": "number"}
+          }
+        }
+      }
+    },
+    "hooks": {
+      "type": "object",
+      "description": "Hook configurations for extensibility",
+      "properties": {
+        "pre_execution": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {"type": "string"},
+              "enabled": {"type": "boolean"}
+            }
+          }
+        },
+        "post_execution": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {"type": "string"},
+              "enabled": {"type": "boolean"}
+            }
+          }
+        }
+      }
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "resource_tier_limits": {
+      "intensive": {
+        "memory_limit": {"min": 4096, "max": 8192},
+        "cpu_limit": {"min": 60, "max": 100},
+        "timeout": {"min": 600, "max": 3600}
+      },
+      "standard": {
+        "memory_limit": {"min": 2048, "max": 4096},
+        "cpu_limit": {"min": 30, "max": 60},
+        "timeout": {"min": 300, "max": 1200}
+      },
+      "lightweight": {
+        "memory_limit": {"min": 512, "max": 2048},
+        "cpu_limit": {"min": 10, "max": 30},
+        "timeout": {"min": 30, "max": 600}
+      }
+    }
+  }
+}

claude_mpm/services/agent_capabilities_generator.py

@@ -0,0 +1,182 @@
+"""Agent Capabilities Content Generator.
+
+This service generates markdown content for agent capabilities section
+from discovered deployed agents.
+"""
+
+from typing import List, Dict, Any
+import logging
+
+from jinja2 import Template
+
+logger = logging.getLogger(__name__)
+
+
+class AgentCapabilitiesGenerator:
+    """Generates markdown content for agent capabilities section."""
+    
+    def __init__(self):
+        """Initialize the generator with default template."""
+        self.template = self._load_template()
+        logger.debug("Initialized AgentCapabilitiesGenerator")
+    
+    def generate_capabilities_section(self, deployed_agents: List[Dict[str, Any]]) -> str:
+        """Generate the complete agent capabilities markdown section.
+        
+        Args:
+            deployed_agents: List of agent information dictionaries
+            
+        Returns:
+            Generated markdown content for agent capabilities
+        """
+        try:
+            # Group agents by source tier for organized display
+            agents_by_tier = self._group_by_tier(deployed_agents)
+            
+            # Generate core agent list
+            core_agent_list = self._generate_core_agent_list(deployed_agents)
+            
+            # Generate detailed capabilities
+            detailed_capabilities = self._generate_detailed_capabilities(deployed_agents)
+            
+            # Render template
+            content = self.template.render(
+                core_agents=core_agent_list,
+                detailed_capabilities=detailed_capabilities,
+                agents_by_tier=agents_by_tier,
+                total_agents=len(deployed_agents)
+            )
+            
+            logger.info(f"Generated capabilities section for {len(deployed_agents)} agents")
+            return content
+            
+        except Exception as e:
+            logger.error(f"Failed to generate capabilities section: {e}")
+            # Return fallback content on error
+            return self._generate_fallback_content()
+    
+    def _group_by_tier(self, agents: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+        """Group agents by their source tier.
+        
+        Args:
+            agents: List of agent information dictionaries
+            
+        Returns:
+            Dictionary mapping tiers to lists of agents
+        """
+        tiers = {'system': [], 'user': [], 'project': []}
+        
+        for agent in agents:
+            tier = agent.get('source_tier', 'system')
+            if tier in tiers:
+                tiers[tier].append(agent)
+            else:
+                # Handle unknown tiers gracefully
+                tiers['system'].append(agent)
+                logger.warning(f"Unknown source tier '{tier}' for agent {agent.get('id')}, defaulting to system")
+        
+        return tiers
+    
+    def _generate_core_agent_list(self, agents: List[Dict[str, Any]]) -> str:
+        """Generate comma-separated list of core agent IDs.
+        
+        Args:
+            agents: List of agent information dictionaries
+            
+        Returns:
+            Comma-separated string of agent IDs
+        """
+        agent_ids = [agent['id'] for agent in agents]
+        return ', '.join(sorted(agent_ids))
+    
+    def _generate_detailed_capabilities(self, agents: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+        """Generate detailed capability descriptions for each agent.
+        
+        Args:
+            agents: List of agent information dictionaries
+            
+        Returns:
+            List of capability dictionaries for template rendering
+        """
+        capabilities = []
+        
+        for agent in sorted(agents, key=lambda a: a['id']):
+            # Extract key capabilities
+            specializations = agent.get('specializations', [])
+            when_to_use = agent.get('capabilities', {}).get('when_to_use', [])
+            
+            # Create capability summary
+            if when_to_use:
+                capability_text = '; '.join(when_to_use[:2])  # First 2 items
+            elif specializations:
+                capability_text = ', '.join(specializations[:3])  # First 3 specializations
+            else:
+                capability_text = agent.get('description', 'General purpose agent')
+            
+            # Truncate long capability text
+            if len(capability_text) > 100:
+                capability_text = capability_text[:97] + '...'
+            
+            capabilities.append({
+                'name': agent['name'],
+                'id': agent['id'],
+                'capability_text': capability_text,
+                'tools': ', '.join(agent.get('tools', [])[:5])  # First 5 tools
+            })
+        
+        return capabilities
+    
+    def _load_template(self) -> Template:
+        """Load the Jinja2 template for agent capabilities.
+        
+        Returns:
+            Configured Jinja2 template
+        """
+        template_content = """
+## Agent Names & Capabilities
+**Core Agents**: {{ core_agents }}
+
+{% if agents_by_tier.project %}
+### Project-Specific Agents
+{% for agent in agents_by_tier.project %}
+- **{{ agent.name }}** ({{ agent.id }}): {{ agent.description }}
+{% endfor %}
+
+{% endif %}
+**Agent Capabilities**:
+{% for cap in detailed_capabilities %}
+- **{{ cap.name }}**: {{ cap.capability_text }}
+{% endfor %}
+
+**Agent Name Formats** (both valid):
+- Capitalized: {{ detailed_capabilities | map(attribute='name') | join('", "') }}
+- Lowercase-hyphenated: {{ detailed_capabilities | map(attribute='id') | join('", "') }}
+
+*Generated from {{ total_agents }} deployed agents*
+""".strip()
+        
+        return Template(template_content)
+    
+    def _generate_fallback_content(self) -> str:
+        """Generate fallback content when agent discovery fails.
+        
+        Returns:
+            Static fallback markdown content
+        """
+        logger.warning("Using fallback content due to generation failure")
+        return """
+## Agent Names & Capabilities
+**Core Agents**: research, engineer, qa, documentation, security, ops, version_control, data_engineer
+
+**Agent Capabilities**:
+- **Research**: Codebase analysis, best practices, technical investigation
+- **Engineer**: Implementation, refactoring, debugging
+- **QA**: Quality assurance, testing, code review
+- **Documentation**: Technical writing, API docs, user guides
+- **Security**: Security analysis, vulnerability assessment
+- **Ops**: Operations, deployment, infrastructure
+- **Version Control**: Git operations, branch management
+- **Data Engineer**: Data pipelines, ETL, database operations
+
+*Note: Unable to dynamically generate agent list. Using default agents.*
+""".strip()