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

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -13,13 +13,25 @@ import sys
 from datetime import datetime
 from typing import Any, Dict, Optional
 
-from .tool_analysis import (
-    assess_security_risk,
-    calculate_duration,
-    classify_tool_operation,
-    extract_tool_parameters,
-    extract_tool_results,
-)
+# Import tool analysis with fallback for direct execution
+try:
+    # Try relative import first (when imported as module)
+    from .tool_analysis import (
+        assess_security_risk,
+        calculate_duration,
+        classify_tool_operation,
+        extract_tool_parameters,
+        extract_tool_results,
+    )
+except ImportError:
+    # Fall back to direct import (when parent script is run directly)
+    from tool_analysis import (
+        assess_security_risk,
+        calculate_duration,
+        classify_tool_operation,
+        extract_tool_parameters,
+        extract_tool_results,
+    )
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
@@ -99,8 +111,8 @@ class EventHandlers:
                         file=sys.stderr,
                     )
 
-        # Emit to /hook namespace
-        self.hook_handler._emit_socketio_event("/hook", "user_prompt", prompt_data)
+        # Emit normalized event (namespace no longer needed with normalized events)
+        self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
 
     def handle_pre_tool_fast(self, event):
         """Handle pre-tool use with comprehensive data capture.
@@ -152,7 +164,7 @@ class EventHandlers:
         if tool_name == "Task" and isinstance(tool_input, dict):
             self._handle_task_delegation(tool_input, pre_tool_data, session_id)
 
-        self.hook_handler._emit_socketio_event("/hook", "pre_tool", pre_tool_data)
+        self.hook_handler._emit_socketio_event("", "pre_tool", pre_tool_data)
 
     def _handle_task_delegation(
         self, tool_input: dict, pre_tool_data: dict, session_id: str
@@ -242,7 +254,7 @@ class EventHandlers:
             "hook_event_name": "SubagentStart",  # For dashboard compatibility
         }
         self.hook_handler._emit_socketio_event(
-            "/hook", "subagent_start", subagent_start_data
+            "", "subagent_start", subagent_start_data
         )
 
     def _get_git_branch(self, working_dir: str = None) -> str:
@@ -362,7 +374,7 @@ class EventHandlers:
                 session_id, agent_type, event, self.hook_handler.delegation_requests
             )
 
-        self.hook_handler._emit_socketio_event("/hook", "post_tool", post_tool_data)
+        self.hook_handler._emit_socketio_event("", "post_tool", post_tool_data)
 
     def handle_notification_fast(self, event):
         """Handle notification events from Claude.
@@ -399,9 +411,9 @@ class EventHandlers:
             ),
         }
 
-        # Emit to /hook namespace
+        # Emit normalized event
         self.hook_handler._emit_socketio_event(
-            "/hook", "notification", notification_data
+            "", "notification", notification_data
         )
 
     def handle_stop_fast(self, event):
@@ -481,8 +493,8 @@ class EventHandlers:
             "has_output": bool(event.get("final_output")),
         }
 
-        # Emit to /hook namespace
-        self.hook_handler._emit_socketio_event("/hook", "stop", stop_data)
+        # Emit normalized event
+        self.hook_handler._emit_socketio_event("", "stop", stop_data)
 
     def handle_subagent_stop_fast(self, event):
         """Handle subagent stop events with improved agent type detection."""
@@ -599,9 +611,9 @@ class EventHandlers:
                 file=sys.stderr,
             )
 
-        # Emit to /hook namespace with high priority
+        # Emit normalized event with high priority
         self.hook_handler._emit_socketio_event(
-            "/hook", "subagent_stop", subagent_stop_data
+            "", "subagent_stop", subagent_stop_data
         )
 
     def _handle_subagent_response_tracking(
@@ -737,7 +749,57 @@ class EventHandlers:
                 )
 
     def handle_assistant_response(self, event):
-        """Handle assistant response events for comprehensive response tracking."""
+        """Handle assistant response events for comprehensive response tracking.
+        
+        WHY emit assistant response events:
+        - Provides visibility into Claude's responses to user prompts
+        - Captures response content and metadata for analysis
+        - Enables tracking of conversation flow and response patterns
+        - Essential for comprehensive monitoring of Claude interactions
+        """
+        # Track the response for logging
         self.hook_handler.response_tracking_manager.track_assistant_response(
             event, self.hook_handler.pending_prompts
         )
