claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/generators/agent_profile_generator.py

@@ -1,137 +1,147 @@
+from pathlib import Path
+
 """
 Agent profile generator using template system.
 
 Inspired by awesome-claude-code's template generation approach.
 """
 
-import yaml
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, Any, Optional
 import re
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+import yaml
 
 
 class AgentProfileGenerator:
     """Generates agent profiles from templates."""
-    
+
     def __init__(self, template_path: Optional[Path] = None):
         """Initialize the generator with a template path."""
-        self.template_path = template_path or Path(__file__).parent.parent / "agents" / "agent-template.yaml"
+        self.template_path = (
+            template_path
+            or Path(__file__).parent.parent / "agents" / "agent-template.yaml"
+        )
         self.template = self._load_template()
-    
+
     def _load_template(self) -> Dict[str, Any]:
         """Load the agent profile template."""
         if not self.template_path.exists():
             raise FileNotFoundError(f"Template not found: {self.template_path}")
-        
-        with open(self.template_path, 'r') as f:
+
+        with open(self.template_path, "r") as f:
             return yaml.safe_load(f)
-    
+
     def generate_profile(self, config: Dict[str, Any]) -> str:
         """Generate an agent profile from configuration."""
         # Set default values
-        config.setdefault('VERSION', '1.0.0')
-        config.setdefault('CREATED_DATE', datetime.now().strftime('%Y-%m-%d'))
-        config.setdefault('AUTHOR', 'claude-mpm')
-        
+        config.setdefault("VERSION", "1.0.0")
+        config.setdefault("CREATED_DATE", datetime.now().strftime("%Y-%m-%d"))
+        config.setdefault("AUTHOR", "claude-mpm")
+
         # Convert template to string
         template_str = yaml.dump(self.template, default_flow_style=False)
-        
+
         # Replace placeholders
         result = self._replace_placeholders(template_str, config)
-        
+
         # Clean up any remaining placeholders
-        result = re.sub(r'\{\{[^}]+\}\}', '', result)
-        
+        result = re.sub(r"\{\{[^}]+\}\}", "", result)
+
         return result
-    
+
     def _replace_placeholders(self, template: str, values: Dict[str, Any]) -> str:
         """Replace template placeholders with actual values."""
         for key, value in values.items():
             placeholder = f"{{{{{key}}}}}"
             if isinstance(value, list):
                 # Format lists nicely
-                formatted_list = '\n'.join(f"      - \"{item}\"" for item in value)
+                formatted_list = "\n".join(f'      - "{item}"' for item in value)
                 template = template.replace(placeholder, formatted_list)
             else:
                 template = template.replace(placeholder, str(value))
-        
+
         return template
-    
+
     def generate_agent_documentation(self, agent_config: Dict[str, Any]) -> str:
         """Generate markdown documentation for an agent."""
         doc_lines = []
-        
+
         # Header
         doc_lines.append(f"# {agent_config.get('name', 'Agent')} Documentation")
         doc_lines.append("")
-        
+
         # Description
-        if 'description' in agent_config:
+        if "description" in agent_config:
             doc_lines.append("## Description")
-            doc_lines.append(agent_config['description'])
+            doc_lines.append(agent_config["description"])
             doc_lines.append("")
-        
+
         # Capabilities
-        if 'capabilities' in agent_config:
+        if "capabilities" in agent_config:
             doc_lines.append("## Capabilities")
-            for capability in agent_config['capabilities']:
+            for capability in agent_config["capabilities"]:
                 doc_lines.append(f"- {capability}")
             doc_lines.append("")
-        
+
         # Tools
-        if 'tools' in agent_config:
+        if "tools" in agent_config:
             doc_lines.append("## Required Tools")
-            for tool in agent_config['tools']:
+            for tool in agent_config["tools"]:
                 if isinstance(tool, dict):
-                    doc_lines.append(f"- **{tool['name']}**: {tool.get('description', '')}")
+                    doc_lines.append(
+                        f"- **{tool['name']}**: {tool.get('description', '')}"
+                    )
                 else:
                     doc_lines.append(f"- {tool}")
             doc_lines.append("")
-        
+
         # Examples
