claude-mpm 3.3.2__py3-none-any.whl → 3.4.0__py3-none-any.whl

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -20,9 +20,33 @@ from datetime import datetime
 from pathlib import Path
 from collections import deque
 
-# Quick environment check
+# Quick environment check - must be defined before any code that might use it
 DEBUG = os.environ.get('CLAUDE_MPM_HOOK_DEBUG', '').lower() == 'true'
 
+# Add imports for memory hook integration with comprehensive error handling
+MEMORY_HOOKS_AVAILABLE = False
+try:
+    # Try to add src to path if not already there (fallback for missing PYTHONPATH)
+    import sys
+    from pathlib import Path
+    src_path = Path(__file__).parent.parent.parent.parent
+    if src_path.exists() and str(src_path) not in sys.path:
+        sys.path.insert(0, str(src_path))
+    
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.hooks.memory_integration_hook import (
+        MemoryPreDelegationHook,
+        MemoryPostDelegationHook
+    )
+    from claude_mpm.hooks.base_hook import HookContext, HookType
+    from claude_mpm.core.config import Config
+    MEMORY_HOOKS_AVAILABLE = True
+except Exception as e:
+    # Catch all exceptions to prevent any import errors from breaking the handler
+    if DEBUG:
+        print(f"Memory hooks not available: {e}", file=sys.stderr)
+    MEMORY_HOOKS_AVAILABLE = False
+
 # Socket.IO import
 try:
     import socketio
@@ -59,6 +83,13 @@ class ClaudeHookHandler:
         self._git_branch_cache = {}
         self._git_branch_cache_time = {}
         
+        # Initialize memory hooks if available
+        self.memory_hooks_initialized = False
+        self.pre_delegation_hook = None
+        self.post_delegation_hook = None
+        if MEMORY_HOOKS_AVAILABLE:
+            self._initialize_memory_hooks()
+        
         # No fallback server needed - we only use Socket.IO now
     
     def _track_delegation(self, session_id: str, agent_type: str):
@@ -100,6 +131,49 @@ class ClaudeHookHandler:
         
         return 'unknown'
     
