claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/socketio/handlers/file.py

@@ -9,7 +9,7 @@ import os
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-from ....core.typing_utils import EventData, PathLike, SocketId
+from ....core.typing_utils import EventData
 from ....core.unified_paths import get_project_root
 from .base import BaseEventHandler
 
@@ -156,7 +156,7 @@ class FileEventHandler(BaseEventHandler):
 
             # Read file content
             try:
-                with open(real_path, "r", encoding="utf-8") as f:
+                with open(real_path, encoding="utf-8") as f:
                     content = f.read()
 
                 # Get file extension for syntax highlighting hint
@@ -203,17 +203,16 @@ class FileEventHandler(BaseEventHandler):
                         "file_path": file_path,
                         "file_size": file_size,
                     }
-                else:
-                    # Text file with different encoding
-                    ext = real_path.suffix
-                    return {
-                        "success": True,
-                        "file_path": file_path,
-                        "content": text_content,
-                        "file_size": file_size,
-                        "extension": ext.lower(),
-                        "encoding": "latin-1",
-                    }
+                # Text file with different encoding
+                ext = real_path.suffix
+                return {
+                    "success": True,
+                    "file_path": file_path,
+                    "content": text_content,
+                    "file_size": file_size,
+                    "extension": ext.lower(),
+                    "encoding": "latin-1",
+                }
             except Exception:
                 return {
                     "success": False,
@@ -223,6 +222,6 @@ class FileEventHandler(BaseEventHandler):
         except Exception as read_error:
             return {
                 "success": False,
-                "error": f"Failed to read file: {str(read_error)}",
+                "error": f"Failed to read file: {read_error!s}",
                 "file_path": file_path,
             }

claude_mpm/services/socketio/handlers/git.py

@@ -10,9 +10,8 @@ import os
 import subprocess
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
-from ....core.typing_utils import EventData, PathLike, SocketId
 from .base import BaseEventHandler
 
 
@@ -53,6 +52,7 @@ class GitEventHandler(BaseEventHandler):
                     cwd=working_dir,
                     capture_output=True,
                     text=True,
+                    check=False,
                 )
 
                 # Debug: Git command completed
@@ -125,6 +125,7 @@ class GitEventHandler(BaseEventHandler):
                     ["git", "-C", working_dir, "ls-files", "--", file_path],
                     capture_output=True,
                     text=True,
+                    check=False,
                 )
 
                 is_tracked = result.returncode == 0 and result.stdout.strip()
@@ -318,6 +319,7 @@ class GitEventHandler(BaseEventHandler):
                     ["git", "-C", working_dir, "add", file_path],
                     capture_output=True,
                     text=True,
+                    check=False,
                 )
 
                 # Debug: Git add completed
@@ -389,7 +391,7 @@ class GitEventHandler(BaseEventHandler):
         ):
             working_dir = os.getcwd()
             self.logger.info(
-                f"[{operation}] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}"
+                f"[{operation}] working_dir was invalid ({original_working_dir!r}), using cwd: {working_dir}"
             )
         else:
             self.logger.info(f"[{operation}] Using provided working_dir: {working_dir}")
@@ -424,7 +426,7 @@ class GitEventHandler(BaseEventHandler):
                 response_event,
                 {
                     "success": False,
-                    "error": f"Directory not found",
+                    "error": "Directory not found",
                     "working_dir": working_dir,
                     "detail": f"Path does not exist: {working_dir}",
                 },
@@ -440,7 +442,7 @@ class GitEventHandler(BaseEventHandler):
                 response_event,
                 {
                     "success": False,
-                    "error": f"Not a directory",
+                    "error": "Not a directory",
                     "working_dir": working_dir,
                     "detail": f"Path is not a directory: {working_dir}",
                 },
@@ -529,6 +531,7 @@ class GitEventHandler(BaseEventHandler):
             ["git", "-C", working_dir, "rev-parse", "--git-dir"],
             capture_output=True,
             text=True,
+            check=False,
         )
         return git_check.returncode == 0
 
@@ -543,6 +546,7 @@ class GitEventHandler(BaseEventHandler):
             ["git", "-C", working_dir, "rev-parse", "--show-toplevel"],
             capture_output=True,
             text=True,
+            check=False,
         )
 
         if git_root_result.returncode == 0:
@@ -570,6 +574,7 @@ class GitEventHandler(BaseEventHandler):
             ["git", "-C", working_dir, "status", "--porcelain", file_path],
             capture_output=True,
             text=True,
+            check=False,
         )
 
         # Check if file is tracked by git
