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

claude_mpm/services/agents/deployment/system_instructions_deployer.py

@@ -17,106 +17,29 @@ class SystemInstructionsDeployer:
         self.logger = logger
         self.working_directory = working_directory
 
-    def deploy_system_instructions_to_claude_mpm(
-        self,
-        target_dir: Path,
-        force_rebuild: bool,
-        results: Dict[str, Any],
-        is_project_specific: bool,
-    ) -> None:
-        """
-        Deploy system instructions to .claude-mpm/ directory (not .claude/).
-        
-        This method should ONLY be called when explicitly requested by the user.
-        It deploys INSTRUCTIONS.md, WORKFLOW.md, and MEMORY.md files to .claude-mpm/
-        
-        Args:
-            target_dir: Target directory (should be .claude-mpm/)
-            force_rebuild: Force rebuild even if exists
-            results: Results dictionary to update
-            is_project_specific: Whether this is a project-specific deployment
-        """
-        try:
-            # Framework files to deploy
-            framework_files = [
-                ("INSTRUCTIONS.md", "INSTRUCTIONS.md"),
-                ("WORKFLOW.md", "WORKFLOW.md"),
-                ("MEMORY.md", "MEMORY.md"),
-            ]
-            
-            # Find the agents directory with framework files
-            from claude_mpm.config.paths import paths
-            agents_path = paths.agents_dir
-            
-            for source_name, target_name in framework_files:
-                source_path = agents_path / source_name
-                
-                if not source_path.exists():
-                    self.logger.warning(f"Framework file not found: {source_path}")
-                    continue
-                
-                target_file = target_dir / target_name
-                
-                # Check if update needed
-                if not force_rebuild and target_file.exists():
-                    # Compare modification times
-                    if target_file.stat().st_mtime >= source_path.stat().st_mtime:
-                        results["skipped"].append(target_name)
-                        self.logger.debug(f"Framework file {target_name} up to date")
-                        continue
-                
-                # Read and deploy framework file
-                file_content = source_path.read_text()
-                target_file.write_text(file_content)
-                
-                # Track deployment
-                file_existed = target_file.exists()
-                deployment_info = {
-                    "name": target_name,
-                    "template": str(source_path),
-                    "target": str(target_file),
-                }
-                
-                if file_existed:
-                    results["updated"].append(deployment_info)
-                    self.logger.info(f"Updated framework file in .claude-mpm: {target_name}")
-                else:
-                    results["deployed"].append(deployment_info)
-                    self.logger.info(f"Deployed framework file to .claude-mpm: {target_name}")
-                    
-        except Exception as e:
-            error_msg = f"Failed to deploy system instructions to .claude-mpm: {e}"
-            self.logger.error(error_msg)
-            results["errors"].append(error_msg)
-
     def deploy_system_instructions(
         self,
         target_dir: Path,
         force_rebuild: bool,
         results: Dict[str, Any],
-        is_project_specific: bool,
     ) -> None:
         """
         Deploy system instructions and framework files for PM framework.
 
-        Deploys INSTRUCTIONS.md, WORKFLOW.md, and MEMORY.md files following hierarchy:
-        - System/User versions → Deploy to ~/.claude/
-        - Project-specific versions → Deploy to <project>/.claude/
+        Always deploys to project .claude directory regardless of agent source
+        (system, user, or project). This ensures consistent project-level
+        deployment while maintaining discovery from both user (~/.claude-mpm)
+        and project (.claude-mpm) directories.
 
         Args:
-            target_dir: Target directory for deployment
+            target_dir: Target directory for deployment (not used - always uses project .claude)
             force_rebuild: Force rebuild even if exists
             results: Results dictionary to update
-            is_project_specific: Whether this is a project-specific deployment
         """
         try:
-            # Determine target location based on deployment type
-            if is_project_specific:
-                # Project-specific files go to project's .claude directory
-                claude_dir = self.working_directory / ".claude"
-            else:
-                # System and user files go to home ~/.claude directory
-                claude_dir = Path.home() / ".claude"
+            # Always use project's .claude directory
+            # This is the key change - all system instructions go to project .claude
+            claude_dir = self.working_directory / ".claude"
 
             # Ensure .claude directory exists
             claude_dir.mkdir(parents=True, exist_ok=True)

claude_mpm/services/agents/memory/content_manager.py

