claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/agents/agent_loader_integration.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Agent Loader Integration
+========================
+
+Integrates the new agent management service with the existing agent loader.
+Provides backward compatibility while enabling advanced features.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+
+from .agent_loader import (
+    load_agent_prompt_from_md,
+    get_agent_prompt,
+    AGENT_MAPPINGS,
+    FRAMEWORK_AGENT_ROLES_DIR
+)
+from ..services.agent_management_service import AgentManager
+from ..models.agent_definition import AgentDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class EnhancedAgentLoader:
+    """Enhanced agent loader with management capabilities."""
+    
+    def __init__(self):
+        """Initialize enhanced loader."""
+        self.manager = AgentManager()
+        
+    def get_agent_definition(self, agent_name: str) -> Optional[AgentDefinition]:
+        """
+        Get full agent definition with structured data.
+        
+        Args:
+            agent_name: Agent name (e.g., 'documentation', 'ticketing')
+            
+        Returns:
+            AgentDefinition or None
+        """
+        # Map from old naming to new naming if needed
+        md_filename = AGENT_MAPPINGS.get(agent_name, f"{agent_name}.md")
+        agent_file_name = md_filename.replace('.md', '')
+        
+        return self.manager.read_agent(agent_file_name)
+    
+    def get_agent_metadata(self, agent_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get agent metadata only.
+        
+        Args:
+            agent_name: Agent name
+            
+        Returns:
+            Metadata dict or None
+        """
+        agent_def = self.get_agent_definition(agent_name)
+        if not agent_def:
+            return None
+            
+        return {
+            "name": agent_def.name,
+            "title": agent_def.title,
+            "version": agent_def.metadata.version,
+            "type": agent_def.metadata.type.value,
+            "model_preference": agent_def.metadata.model_preference,
+            "specializations": agent_def.metadata.specializations,
+            "last_updated": agent_def.metadata.last_updated.isoformat() 
+                if agent_def.metadata.last_updated else None
+        }
+    
+    def get_agent_capabilities(self, agent_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get agent capabilities and permissions.
+        
+        Args:
+            agent_name: Agent name
+            
+        Returns:
+            Capabilities dict or None
+        """
+        agent_def = self.get_agent_definition(agent_name)
+        if not agent_def:
+            return None
+            
+        return {
+            "capabilities": agent_def.capabilities,
+            "authority": {
+                "write_access": agent_def.authority.exclusive_write_access,
+                "forbidden": agent_def.authority.forbidden_operations,
+                "read_access": agent_def.authority.read_access
+            },
+            "workflows": [w.name for w in agent_def.workflows],
+            "tools_available": bool(agent_def.tools_commands)
+        }
+    
+    def get_agent_selection_criteria(self, agent_name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get agent selection criteria for routing.
+        
+        Args:
+            agent_name: Agent name
+            
+        Returns:
+            Selection criteria dict or None
+        """
+        agent_def = self.get_agent_definition(agent_name)
+        if not agent_def:
+            return None
+            
+        return {
+            "when_to_select": agent_def.when_to_use.get("select", []),
+            "when_not_to_select": agent_def.when_to_use.get("do_not_select", []),
+            "specializations": agent_def.metadata.specializations,
+            "dependencies": agent_def.dependencies,
+            "escalation_triggers": agent_def.escalation_triggers
+        }
+    
+    def update_agent_version(self, agent_name: str) -> bool:
+        """
+        Increment agent version (serial).
+        
+        Args:
+            agent_name: Agent name
+            
+        Returns:
+            True if updated, False otherwise
+        """
+        # Map name
+        md_filename = AGENT_MAPPINGS.get(agent_name, f"{agent_name}.md")
+        agent_file_name = md_filename.replace('.md', '')
+        
+        result = self.manager.update_agent(agent_file_name, {}, increment_version=True)
+        return result is not None
+    
+    def refresh_agent_prompt(self, agent_name: str) -> str:
+        """
+        Force refresh agent prompt from file.
+        
+        Args:
+            agent_name: Agent name
+            
+        Returns:
+            Agent prompt with base instructions
+        """
+        # Use existing loader for backward compatibility
+        return get_agent_prompt(agent_name, force_reload=True)
+
+
+# Global instance for convenience
+_enhanced_loader = None
+
+
+def get_enhanced_loader() -> EnhancedAgentLoader:
+    """Get global enhanced loader instance."""
+    global _enhanced_loader
+    if _enhanced_loader is None:
+        _enhanced_loader = EnhancedAgentLoader()
+    return _enhanced_loader
+
+
+# Convenience functions
+def get_agent_full_definition(agent_name: str) -> Optional[AgentDefinition]:
+    """Get complete agent definition."""
+    return get_enhanced_loader().get_agent_definition(agent_name)
+
+
+def get_agent_version(agent_name: str) -> Optional[str]:
+    """Get agent version."""
+    metadata = get_enhanced_loader().get_agent_metadata(agent_name)
+    return metadata["version"] if metadata else None
+
+
+def check_agent_capability(agent_name: str, capability_keyword: str) -> bool:
+    """Check if agent has a specific capability."""
+    caps = get_enhanced_loader().get_agent_capabilities(agent_name)
+    if not caps:
+        return False
+        
+    # Check in capabilities list
+    for cap in caps["capabilities"]:
+        if capability_keyword.lower() in cap.lower():
+            return True
+    return False
+
+
+def should_select_agent(agent_name: str, task_description: str) -> Dict[str, Any]:
+    """
+    Determine if an agent should be selected for a task.
+    
+    Args:
+        agent_name: Agent name
+        task_description: Task description
+        
+    Returns:
+        Dict with selection recommendation and reasons
+    """
+    criteria = get_enhanced_loader().get_agent_selection_criteria(agent_name)
+    if not criteria:
+        return {"should_select": False, "reason": "Agent not found"}
+    
+    task_lower = task_description.lower()
+    
+    # Check positive matches
+    positive_matches = []
+    for criterion in criteria["when_to_select"]:
+        # Extract keywords from criterion
+        if "Keywords:" in criterion:
+            keywords = criterion.split("Keywords:")[1].strip()
+            for keyword in keywords.split(','):
+                keyword = keyword.strip().strip('"').strip("'")
+                if keyword.lower() in task_lower:
+                    positive_matches.append(f"Keyword match: {keyword}")
+        elif any(word in task_lower for word in criterion.lower().split()):
+            positive_matches.append(f"Criterion match: {criterion[:50]}...")
+    
+    # Check negative matches
+    negative_matches = []
+    for criterion in criteria["when_not_to_select"]:
+        if any(word in task_lower for word in criterion.lower().split()[:5]):
+            negative_matches.append(f"Exclusion: {criterion[:50]}...")
+    
+    return {
+        "should_select": len(positive_matches) > 0 and len(negative_matches) == 0,
+        "positive_matches": positive_matches,
+        "negative_matches": negative_matches,
+        "specializations": criteria["specializations"]
+    }

claude_mpm/agents/agents_metadata.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+Agent Metadata Definitions
+=========================
+
+Preserves AGENT_CONFIG metadata for all agents.
+This metadata is used for agent registration, capability tracking, and performance targets.
+"""
+
+# Documentation Agent Metadata
+DOCUMENTATION_CONFIG = {
+    "name": "documentation_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "documentation_analysis",
+        "changelog_generation",
+        "release_notes",
+        "api_documentation",
+        "version_documentation",
+        "operational_docs",
+        "quality_assurance"
+    ],
+    "primary_interface": "documentation_management",
+    "performance_targets": {
+        "changelog_generation": "5m",
+        "documentation_update": "24h",
+        "coverage_target": "90%"
+    }
+}
+
+
+# Version Control Agent Metadata
+VERSION_CONTROL_CONFIG = {
+    "name": "version_control_agent",
+    "version": "2.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "git_operations",
+        "branch_management",
+        "merge_conflict_resolution",
+        "semantic_versioning",
+        "tag_management",
+        "release_coordination",
+        "version_file_updates"
+    ],
+    "primary_interface": "git_cli",
+    "performance_targets": {
+        "branch_creation": "5s",
+        "merge_operation": "30s",
+        "version_bump": "10s",
+        "conflict_resolution": "5m"
+    }
+}
+
+# QA Agent Metadata
+QA_CONFIG = {
+    "name": "qa_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "test_execution",
+        "quality_validation",
+        "coverage_analysis",
+        "performance_testing",
+        "security_testing",
+        "regression_testing",
+        "test_automation"
+    ],
+    "primary_interface": "testing_framework",
+    "performance_targets": {
+        "unit_test_suite": "5m",
+        "integration_tests": "15m",
+        "full_test_suite": "30m",
+        "coverage_target": "80%"
+    }
+}
+
+# Research Agent Metadata
+RESEARCH_CONFIG = {
+    "name": "research_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "technology_research",
+        "library_analysis",
+        "best_practices_research",
+        "performance_analysis",
+        "security_research",
+        "market_analysis",
+        "feasibility_studies"
+    ],
+    "primary_interface": "research_tools",
+    "performance_targets": {
+        "quick_research": "15m",
+        "deep_analysis": "2h",
+        "comprehensive_report": "24h"
+    }
+}
+
+# Ops Agent Metadata
+OPS_CONFIG = {
+    "name": "ops_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "deployment_automation",
+        "infrastructure_management",
+        "monitoring_setup",
+        "ci_cd_pipeline",
+        "containerization",
+        "cloud_services",
+        "performance_optimization"
+    ],
+    "primary_interface": "deployment_tools",
+    "performance_targets": {
+        "deployment": "10m",
+        "rollback": "5m",
+        "infrastructure_update": "30m",
+        "monitoring_setup": "1h"
+    }
+}
+
+# Security Agent Metadata
+SECURITY_CONFIG = {
+    "name": "security_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "vulnerability_assessment",
+        "security_audit",
+        "penetration_testing",
+        "code_security_review",
+        "dependency_scanning",
+        "security_patching",
+        "compliance_checking"
+    ],
+    "primary_interface": "security_tools",
+    "performance_targets": {
+        "quick_scan": "10m",
+        "full_audit": "2h",
+        "penetration_test": "4h",
+        "dependency_scan": "30m"
+    }
+}
+
+# Engineer Agent Metadata
+ENGINEER_CONFIG = {
+    "name": "engineer_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "code_implementation",
+        "feature_development",
+        "bug_fixing",
+        "code_refactoring",
+        "performance_optimization",
+        "api_development",
+        "database_design"
+    ],
+    "primary_interface": "development_tools",
+    "performance_targets": {
+        "feature_implementation": "4h",
+        "bug_fix": "1h",
+        "code_review": "30m",
+        "refactoring": "2h"
+    }
+}
+
+# Data Engineer Agent Metadata
+DATA_ENGINEER_CONFIG = {
+    "name": "data_engineer_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "data_store_management",
+        "ai_api_integration",
+        "data_pipeline_design",
+        "database_optimization",
+        "data_migration",
+        "api_key_management",
+        "data_analytics",
+        "schema_design"
+    ],
+    "primary_interface": "data_management_tools",
+    "performance_targets": {
+        "pipeline_setup": "2h",
+        "data_migration": "4h",
+        "api_integration": "1h",
+        "schema_update": "30m"
+    }
+}
+
+# Aggregate all configs for easy access
+ALL_AGENT_CONFIGS = {
+    "documentation": DOCUMENTATION_CONFIG,
+    "version_control": VERSION_CONTROL_CONFIG,
+    "qa": QA_CONFIG,
+    "research": RESEARCH_CONFIG,
+    "ops": OPS_CONFIG,
+    "security": SECURITY_CONFIG,
+    "engineer": ENGINEER_CONFIG,
+    "data_engineer": DATA_ENGINEER_CONFIG
+}