+    def _initialize_memory_hooks(self):
+        """Initialize memory hooks for automatic agent memory management.
+        
+        WHY: This activates the memory system by connecting Claude Code hook events
+        to our memory integration hooks. This enables automatic memory injection
+        before delegations and learning extraction after delegations.
+        
+        DESIGN DECISION: We initialize hooks here in the Claude hook handler because
+        this is where Claude Code events are processed. This ensures memory hooks
+        are triggered at the right times during agent delegation.
+        """
+        try:
+            # Create configuration
+            config = Config()
+            
+            # Only initialize if memory system is enabled
+            if not config.get('memory.enabled', True):
+                if DEBUG:
+                    print("Memory system disabled - skipping hook initialization", file=sys.stderr)
+                return
+            
+            # Initialize pre-delegation hook for memory injection
+            self.pre_delegation_hook = MemoryPreDelegationHook(config)
+            
+            # Initialize post-delegation hook if auto-learning is enabled
+            if config.get('memory.auto_learning', True):  # Default to True now
+                self.post_delegation_hook = MemoryPostDelegationHook(config)
+            
+            self.memory_hooks_initialized = True
+            
+            if DEBUG:
+                hooks_info = []
+                if self.pre_delegation_hook:
+                    hooks_info.append("pre-delegation")
+                if self.post_delegation_hook:
+                    hooks_info.append("post-delegation")
+                print(f"✅ Memory hooks initialized: {', '.join(hooks_info)}", file=sys.stderr)
+                
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Failed to initialize memory hooks: {e}", file=sys.stderr)
+            # Don't fail the entire handler - memory system is optional
+    
     def _get_git_branch(self, working_dir: str = None) -> str:
         """Get git branch for the given directory with caching.
         
@@ -366,6 +440,9 @@ class ClaudeHookHandler:
             session_id = event.get('session_id', '')
             if session_id and agent_type != 'unknown':
                 self._track_delegation(session_id, agent_type)
+            
+            # Trigger memory pre-delegation hook
+            self._trigger_memory_pre_delegation_hook(agent_type, tool_input, session_id)
         
         self._emit_socketio_event('/hook', 'pre_tool', pre_tool_data)
     
@@ -407,6 +484,12 @@ class ClaudeHookHandler:
             'output_size': len(str(result_data.get('output', ''))) if result_data.get('output') else 0
         }
         
+        # Handle Task delegation completion for memory hooks
+        if tool_name == 'Task':
+            session_id = event.get('session_id', '')
+            agent_type = self._get_delegation_agent_type(session_id)
+            self._trigger_memory_post_delegation_hook(agent_type, event, session_id)
+        
         self._emit_socketio_event('/hook', 'post_tool', post_tool_data)
     
     def _extract_tool_parameters(self, tool_name: str, tool_input: dict) -> dict:
@@ -711,6 +794,122 @@ class ClaudeHookHandler:
         # Emit to /hook namespace
         self._emit_socketio_event('/hook', 'subagent_stop', subagent_stop_data)
     
+    def _trigger_memory_pre_delegation_hook(self, agent_type: str, tool_input: dict, session_id: str):
+        """Trigger memory pre-delegation hook for agent memory injection.
+        
+        WHY: This connects Claude Code's Task delegation events to our memory system.
+        When Claude is about to delegate to an agent, we inject the agent's memory
+        into the delegation context so the agent has access to accumulated knowledge.
+        
+        DESIGN DECISION: We modify the tool_input in place to inject memory context.
+        This ensures the agent receives the memory as part of their initial context.
+        """
+        if not self.memory_hooks_initialized or not self.pre_delegation_hook:
+            return
+        
+        try:
+            # Create hook context for memory injection
+            hook_context = HookContext(
+                hook_type=HookType.PRE_DELEGATION,
+                data={
+                    'agent': agent_type,
+                    'context': tool_input,
+                    'session_id': session_id
+                },
+                metadata={
+                    'source': 'claude_hook_handler',
+                    'tool_name': 'Task'
+                },
+                timestamp=datetime.now().isoformat(),
+                session_id=session_id
+            )
+            
+            # Execute pre-delegation hook
+            result = self.pre_delegation_hook.execute(hook_context)
+            
+            if result.success and result.modified and result.data:
+                # Update tool_input with memory-enhanced context
+                enhanced_context = result.data.get('context', {})
+                if enhanced_context and 'agent_memory' in enhanced_context:
+                    # Inject memory into the task prompt/description
+                    original_prompt = tool_input.get('prompt', '')
+                    memory_section = enhanced_context['agent_memory']
+                    
+                    # Prepend memory to the original prompt
+                    enhanced_prompt = f"{memory_section}\n\n{original_prompt}"
+                    tool_input['prompt'] = enhanced_prompt
+                    
+                    if DEBUG:
+                        memory_size = len(memory_section.encode('utf-8'))
+                        print(f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'", file=sys.stderr)
+            
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Memory pre-delegation hook failed: {e}", file=sys.stderr)
+            # Don't fail the delegation - memory is optional
+    
+    def _trigger_memory_post_delegation_hook(self, agent_type: str, event: dict, session_id: str):
+        """Trigger memory post-delegation hook for learning extraction.
+        
+        WHY: This connects Claude Code's Task completion events to our memory system.
+        When an agent completes a task, we extract learnings from the result and
+        store them in the agent's memory for future use.
+        
+        DESIGN DECISION: We extract learnings from both the tool output and any
+        error messages, providing comprehensive context for the memory system.
+        """
+        if not self.memory_hooks_initialized or not self.post_delegation_hook:
+            return
+        
+        try:
+            # Extract result content from the event
+            result_content = ""
+            output = event.get('output', '')
+            error = event.get('error', '')
+            exit_code = event.get('exit_code', 0)
+            
+            # Build result content
+            if output:
+                result_content = str(output)
+            elif error:
+                result_content = f"Error: {str(error)}"
+            else:
+                result_content = f"Task completed with exit code: {exit_code}"
+            
+            # Create hook context for learning extraction
+            hook_context = HookContext(
+                hook_type=HookType.POST_DELEGATION,
+                data={
+                    'agent': agent_type,
+                    'result': {
+                        'content': result_content,
+                        'success': exit_code == 0,
+                        'exit_code': exit_code
+                    },
+                    'session_id': session_id
+                },
+                metadata={
+                    'source': 'claude_hook_handler',
+                    'tool_name': 'Task',
+                    'duration_ms': event.get('duration_ms', 0)
+                },
+                timestamp=datetime.now().isoformat(),
+                session_id=session_id
+            )
+            
+            # Execute post-delegation hook
+            result = self.post_delegation_hook.execute(hook_context)
+            
+            if result.success and result.metadata:
+                learnings_extracted = result.metadata.get('learnings_extracted', 0)
+                if learnings_extracted > 0 and DEBUG:
+                    print(f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'", file=sys.stderr)
+            
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Memory post-delegation hook failed: {e}", file=sys.stderr)
+            # Don't fail the delegation result - memory is optional
+    
     def __del__(self):
         """Cleanup Socket.IO client on handler destruction."""
         if self.sio_client and self.sio_connected:
@@ -721,9 +920,17 @@ class ClaudeHookHandler:
 
 
 def main():
-    """Entry point."""
-    handler = ClaudeHookHandler()
-    handler.handle()
+    """Entry point with comprehensive error handling."""
+    try:
+        handler = ClaudeHookHandler()
+        handler.handle()
+    except Exception as e:
+        # Always output continue action to not block Claude
+        print(json.dumps({"action": "continue"}))
+        # Log error for debugging
+        if DEBUG:
+            print(f"Hook handler error: {e}", file=sys.stderr)
+        sys.exit(0)  # Exit cleanly even on error
 
 
 if __name__ == "__main__":

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -48,5 +48,12 @@ echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/hook
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD $SCRIPT_DIR/hook_handler.py" >> /tmp/hook-wrapper.log
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] SOCKETIO_PORT: $CLAUDE_MPM_SOCKETIO_PORT" >> /tmp/hook-wrapper.log
 
-# Run the Python hook handler (now optimized by default)
-exec "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@"
+# Run the Python hook handler with error handling
+# Use exec to replace the shell process, but wrap in error handling
+if ! "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@" 2>/tmp/hook-error.log; then
+    # If the Python handler fails, always return continue to not block Claude
+    echo '{"action": "continue"}'
+    # Log the error for debugging
+    echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/hook-error.log" >> /tmp/hook-wrapper.log
+    exit 0
+fi

claude_mpm/hooks/memory_integration_hook.py

@@ -15,13 +15,29 @@ agent outputs because:
 import re
 from typing import Dict, Any, List
 from claude_mpm.hooks.base_hook import PreDelegationHook, PostDelegationHook, HookContext, HookResult
-from claude_mpm.services.agent_memory_manager import AgentMemoryManager
-from claude_mpm.services.socketio_server import get_socketio_server
 from claude_mpm.core.config import Config
 from claude_mpm.core.logger import get_logger
 
 logger = get_logger(__name__)
 
+# Try to import memory manager with fallback handling
+try:
+    from claude_mpm.services.agent_memory_manager import AgentMemoryManager
+    MEMORY_MANAGER_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"AgentMemoryManager not available: {e}")
+    MEMORY_MANAGER_AVAILABLE = False
+    AgentMemoryManager = None
+
+# Try to import socketio server with fallback handling
+try:
+    from claude_mpm.services.socketio_server import get_socketio_server
+    SOCKETIO_AVAILABLE = True
+except ImportError as e:
+    logger.debug(f"SocketIO server not available: {e}")
+    SOCKETIO_AVAILABLE = False
+    get_socketio_server = None
+
 
 class MemoryPreDelegationHook(PreDelegationHook):
     """Inject agent memory into delegation context.