@@ -577,6 +582,7 @@ class GitEventHandler(BaseEventHandler):
             ["git", "-C", working_dir, "ls-files", file_path],
             capture_output=True,
             text=True,
+            check=False,
         )
 
         is_tracked = ls_files_result.returncode == 0 and ls_files_result.stdout.strip()
@@ -633,7 +639,6 @@ class GitEventHandler(BaseEventHandler):
                         )
 
             # Handle case where working_dir is None, empty string, or 'Unknown'
-            original_working_dir = working_dir
             if not working_dir or working_dir == "Unknown" or working_dir.strip() == "":
                 working_dir = os.getcwd()
                 # Debug: working_dir was invalid, using cwd
@@ -952,6 +957,6 @@ class GitEventHandler(BaseEventHandler):
             self.logger.error(f"Error in generate_git_diff: {e}")
             return {
                 "success": False,
-                "error": f"Git diff generation failed: {str(e)}",
+                "error": f"Git diff generation failed: {e!s}",
                 "file_path": file_path,
             }

claude_mpm/services/socketio/handlers/hook.py

@@ -5,48 +5,47 @@ agent delegations, and other hook-based activity for the system heartbeat.
 """
 
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 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.
-        
+
         NOTE: This handler no longer registers a claude_event handler directly
         to avoid conflicts with ConnectionEventHandler. Instead, it processes
         hook events passed from ConnectionEventHandler.
         """
         # No direct event registration - events are passed from ConnectionEventHandler
-        pass
-    
+
     async def process_hook_event(self, data: Dict[str, Any]) -> None:
         """Process a hook event received from ConnectionEventHandler.
-        
+
         WHY: This method is called by ConnectionEventHandler when it receives
         a claude_event with type starting with 'hook.'. This separation avoids handler conflicts.
-        
+
         Args:
             data: The complete event data including type, timestamp, and data fields
         """
         if not isinstance(data, dict):
             return
-            
+
         # Extract hook event details
         # Hook events can come in two formats:
         # 1. Normalized: { type: "hook", subtype: "user_prompt", ... }
         # 2. Legacy: { type: "hook.user_prompt", ... }
         event_type = data.get("type", "")
         event_subtype = data.get("subtype", "")
-        
+
         # Determine the actual hook event name
         hook_event = ""
         if event_type == "hook" and event_subtype:
@@ -58,26 +57,26 @@ class HookEventHandler(BaseEventHandler):
         else:
             # Fallback: check for 'event' field (another legacy format)
             hook_event = data.get("event", "")
-            
+
         hook_data = data.get("data", {})
-        
+
         # Create properly formatted event for history
         # Note: add_to_history expects the event data directly, not wrapped
         history_event = {
             "type": "hook",
             "event": hook_event,
             "data": hook_data,
-            "timestamp": data.get("timestamp") or datetime.now().isoformat()
+            "timestamp": data.get("timestamp") or datetime.now().isoformat(),
         }
-        
+
         # Add the event to history for replay
         # The base handler's add_to_history will wrap it properly
         self.event_history.append(history_event)
-        
+
         # Broadcast the original event to all connected clients
         # (preserves all original fields)
         await self.broadcast_event("claude_event", data)
-        
+
         # Track sessions based on hook events
         if hook_event == "subagent_start":
             await self._handle_subagent_start(hook_data)
@@ -87,23 +86,23 @@ class HookEventHandler(BaseEventHandler):
             await self._handle_user_prompt(hook_data)
         elif hook_event == "pre_tool":
             await self._handle_pre_tool(hook_data)
-        
+
         self.logger.debug(f"Processed hook event: {hook_event}")
-                
+
     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'):