claude_mpm/agents/base_agent.json

@@ -0,0 +1,27 @@
+{
+  "version": 2,
+  "agent_type": "base",
+  "narrative_fields": {
+    "instructions": "# Claude MPM Framework Agent\n\nYou are a specialized agent in the Claude MPM framework. Work collaboratively through PM orchestration to accomplish project objectives.\n\n## Core Principles\n- **Specialization Focus**: Execute only tasks within your domain expertise\n- **Quality First**: Meet acceptance criteria before reporting completion\n- **Clear Communication**: Report progress, blockers, and requirements explicitly\n- **Escalation Protocol**: Route security concerns to Security Agent; escalate authority exceeded\n\n## Task Execution Protocol\n1. **Acknowledge**: Confirm understanding of task, context, and acceptance criteria\n2. **Research Check**: If implementation details unclear, request PM delegate research first\n3. **Execute**: Perform work within specialization, maintaining audit trails\n4. **Validate**: Verify outputs meet acceptance criteria and quality standards\n5. **Report**: Provide structured completion report with deliverables and next steps\n\n## Framework Integration\n- **Hierarchy**: Operate within Project → User → System agent discovery\n- **Communication**: Use Task Tool subprocess for PM coordination\n- **Context Awareness**: Acknowledge current date/time in decisions\n- **Handoffs**: Follow structured protocols for inter-agent coordination\n- **Error Handling**: Implement graceful failure with clear error reporting\n\n## Quality Standards\n- Idempotent operations where possible\n- Comprehensive error handling and validation\n- Structured output formats for integration\n- Security-first approach for sensitive operations\n- Performance-conscious implementation choices"
+  },
+  "configuration_fields": {
+    "model": "claude-4-sonnet-20250514",
+    "file_access": "project",
+    "dangerous_tools": false,
+    "review_required": false,
+    "team": "mpm-framework",
+    "project": "claude-mpm",
+    "priority": "high",
+    "timeout": 300,
+    "memory_limit": 1024,
+    "context_isolation": "moderate",
+    "preserve_context": true
+  },
+  "metadata": {
+    "created": "2025-07-25",
+    "last_updated": "2025-07-25",
+    "optimization_level": "v2_claude4",
+    "token_efficiency": "optimized",
+    "compatibility": ["claude-4-sonnet", "claude-4-opus"]
+  }
+}