@@ -222,7 +222,7 @@ class MemoryContentManager:
         """Validate memory file and repair if needed.
 
         WHY: Memory files might be manually edited by developers or corrupted.
-        This method ensures the file maintains required structure and sections.
+        This method ensures the file maintains proper simple list structure.
 
         Args:
             content: Content to validate
@@ -232,88 +232,94 @@ class MemoryContentManager:
             str: Validated and repaired content
         """
         lines = content.split("\n")
-        existing_sections = set()
-
-        # Find existing sections
-        for line in lines:
-            if line.startswith("## "):
-                section_name = line[3:].split("(")[0].strip()
-                existing_sections.add(section_name)
-
-        # Check for required sections
-        missing_sections = []
-        for required in self.REQUIRED_SECTIONS:
-            if required not in existing_sections:
-                missing_sections.append(required)
-
-        if missing_sections:
-            self.logger.info(
-                f"Adding missing sections to {agent_id} memory: {missing_sections}"
-            )
-
-            # Add missing sections before Recent Learnings
-            insert_point = len(lines)
-            for i, line in enumerate(lines):
-                if line.startswith("## Recent Learnings"):
-                    insert_point = i
-                    break
-
-            for section in missing_sections:
-                section_content = [
-                    "",
-                    f"## {section}",
-                    "<!-- Section added by repair -->",
-                    "",
-                ]
-                for j, line in enumerate(section_content):
-                    lines.insert(insert_point + j, line)
-                insert_point += len(section_content)
-
+        
+        # Ensure proper header format
+        has_header = False
+        has_timestamp = False
+        
+        for i, line in enumerate(lines[:5]):  # Check first 5 lines
+            if line.startswith("# Agent Memory:"):
+                has_header = True
+            elif line.startswith("<!-- Last Updated:"):
+                has_timestamp = True
+        
+        # Add missing header or timestamp
+        if not has_header or not has_timestamp:
+            from datetime import datetime
+            new_lines = []
+            
+            if not has_header:
+                new_lines.append(f"# Agent Memory: {agent_id}")
+            else:
+                # Keep existing header
+                for line in lines:
+                    if line.startswith("# "):
+                        new_lines.append(line)
+                        lines.remove(line)
+                        break
+            
+            if not has_timestamp:
+                new_lines.append(f"<!-- Last Updated: {datetime.now().isoformat()}Z -->")
+                new_lines.append("")
+            else:
+                # Keep existing timestamp
+                for line in lines:
+                    if line.startswith("<!-- Last Updated:"):
+                        new_lines.append(line)
+                        lines.remove(line)
+                        break
+            
+            # Add remaining content
+            for line in lines:
+                if not line.startswith("# ") and not line.startswith("<!-- Last Updated:"):
+                    new_lines.append(line)
+            
+            return "\n".join(new_lines)
+        
         return "\n".join(lines)
 
-    def parse_memory_content_to_dict(self, content: str) -> Dict[str, List[str]]:
-        """Parse memory content into structured dictionary format.
+    def parse_memory_content_to_list(self, content: str) -> List[str]:
+        """Parse memory content into a simple list format.
 
-        WHY: Provides consistent parsing of memory content into sections and items
-        for both display and programmatic access. This ensures the same parsing
-        logic is used across the system.
+        WHY: Provides consistent parsing of memory content as a simple list
+        for both display and programmatic access.
 
         Args:
             content: Raw memory file content
 
         Returns:
-            Dict mapping section names to lists of items
+            List of memory items
         """
-        sections = {}
-        current_section = None
-        current_items = []
+        items = []
 
         for line in content.split("\n"):
             line = line.strip()
 
-            # Skip empty lines and header information
-            if not line or line.startswith("#") and "Memory Usage" in line:
+            # Skip empty lines, headers, and metadata
+            if not line or line.startswith("#") or line.startswith("<!--"):
                 continue
 
-            if line.startswith("## ") and not line.startswith("## Memory Usage"):
-                # New section found
-                if current_section and current_items:
-                    sections[current_section] = current_items.copy()
-
-                current_section = line[3:].strip()
-                current_items = []
-
-            elif line.startswith("- ") and current_section:
-                # Item in current section
+            if line.startswith("- "):
+                # Item in list
                 item = line[2:].strip()
                 if item and len(item) > 3:  # Filter out very short items
-                    current_items.append(item)
-
-        # Add final section
-        if current_section and current_items:
-            sections[current_section] = current_items
+                    items.append(item)
 
-        return sections
+        return items
+    
+    def parse_memory_content_to_dict(self, content: str) -> Dict[str, List[str]]:
+        """Legacy method for backward compatibility.
+        
+        Returns a dict with single key 'memories' containing all items.
+        
+        Args:
+            content: Raw memory file content
+            
+        Returns:
+            Dict with 'memories' key mapping to list of items
+        """
+        items = self.parse_memory_content_to_list(content)
+        return {"memories": items}
 
     def _calculate_similarity(self, str1: str, str2: str) -> float:
         """Calculate similarity between two strings using fuzzy matching.