+        if hasattr(self.server, "active_sessions"):
             self.server.active_sessions[session_id] = {
                 "session_id": session_id,
                 "start_time": datetime.now().isoformat(),
@@ -112,46 +111,48 @@ class HookEventHandler(BaseEventHandler):
                 "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 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.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 hasattr(self.server, "active_sessions"):
             if session_id not in self.server.active_sessions:
                 self.server.active_sessions[session_id] = {
                     "session_id": session_id,
@@ -164,31 +165,35 @@ class HookEventHandler(BaseEventHandler):
                 }
             else:
                 # Update last activity
-                self.server.active_sessions[session_id]["last_activity"] = datetime.now().isoformat()
-                
+                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 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.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/socketio/handlers/memory.py

@@ -24,4 +24,3 @@ class MemoryEventHandler(BaseEventHandler):
         """
         # Future memory management events will be registered here
         # For example: query_memory, clear_memory, export_memory, etc.
-        pass

claude_mpm/services/socketio/handlers/project.py

@@ -22,4 +22,3 @@ class ProjectEventHandler(BaseEventHandler):
         handler is ready for future expansion.
         """
         # Future project events will be registered here
-        pass

claude_mpm/services/socketio/handlers/registry.py

@@ -5,13 +5,14 @@ providing a clean interface for the SocketIOServer to register all
 events without knowing the details of each handler.
 """
 
-from logging import Logger
 from typing import TYPE_CHECKING, List, Optional, Type
 
 from ....core.logger import get_logger
 from .base import BaseEventHandler
 
 if TYPE_CHECKING:
+    from logging import Logger
+
     from ..server import SocketIOServer
 
 from .connection import ConnectionEventHandler
@@ -46,7 +47,7 @@ class EventHandlerRegistry:
         Args:
             server: The SocketIOServer instance
         """
-        self.server: "SocketIOServer" = server
+        self.server: SocketIOServer = server
         self.logger: Logger = get_logger("EventHandlerRegistry")
         self.handlers: List[BaseEventHandler] = []
         self._initialized: bool = False
@@ -73,8 +74,11 @@ class EventHandlerRegistry:
         # Add debug logging for deployment context
         try:
             from ....core.unified_paths import PathContext
+
             deployment_context = PathContext.detect_deployment_context()
-            self.logger.info(f"Initializing event handlers in {deployment_context.value} mode")
+            self.logger.info(
+                f"Initializing event handlers in {deployment_context.value} mode"
+            )
         except Exception as e:
             self.logger.debug(f"Could not detect deployment context: {e}")
 
@@ -88,7 +92,9 @@ class EventHandlerRegistry:
                 self.handlers.append(handler)
                 self.logger.info(f"✅ Initialized handler: {handler_class.__name__}")
             except Exception as e:
-                self.logger.error(f"❌ Failed to initialize {handler_class.__name__}: {e}")
+                self.logger.error(
+                    f"❌ Failed to initialize {handler_class.__name__}: {e}"
+                )
                 import traceback
 
                 self.logger.error(f"Stack trace: {traceback.format_exc()}")
@@ -107,31 +113,43 @@ class EventHandlerRegistry:
             self.logger.error("Registry not initialized. Call initialize() first.")
             raise RuntimeError("EventHandlerRegistry not initialized")
 
-        self.logger.info(f"🔄 Starting event registration for {len(self.handlers)} handlers")
-        
+        self.logger.info(
+            f"🔄 Starting event registration for {len(self.handlers)} handlers"
+        )
+
         # Verify Socket.IO server is available
-        if not hasattr(self.server, 'core') or not self.server.core or not self.server.core.sio:
-            self.logger.error("❌ Socket.IO server instance not available for event registration")
+        if (
+            not hasattr(self.server, "core")
+            or not self.server.core
+            or not self.server.core.sio
+        ):
+            self.logger.error(
+                "❌ Socket.IO server instance not available for event registration"
+            )
             raise RuntimeError("Socket.IO server not available")
-        
+
         self.logger.debug(f"Socket.IO server available: {type(self.server.core.sio)}")
 
         registered_count = 0
         for handler in self.handlers:
             try:
-                self.logger.debug(f"Registering events for {handler.__class__.__name__}")
-                
+                self.logger.debug(
+                    f"Registering events for {handler.__class__.__name__}"
+                )
+
                 # Get the number of registered events before and after
-                sio_events_before = len(getattr(self.server.core.sio, 'handlers', {}))
-                
+                sio_events_before = len(getattr(self.server.core.sio, "handlers", {}))
+
                 handler.register_events()
-                
-                sio_events_after = len(getattr(self.server.core.sio, 'handlers', {}))
+
+                sio_events_after = len(getattr(self.server.core.sio, "handlers", {}))
                 events_added = sio_events_after - sio_events_before
-                
+
                 registered_count += 1
-                self.logger.info(f"✅ Registered {events_added} events for {handler.__class__.__name__}")
-                
+                self.logger.info(
+                    f"✅ Registered {events_added} events for {handler.__class__.__name__}"
+                )
+
             except NotImplementedError:
                 # Handler has no events to register (like ProjectEventHandler)
                 self.logger.debug(
@@ -146,7 +164,7 @@ class EventHandlerRegistry:
                 self.logger.error(f"Stack trace: {traceback.format_exc()}")
 
         # Final verification
-        total_sio_events = len(getattr(self.server.core.sio, 'handlers', {}))
+        total_sio_events = len(getattr(self.server.core.sio, "handlers", {}))
         self.logger.info(
             f"🎉 Event registration complete: {registered_count} handlers processed, "
             f"{total_sio_events} total Socket.IO events registered"