claude-mpm 4.20.3__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/services/socketio/handlers/connection.py

@@ -539,7 +539,7 @@ class ConnectionEventHandler(BaseEventHandler):
             if data and "timestamp" in data:
                 rtt = current_time - data["timestamp"]
                 if rtt < 10:  # Reasonable RTT
-                    self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt*1000:.1f}ms")
+                    self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt * 1000:.1f}ms")
 
     def _normalize_event(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
         """Normalize event format to ensure consistency.

claude_mpm/services/socketio/handlers/connection.py.backup

@@ -0,0 +1,217 @@
+"""Connection event handlers for Socket.IO.
+
+WHY: This module handles all connection-related events including connect,
+disconnect, status requests, and history management. Separating these
+from other handlers makes connection management more maintainable.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set
+
+from ....core.typing_utils import ClaudeStatus, EventData, SocketId
+from .base import BaseEventHandler
+
+
+class ConnectionEventHandler(BaseEventHandler):
+    """Handles Socket.IO connection lifecycle events.
+
+    WHY: Connection management is a critical aspect of the Socket.IO server
+    that deserves its own focused handler. This includes client connections,
+    disconnections, status updates, and event history management.
+    """
+
+    def register_events(self) -> None:
+        """Register connection-related event handlers."""
+
+        @self.sio.event
+        async def connect(sid, environ, *args):
+            """Handle client connection.
+
+            WHY: When a client connects, we need to track them, send initial
+            status information, and provide recent event history so they have
+            context for what's happening in the session.
+            """
+            self.clients.add(sid)
+            client_addr = environ.get("REMOTE_ADDR", "unknown")
+            user_agent = environ.get("HTTP_USER_AGENT", "unknown")
+            self.logger.info(f"🔗 NEW CLIENT CONNECTED: {sid} from {client_addr}")
+            self.logger.info(f"📱 User Agent: {user_agent[:100]}...")
+            self.logger.info(f"📈 Total clients now: {len(self.clients)}")
+
+            # Send initial status immediately with enhanced data
+            status_data = {
+                "server": "claude-mpm-python-socketio",
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "clients_connected": len(self.clients),
+                "session_id": self.server.session_id,
+                "claude_status": self.server.claude_status,
+                "claude_pid": self.server.claude_pid,
+                "server_version": "2.0.0",
+                "client_id": sid,
+            }
+
+            try:
+                await self.emit_to_client(sid, "status", status_data)
+                await self.emit_to_client(
+                    sid,
+                    "welcome",
+                    {
+                        "message": "Connected to Claude MPM Socket.IO server",
+                        "client_id": sid,
+                        "server_time": datetime.utcnow().isoformat() + "Z",
+                    },
+                )
+
+                # Automatically send the last 50 events to new clients
+                await self._send_event_history(sid, limit=50)
+
+                self.logger.debug(
+                    f"✅ Sent welcome messages and event history to client {sid}"
+                )
+            except Exception as e:
+                self.log_error(f"sending welcome to client {sid}", e)
+
+        @self.sio.event
+        async def disconnect(sid):
+            """Handle client disconnection.
+
+            WHY: We need to clean up client tracking when they disconnect
+            to maintain accurate connection counts and avoid memory leaks.
+            """
+            if sid in self.clients:
+                self.clients.remove(sid)
+                self.logger.info(f"🔌 CLIENT DISCONNECTED: {sid}")
+                self.logger.info(f"📉 Total clients now: {len(self.clients)}")
+            else:
+                self.logger.warning(
+                    f"⚠️  Attempted to disconnect unknown client: {sid}"
+                )
+
+        @self.sio.event
+        async def get_status(sid):
+            """Handle status request.
+
+            WHY: Clients need to query current server status on demand
+            to update their UI or verify connection health.
+            """
+            status_data = {
+                "server": "claude-mpm-python-socketio",
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "clients_connected": len(self.clients),
+                "session_id": self.server.session_id,
+                "claude_status": self.server.claude_status,
+                "claude_pid": self.server.claude_pid,
+            }
+            await self.emit_to_client(sid, "status", status_data)
+
+        @self.sio.event
+        async def get_history(sid, data=None):
+            """Handle history request.
+
+            WHY: Clients may need to request specific event history
+            to reconstruct state or filter by event types.
+            """
+            params = data or {}
+            event_types = params.get("event_types", [])
+            limit = min(params.get("limit", 100), len(self.event_history))
+
+            await self._send_event_history(sid, event_types=event_types, limit=limit)
+
+        @self.sio.event
+        async def request_history(sid, data=None):
+            """Handle legacy history request (for client compatibility).
+
+            WHY: Maintains backward compatibility with clients using
+            the older 'request.history' event name.
+            """
+            params = data or {}
+            event_types = params.get("event_types", [])
+            limit = min(params.get("limit", 50), len(self.event_history))
+
+            await self._send_event_history(sid, event_types=event_types, limit=limit)
+
+        @self.sio.event
+        async def subscribe(sid, data=None):
+            """Handle subscription request.
+
+            WHY: Allows clients to subscribe to specific event channels
+            for filtered event streaming.
+            """
+            channels = data.get("channels", ["*"]) if data else ["*"]
+            await self.emit_to_client(sid, "subscribed", {"channels": channels})
+
+        @self.sio.event
+        async def claude_event(sid, data):
+            """Handle events from client proxies.
+
+            WHY: Client proxies send events that need to be stored
+            in history and re-broadcast to other clients.
+            """
+            # Store in history
+            self.event_history.append(data)
+            self.logger.debug(
+                f"📚 Event from client stored in history (total: {len(self.event_history)})"
+            )
+
+            # Re-broadcast to all other clients
+            await self.broadcast_event("claude_event", data, skip_sid=sid)
+
+    async def _send_event_history(
+        self, sid: str, event_types: Optional[List[str]] = None, limit: int = 50
+    ):
+        """Send event history to a specific client.
+
+        WHY: When clients connect to the dashboard, they need context from recent events
+        to understand what's been happening. This sends the most recent events in
+        chronological order (oldest first) so the dashboard displays them properly.
+
+        Args:
+            sid: Socket.IO session ID of the client
+            event_types: Optional list of event types to filter by
+            limit: Maximum number of events to send (default: 50)
+        """
+        try:
+            if not self.event_history:
+                self.logger.debug(f"No event history to send to client {sid}")
+                return
+
+            # Limit to reasonable number to avoid overwhelming client
+            limit = min(limit, 100)
+
+            # Get the most recent events, filtered by type if specified
+            history = []
+            for event in reversed(self.event_history):
+                if not event_types or event.get("type") in event_types:
+                    history.append(event)
+                    if len(history) >= limit:
+                        break
+
+            # Reverse to get chronological order (oldest first)
+            history = list(reversed(history))
+
+            if history:
+                # Send as 'history' event that the client expects
+                await self.emit_to_client(
+                    sid,
+                    "history",
+                    {
+                        "events": history,
+                        "count": len(history),
+                        "total_available": len(self.event_history),
+                    },
+                )
+
+                self.logger.info(
+                    f"📚 Sent {len(history)} historical events to client {sid}"
+                )
+            else:
+                self.logger.debug(
+                    f"No matching events found for client {sid} with filters: {event_types}"
+                )
+
+        except Exception as e:
+            self.log_error(
+                f"sending event history to client {sid}",
+                e,
+                {"event_types": event_types, "limit": limit},
+            )

claude_mpm/services/socketio/handlers/git.py

@@ -745,7 +745,7 @@ class GitEventHandler(BaseEventHandler):
                                     stdout=asyncio.subprocess.PIPE,
                                     stderr=asyncio.subprocess.PIPE,
                                 )