@@ -42,7 +58,17 @@ class MemoryPreDelegationHook(PreDelegationHook):
         """
         super().__init__(name="memory_pre_delegation", priority=20)
         self.config = config or Config()
-        self.memory_manager = AgentMemoryManager(self.config)
+        
+        # Initialize memory manager only if available
+        if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager:
+            try:
+                self.memory_manager = AgentMemoryManager(self.config)
+            except Exception as e:
+                logger.error(f"Failed to initialize AgentMemoryManager: {e}")
+                self.memory_manager = None
+        else:
+            logger.info("Memory manager not available - hook will be inactive")
+            self.memory_manager = None
     
     def execute(self, context: HookContext) -> HookResult:
         """Add agent memory to delegation context.
@@ -50,6 +76,11 @@ class MemoryPreDelegationHook(PreDelegationHook):
         WHY: By loading memory before delegation, agents can reference their
         accumulated knowledge when performing tasks, leading to better outcomes.
         """
+        # If memory manager is not available, skip memory injection
+        if not self.memory_manager:
+            logger.debug("Memory manager not available - skipping memory injection")
+            return HookResult(success=True, data=context.data, modified=False)
+            
         try:
             # Extract and normalize agent ID from context
             agent_name = context.data.get('agent', '')
@@ -152,7 +183,17 @@ class MemoryPostDelegationHook(PostDelegationHook):
         """
         super().__init__(name="memory_post_delegation", priority=80)
         self.config = config or Config()
