claude-mpm 3.1.2__py3-none-any.whl → 3.2.1__py3-none-any.whl

claude_mpm/core/config.py

@@ -227,7 +227,27 @@ class Config:
             # Additional configuration
             "correction_max_file_size_mb": 10,
             "correction_backup_enabled": True,
-            "correction_compression_enabled": True
+            "correction_compression_enabled": True,
+            # Agent Memory System configuration
+            "memory": {
+                "enabled": True,                    # Master switch for memory system
+                "auto_learning": False,             # Automatic learning extraction
+                "limits": {
+                    "default_size_kb": 8,           # Default file size limit
+                    "max_sections": 10,             # Maximum sections per file
+                    "max_items_per_section": 15,    # Maximum items per section
+                    "max_line_length": 120          # Maximum line length
+                },
+                "agent_overrides": {
+                    "research": {                   # Research agent override
+                        "size_kb": 16,              # Can have larger memory
+                        "auto_learning": True       # Enable auto learning
+                    },
+                    "qa": {                         # QA agent override
+                        "auto_learning": True       # Enable auto learning
+                    }
+                }
+            }
         }
 
         # Apply defaults for missing keys

claude_mpm/core/hook_manager.py

@@ -0,0 +1,196 @@
+"""Hook manager for manually triggering hook events in PM operations.
+
+This module provides a way for the PM agent to manually trigger hook events
+that would normally be handled by Claude Code's hook system. This ensures
+consistency between PM operations and regular agent operations.
+
+WHY this is needed:
+- PM runs directly in Python, bypassing Claude Code's hook system
+- TodoWrite and other PM operations should trigger the same hooks as agent operations
+- Ensures consistent event streaming to Socket.IO dashboard
+"""
+
+import json
+import os
+import subprocess
+import uuid
+from datetime import datetime
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+from ..core.logger import get_logger
+from ..deployment_paths import get_package_root
+
+
+class HookManager:
+    """Manager for manually triggering hook events from PM operations.
+    
+    WHY this design:
+    - Mimics Claude Code's hook event structure exactly
+    - Uses the same hook handler that regular agents use
+    - Provides session tracking consistent with regular hook events
+    - Enables PM operations to appear in Socket.IO dashboard
+    """
+    
+    def __init__(self):
+        self.logger = get_logger("hook_manager")
+        self.session_id = self._get_or_create_session_id()
+        self.hook_handler_path = self._find_hook_handler()
+        
+    def _get_or_create_session_id(self) -> str:
+        """Get or create a session ID for hook events."""
+        # Try to get session ID from environment (set by ClaudeRunner)
+        session_id = os.environ.get('CLAUDE_MPM_SESSION_ID')
+        if not session_id:
+            # Generate new session ID
+            session_id = str(uuid.uuid4())
+            os.environ['CLAUDE_MPM_SESSION_ID'] = session_id
+        return session_id
+    
+    def _find_hook_handler(self) -> Optional[Path]:
+        """Find the hook handler script."""
+        try:
+            # Look for hook handler in the expected location
+            hook_handler = get_package_root() / "hooks" / "claude_hooks" / "hook_handler.py"
+            
+            if hook_handler.exists():
+                return hook_handler
+            else:
+                self.logger.warning(f"Hook handler not found at: {hook_handler}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Error finding hook handler: {e}")
+            return None
+    
+    def trigger_pre_tool_hook(self, tool_name: str, tool_args: Dict[str, Any] = None) -> bool:
+        """Trigger PreToolUse hook event.
+        
+        Args:
+            tool_name: Name of the tool being used (e.g., "TodoWrite")
+            tool_args: Arguments passed to the tool
+            
+        Returns:
+            bool: True if hook was triggered successfully
+        """
+        return self._trigger_hook_event("PreToolUse", {
+            "tool_name": tool_name,
+            "tool_args": tool_args or {},
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    def trigger_post_tool_hook(self, tool_name: str, exit_code: int = 0, result: Any = None) -> bool:
+        """Trigger PostToolUse hook event.
+        
+        Args:
+            tool_name: Name of the tool that was used
+            exit_code: Exit code (0 for success, non-zero for error)
+            result: Result returned by the tool
+            
+        Returns:
+            bool: True if hook was triggered successfully
+        """
+        return self._trigger_hook_event("PostToolUse", {
+            "tool_name": tool_name,
+            "exit_code": exit_code,
+            "result": str(result) if result is not None else None,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    def trigger_user_prompt_hook(self, prompt: str) -> bool:
+        """Trigger UserPromptSubmit hook event.
+        
+        Args:
+            prompt: The user prompt
+            
+        Returns:
+            bool: True if hook was triggered successfully
+        """
+        return self._trigger_hook_event("UserPromptSubmit", {
+            "prompt": prompt,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+    
+    def _trigger_hook_event(self, hook_type: str, event_data: Dict[str, Any]) -> bool:
+        """Trigger a hook event by calling the hook handler.
+        
+        Args:
+            hook_type: Type of hook event
+            event_data: Event data
+            
+        Returns:
+            bool: True if hook was triggered successfully
+        """
+        if not self.hook_handler_path:
+            self.logger.debug("Hook handler not available - skipping hook event")
+            return False
+        
+        try:
+            # Create the hook event in the same format as Claude Code
+            hook_event = {
+                "hook_event_name": hook_type,
+                "session_id": self.session_id,
+                "timestamp": datetime.utcnow().isoformat(),
+                **event_data
+            }
+            
+            # Convert to JSON
+            event_json = json.dumps(hook_event)
+            
+            # Call the hook handler
+            env = os.environ.copy()
+            env['CLAUDE_MPM_HOOK_DEBUG'] = 'true'  # Enable debug logging
+            
+            result = subprocess.run(
+                ["python", str(self.hook_handler_path)],
+                input=event_json,
+                text=True,
+                capture_output=True,
+                env=env,
+                timeout=5  # 5 second timeout to prevent hanging
+            )
+            
+            if result.returncode == 0:
+                self.logger.debug(f"Successfully triggered {hook_type} hook")
+                return True
+            else:
+                self.logger.warning(f"Hook handler returned non-zero exit code: {result.returncode}")
+                if result.stderr:
+                    self.logger.warning(f"Hook handler stderr: {result.stderr}")
+                return False
+                
+        except subprocess.TimeoutExpired:
+            self.logger.warning(f"Hook handler timed out for {hook_type}")
+            return False
+        except Exception as e:
+            self.logger.error(f"Error triggering {hook_type} hook: {e}")
+            return False
+
+
+# Global instance
+_hook_manager: Optional[HookManager] = None
+
+
+def get_hook_manager() -> HookManager:
+    """Get the global hook manager instance."""
+    global _hook_manager
+    if _hook_manager is None:
+        _hook_manager = HookManager()
+    return _hook_manager
+
+
+def trigger_tool_hooks(tool_name: str, tool_args: Dict[str, Any] = None, result: Any = None, exit_code: int = 0):
+    """Convenience function to trigger both pre and post tool hooks.
+    
+    Args:
+        tool_name: Name of the tool
+        tool_args: Arguments passed to the tool
+        result: Result returned by the tool
+        exit_code: Exit code (0 for success)
+    """
+    manager = get_hook_manager()
+    
+    # Trigger pre-tool hook
+    manager.trigger_pre_tool_hook(tool_name, tool_args)
+    
+    # Trigger post-tool hook
+    manager.trigger_post_tool_hook(tool_name, exit_code, result)

claude_mpm/core/pm_hook_interceptor.py

@@ -0,0 +1,205 @@
+"""PM Hook Interceptor for TodoWrite operations.
+
+This module intercepts TodoWrite operations from the PM agent and ensures
+that the appropriate hook events are triggered, making PM operations
+consistent with regular agent operations in terms of event streaming.
+
+WHY this is needed:
+- PM agent runs directly in Python, bypassing Claude Code's hook system
+- TodoWrite calls from PM should trigger the same hooks as agent TodoWrite calls
+- Ensures consistent event streaming to Socket.IO dashboard
+- Maintains compatibility with existing hook-based monitoring systems
+"""
+
+import functools
+import json
+import os
+import threading
+import time
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from ..core.logger import get_logger
+from ..core.hook_manager import get_hook_manager
+
+
+class PMHookInterceptor:
+    """Interceptor for PM operations that ensures hook events are triggered.
+    
+    WHY this design:
+    - Acts as a transparent proxy for tool operations
+    - Automatically triggers pre/post hook events
+    - Maintains session consistency with regular Claude Code operations
+    - Provides real-time event streaming for PM operations
+    """
+    
+    def __init__(self):
+        self.logger = get_logger("pm_hook_interceptor")
+        self.hook_manager = get_hook_manager()
+        self._in_intercept = threading.local()  # Prevent recursion
+        
+    def intercept_todowrite(self, original_function):
+        """Decorator to intercept TodoWrite calls and trigger hooks.
+        
+        Args:
+            original_function: The original TodoWrite function
+            
+        Returns:
+            Wrapped function that triggers hooks
+        """
+        @functools.wraps(original_function)
+        def wrapper(*args, **kwargs):
+            # Prevent recursive interception
+            if getattr(self._in_intercept, 'active', False):
+                return original_function(*args, **kwargs)
+            
+            self._in_intercept.active = True
+            
+            try:
+                # Extract todos from arguments
+                todos = self._extract_todos_from_args(args, kwargs)
+                
+                # Trigger pre-tool hook
+                self.hook_manager.trigger_pre_tool_hook("TodoWrite", {
+                    "todos": todos,
+                    "source": "PM",
+                    "intercepted": True
+                })
+                
+                # Call the original function
+                result = original_function(*args, **kwargs)
+                
+                # Trigger post-tool hook
+                self.hook_manager.trigger_post_tool_hook("TodoWrite", 0, {
+                    "todos_count": len(todos) if todos else 0,
+                    "source": "PM",
+                    "success": True
+                })
+                
+                self.logger.debug(f"Successfully intercepted TodoWrite with {len(todos) if todos else 0} todos")
+                
+                return result
+                
+            except Exception as e:
+                # Trigger post-tool hook with error
+                self.hook_manager.trigger_post_tool_hook("TodoWrite", 1, {
+                    "error": str(e),
+                    "source": "PM",
+                    "success": False
+                })
+                
+                self.logger.error(f"Error in TodoWrite interception: {e}")
+                raise
+            finally:
+                self._in_intercept.active = False
+        
+        return wrapper
+    
+    def _extract_todos_from_args(self, args, kwargs) -> List[Dict[str, Any]]:
+        """Extract todos from function arguments.
+        
+        Args:
+            args: Positional arguments
+            kwargs: Keyword arguments
+            
+        Returns:
+            List of todo dictionaries
+        """
+        # Look for todos in kwargs first
+        if 'todos' in kwargs:
+            return kwargs['todos']
+        
+        # Look for todos in positional args
+        for arg in args:
+            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
+                # Check if this looks like a todos list
+                if 'content' in arg[0] or 'id' in arg[0]:
+                    return arg
+        
+        return []
+    
+    def trigger_manual_todowrite_hooks(self, todos: List[Dict[str, Any]]):
+        """Manually trigger TodoWrite hooks for given todos.
+        
+        This method can be called directly when TodoWrite operations
+        are detected outside of function interception.
+        
+        Args:
+            todos: List of todo dictionaries
+        """
+        try:
+            # Trigger pre-tool hook
+            success1 = self.hook_manager.trigger_pre_tool_hook("TodoWrite", {
+                "todos": todos,
+                "source": "PM_Manual",
+                "timestamp": datetime.utcnow().isoformat()
+            })
+            
+            # Small delay to ensure proper event ordering
+            time.sleep(0.1)
+            
+            # Trigger post-tool hook
+            success2 = self.hook_manager.trigger_post_tool_hook("TodoWrite", 0, {
+                "todos_count": len(todos),
+                "source": "PM_Manual",
+                "success": True,
+                "timestamp": datetime.utcnow().isoformat()
+            })
+            
+            if success1 and success2:
+                self.logger.info(f"Manually triggered TodoWrite hooks for {len(todos)} todos")
+            else:
+                self.logger.warning(f"Hook triggering partially failed: pre={success1}, post={success2}")
+            
+            return success1 and success2
+            
+        except Exception as e:
+            self.logger.error(f"Error manually triggering TodoWrite hooks: {e}")
+            return False
+
+
+# Global instance
+_pm_hook_interceptor: Optional[PMHookInterceptor] = None
+
+
+def get_pm_hook_interceptor() -> PMHookInterceptor:
+    """Get the global PM hook interceptor instance."""
+    global _pm_hook_interceptor
+    if _pm_hook_interceptor is None:
+        _pm_hook_interceptor = PMHookInterceptor()
+    return _pm_hook_interceptor
+
+
+def trigger_pm_todowrite_hooks(todos: List[Dict[str, Any]]) -> bool:
+    """Convenience function to trigger PM TodoWrite hooks.
+    
+    Args:
+        todos: List of todo dictionaries
+        
+    Returns:
+        bool: True if hooks were triggered successfully
+    """
+    interceptor = get_pm_hook_interceptor()
+    return interceptor.trigger_manual_todowrite_hooks(todos)
+
+
+def simulate_pm_todowrite_operation(todos: List[Dict[str, Any]]):
+    """Simulate a PM TodoWrite operation with proper hook triggering.
+    
+    This function is useful for testing and for cases where we want to
+    simulate a TodoWrite operation from the PM agent.
+    
+    Args:
+        todos: List of todo dictionaries
+    """
+    interceptor = get_pm_hook_interceptor()
+    
+    # Log the operation
+    logger = get_logger("pm_todowrite_simulation")
+    logger.info(f"Simulating PM TodoWrite operation with {len(todos)} todos")
+    
+    # Trigger hooks
+    interceptor.trigger_manual_todowrite_hooks(todos)
+    
+    # Log completion
+    logger.info("PM TodoWrite simulation completed")