-                                diff_output, diff_error = await diff_proc.communicate()
+                                diff_output, _ = await diff_proc.communicate()
 
                                 if diff_proc.returncode == 0:
                                     return {
@@ -792,7 +792,7 @@ class GitEventHandler(BaseEventHandler):
                         stdout=asyncio.subprocess.PIPE,
                         stderr=asyncio.subprocess.PIPE,
                     )
-                    diff_output, diff_error = await diff_proc.communicate()
+                    diff_output, _diff_error = await diff_proc.communicate()
 
                     if diff_proc.returncode == 0:
                         return {

claude_mpm/services/socketio/handlers/hook.py.backup

@@ -0,0 +1,154 @@
+"""Hook event handlers for Socket.IO.
+
+WHY: This module handles hook events from Claude to track session information,
+agent delegations, and other hook-based activity for the system heartbeat.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from .base import BaseEventHandler
+
+
+class HookEventHandler(BaseEventHandler):
+    """Handles hook events from Claude for session tracking.
+
+    WHY: Hook events provide rich information about Claude's activity including
+    session starts/stops, agent delegations, and tool usage. This handler
+    extracts session information to populate the system heartbeat data.
+    """
+
+    def register_events(self) -> None:
+        """Register hook event handlers."""
+
+        @self.sio.event
+        async def claude_event(sid, data):
+            """Handle claude_event which includes hook events.
+
+            WHY: Hook events are sent as claude_event with type 'hook'
+            and contain session and agent delegation information.
+            """
+            if not isinstance(data, dict):
+                return
+
+            # Check if this is a hook event
+            event_type = data.get("type")
+            if event_type != "hook":
+                return
+
+            # Extract hook event details
+            hook_event = data.get("event")
+            hook_data = data.get("data", {})
+
+            # Track sessions based on hook events
+            if hook_event == "subagent_start":
+                await self._handle_subagent_start(hook_data)
+            elif hook_event == "subagent_stop":
+                await self._handle_subagent_stop(hook_data)
+            elif hook_event == "user_prompt":
+                await self._handle_user_prompt(hook_data)
+            elif hook_event == "pre_tool":
+                await self._handle_pre_tool(hook_data)
+
+    async def _handle_subagent_start(self, data: Dict[str, Any]):
+        """Handle subagent start events.
+
+        WHY: When a subagent starts, we track it as an active session
+        with the agent type and start time for the heartbeat.
+        """
+        session_id = data.get("session_id")
+        agent_type = data.get("agent_type", "unknown")
+
+        if not session_id:
+            return
+
+        # Update or create session tracking
+        if hasattr(self.server, 'active_sessions'):
+            self.server.active_sessions[session_id] = {
+                "session_id": session_id,
+                "start_time": datetime.now().isoformat(),
+                "agent": agent_type,
+                "status": "active",
+                "prompt": data.get("prompt", "")[:100],  # First 100 chars
+                "last_activity": datetime.now().isoformat(),
+            }
+
+            self.logger.debug(
+                f"Tracked subagent start: session={session_id[:8]}..., agent={agent_type}"
+            )
+
+    async def _handle_subagent_stop(self, data: Dict[str, Any]):
+        """Handle subagent stop events.
+
+        WHY: When a subagent stops, we update its status or remove it
+        from active sessions depending on the stop reason.
+        """
+        session_id = data.get("session_id")
+
+        if not session_id:
+            return
+
+        # Update session status
+        if hasattr(self.server, 'active_sessions'):
+            if session_id in self.server.active_sessions:
+                # Mark as completed rather than removing immediately
+                self.server.active_sessions[session_id]["status"] = "completed"
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now().isoformat()
+
+                self.logger.debug(
+                    f"Marked session completed: session={session_id[:8]}..."
+                )
+
+    async def _handle_user_prompt(self, data: Dict[str, Any]):
+        """Handle user prompt events.
+
+        WHY: User prompts indicate the start of a new interaction,
+        which we track as a PM session if no delegation occurs.
+        """
+        session_id = data.get("session_id")
+
+        if not session_id:
+            return
+
+        # Create or update PM session
+        if hasattr(self.server, 'active_sessions'):
+            if session_id not in self.server.active_sessions:
+                self.server.active_sessions[session_id] = {
+                    "session_id": session_id,
+                    "start_time": datetime.now().isoformat(),
+                    "agent": "pm",  # Default to PM
+                    "status": "active",
+                    "prompt": data.get("prompt_text", "")[:100],
+                    "working_directory": data.get("working_directory", ""),
+                    "last_activity": datetime.now().isoformat(),
+                }
+            else:
+                # Update last activity
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now().isoformat()
+
+    async def _handle_pre_tool(self, data: Dict[str, Any]):
+        """Handle pre-tool events.
+
+        WHY: Pre-tool events with Task delegation indicate agent changes
+        that we need to track for accurate session information.
+        """
+        if data.get("tool_name") != "Task":
+            return
+
+        session_id = data.get("session_id")
+        delegation_details = data.get("delegation_details", {})
+        agent_type = delegation_details.get("agent_type", "unknown")
+
+        if not session_id:
+            return
+
+        # Update session with new agent
+        if hasattr(self.server, 'active_sessions'):
+            if session_id in self.server.active_sessions:
+                self.server.active_sessions[session_id]["agent"] = agent_type
+                self.server.active_sessions[session_id]["status"] = "delegated"
+                self.server.active_sessions[session_id]["last_activity"] = datetime.now().isoformat()
+
+                self.logger.debug(
+                    f"Updated session delegation: session={session_id[:8]}..., agent={agent_type}"
+                )

claude_mpm/services/static/.gitkeep

@@ -0,0 +1,2 @@
+# Static files directory for SocketIO service
+# This directory is created to prevent FileNotFoundError when the SocketIO service starts

claude_mpm/services/system_instructions_service.py

@@ -112,9 +112,7 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
                 self.agent_capabilities_service
                 and "{{AGENT_CAPABILITIES}}" in base_pm_content
             ):
-                capabilities = (
-                    self.agent_capabilities_service.generate_deployed_agent_capabilities()
-                )
+                capabilities = self.agent_capabilities_service.generate_deployed_agent_capabilities()
                 base_pm_content = base_pm_content.replace(
                     "{{AGENT_CAPABILITIES}}", capabilities
                 )

claude_mpm/services/unified/analyzer_strategies/performance_analyzer.py

@@ -527,13 +527,11 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
                         and node.iter.func.id == "range"
                         and len(node.iter.args) == 1
                     ):
-
                         if isinstance(node.iter.args[0], ast.Call):
                             if (
                                 isinstance(node.iter.args[0].func, ast.Name)
                                 and node.iter.args[0].func.id == "len"
                             ):
-
                                 results["optimizations"].append(
                                     {
                                         "type": "range_len_pattern",
@@ -562,7 +560,6 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
                         "min",
                         "max",
                     ]:
-
                         results["optimizations"].append(
                             {
                                 "type": "generator_opportunity",

claude_mpm/services/unified/analyzer_strategies/security_analyzer.py

@@ -436,7 +436,6 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
                             and node.func.value.id == "subprocess"
                             and node.func.attr in ["run", "call", "Popen"]
                         ):
-
                             for keyword in node.keywords:
                                 if (
                                     keyword.arg == "shell"

claude_mpm/services/unified/deployment_strategies/cloud_strategies.py

@@ -64,7 +64,7 @@ class RailwayDeploymentStrategy(DeploymentStrategy):
 
     def prepare(self, context: DeploymentContext) -> List[Path]:
         """Prepare Railway artifacts."""
-        artifact_path, metadata = prepare_deployment_artifact(
+        artifact_path, _metadata = prepare_deployment_artifact(
             context.source, "directory", context.config
         )
         return [artifact_path]

claude_mpm/services/version_control/VERSION

@@ -0,0 +1 @@
+0.9.0

claude_mpm/services/version_control/conflict_resolution.py

@@ -458,17 +458,19 @@ class ConflictResolutionManager:
 
         for i, marker in enumerate(markers):
             if not marker.ours_content and marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Accept incoming changes (theirs)")
+                suggestions.append(
+                    f"Conflict {i + 1}: Accept incoming changes (theirs)"
+                )
             elif marker.ours_content and not marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Keep current changes (ours)")
+                suggestions.append(f"Conflict {i + 1}: Keep current changes (ours)")
             elif self._only_whitespace_differences(
                 marker.ours_content, marker.theirs_content
             ):
                 suggestions.append(
-                    f"Conflict {i+1}: Whitespace differences only - can auto-resolve"
+                    f"Conflict {i + 1}: Whitespace differences only - can auto-resolve"
                 )
             else:
-                suggestions.append(f"Conflict {i+1}: Manual merge required")
+                suggestions.append(f"Conflict {i + 1}: Manual merge required")
 
         return "; ".join(suggestions)
 

claude_mpm/services/visualization/mermaid_generator.py

@@ -307,9 +307,8 @@ class MermaidGeneratorService(SyncBaseService):
                         import_from = imp.get("from", imp.get("module", ""))
                         if import_from:
                             import_name = self._extract_module_name(import_from)
-                            if (
-                                not config.include_external
-                                and self._is_external_module(import_name)
+                            if not config.include_external and self._is_external_module(
+                                import_name
                             ):
                                 continue
                             modules.add(import_name)

claude_mpm/skills/__init__.py

@@ -30,13 +30,13 @@ from .skills_registry import SkillsRegistry as SkillsRegistryHelper
 from .skills_service import SkillsService
 
 __all__ = [
-    # New Skills Integration System
-    "SkillsService",
     "AgentSkillsInjector",
-    "SkillsRegistryHelper",
     # Legacy System
     "Skill",
     "SkillManager",
     "SkillsRegistry",
+    "SkillsRegistryHelper",
+    # New Skills Integration System
+    "SkillsService",
     "get_registry",
 ]