+        
+        # Get working directory and git branch
+        working_dir = event.get("cwd", "")
+        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+        
+        # Extract response data
+        response_text = event.get("response", "")
+        session_id = event.get("session_id", "")
+        
+        # Prepare assistant response data for Socket.IO emission
+        assistant_response_data = {
+            "response_text": response_text,
+            "response_preview": response_text[:500] if len(response_text) > 500 else response_text,
+            "response_length": len(response_text),
+            "session_id": session_id,
+            "working_directory": working_dir,
+            "git_branch": git_branch,
+            "timestamp": datetime.now().isoformat(),
+            "contains_code": "```" in response_text,
+            "contains_json": "```json" in response_text,
+            "hook_event_name": "AssistantResponse",  # Explicitly set for dashboard
+            "has_structured_response": bool(re.search(r"```json\s*\{.*?\}\s*```", response_text, re.DOTALL)),
+        }
+        
+        # Check if this is a response to a tracked prompt
+        if session_id in self.hook_handler.pending_prompts:
+            prompt_data = self.hook_handler.pending_prompts[session_id]
+            assistant_response_data["original_prompt"] = prompt_data.get("prompt", "")[:200]
+            assistant_response_data["prompt_timestamp"] = prompt_data.get("timestamp", "")
+            assistant_response_data["is_tracked_response"] = True
+        else:
+            assistant_response_data["is_tracked_response"] = False
+        
+        # Debug logging
+        if DEBUG:
+            print(
+                f"Hook handler: Processing AssistantResponse - session: '{session_id}', response_length: {len(response_text)}",
+                file=sys.stderr,
+            )
+        
+        # Emit normalized event
+        self.hook_handler._emit_socketio_event("", "assistant_response", assistant_response_data)

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -24,11 +24,49 @@ import time
 from collections import deque
 from datetime import datetime
 
-# Import extracted modules
-from .connection_pool import SocketIOConnectionPool
-from .event_handlers import EventHandlers
-from .memory_integration import MemoryHookManager
-from .response_tracking import ResponseTrackingManager
+# Import extracted modules with fallback for direct execution
+try:
+    # Try relative imports first (when imported as module)
+    from .connection_pool import SocketIOConnectionPool
+    from .event_handlers import EventHandlers
+    from .memory_integration import MemoryHookManager
+    from .response_tracking import ResponseTrackingManager
+except ImportError:
+    # Fall back to absolute imports (when run directly)
+    import sys
+    from pathlib import Path
+    # Add parent directory to path
+    sys.path.insert(0, str(Path(__file__).parent))
+    from connection_pool import SocketIOConnectionPool
+    from event_handlers import EventHandlers
+    from memory_integration import MemoryHookManager
+    from response_tracking import ResponseTrackingManager
+
+# Import EventNormalizer for consistent event formatting
+try:
+    from claude_mpm.services.socketio.event_normalizer import EventNormalizer
+except ImportError:
+    # Create a simple fallback EventNormalizer if import fails
+    class EventNormalizer:
+        def normalize(self, event_data):
+            """Simple fallback normalizer that returns event as-is."""
+            return type('NormalizedEvent', (), {
+                'to_dict': lambda: {
+                    'event': 'claude_event',
+                    'type': event_data.get('type', 'unknown'),
+                    'subtype': event_data.get('subtype', 'generic'),
+                    'timestamp': event_data.get('timestamp', datetime.now().isoformat()),
+                    'data': event_data.get('data', event_data)
+                }
+            })
+
+# Import EventBus for decoupled event distribution
+try:
+    from claude_mpm.services.event_bus import EventBus
+    EVENTBUS_AVAILABLE = True
+except ImportError:
+    EVENTBUS_AVAILABLE = False
+    EventBus = None
 
 # Import constants for configuration
 try:
@@ -81,11 +119,23 @@ class ClaudeHookHandler:
     """
 
     def __init__(self):
-        # Socket.IO client (persistent if possible)
-        self.connection_pool = SocketIOConnectionPool(max_connections=3)
         # Track events for periodic cleanup
         self.events_processed = 0
         self.last_cleanup = time.time()
+        # Event normalizer for consistent event schema
+        self.event_normalizer = EventNormalizer()
+        
+        # Initialize EventBus for decoupled event distribution
+        self.event_bus = None
+        if EVENTBUS_AVAILABLE:
+            try:
+                self.event_bus = EventBus.get_instance()
+                if DEBUG:
+                    print("✅ EventBus initialized for hook handler", file=sys.stderr)
+            except Exception as e:
+                if DEBUG:
+                    print(f"⚠️ Failed to initialize EventBus: {e}", file=sys.stderr)
+                self.event_bus = None
 
         # Maximum sizes for tracking
         self.MAX_DELEGATION_TRACKING = 200
@@ -479,167 +529,61 @@ class ClaudeHookHandler:
         """
         print(json.dumps({"action": "continue"}))
 
-    def _discover_socketio_port(self) -> int:
-        """Discover the port of the running SocketIO server."""
-        try:
-            # Try to import port manager
-            from claude_mpm.services.port_manager import PortManager
-
-            port_manager = PortManager()
-            instances = port_manager.list_active_instances()
-
-            if instances:
-                # Prefer port 8765 if available
-                for instance in instances:
-                    if instance.get("port") == 8765:
-                        return 8765
-                # Otherwise use the first active instance
-                return instances[0].get("port", 8765)
-            else:
-                # No active instances, use default
-                return 8765
-        except Exception:
-            # Fallback to environment variable or default
-            return int(os.environ.get("CLAUDE_MPM_SOCKETIO_PORT", "8765"))
 
     def _emit_socketio_event(self, namespace: str, event: str, data: dict):
-        """Emit Socket.IO event with improved reliability and persistent connections.
-
-        WHY improved approach:
-        - Maintains persistent connections throughout handler lifecycle
-        - Better error handling and automatic recovery
-        - Connection health monitoring before emission
-        - Automatic reconnection for critical events
-        - Validates data before emission
+        """Emit event through EventBus for Socket.IO relay.
+
+        WHY EventBus-only approach:
+        - Single event path prevents duplicates
+        - EventBus relay handles Socket.IO connection management
+        - Better separation of concerns
+        - More resilient with centralized failure handling
+        - Cleaner architecture and easier testing
         """
-        # Always try to emit Socket.IO events if available
-        # The daemon should be running when manager is active
-
-        # Get Socket.IO client with dynamic port discovery
-        port = self._discover_socketio_port()
-        client = self.connection_pool.get_connection(port)
+        # Create event data for normalization
+        raw_event = {
+            "type": "hook",
+            "subtype": event,  # e.g., "user_prompt", "pre_tool", "subagent_stop"
+            "timestamp": datetime.now().isoformat(),
+            "data": data,
+            "source": "claude_hooks",  # Identify the source
+            "session_id": data.get("sessionId"),  # Include session if available
+        }
         
-        # If no client available, try to create one
-        if not client:
-            if DEBUG:
+        # Normalize the event using EventNormalizer for consistent schema
+        normalized_event = self.event_normalizer.normalize(raw_event, source="hook")
+        claude_event_data = normalized_event.to_dict()
+
+        # 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: No Socket.IO client available, attempting to create connection for event: hook.{event}",
+                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
                     file=sys.stderr,
                 )
-            # Force creation of a new connection
-            client = self.connection_pool._create_connection(port)
-            if client:
-                # Add to pool for future use
-                self.connection_pool.connections.append(
-                    {"port": port, "client": client, "created": time.time()}
+            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: Publishing Task delegation to agent '{agent_type}'",
+                    file=sys.stderr,
                 )
-            else:
+        
+        # Publish to EventBus for distribution through relay
+        if self.event_bus and EVENTBUS_AVAILABLE:
+            try:
+                # Publish to EventBus with topic format: hook.{event}
+                topic = f"hook.{event}"
+                self.event_bus.publish(topic, claude_event_data)
                 if DEBUG:
-                    print(
-                        f"Hook handler: Failed to create Socket.IO connection for event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                return
-
-        try:
-            # Verify connection is alive before emitting
-            if not client.connected:
+                    print(f"✅ Published to EventBus: {topic}", file=sys.stderr)
+            except Exception as e:
                 if DEBUG:
-                    print(
-                        f"Hook handler: Client not connected, attempting reconnection for event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                # Try to reconnect
-                try:
-                    client.connect(
-                        f"http://localhost:{port}",
-                        wait=True,
-                        wait_timeout=1.0,
-                        transports=['websocket', 'polling'],
-                    )
-                except:
-                    # If reconnection fails, get a fresh client
-                    client = self.connection_pool._create_connection(port)
-                    if not client:
-                        if DEBUG:
-                            print(
-                                f"Hook handler: Reconnection failed for event: hook.{event}",
-                                file=sys.stderr,
-                            )
-                        return
-            
-            # 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
-            client.emit("claude_event", claude_event_data)
-            
-            # For critical events, wait a moment to ensure delivery
-            if event in ["subagent_stop", "pre_tool"]:
-                time.sleep(0.01)  # Small delay to ensure event is sent
-
-            # 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} (connection still active)",
-                        file=sys.stderr,
-                    )
-                else:
-                    print(
-                        f"⚠️ Event emitted but connection closed after: hook.{event}",
-                        file=sys.stderr,
-                    )
-
-        except Exception as e:
+                    print(f"⚠️ Failed to publish to EventBus: {e}", file=sys.stderr)
+        else:
             if DEBUG:
-                print(f"❌ Socket.IO emit failed for hook.{event}: {e}", file=sys.stderr)
-
-            # Try to reconnect immediately for critical events
-            if event in ["subagent_stop", "pre_tool"]:
-                if DEBUG:
-                    print(
-                        f"Hook handler: Attempting immediate reconnection for critical event: hook.{event}",
-                        file=sys.stderr,
-                    )
-                # Force get a new client and emit again
-                self.connection_pool._cleanup_dead_connections()
-                retry_client = self.connection_pool._create_connection(port)
-                if retry_client:
-                    try:
-                        retry_client.emit("claude_event", claude_event_data)
-                        # Add to pool for future use
-                        self.connection_pool.connections.append(
-                            {"port": port, "client": retry_client, "created": time.time()}
-                        )
-                        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)
+                print(f"⚠️ EventBus not available for event: hook.{event}", file=sys.stderr)
 
     def handle_subagent_stop(self, event: dict):
         """Handle subagent stop events with improved agent type detection.