@@ -357,44 +363,27 @@ class MemoryContentManager:
         
         return similarity
 
-    def deduplicate_section(self, content: str, section: str) -> Tuple[str, int]:
-        """Deduplicate items within a section using NLP similarity.
+    def deduplicate_list(self, content: str) -> Tuple[str, int]:
+        """Deduplicate items in the memory list using NLP similarity.
 
-        WHY: Over time, sections can accumulate similar or duplicate items from
-        different sessions. This method cleans up existing sections by removing
-        similar items while preserving the most recent/relevant ones.
+        WHY: Over time, memory lists can accumulate similar or duplicate items from
+        different sessions. This method cleans up by removing similar items while
+        preserving the most recent ones.
 
         Args:
             content: Current memory file content
-            section: Section name to deduplicate
 
         Returns:
             Tuple of (updated content, number of items removed)
         """
         lines = content.split("\n")
-        section_start = None
-        section_end = None
-        
-        # Find section boundaries
-        for i, line in enumerate(lines):
-            if line.startswith(f"## {section}"):
-                section_start = i
-            elif section_start is not None and line.startswith("## "):
-                section_end = i
-                break
-        
-        if section_start is None:
-            return content, 0  # Section not found
-        
-        if section_end is None:
-            section_end = len(lines)
         
-        # Collect all items in the section
+        # Collect all items in the list
         items = []
         item_indices = []
-        for i in range(section_start + 1, section_end):
-            if lines[i].strip().startswith("- "):
-                items.append(lines[i].strip()[2:])  # Remove "- " prefix
+        for i, line in enumerate(lines):
+            if line.strip().startswith("- "):
+                items.append(line.strip()[2:])  # Remove "- " prefix
                 item_indices.append(i)
         
         # Find duplicates using pairwise comparison
@@ -421,6 +410,18 @@ class MemoryContentManager:
             lines.pop(item_indices[idx])
         
         return "\n".join(lines), removed_count
+    
+    def deduplicate_section(self, content: str, section: str) -> Tuple[str, int]:
+        """Legacy method for backward compatibility - delegates to deduplicate_list.
+        
+        Args:
+            content: Current memory file content
+            section: Section name (ignored in simple list format)
+            
+        Returns:
+            Tuple of (updated content, number of items removed)
+        """
+        return self.deduplicate_list(content)
 
     def validate_memory_size(self, content: str) -> tuple[bool, Optional[str]]:
         """Validate memory content size and structure.
@@ -434,7 +435,7 @@ class MemoryContentManager:
         try:
             # Check file size
             size_kb = len(content.encode("utf-8")) / 1024
