claude-mpm 3.7.4__py3-none-any.whl → 3.8.1__py3-none-any.whl

claude_mpm/services/agents/deployment/async_agent_deployment.py

@@ -462,10 +462,14 @@ class AsyncAgentDeploymentService:
         # IMPORTANT: No spaces after commas - Claude Code requires exact format
         tools_str = ','.join(tools) if isinstance(tools, list) else str(tools)
         
+        # Convert agent_id to Claude Code compatible name (replace underscores with hyphens)
+        # Claude Code requires name to match pattern: ^[a-z0-9]+(-[a-z0-9]+)*$
+        claude_code_name = agent_id.replace('_', '-').lower()
+        
         # Build frontmatter with only the fields Claude Code uses
         frontmatter_lines = [
             "---",
-            f"name: {agent_id}",
+            f"name: {claude_code_name}",
             f"description: {description}",
             f"version: {version_string}",
             f"base_version: {self._format_version_display(base_version)}",

claude_mpm/services/agents/management/agent_capabilities_generator.py

@@ -116,9 +116,12 @@ class AgentCapabilitiesGenerator:
             if len(capability_text) > 100:
                 capability_text = capability_text[:97] + '...'
             
+            # Clean up the agent name for TodoWrite usage
+            clean_name = agent['name'].replace(' Agent', '').replace('-', ' ')
+            
             capabilities.append({
-                'name': agent['name'],
-                'id': agent['id'],
+                'name': clean_name,  # Clean name for TodoWrite
+                'id': agent['id'],    # Agent ID for Task tool
                 'capability_text': capability_text,
                 'tools': ', '.join(agent.get('tools', [])[:5])  # First 5 tools
             })
@@ -132,26 +135,33 @@ class AgentCapabilitiesGenerator:
             Configured Jinja2 template
         """
         template_content = """
-## Agent Names & Capabilities
-**Core Agents**: {{ core_agents }}
+## Available Agent Capabilities
+
+You have the following specialized agents available for delegation:
 
 {% if agents_by_tier.project %}
 ### Project-Specific Agents
 {% for agent in agents_by_tier.project %}
-- **{{ agent.name }}** ({{ agent.id }}): {{ agent.description }}
+- **{{ agent.name|replace(' Agent', '')|replace('-', ' ') }}** (`{{ agent.id }}`): {{ agent.description }}
 {% endfor %}
 
 {% endif %}
-**Agent Capabilities**:
+### Engineering Agents
 {% for cap in detailed_capabilities %}
-- **{{ cap.name }}**: {{ cap.capability_text }}
+{% if cap.id in ['engineer', 'data_engineer', 'documentation', 'ops', 'security', 'ticketing', 'version_control', 'web_ui'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
 {% endfor %}
 
-**Agent Name Formats** (both valid):
-- Capitalized: {{ detailed_capabilities | map(attribute='name') | join('", "') }}
-- Lowercase-hyphenated: {{ detailed_capabilities | map(attribute='id') | join('", "') }}
+### Research Agents
+{% for cap in detailed_capabilities %}
+{% if cap.id in ['code_analyzer', 'qa', 'research', 'web_qa'] %}
+- **{{ cap.name }}** (`{{ cap.id }}`): {{ cap.capability_text }}
+{% endif %}
+{% endfor %}
 
-*Generated from {{ total_agents }} deployed agents*
+**Total Available Agents**: {{ total_agents }}
+Use the agent ID in parentheses when delegating tasks via the Task tool.
 """.strip()
         
         return Template(template_content)

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -29,10 +29,11 @@ from claude_mpm.core.config import Config
 from claude_mpm.core.mixins import LoggerMixin
 from claude_mpm.utils.paths import PathResolver
 from claude_mpm.services.project_analyzer import ProjectAnalyzer
+from claude_mpm.core.interfaces import MemoryServiceInterface
 # Socket.IO notifications are optional - we'll skip them if server is not available
 
 
-class AgentMemoryManager:
+class AgentMemoryManager(MemoryServiceInterface):
     """Manages agent memory files with size limits and validation.
     
     WHY: Agents need to accumulate project-specific knowledge over time to become
@@ -1394,6 +1395,160 @@ Standard markdown with structured sections. Agents expect:
         except Exception as e:
             self.logger.error(f"Error ensuring memories directory: {e}")
             # Continue anyway - memory system should not block operations
+    
+    # ================================================================================
+    # Interface Adapter Methods
+    # ================================================================================
+    # These methods adapt the existing implementation to comply with MemoryServiceInterface
+    
+    def load_memory(self, agent_id: str) -> Optional[str]:
+        """Load memory for a specific agent.
+        
+        WHY: This adapter method provides interface compliance by wrapping
+        the existing load_agent_memory method.
+        
+        Args:
+            agent_id: Identifier of the agent
+            
+        Returns:
+            Memory content as string or None if not found
+        """
+        try:
+            content = self.load_agent_memory(agent_id)
+            return content if content else None
+        except Exception as e:
+            self.logger.error(f"Failed to load memory for {agent_id}: {e}")
+            return None
+    
+    def save_memory(self, agent_id: str, content: str) -> bool:
+        """Save memory for a specific agent.
+        
+        WHY: This adapter method provides interface compliance. The existing
+        implementation uses update_agent_memory for modifications, so we
+        implement a full save by writing directly to the file.
+        
+        Args:
+            agent_id: Identifier of the agent
+            content: Memory content to save
+            
+        Returns:
+            True if save successful
+        """
+        try:
+            memory_path = self.memories_dir / f"{agent_id}_agent.md"
+            
+            # Validate size before saving
+            is_valid, error_msg = self.validate_memory_size(content)
+            if not is_valid:
+                self.logger.error(f"Memory validation failed: {error_msg}")
+                return False
+            
+            # Write the content
+            memory_path.write_text(content, encoding='utf-8')
+            self.logger.info(f"Saved memory for agent {agent_id}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to save memory for {agent_id}: {e}")
+            return False
+    
+    def validate_memory_size(self, content: str) -> tuple[bool, Optional[str]]:
+        """Validate memory content size and structure.
+        
+        WHY: This adapter method provides interface compliance by implementing
+        validation based on configured limits.
+        
+        Args:
+            content: Memory content to validate
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            # Check file size
+            size_kb = len(content.encode('utf-8')) / 1024
+            max_size_kb = self.memory_limits.get('max_file_size_kb', 8)
+            
+            if size_kb > max_size_kb:
+                return False, f"Memory size {size_kb:.1f}KB exceeds limit of {max_size_kb}KB"
+            
+            # Check section count
+            sections = re.findall(r'^##\s+(.+)$', content, re.MULTILINE)
+            max_sections = self.memory_limits.get('max_sections', 10)
+            
+            if len(sections) > max_sections:
+                return False, f"Too many sections: {len(sections)} (max {max_sections})"
+            
+            # Check for required sections
+            required = set(self.REQUIRED_SECTIONS)
+            found = set(sections)
+            missing = required - found
+            
+            if missing:
+                return False, f"Missing required sections: {', '.join(missing)}"
+            
+            return True, None
+            
+        except Exception as e:
+            return False, f"Validation error: {str(e)}"
+    
+    def get_memory_metrics(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get memory usage metrics.
+        
+        WHY: This adapter method provides interface compliance by gathering
+        metrics about memory usage.
+        
+        Args:
+            agent_id: Optional specific agent ID, or None for all
+            
+        Returns:
+            Dictionary with memory metrics
+        """
+        metrics = {
+            "total_memories": 0,
+            "total_size_kb": 0,
+            "agent_metrics": {},
+            "limits": self.memory_limits.copy()
+        }
+        
+        try:
+            if agent_id:
+                # Get metrics for specific agent
+                memory_path = self.memories_dir / f"{agent_id}_agent.md"
+                if memory_path.exists():
+                    content = memory_path.read_text(encoding='utf-8')
+                    size_kb = len(content.encode('utf-8')) / 1024
+                    sections = re.findall(r'^##\s+(.+)$', content, re.MULTILINE)
+                    
+                    metrics["agent_metrics"][agent_id] = {
+                        "size_kb": round(size_kb, 2),
+                        "sections": len(sections),
+                        "exists": True
+                    }
+                    metrics["total_memories"] = 1
+                    metrics["total_size_kb"] = round(size_kb, 2)
+            else:
+                # Get metrics for all agents
+                for memory_file in self.memories_dir.glob("*_agent.md"):
+                    agent_name = memory_file.stem.replace("_agent", "")
+                    content = memory_file.read_text(encoding='utf-8')
+                    size_kb = len(content.encode('utf-8')) / 1024
+                    sections = re.findall(r'^##\s+(.+)$', content, re.MULTILINE)
+                    
+                    metrics["agent_metrics"][agent_name] = {
+                        "size_kb": round(size_kb, 2),
+                        "sections": len(sections),
+                        "exists": True
+                    }
+                    metrics["total_memories"] += 1
+                    metrics["total_size_kb"] += size_kb
+                
+                metrics["total_size_kb"] = round(metrics["total_size_kb"], 2)
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get memory metrics: {e}")
+        
+        return metrics
 
 
 # Convenience functions for external use

claude_mpm/services/async_session_logger.py

@@ -27,6 +27,11 @@ import logging
 import logging.handlers
 from dataclasses import dataclass, asdict
 from enum import Enum
+from claude_mpm.core.constants import (
+    SystemLimits,
+    TimeoutConfig,
+    PerformanceConfig
+)
 
 # Import configuration manager
 from ..core.config import Config
@@ -108,7 +113,7 @@ class AsyncSessionLogger:
         else:
             self.log_format = LogFormat.JSON
         
-        self.max_queue_size = max_queue_size if max_queue_size is not None else response_config.get('max_queue_size', 10000)
+        self.max_queue_size = max_queue_size if max_queue_size is not None else response_config.get('max_queue_size', SystemLimits.MAX_QUEUE_SIZE)
         
         # Handle async configuration with backward compatibility
         if enable_async is not None:
@@ -223,12 +228,12 @@ class AsyncSessionLogger:
         while not self._shutdown:
             try:
                 # Get entry with timeout to allow shutdown checks
-                entry = self._queue.get(timeout=0.1)
+                entry = self._queue.get(timeout=TimeoutConfig.QUEUE_GET_TIMEOUT)
                 
                 # Time the write operation
                 start_time = time.perf_counter()
                 self._write_entry(entry)
-                write_time = (time.perf_counter() - start_time) * 1000
+                write_time = (time.perf_counter() - start_time) * PerformanceConfig.SECONDS_TO_MS
                 
                 # Update statistics
                 write_times.append(write_time)

claude_mpm/services/communication/__init__.py

@@ -0,0 +1,21 @@
+"""
+Communication Services Module
+============================
+
+This module contains all communication-related services including
+SocketIO server and WebSocket utilities.
+
+Part of TSK-0046: Service Layer Architecture Reorganization
+
+Services:
+- SocketIOServer: Main SocketIO server for real-time communication
+- WebSocketClientManager: WebSocket client management utilities
+"""
+
+from .socketio import SocketIOServer
+from .websocket import SocketIOClientManager
+
+__all__ = [
+    'SocketIOServer',
+    'SocketIOClientManager',
+]