claude-mpm 3.4.26__py3-none-any.whl → 3.5.0__py3-none-any.whl

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -17,6 +17,7 @@ import sys
 import os
 import subprocess
 from datetime import datetime
+import time
 from pathlib import Path
 from collections import deque
 
@@ -26,12 +27,9 @@ 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))
+    # Use centralized path management for adding src to path
+    from claude_mpm.config.paths import paths
+    paths.ensure_in_path()
     
     from claude_mpm.services.hook_service import HookService
     from claude_mpm.hooks.memory_integration_hook import (
@@ -47,6 +45,16 @@ except Exception as e:
         print(f"Memory hooks not available: {e}", file=sys.stderr)
     MEMORY_HOOKS_AVAILABLE = False
 
+# Response tracking integration
+RESPONSE_TRACKING_AVAILABLE = False
+try:
+    from claude_mpm.services.response_tracker import ResponseTracker
+    RESPONSE_TRACKING_AVAILABLE = True
+except Exception as e:
+    if DEBUG:
+        print(f"Response tracking not available: {e}", file=sys.stderr)
+    RESPONSE_TRACKING_AVAILABLE = False
+
 # Socket.IO import
 try:
     import socketio
@@ -78,6 +86,8 @@ class ClaudeHookHandler:
         self.active_delegations = {}
         # Use deque to limit memory usage (keep last 100 delegations)
         self.delegation_history = deque(maxlen=100)
+        # Store delegation request data for response correlation: session_id -> request_data
+        self.delegation_requests = {}
         
         # Git branch cache (to avoid repeated subprocess calls)
         self._git_branch_cache = {}
@@ -90,15 +100,29 @@ class ClaudeHookHandler:
         if MEMORY_HOOKS_AVAILABLE:
             self._initialize_memory_hooks()
         
+        # Initialize response tracking if available and enabled
+        self.response_tracker = None
+        self.response_tracking_enabled = False
+        if RESPONSE_TRACKING_AVAILABLE:
+            self._initialize_response_tracking()
+        
         # No fallback server needed - we only use Socket.IO now
     
-    def _track_delegation(self, session_id: str, agent_type: str):
-        """Track a new agent delegation."""
+    def _track_delegation(self, session_id: str, agent_type: str, request_data: dict = None):
+        """Track a new agent delegation with optional request data for response correlation."""
         if session_id and agent_type and agent_type != 'unknown':
             self.active_delegations[session_id] = agent_type
             key = f"{session_id}:{datetime.now().timestamp()}"
             self.delegation_history.append((key, agent_type))
             
+            # Store request data for response tracking correlation
+            if request_data:
+                self.delegation_requests[session_id] = {
+                    'agent_type': agent_type,
+                    'request': request_data,
+                    'timestamp': datetime.now().isoformat()
+                }
+            
             # Clean up old delegations (older than 5 minutes)
             cutoff_time = datetime.now().timestamp() - 300
             keys_to_remove = []
@@ -115,7 +139,10 @@ class ClaudeHookHandler:
                     keys_to_remove.append(sid)
             
             for key in keys_to_remove:
-                del self.active_delegations[key]
+                if key in self.active_delegations:
+                    del self.active_delegations[key]
+                if key in self.delegation_requests:
+                    del self.delegation_requests[key]
     
     def _get_delegation_agent_type(self, session_id: str) -> str:
         """Get the agent type for a session's active delegation."""
@@ -174,6 +201,129 @@ class ClaudeHookHandler:
                 print(f"❌ Failed to initialize memory hooks: {e}", file=sys.stderr)
             # Don't fail the entire handler - memory system is optional
     
+    def _initialize_response_tracking(self):
+        """Initialize response tracking if enabled in configuration.
+        
+        WHY: This enables automatic capture and storage of agent responses
+        for analysis, debugging, and learning purposes. Integration into the
+        existing hook handler avoids duplicate event capture.
+        
+        DESIGN DECISION: Check configuration to allow enabling/disabling
+        response tracking without code changes.
+        """
+        try:
+            # Create configuration with optional config file
+            config_file = os.environ.get('CLAUDE_PM_CONFIG_FILE')
+            config = Config(config_file=config_file) if config_file else Config()
+            
+            # Check if response tracking is enabled (check both sections for compatibility)
+            response_tracking_enabled = config.get('response_tracking.enabled', False)
+            response_logging_enabled = config.get('response_logging.enabled', False)
+            
+            if not (response_tracking_enabled or response_logging_enabled):
+                if DEBUG:
+                    print("Response tracking disabled - skipping initialization", file=sys.stderr)
+                return
+            
+            # Initialize response tracker with config
+            self.response_tracker = ResponseTracker(config=config)
+            self.response_tracking_enabled = self.response_tracker.is_enabled()
+            
+            if DEBUG:
+                print("✅ Response tracking initialized", file=sys.stderr)
+                
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Failed to initialize response tracking: {e}", file=sys.stderr)
+            # Don't fail the entire handler - response tracking is optional
+    
+    def _track_agent_response(self, session_id: str, agent_type: str, event: dict):
+        """Track agent response by correlating with original request and saving response.
+        
+        WHY: This integrates response tracking into the existing hook flow,
+        capturing agent responses when Task delegations complete. It correlates
+        the response with the original request stored during pre-tool processing.
+        
+        DESIGN DECISION: Only track responses if response tracking is enabled
+        and we have the original request data. Graceful error handling ensures
+        response tracking failures don't break hook processing.
+        """
+        if not self.response_tracking_enabled or not self.response_tracker:
+            return
+        
+        try:
+            # Get the original request data stored during pre-tool
+            request_info = self.delegation_requests.get(session_id)
+            if not request_info:
+                if DEBUG:
+                    print(f"No request data found for session {session_id}, skipping response tracking", file=sys.stderr)
+                return
+            
+            # Extract response from event output
+            response = event.get('output', '')
+            if not response:
+                # If no output, use error or construct a basic response
+                error = event.get('error', '')
+                exit_code = event.get('exit_code', 0)
+                if error:
+                    response = f"Error: {error}"
+                else:
+                    response = f"Task completed with exit code: {exit_code}"
+            
+            # Convert response to string if it's not already
+            response_text = str(response)
+            
+            # Get the original request (prompt + description)
+            original_request = request_info.get('request', {})
+            prompt = original_request.get('prompt', '')
+            description = original_request.get('description', '')
+            
+            # Combine prompt and description for the full request
+            full_request = prompt
+            if description and description != prompt:
+                if full_request:
+                    full_request += f"\n\nDescription: {description}"
+                else:
+                    full_request = description
+            
+            if not full_request:
+                full_request = f"Task delegation to {agent_type} agent"
+            
+            # Prepare metadata
+            metadata = {
+                'exit_code': event.get('exit_code', 0),
+                'success': event.get('exit_code', 0) == 0,
+                'has_error': bool(event.get('error')),
+                'duration_ms': event.get('duration_ms'),
+                'working_directory': event.get('cwd', ''),
+                'timestamp': datetime.now().isoformat(),
+                'tool_name': 'Task',
+                'original_request_timestamp': request_info.get('timestamp')
+            }
+            
+            # Track the response
+            file_path = self.response_tracker.track_response(
+                agent_name=agent_type,
+                request=full_request,
+                response=response_text,
+                session_id=session_id,
+                metadata=metadata
+            )
+            
+            if file_path and DEBUG:
+                print(f"✅ Tracked response for {agent_type} agent in session {session_id}: {file_path.name}", file=sys.stderr)
+            elif DEBUG and not file_path:
+                print(f"Response tracking returned None for {agent_type} agent (might be excluded or disabled)", file=sys.stderr)
+            
+            # Clean up the request data after successful tracking
+            if session_id in self.delegation_requests:
+                del self.delegation_requests[session_id]
+                
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Failed to track agent response: {e}", file=sys.stderr)
+            # Don't fail the hook processing - response tracking is optional
+    
     def _get_git_branch(self, working_dir: str = None) -> str:
         """Get git branch for the given directory with caching.
         
@@ -232,12 +382,13 @@ class ClaudeHookHandler:
             return 'Unknown'
     
     def _get_socketio_client(self):
-        """Get or create Socket.IO client.
+        """Get or create Socket.IO client with improved reliability.
         
-        WHY this approach:
-        - Reuses existing connection when possible
-        - Creates new connection only when needed
-        - Handles connection failures gracefully
+        WHY improved approach:
+        - Implements retry logic with exponential backoff
+        - Properly tests connection before returning
+        - Ensures connection persists across events
+        - Better error handling and recovery
         """
         if not SOCKETIO_AVAILABLE:
             return None
@@ -248,33 +399,68 @@ class ClaudeHookHandler:
                 # Test if still connected
                 if self.sio_client.connected:
                     return self.sio_client
+                else:
+                    # Connection lost, clear it
+                    if DEBUG:
+                        print("Hook handler: Socket.IO connection lost, reconnecting...", file=sys.stderr)
+                    self.sio_connected = False
             except:
-                pass
+                self.sio_connected = False
         
-        # Need to create new client
-        try:
-            port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
-            self.sio_client = socketio.Client(
-                reconnection=False,  # Don't auto-reconnect in hooks
-                logger=False,
-                engineio_logger=False
-            )
-            
-            # Try to connect with short timeout
-            self.sio_client.connect(f'http://localhost:{port}', wait_timeout=1)
-            self.sio_connected = True
-            
-            if DEBUG:
-                print(f"Hook handler: Connected to Socket.IO server on port {port}", file=sys.stderr)
-            
-            return self.sio_client
-            
-        except Exception as e:
-            if DEBUG:
-                print(f"Hook handler: Failed to connect to Socket.IO: {e}", file=sys.stderr)
-            self.sio_client = None
-            self.sio_connected = False
-            return None
+        # Need to create or reconnect client
+        port = int(os.environ.get('CLAUDE_MPM_SOCKETIO_PORT', '8765'))
+        max_retries = 3
+        retry_delay = 0.1  # Start with 100ms
+        
+        for attempt in range(max_retries):
+            try:
+                # Clean up old client if exists
+                if self.sio_client and not self.sio_connected:
+                    try:
+                        self.sio_client.disconnect()
+                    except:
+                        pass
+                    self.sio_client = None
+                
+                # Create new client
+                self.sio_client = socketio.Client(
+                    reconnection=True,  # Enable auto-reconnection
+                    reconnection_attempts=3,
+                    reconnection_delay=0.5,
+                    reconnection_delay_max=2,
+                    logger=False,
+                    engineio_logger=False
+                )
+                
+                # Try to connect with proper wait
+                self.sio_client.connect(
+                    f'http://localhost:{port}', 
+                    wait=True, 
+                    wait_timeout=1.0  # Reasonable timeout
+                )
+                
+                # Verify connection
+                if self.sio_client.connected:
+                    self.sio_connected = True
+                    if DEBUG:
+                        print(f"Hook handler: Successfully connected to Socket.IO server on port {port} (attempt {attempt + 1})", file=sys.stderr)
+                    return self.sio_client
+                    
+            except Exception as e:
+                if DEBUG and attempt == max_retries - 1:
+                    print(f"Hook handler: Failed to connect to Socket.IO after {max_retries} attempts: {e}", file=sys.stderr)
+                elif DEBUG:
+                    print(f"Hook handler: Connection attempt {attempt + 1} failed, retrying...", file=sys.stderr)
+                
+                # Exponential backoff
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                    retry_delay *= 2  # Double the delay for next attempt
+        
+        # All attempts failed
+        self.sio_client = None
+        self.sio_connected = False
+        return None
     
     def handle(self):
         """Process hook event with minimal overhead and zero blocking delays.
@@ -318,40 +504,75 @@ class ClaudeHookHandler:
             print(json.dumps({"action": "continue"}))
     
     def _emit_socketio_event(self, namespace: str, event: str, data: dict):
-        """Emit Socket.IO event using direct client.
+        """Emit Socket.IO event with improved reliability and logging.
         
-        WHY direct client approach:
-        - Simple synchronous emission
-        - No threading complexity
-        - Reliable delivery
-        - Fast when connection is reused
+        WHY improved approach:
+        - Better error handling and recovery
+        - Comprehensive event logging for debugging
+        - Automatic reconnection on failure
+        - Validates data before emission
         """
-        # Fast path: Skip all Socket.IO operations unless configured
-        if not os.environ.get('CLAUDE_MPM_SOCKETIO_PORT') and not DEBUG:
-            return
+        # Always try to emit Socket.IO events if available
+        # The daemon should be running when manager is active
         
         # Get Socket.IO client
         client = self._get_socketio_client()
-        if client:
-            try:
-                # Format event for Socket.IO server
-                claude_event_data = {
-                    'type': f'hook.{event}',
-                    'timestamp': datetime.now().isoformat(),
-                    'data': data
-                }
-                
-                # Emit synchronously
-                client.emit('claude_event', claude_event_data)
-                
-                if DEBUG:
-                    print(f"Emitted Socket.IO event: hook.{event}", file=sys.stderr)
+        if not client:
+            if DEBUG:
+                print(f"Hook handler: No Socket.IO client available for event: hook.{event}", file=sys.stderr)
+            return
+        
+        try:
+            # Format event for Socket.IO server
+            claude_event_data = {
+                'type': f'hook.{event}',  # Dashboard expects 'hook.' prefix
+                'timestamp': datetime.now().isoformat(),
+                'data': data
+            }
+            
+            # Log important events for debugging
+            if DEBUG and event in ['subagent_stop', 'pre_tool']:
+                if event == 'subagent_stop':
+                    agent_type = data.get('agent_type', 'unknown')
+                    print(f"Hook handler: Emitting SubagentStop for agent '{agent_type}'", file=sys.stderr)
+                elif event == 'pre_tool' and data.get('tool_name') == 'Task':
+                    delegation = data.get('delegation_details', {})
+                    agent_type = delegation.get('agent_type', 'unknown')
+                    print(f"Hook handler: Emitting Task delegation to agent '{agent_type}'", file=sys.stderr)
+            
+            # Emit synchronously with verification
+            client.emit('claude_event', claude_event_data)
+            
+            # Verify emission for critical events
+            if event in ['subagent_stop', 'pre_tool'] and DEBUG:
+                if client.connected:
+                    print(f"✅ Successfully emitted Socket.IO event: hook.{event}", file=sys.stderr)
+                else:
+                    print(f"⚠️ Event emitted but connection status uncertain: hook.{event}", file=sys.stderr)
+                    self.sio_connected = False  # Force reconnection next time
                     
-            except Exception as e:
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Socket.IO emit failed for hook.{event}: {e}", file=sys.stderr)
+            # Mark as disconnected so next call will reconnect
+            self.sio_connected = False
+            
+            # Try to reconnect immediately for critical events
+            if event in ['subagent_stop', 'pre_tool']:
                 if DEBUG:
-                    print(f"Socket.IO emit failed: {e}", file=sys.stderr)
-                # Mark as disconnected so next call will reconnect
-                self.sio_connected = False
+                    print(f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}", file=sys.stderr)
+                # Clear the client to force reconnection
+                self.sio_client = None
+                # Try to get a new client and emit again
+                retry_client = self._get_socketio_client()
+                if retry_client:
+                    try:
+                        retry_client.emit('claude_event', claude_event_data)
+                        if DEBUG:
+                            print(f"✅ Successfully re-emitted event after reconnection: hook.{event}", file=sys.stderr)
+                    except Exception as retry_e:
+                        if DEBUG:
+                            print(f"❌ Re-emission failed: {retry_e}", file=sys.stderr)
     
     def _handle_user_prompt_fast(self, event):
         """Handle user prompt with comprehensive data capture.
@@ -373,7 +594,6 @@ class ClaudeHookHandler:
         
         # Extract comprehensive prompt data
         prompt_data = {
-            'event_type': 'user_prompt',
             'prompt_text': prompt,
             'prompt_preview': prompt[:200] if len(prompt) > 200 else prompt,
             'prompt_length': len(prompt),
@@ -411,7 +631,6 @@ class ClaudeHookHandler:
         git_branch = self._get_git_branch(working_dir) if working_dir else 'Unknown'
         
         pre_tool_data = {
-            'event_type': 'pre_tool',
             'tool_name': tool_name,
             'operation_type': operation_type,
             'tool_parameters': tool_params,
@@ -428,21 +647,56 @@ class ClaudeHookHandler:
         
         # Add delegation-specific data if this is a Task tool
         if tool_name == 'Task' and isinstance(tool_input, dict):
-            agent_type = tool_input.get('subagent_type', 'unknown')
+            # Normalize agent type to handle capitalized names like "Research", "Engineer", etc.
+            raw_agent_type = tool_input.get('subagent_type', 'unknown')
+            
+            # Use AgentNameNormalizer if available, otherwise simple lowercase normalization
+            try:
+                from claude_mpm.core.agent_name_normalizer import AgentNameNormalizer
+                normalizer = AgentNameNormalizer()
+                # Convert to Task format (lowercase with hyphens)
+                agent_type = normalizer.to_task_format(raw_agent_type) if raw_agent_type != 'unknown' else 'unknown'
+            except ImportError:
+                # Fallback to simple normalization
+                agent_type = raw_agent_type.lower().replace('_', '-') if raw_agent_type != 'unknown' else 'unknown'
+            
             pre_tool_data['delegation_details'] = {
                 'agent_type': agent_type,
+                'original_agent_type': raw_agent_type,  # Keep original for debugging
                 'prompt': tool_input.get('prompt', ''),
                 'description': tool_input.get('description', ''),
                 'task_preview': (tool_input.get('prompt', '') or tool_input.get('description', ''))[:100]
             }
             
-            # Track this delegation for SubagentStop correlation
+            # Track this delegation for SubagentStop correlation and response tracking
             session_id = event.get('session_id', '')
             if session_id and agent_type != 'unknown':
-                self._track_delegation(session_id, agent_type)
+                # Prepare request data for response tracking correlation
+                request_data = {
+                    'prompt': tool_input.get('prompt', ''),
+                    'description': tool_input.get('description', ''),
+                    'agent_type': agent_type
+                }
+                self._track_delegation(session_id, agent_type, request_data)
+                
+                # Log important delegations for debugging
+                if DEBUG or agent_type in ['research', 'engineer', 'qa', 'documentation']:
+                    print(f"Hook handler: Task delegation started - agent: '{agent_type}', session: '{session_id}'", file=sys.stderr)
             
             # Trigger memory pre-delegation hook
             self._trigger_memory_pre_delegation_hook(agent_type, tool_input, session_id)
+            
+            # Emit a subagent_start event for better tracking
+            subagent_start_data = {
+                'agent_type': agent_type,
+                'agent_id': f"{agent_type}_{session_id}",
+                'session_id': session_id,
+                'prompt': tool_input.get('prompt', ''),
+                'description': tool_input.get('description', ''),
+                'timestamp': datetime.now().isoformat(),
+                'hook_event_name': 'SubagentStart'  # For dashboard compatibility
+            }
+            self._emit_socketio_event('/hook', 'subagent_start', subagent_start_data)
         
         self._emit_socketio_event('/hook', 'pre_tool', pre_tool_data)
     
@@ -468,7 +722,6 @@ class ClaudeHookHandler:
         git_branch = self._get_git_branch(working_dir) if working_dir else 'Unknown'
         
         post_tool_data = {
-            'event_type': 'post_tool',
             'tool_name': tool_name,
             'exit_code': exit_code,
             'success': exit_code == 0,
@@ -484,11 +737,16 @@ class ClaudeHookHandler:
             'output_size': len(str(result_data.get('output', ''))) if result_data.get('output') else 0
         }
         
-        # Handle Task delegation completion for memory hooks
+        # Handle Task delegation completion for memory hooks and response tracking
         if tool_name == 'Task':
             session_id = event.get('session_id', '')
             agent_type = self._get_delegation_agent_type(session_id)
+            
+            # Trigger memory post-delegation hook
             self._trigger_memory_post_delegation_hook(agent_type, event, session_id)
+            
+            # Track agent response if response tracking is enabled
+            self._track_agent_response(session_id, agent_type, event)
         
         self._emit_socketio_event('/hook', 'post_tool', post_tool_data)
     
@@ -687,7 +945,6 @@ class ClaudeHookHandler:
         git_branch = self._get_git_branch(working_dir) if working_dir else 'Unknown'
         
         notification_data = {
-            'event_type': 'notification',
             'notification_type': notification_type,
             'message': message,
             'message_preview': message[:200] if len(message) > 200 else message,
@@ -721,7 +978,6 @@ class ClaudeHookHandler:
         git_branch = self._get_git_branch(working_dir) if working_dir else 'Unknown'
         
         stop_data = {
-            'event_type': 'stop',
             'reason': reason,
             'stop_type': stop_type,
             'session_id': event.get('session_id', ''),
@@ -738,7 +994,7 @@ class ClaudeHookHandler:
         self._emit_socketio_event('/hook', 'stop', stop_data)
     
     def _handle_subagent_stop_fast(self, event):
-        """Handle subagent stop events when subagent processing stops.
+        """Handle subagent stop events with improved agent type detection.
         
         WHY comprehensive subagent stop capture:
         - Provides visibility into subagent lifecycle and delegation patterns
@@ -767,31 +1023,35 @@ class ClaudeHookHandler:
             elif 'pm' in task_desc or 'project' in task_desc:
                 agent_type = 'pm'
         
+        # Always log SubagentStop events for debugging
+        if DEBUG or agent_type != 'unknown':
+            print(f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'", file=sys.stderr)
+        
         # Get working directory and git branch
         working_dir = event.get('cwd', '')
         git_branch = self._get_git_branch(working_dir) if working_dir else 'Unknown'
         
         subagent_stop_data = {
-            'event_type': 'subagent_stop',
             'agent_type': agent_type,
             'agent_id': agent_id,
             'reason': reason,
-            'session_id': event.get('session_id', ''),
+            'session_id': session_id,
             'working_directory': working_dir,
             'git_branch': git_branch,
             'timestamp': datetime.now().isoformat(),
             'is_successful_completion': reason in ['completed', 'finished', 'done'],
             'is_error_termination': reason in ['error', 'timeout', 'failed', 'blocked'],
-            'is_delegation_related': agent_type in ['research', 'engineer', 'pm', 'ops'],
+            'is_delegation_related': agent_type in ['research', 'engineer', 'pm', 'ops', 'qa', 'documentation', 'security'],
             'has_results': bool(event.get('results') or event.get('output')),
-            'duration_context': event.get('duration_ms')
+            'duration_context': event.get('duration_ms'),
+            'hook_event_name': 'SubagentStop'  # Explicitly set for dashboard
         }
         
-        # Debug log the raw event data
+        # Debug log the processed data
         if DEBUG:
-            print(f"SubagentStop raw event data: {json.dumps(event, indent=2)}", file=sys.stderr)
+            print(f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'", file=sys.stderr)
         
-        # Emit to /hook namespace
+        # Emit to /hook namespace with high priority
         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):

claude_mpm/hooks/memory_integration_hook.py

@@ -22,7 +22,7 @@ logger = get_logger(__name__)
 
 # Try to import memory manager with fallback handling
 try:
-    from claude_mpm.services.agent_memory_manager import AgentMemoryManager
+    from claude_mpm.services.agents.memory import AgentMemoryManager
     MEMORY_MANAGER_AVAILABLE = True
 except ImportError as e:
     logger.warning(f"AgentMemoryManager not available: {e}")