-        if 'examples' in agent_config:
+        if "examples" in agent_config:
             doc_lines.append("## Usage Examples")
-            for i, example in enumerate(agent_config['examples'], 1):
-                doc_lines.append(f"### Example {i}: {example.get('scenario', 'Scenario')}")
+            for i, example in enumerate(agent_config["examples"], 1):
+                doc_lines.append(
+                    f"### Example {i}: {example.get('scenario', 'Scenario')}"
+                )
                 doc_lines.append("```")
                 doc_lines.append(f"Input: {example.get('input', '')}")
                 doc_lines.append("```")
                 doc_lines.append("Expected Output:")
                 doc_lines.append("```")
-                doc_lines.append(example.get('expected_output', ''))
+                doc_lines.append(example.get("expected_output", ""))
                 doc_lines.append("```")
                 doc_lines.append("")
-        
+
         # Best Practices
-        if 'best_practices' in agent_config:
+        if "best_practices" in agent_config:
             doc_lines.append("## Best Practices")
-            for practice in agent_config['best_practices']:
+            for practice in agent_config["best_practices"]:
                 doc_lines.append(f"- {practice}")
             doc_lines.append("")
-        
-        return '\n'.join(doc_lines)
-    
-    def create_agent_from_template(self, agent_name: str, role: str, 
-                                 category: str = "analysis") -> Dict[str, Any]:
+
+        return "\n".join(doc_lines)
+
+    def create_agent_from_template(
+        self, agent_name: str, role: str, category: str = "analysis"
+    ) -> Dict[str, Any]:
         """Create a new agent configuration from template."""
         return {
-            'AGENT_NAME': agent_name,
-            'AGENT_ID': agent_name.lower().replace(' ', '_'),
-            'ROLE': role,
-            'CATEGORY': category,
-            'DESCRIPTION': f"Agent profile for {agent_name}",
-            'AGENT_DESCRIPTION': f"Specialized {role} agent",
-            'SPECIALIZATION': role.lower(),
-            'CAPABILITIES_LIST': "- Analyze code structure\n- Identify patterns\n- Generate reports",
-            'CONSTRAINTS_LIST': "- Read-only operations\n- Respect file permissions",
-            'TOOL_NAME': 'code_analysis',
-            'TOOL_DESCRIPTION': 'Analyzes code structure and patterns',
-            'EXAMPLE_SCENARIO': 'Analyzing a Python project',
-            'EXAMPLE_INPUT': 'Analyze the architecture of this codebase',
-            'EXAMPLE_OUTPUT': 'Detailed analysis report with recommendations',
-            'BEST_PRACTICE_1': 'Always validate input parameters',
-            'BEST_PRACTICE_2': 'Provide clear, actionable insights',
-            'BEST_PRACTICE_3': 'Include examples in reports',
-            'ADDITIONAL_INSTRUCTIONS': 'Be thorough but concise in your analysis.'
-        }
+            "AGENT_NAME": agent_name,
+            "AGENT_ID": agent_name.lower().replace(" ", "_"),
+            "ROLE": role,
+            "CATEGORY": category,
+            "DESCRIPTION": f"Agent profile for {agent_name}",
+            "AGENT_DESCRIPTION": f"Specialized {role} agent",
+            "SPECIALIZATION": role.lower(),
+            "CAPABILITIES_LIST": "- Analyze code structure\n- Identify patterns\n- Generate reports",
+            "CONSTRAINTS_LIST": "- Read-only operations\n- Respect file permissions",
+            "TOOL_NAME": "code_analysis",
+            "TOOL_DESCRIPTION": "Analyzes code structure and patterns",
+            "EXAMPLE_SCENARIO": "Analyzing a Python project",
+            "EXAMPLE_INPUT": "Analyze the architecture of this codebase",
+            "EXAMPLE_OUTPUT": "Detailed analysis report with recommendations",
+            "BEST_PRACTICE_1": "Always validate input parameters",
+            "BEST_PRACTICE_2": "Provide clear, actionable insights",
+            "BEST_PRACTICE_3": "Include examples in reports",
+            "ADDITIONAL_INSTRUCTIONS": "Be thorough but concise in your analysis.",
+        }