@@ -876,6 +820,17 @@ class ClaudeHookHandler:
                         metadata["task_completed"] = structured_response.get(
                             "task_completed", False
                         )
+                        
+                        # Check for MEMORIES field and process if present
+                        if "MEMORIES" in structured_response and structured_response["MEMORIES"]:
+                            memories = structured_response["MEMORIES"]
+                            if DEBUG:
+                                print(
+                                    f"Found MEMORIES field in {agent_type} response with {len(memories)} items",
+                                    file=sys.stderr,
+                                )
+                            # The memory will be processed by extract_and_update_memory
+                            # which is called by the memory hook service
 
                     # Track the response
                     file_path = (
@@ -937,7 +892,17 @@ class ClaudeHookHandler:
                 "files_modified": structured_response.get("files_modified", []),
                 "tools_used": structured_response.get("tools_used", []),
                 "remember": structured_response.get("remember"),
+                "MEMORIES": structured_response.get("MEMORIES"),  # Complete memory replacement
             }
+            
+            # Log if MEMORIES field is present
+            if "MEMORIES" in structured_response and structured_response["MEMORIES"]:
+                if DEBUG:
+                    memories_count = len(structured_response["MEMORIES"])
+                    print(
+                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items",
+                        file=sys.stderr,
+                    )
 
         # Debug log the processed data
         if DEBUG:
@@ -950,12 +915,9 @@ class ClaudeHookHandler:
         self._emit_socketio_event("/hook", "subagent_stop", subagent_stop_data)
 
     def __del__(self):
-        """Cleanup Socket.IO connections on handler destruction."""
-        if hasattr(self, "connection_pool") and self.connection_pool:
-            try:
-                self.connection_pool.close_all()
-            except:
-                pass
+        """Cleanup on handler destruction."""
+        # Connection pool no longer used - EventBus handles cleanup
+        pass
 
 
 def main():