-            max_size_kb = self.memory_limits.get("max_file_size_kb", 8)
+            max_size_kb = self.memory_limits.get("max_file_size_kb", 80)
 
             if size_kb > max_size_kb:
                 return (
@@ -442,20 +443,12 @@ class MemoryContentManager:
                     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
+            # Check item count
+            items = sum(1 for line in content.split("\n") if line.strip().startswith("- "))
+            max_items = self.memory_limits.get("max_items", 100)
 
-            if missing:
-                return False, f"Missing required sections: {', '.join(missing)}"
+            if items > max_items:
+                return False, f"Too many items: {items} (max {max_items})"
 
             return True, None
 

claude_mpm/services/event_bus/__init__.py

@@ -0,0 +1,18 @@
+"""Event Bus Service for decoupled event handling.
+
+This module provides a centralized event bus that decouples event producers
+(like hooks) from consumers (like Socket.IO). It uses pyee's AsyncIOEventEmitter
+to support both synchronous publishing and asynchronous consumption.
+
+WHY event bus architecture:
+- Decouples hooks from Socket.IO implementation details
+- Allows multiple consumers for the same events
+- Enables easy testing without Socket.IO dependencies
+- Provides event filtering and routing capabilities
+- Supports both sync (hooks) and async (Socket.IO) contexts
+"""
+
+from .event_bus import EventBus
+from .relay import SocketIORelay
+
+__all__ = ["EventBus", "SocketIORelay"]

claude_mpm/services/event_bus/config.py

@@ -0,0 +1,165 @@
+"""Configuration for EventBus service.
+
+WHY configuration module:
+- Centralized configuration management
+- Environment variable support
+- Easy testing with different configurations
+- Runtime configuration changes
+"""
+
+import os
+from typing import List, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class EventBusConfig:
+    """Configuration for EventBus service.
+    
+    All settings can be overridden via environment variables.
+    """
+    
+    # Enable/disable the EventBus
+    enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_ENABLED", "true").lower() == "true"
+    )
+    
+    # Debug logging
+    debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_EVENTBUS_DEBUG", "false").lower() == "true"
+    )
+    
+    # Event history settings
+    max_history_size: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_EVENTBUS_HISTORY_SIZE", "100"))
+    )
+    
+    # Event filters (comma-separated list)
+    event_filters: List[str] = field(
+        default_factory=lambda: [
+            f.strip() for f in os.environ.get("CLAUDE_MPM_EVENTBUS_FILTERS", "").split(",") 
+            if f.strip()
+        ]
+    )
+    
+    # Relay configuration
+    relay_enabled: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_ENABLED", "true").lower() == "true"
+    )
+    
+    relay_port: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
+    )
+    
+    relay_debug: bool = field(
+        default_factory=lambda: os.environ.get("CLAUDE_MPM_RELAY_DEBUG", "false").lower() == "true"
+    )
+    
+    # Connection settings
+    relay_max_retries: int = field(
+        default_factory=lambda: int(os.environ.get("CLAUDE_MPM_RELAY_MAX_RETRIES", "3"))
+    )
+    
+    relay_retry_delay: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_RETRY_DELAY", "0.5"))
+    )
+    
+    relay_connection_cooldown: float = field(
+        default_factory=lambda: float(os.environ.get("CLAUDE_MPM_RELAY_CONNECTION_COOLDOWN", "5.0"))
+    )
+    
+    @classmethod
+    def from_env(cls) -> "EventBusConfig":
+        """Create configuration from environment variables.
+        
+        Returns:
+            EventBusConfig: Configuration instance
+        """
+        return cls()
+    
+    def to_dict(self) -> dict:
+        """Convert configuration to dictionary.
+        
+        Returns:
+            dict: Configuration as dictionary
+        """
+        return {
+            "enabled": self.enabled,
+            "debug": self.debug,
+            "max_history_size": self.max_history_size,
+            "event_filters": self.event_filters,
+            "relay_enabled": self.relay_enabled,
+            "relay_port": self.relay_port,
+            "relay_debug": self.relay_debug,
+            "relay_max_retries": self.relay_max_retries,
+            "relay_retry_delay": self.relay_retry_delay,
+            "relay_connection_cooldown": self.relay_connection_cooldown
+        }
+    
+    def apply_to_eventbus(self, event_bus) -> None:
+        """Apply configuration to an EventBus instance.
+        
+        Args:
+            event_bus: EventBus instance to configure
+        """
+        if not self.enabled:
+            event_bus.disable()
+        else:
+            event_bus.enable()
+        
+        event_bus.set_debug(self.debug)
+        event_bus._max_history_size = self.max_history_size
+        
+        # Apply filters
+        event_bus.clear_filters()
+        for filter_pattern in self.event_filters:
+            event_bus.add_filter(filter_pattern)
+    
+    def apply_to_relay(self, relay) -> None:
+        """Apply configuration to a SocketIORelay instance.
+        
+        Args:
+            relay: SocketIORelay instance to configure
+        """
+        if not self.relay_enabled:
+            relay.disable()
+        else:
+            relay.enable()
+        
+        relay.port = self.relay_port
+        relay.debug = self.relay_debug
+        relay.max_retries = self.relay_max_retries
+        relay.retry_delay = self.relay_retry_delay
+        relay.connection_cooldown = self.relay_connection_cooldown
+
+
+# Global configuration instance
+_config: Optional[EventBusConfig] = None
+
+
+def get_config() -> EventBusConfig:
+    """Get the global EventBus configuration.
+    
+    Returns:
+        EventBusConfig: Configuration instance
+    """
+    global _config
+    if _config is None:
+        _config = EventBusConfig.from_env()
+    return _config
+
+
+def set_config(config: EventBusConfig) -> None:
+    """Set the global EventBus configuration.
+    
+    Args:
+        config: Configuration to set
+    """
+    global _config
+    _config = config
+
+
+def reset_config() -> None:
+    """Reset configuration to defaults from environment."""
+    global _config
+    _config = EventBusConfig.from_env()