claude-mpm 4.1.8__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/services/socketio/handlers/__init__.py

@@ -7,6 +7,7 @@ and maintainability.
 """
 
 from .base import BaseEventHandler
+from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -16,6 +17,7 @@ from .registry import EventHandlerRegistry
 
 __all__ = [
     "BaseEventHandler",
+    "CodeAnalysisEventHandler",
     "ConnectionEventHandler",
     "EventHandlerRegistry",
     "FileEventHandler",

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -0,0 +1,170 @@
+"""
+Code Analysis Event Handler for Socket.IO
+==========================================
+
+WHY: Handles code analysis requests from the dashboard, managing the analysis
+runner subprocess and streaming results back to connected clients.
+
+DESIGN DECISIONS:
+- Single analysis runner instance per server
+- Queue multiple requests for sequential processing
+- Support cancellation of running analysis
+- Stream events in real-time to all connected clients
+"""
+
+import uuid
+from typing import Any, Dict
+
+from ....core.logging_config import get_logger
+from ....dashboard.analysis_runner import CodeAnalysisRunner
+from .base import BaseEventHandler
+
+
+class CodeAnalysisEventHandler(BaseEventHandler):
+    """Handles code analysis events from dashboard clients.
+
+    WHY: Provides a clean interface between the dashboard UI and the
+    code analysis subprocess, managing requests and responses.
+    """
+
+    def __init__(self, server):
+        """Initialize the code analysis event handler.
+
+        Args:
+            server: The SocketIOServer instance
+        """
+        super().__init__(server)
+        self.logger = get_logger(__name__)
+        self.analysis_runner = None
+
+    def initialize(self):
+        """Initialize the analysis runner."""
+        if not self.analysis_runner:
+            self.analysis_runner = CodeAnalysisRunner(self.server)
+            self.analysis_runner.start()
+            self.logger.info("Code analysis runner initialized")
+
+    def cleanup(self):
+        """Cleanup the analysis runner on shutdown."""
+        if self.analysis_runner:
+            self.analysis_runner.stop()
+            self.analysis_runner = None
+            self.logger.info("Code analysis runner stopped")
+
+    def get_events(self) -> Dict[str, Any]:
+        """Get the events this handler manages.
+
+        Returns:
+            Dictionary mapping event names to handler methods
+        """
+        return {
+            "code:analyze:request": self.handle_analyze_request,
+            "code:analyze:cancel": self.handle_cancel_request,
+            "code:analyze:status": self.handle_status_request,
+        }
+
+    def register_events(self) -> None:
+        """Register Socket.IO event handlers.
+
+        WHY: Required by BaseEventHandler to register events with the Socket.IO server.
+        """
+        events = self.get_events()
+        for event_name, handler_method in events.items():
+            self.server.core.sio.on(event_name, handler_method)
+            self.logger.info(f"Registered event handler: {event_name}")
+
+    async def handle_analyze_request(self, sid: str, data: Dict[str, Any]):
+        """Handle code analysis request from client.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data containing path and options
+        """
+        self.logger.info(f"Code analysis requested from {sid}: {data}")
+
+        # Initialize runner if needed
+        if not self.analysis_runner:
+            self.initialize()
+
+        # Validate request
+        path = data.get("path")
+        if not path:
+            await self.server.sio.emit(
+                "code:analysis:error",
+                {
+                    "message": "Path is required for analysis",
+                    "request_id": data.get("request_id"),
+                },
+                room=sid,
+            )
+            return
+
+        # Generate request ID if not provided
+        request_id = data.get("request_id") or str(uuid.uuid4())
+
+        # Extract options
+        languages = data.get("languages")
+        max_depth = data.get("max_depth")
+        ignore_patterns = data.get("ignore_patterns")
+
+        # Queue analysis request
+        success = self.analysis_runner.request_analysis(
+            request_id=request_id,
+            path=path,
+            languages=languages,
+            max_depth=max_depth,
+            ignore_patterns=ignore_patterns,
+        )
+
+        if success:
+            # Send acknowledgment to requesting client
+            await self.server.sio.emit(
+                "code:analysis:accepted",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    "message": "Analysis request queued",
+                },
+                room=sid,
+            )
+        else:
+            # Send error if request failed
+            await self.server.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "message": "Failed to queue analysis request",
+                },
+                room=sid,
+            )
+
+    async def handle_cancel_request(self, sid: str, data: Dict[str, Any]):
+        """Handle analysis cancellation request.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data (may contain request_id)
+        """
+        self.logger.info(f"Analysis cancellation requested from {sid}")
+
+        # Cancel current analysis
+        self.analysis_runner.cancel_current()
+
+        # Send confirmation
+        await self.server.sio.emit(
+            "code:analysis:cancelled",
+            {"message": "Analysis cancelled", "request_id": data.get("request_id")},
+            room=sid,
+        )
+
+    async def handle_status_request(self, sid: str, data: Dict[str, Any]):
+        """Handle status request from client.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data (unused)
+        """
+        status = self.analysis_runner.get_status()
+
+        # Send status to requesting client
+        await self.server.sio.emit("code:analysis:status", status, room=sid)

claude_mpm/services/socketio/handlers/registry.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
 
     from ..server import SocketIOServer
 
+from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -37,6 +38,7 @@ class EventHandlerRegistry:
         HookEventHandler,  # Hook events for session tracking
         GitEventHandler,  # Git operations
         FileEventHandler,  # File operations
+        CodeAnalysisEventHandler,  # Code analysis for dashboard
         ProjectEventHandler,  # Project management (future)
         MemoryEventHandler,  # Memory management (future)
     ]

claude_mpm/services/socketio/server/connection_manager.py

@@ -10,6 +10,7 @@ of client states, proper event delivery, and automatic recovery mechanisms.
 """
 
 import asyncio