claude_mpm/hooks/__init__.py

@@ -2,4 +2,4 @@
 
 from .base_hook import BaseHook, HookContext, HookResult, HookType
 
-__all__ = ["BaseHook", "HookContext", "HookResult", "HookType"]
+__all__ = ["BaseHook", "HookContext", "HookResult", "HookType"]

claude_mpm/hooks/base_hook.py

@@ -1,18 +1,19 @@
 """Base hook class and types for claude-mpm hook system."""
 
+import asyncio
+import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
-import asyncio
-import logging
-from datetime import datetime
 
 logger = logging.getLogger(__name__)
 
 
 class HookType(Enum):
     """Types of hooks available in the system."""
+
     SUBMIT = "submit"  # Process user prompts
     PRE_DELEGATION = "pre_delegation"  # Filter context before delegation
     POST_DELEGATION = "post_delegation"  # Process results after delegation
@@ -23,22 +24,24 @@ class HookType(Enum):
 @dataclass
 class HookContext:
     """Context passed to hooks for processing."""
+
     hook_type: HookType
     data: Dict[str, Any]
     metadata: Dict[str, Any]
     timestamp: datetime
     session_id: Optional[str] = None
     user_id: Optional[str] = None
-    
+
     def __post_init__(self):
         """Ensure timestamp is set."""
-        if not hasattr(self, 'timestamp') or self.timestamp is None:
+        if not hasattr(self, "timestamp") or self.timestamp is None:
             self.timestamp = datetime.now()
 
 
 @dataclass
 class HookResult:
     """Result returned from hook execution."""
+
     success: bool
     data: Optional[Dict[str, Any]] = None
     error: Optional[str] = None
@@ -49,10 +52,10 @@ class HookResult:
 
 class BaseHook(ABC):
     """Base class for all hooks."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         """Initialize hook with name and priority.
-        
+
         Args:
             name: Unique name for the hook
             priority: Execution priority (0-100, lower executes first)
@@ -61,40 +64,40 @@ class BaseHook(ABC):
         self.priority = max(0, min(100, priority))  # Clamp to 0-100
         self.enabled = True
         self._async = False
-        
+
     @abstractmethod
     def execute(self, context: HookContext) -> HookResult:
         """Execute the hook with given context.
-        
+
         Args:
             context: Hook context containing data and metadata
-            
+
         Returns:
             HookResult with execution results
         """
         pass
-    
+
     async def async_execute(self, context: HookContext) -> HookResult:
         """Async version of execute. Override for async hooks."""
         # Default implementation calls sync execute in executor
         loop = asyncio.get_event_loop()
         return await loop.run_in_executor(None, self.execute, context)
-    
+
     def validate(self, context: HookContext) -> bool:
         """Validate if hook should run for given context.
-        
+
         Args:
             context: Hook context to validate
-            
+
         Returns:
             True if hook should execute, False otherwise
         """
         return self.enabled
-    
+
     def __repr__(self):
         """String representation of hook."""
         return f"{self.__class__.__name__}(name='{self.name}', priority={self.priority}, enabled={self.enabled})"
-    
+
     def __lt__(self, other):
         """Compare hooks by priority for sorting."""
         if not isinstance(other, BaseHook):
@@ -104,51 +107,53 @@ class BaseHook(ABC):
 
 class SubmitHook(BaseHook):
     """Base class for hooks that process user prompts."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate submit hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.SUBMIT and 'prompt' in context.data
+        return context.hook_type == HookType.SUBMIT and "prompt" in context.data
 
 
 class PreDelegationHook(BaseHook):
     """Base class for hooks that filter context before delegation."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate pre-delegation hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.PRE_DELEGATION and 'agent' in context.data