-        self.memory_manager = AgentMemoryManager(self.config)
+        
+        # Initialize memory manager only if available
+        if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager:
+            try:
+                self.memory_manager = AgentMemoryManager(self.config)
+            except Exception as e:
+                logger.error(f"Failed to initialize AgentMemoryManager in PostDelegationHook: {e}")
+                self.memory_manager = None
+        else:
+            logger.info("Memory manager not available - post-delegation hook will be inactive")
+            self.memory_manager = None
         
         # Map of supported types to memory sections
         self.type_mapping = {
@@ -172,9 +213,14 @@ class MemoryPostDelegationHook(PostDelegationHook):
         WHY: Capturing learnings immediately after task completion ensures we
         don't lose valuable insights that agents discover during execution.
         """
+        # If memory manager is not available, skip learning extraction
+        if not self.memory_manager:
+            logger.debug("Memory manager not available - skipping learning extraction")
+            return HookResult(success=True, data=context.data, modified=False)
+            
         try:
             # Check if auto-learning is enabled
-            if not self.config.get('memory.auto_learning', False):
+            if not self.config.get('memory.auto_learning', True):  # Changed default to True
                 return HookResult(success=True, data=context.data, modified=False)
             
             # Extract agent ID

claude_mpm/services/__init__.py

@@ -1,15 +1,33 @@
 """Services for Claude MPM."""
 
-from .ticket_manager import TicketManager
-from .agent_deployment import AgentDeploymentService
-from .agent_memory_manager import AgentMemoryManager, get_memory_manager
-from .hook_service import HookService
+# Use lazy imports to prevent circular dependency issues
+def __getattr__(name):
+    """Lazy import to prevent circular dependencies."""
+    if name == "TicketManager":
+        from .ticket_manager import TicketManager
+        return TicketManager
+    elif name == "AgentDeploymentService":
+        from .agent_deployment import AgentDeploymentService
+        return AgentDeploymentService
+    elif name == "AgentMemoryManager":
+        from .agent_memory_manager import AgentMemoryManager
+        return AgentMemoryManager
+    elif name == "get_memory_manager":
+        from .agent_memory_manager import get_memory_manager
+        return get_memory_manager
+    elif name == "HookService":
+        from .hook_service import HookService
+        return HookService
+    elif name == "ProjectAnalyzer":
+        from .project_analyzer import ProjectAnalyzer
+        return ProjectAnalyzer
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
-# Import other services as needed
 __all__ = [
     "TicketManager",
     "AgentDeploymentService",
     "AgentMemoryManager",
     "get_memory_manager",
     "HookService",
+    "ProjectAnalyzer",
 ]