+import contextlib
 import time
 from collections import deque
 from dataclasses import dataclass, field
@@ -148,7 +149,7 @@ class ConnectionManager:
     - Automatic event replay on reconnection
     """
 
-    def __init__(self, max_buffer_size: int = None, event_ttl: int = None):
+    def __init__(self, max_buffer_size: Optional[int] = None, event_ttl: Optional[int] = None):
         """
         Initialize connection manager with centralized configuration.
 
@@ -263,6 +264,7 @@ class ConnectionManager:
                     )
                     self.connections[sid] = conn
                     return conn
+        return None
 
     def _create_new_connection(
         self, sid: str, client_id: str, now: float
@@ -434,10 +436,8 @@ class ConnectionManager:
         """Stop the health monitoring task."""
         if self.health_task:
             self.health_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self.health_task
-            except asyncio.CancelledError:
-                pass
             self.health_task = None
             self.logger.info("Stopped connection health monitoring")
 

claude_mpm/services/socketio/server/core.py

@@ -273,24 +273,113 @@ class SocketIOServerCore:
                 # Parse JSON payload
                 event_data = await request.json()
 
-                # Log receipt if debugging
-                event_type = event_data.get("subtype", "unknown")
-                self.logger.debug(f"Received HTTP event: {event_type}")
+                # Log receipt with more detail
+                event_type = (
+                    event_data.get("subtype")
+                    or event_data.get("hook_event_name")
+                    or "unknown"
+                )
+                self.logger.info(f"📨 Received HTTP event: {event_type}")
+                self.logger.debug(f"Event data keys: {list(event_data.keys())}")
+                self.logger.debug(f"Connected clients: {len(self.connected_clients)}")
+
+                # Transform hook event format to claude_event format if needed
+                if "hook_event_name" in event_data and "event" not in event_data:
+                    # This is a raw hook event, transform it
+                    from claude_mpm.services.socketio.event_normalizer import (
+                        EventNormalizer,
+                    )
+
+                    normalizer = EventNormalizer()
+
+                    # Create the format expected by normalizer
+                    raw_event = {
+                        "type": "hook",
+                        "subtype": event_data.get("hook_event_name", "unknown")
+                        .lower()
+                        .replace("submit", "")
+                        .replace("use", "_use"),
+                        "timestamp": event_data.get("timestamp"),
+                        "data": event_data.get("hook_input_data", {}),
+                        "source": "claude_hooks",
+                        "session_id": event_data.get("session_id"),
+                    }
+
+                    # Map hook event names to dashboard subtypes
+                    subtype_map = {
+                        "UserPromptSubmit": "user_prompt",
+                        "PreToolUse": "pre_tool",
+                        "PostToolUse": "post_tool",
+                        "Stop": "stop",
+                        "SubagentStop": "subagent_stop",
+                        "AssistantResponse": "assistant_response",
+                    }
+                    raw_event["subtype"] = subtype_map.get(
+                        event_data.get("hook_event_name"), "unknown"
+                    )
+
+                    normalized = normalizer.normalize(raw_event, source="hook")
+                    event_data = normalized.to_dict()
+                    self.logger.debug(
+                        f"Normalized event: type={event_data.get('type')}, subtype={event_data.get('subtype')}"
+                    )
 
                 # Broadcast to all connected dashboard clients via SocketIO
                 if self.sio:
-                    # The event is already in claude_event format from the hook handler
-                    await self.sio.emit("claude_event", event_data)
+                    # CRITICAL: Use the main server's broadcaster for proper event handling
+                    # The broadcaster handles retries, connection management, and buffering
+                    if (
+                        self.main_server
+                        and hasattr(self.main_server, "broadcaster")
+                        and self.main_server.broadcaster
+                    ):
+                        # The broadcaster expects raw event data and will normalize it
+                        # Since we already normalized it, we need to pass it in a way that won't double-normalize
+                        # We'll emit directly through the broadcaster's sio with proper handling
+
+                        # Add to event buffer and history
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
+
+                        # Add to main server's event history
+                        if hasattr(self.main_server, "event_history"):
+                            self.main_server.event_history.append(event_data)
+
+                        # Use the broadcaster's sio to emit (it's the same as self.sio)
+                        # This ensures the event goes through the proper channels
+                        await self.sio.emit("claude_event", event_data)
+
+                        # Update broadcaster stats
+                        if hasattr(self.main_server.broadcaster, "stats"):
+                            self.main_server.broadcaster.stats["events_sent"] = (
+                                self.main_server.broadcaster.stats.get("events_sent", 0)
+                                + 1
+                            )
+
+                        self.logger.info(
+                            f"✅ Event broadcasted: {event_data.get('subtype', 'unknown')} to {len(self.connected_clients)} clients"
+                        )
+                        self.logger.debug(
+                            f"Connected client IDs: {list(self.connected_clients) if self.connected_clients else 'None'}"
+                        )
+                    else:
+                        # Fallback: Direct emit if broadcaster not available (shouldn't happen)
+                        self.logger.warning(
+                            "Broadcaster not available, using direct emit"
+                        )
+                        await self.sio.emit("claude_event", event_data)
 
-                    # Update stats
-                    self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
+                        # Update stats manually if using fallback
+                        self.stats["events_sent"] = self.stats.get("events_sent", 0) + 1
 
-                    # Add to event buffer for late-joining clients
-                    with self.buffer_lock:
-                        self.event_buffer.append(event_data)
-                        self.stats["events_buffered"] = len(self.event_buffer)
+                        # Add to event buffer for late-joining clients
+                        with self.buffer_lock:
+                            self.event_buffer.append(event_data)
+                            self.stats["events_buffered"] = len(self.event_buffer)
 
                 # Return 204 No Content for success
+                self.logger.debug(f"✅ HTTP event processed successfully: {event_type}")
                 return web.Response(status=204)
 
             except Exception as e:

claude_mpm/services/socketio/server/main.py

@@ -265,10 +265,16 @@ class SocketIOServer(SocketIOServiceInterface):
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
 
-        # Stop health monitoring in connection handler
+        # Stop code analysis handler
         if self.event_registry:
-            from ..handlers import ConnectionEventHandler
+            from ..handlers import CodeAnalysisEventHandler, ConnectionEventHandler
 
+            # Stop analysis runner
+            analysis_handler = self.event_registry.get_handler(CodeAnalysisEventHandler)
+            if analysis_handler and hasattr(analysis_handler, "cleanup"):
+                analysis_handler.cleanup()
+
+            # Stop health monitoring in connection handler
             conn_handler = self.event_registry.get_handler(ConnectionEventHandler)
             if conn_handler and hasattr(conn_handler, "stop_health_monitoring"):
                 conn_handler.stop_health_monitoring()

claude_mpm/services/visualization/__init__.py

@@ -0,0 +1,19 @@
+"""
+Visualization Services for Claude MPM
+=====================================
+
+This module provides visualization services for code analysis,
+including Mermaid diagram generation for various code structures.
+"""
+
+from .mermaid_generator import (
+    DiagramConfig,
+    DiagramType,
+    MermaidGeneratorService,
+)
+
+__all__ = [
+    "DiagramConfig",
+    "DiagramType",
+    "MermaidGeneratorService",
+]