+        return context.hook_type == HookType.PRE_DELEGATION and "agent" in context.data
 
 
 class PostDelegationHook(BaseHook):
     """Base class for hooks that process results after delegation."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate post-delegation hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.POST_DELEGATION and 'result' in context.data
+        return (
+            context.hook_type == HookType.POST_DELEGATION and "result" in context.data
+        )
 
 
 class TicketExtractionHook(BaseHook):
     """Base class for hooks that extract and create tickets."""
-    
+
     def __init__(self, name: str, priority: int = 50):
         super().__init__(name, priority)
-        
+
     def validate(self, context: HookContext) -> bool:
         """Validate ticket extraction hook context."""
         if not super().validate(context):
             return False
-        return context.hook_type == HookType.TICKET_EXTRACTION
+        return context.hook_type == HookType.TICKET_EXTRACTION

claude_mpm/hooks/claude_hooks/__init__.py

@@ -2,4 +2,4 @@
 
 from .hook_handler import ClaudeHookHandler
 
-__all__ = ['ClaudeHookHandler']
+__all__ = ["ClaudeHookHandler"]

claude_mpm/hooks/claude_hooks/connection_pool.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Socket.IO connection pool for Claude Code hook handler.
+
+This module provides connection pooling for Socket.IO clients to reduce
+connection overhead and implement circuit breaker patterns.
+"""
+
+import time
+from typing import Any, Dict, List, Optional
+
+# Import constants for configuration
+try:
+    from claude_mpm.core.constants import NetworkConfig
+except ImportError:
+    # Fallback values if constants module not available
+    class NetworkConfig:
+        SOCKETIO_PORT_RANGE = (8080, 8099)
+        RECONNECTION_DELAY = 0.5
+        SOCKET_WAIT_TIMEOUT = 1.0
+
+
+# Socket.IO import
+try:
+    import socketio
+
+    SOCKETIO_AVAILABLE = True
+except ImportError:
+    SOCKETIO_AVAILABLE = False
+    socketio = None
+
+
+class SocketIOConnectionPool:
+    """Connection pool for Socket.IO clients to prevent connection leaks."""
+
+    def __init__(self, max_connections: int = 3):
+        self.max_connections = max_connections
+        self.connections: List[Dict[str, Any]] = []
+        self.last_cleanup = time.time()
+
+    def get_connection(self, port: int) -> Optional[Any]:
+        """Get or create a connection to the specified port."""
+        if time.time() - self.last_cleanup > 60:
+            self._cleanup_dead_connections()
+            self.last_cleanup = time.time()
+
+        for conn in self.connections:
+            if conn.get("port") == port and conn.get("client"):
+                client = conn["client"]
+                if self._is_connection_alive(client):
+                    return client
+                else:
+                    self.connections.remove(conn)
+
+        if len(self.connections) < self.max_connections:
+            client = self._create_connection(port)
+            if client:
+                self.connections.append(
+                    {"port": port, "client": client, "created": time.time()}
+                )
+                return client
+
+        if self.connections:
+            oldest = min(self.connections, key=lambda x: x["created"])
+            self._close_connection(oldest["client"])
+            oldest["client"] = self._create_connection(port)
+            oldest["port"] = port
+            oldest["created"] = time.time()
+            return oldest["client"]
+
+        return None
+
+    def _create_connection(self, port: int) -> Optional[Any]:
+        """Create a new Socket.IO connection."""
+        if not SOCKETIO_AVAILABLE:
+            return None
+        try:
+            client = socketio.Client(
+                reconnection=False,
+                logger=False,
+                engineio_logger=False,  # Disable auto-reconnect
+            )
+            client.connect(
+                f"http://localhost:{port}",
+                wait=True,
+                wait_timeout=NetworkConfig.SOCKET_WAIT_TIMEOUT,
+            )
+            if client.connected:
+                return client
+        except Exception:
+            pass
+        return None
+
+    def _is_connection_alive(self, client: Any) -> bool:
+        """Check if a connection is still alive."""
+        try:
+            return client and client.connected
+        except:
+            return False
+
+    def _close_connection(self, client: Any) -> None:
+        """Safely close a connection."""
+        try:
+            if client:
+                client.disconnect()
+        except:
+            pass
+
+    def _cleanup_dead_connections(self) -> None:
+        """Remove dead connections from the pool."""
+        self.connections = [
+            conn
+            for conn in self.connections
+            if self._is_connection_alive(conn.get("client"))
+        ]
+
+    def close_all(self) -> None:
+        """Close all connections in the pool."""
+        for conn in self.connections:
+            self._close_connection(conn.get("client"))
+        self.connections.clear()