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

claude_mpm/services/socketio/server/main.py

@@ -10,8 +10,6 @@ delegates to specialized components rather than inheriting from them.
 """
 
 import asyncio
-import logging
-import os
 import threading
 import time
 from collections import deque
@@ -31,15 +29,10 @@ except ImportError:
     web = None
 
 from ....core.constants import (
-    NetworkConfig,
-    PerformanceConfig,
     SystemLimits,
-    TimeoutConfig,
 )
+from ....core.logging_config import get_logger
 from ...core.interfaces.communication import SocketIOServiceInterface
-from ....core.logging_config import get_logger, log_operation, log_performance_context
-from ....core.unified_paths import get_project_root, get_scripts_dir
-from ...exceptions import SocketIOServerError as MPMConnectionError
 from ..handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler
 from .broadcaster import SocketIOEventBroadcaster
 from .core import SocketIOServerCore
@@ -91,10 +84,10 @@ class SocketIOServer(SocketIOServiceInterface):
         self.claude_status = "unknown"
         self.claude_pid = None
         self.event_history = deque(maxlen=SystemLimits.MAX_EVENTS_BUFFER)
-        
+
         # Active session tracking for heartbeat
         self.active_sessions: Dict[str, Dict[str, Any]] = {}
-        
+
         # EventBus integration
         self.eventbus_integration = None
 
@@ -106,7 +99,14 @@ class SocketIOServer(SocketIOServiceInterface):
 
         # Set reference to main server for session data
         self.core.main_server = self
-        
+
+        # Debug logging for EventBus initialization
+        self.logger.info("Starting Socket.IO server with EventBus integration...")
+        print(
+            f"[{datetime.now().isoformat()}] SocketIOServer.start_sync() called",
+            flush=True,
+        )
+
         # Start the core server
         self.core.start_sync()
 
@@ -127,11 +127,11 @@ class SocketIOServer(SocketIOServiceInterface):
         max_wait = 5.0  # Maximum wait time in seconds
         wait_interval = 0.1  # Check interval
         waited = 0.0
-        
+
         while self.core.loop is None and waited < max_wait:
             time.sleep(wait_interval)
             waited += wait_interval
-        
+
         if self.core.loop is None:
             self.logger.warning(
                 f"Event loop not initialized after {max_wait}s wait. "
@@ -139,27 +139,51 @@ class SocketIOServer(SocketIOServiceInterface):
             )
         else:
             self.logger.debug(f"Event loop ready after {waited:.1f}s")
-            
+
             # Set the loop reference for broadcaster
             self.broadcaster.loop = self.core.loop
-            
+
             # Start the retry processor for resilient event delivery
             self.broadcaster.start_retry_processor()
 
         # Register events
         self._register_events()
-        
+
         # Setup EventBus integration
         # WHY: This connects the EventBus to the Socket.IO server, allowing
         # events from other parts of the system to be broadcast to dashboard
+        print(
+            f"[{datetime.now().isoformat()}] Setting up EventBus integration...",
+            flush=True,
+        )
         try:
             self.eventbus_integration = EventBusIntegration(self)
+            print(
+                f"[{datetime.now().isoformat()}] EventBusIntegration instance created",
+                flush=True,
+            )
+
             if self.eventbus_integration.setup(self.port):
                 self.logger.info("EventBus integration setup successful")
+                print(
+                    f"[{datetime.now().isoformat()}] EventBus integration setup successful",
+                    flush=True,
+                )
             else:
                 self.logger.warning("EventBus integration setup failed or disabled")
+                print(
+                    f"[{datetime.now().isoformat()}] EventBus integration setup failed or disabled",
+                    flush=True,
+                )
         except Exception as e:
             self.logger.error(f"Failed to setup EventBus integration: {e}")
+            print(
+                f"[{datetime.now().isoformat()}] Failed to setup EventBus integration: {e}",
+                flush=True,
+            )
+            import traceback
+
+            traceback.print_exc()
             self.eventbus_integration = None
 
         # Update running state
@@ -175,7 +199,7 @@ class SocketIOServer(SocketIOServiceInterface):
         # Stop the retry processor if running
         if self.broadcaster:
             self.broadcaster.stop_retry_processor()
-        
+
         # Teardown EventBus integration
         if self.eventbus_integration:
             try:
@@ -183,14 +207,15 @@ class SocketIOServer(SocketIOServiceInterface):
                 self.logger.info("EventBus integration teardown complete")
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
-        
+
         # Stop health monitoring in connection handler
         if self.event_registry:
             from ..handlers import ConnectionEventHandler
+
             conn_handler = self.event_registry.get_handler(ConnectionEventHandler)
-            if conn_handler and hasattr(conn_handler, 'stop_health_monitoring'):
+            if conn_handler and hasattr(conn_handler, "stop_health_monitoring"):
                 conn_handler.stop_health_monitoring()
-        
+
         self.core.stop_sync()
         self.running = False
 
@@ -219,25 +244,27 @@ class SocketIOServer(SocketIOServiceInterface):
         """Broadcast an event to all connected clients."""
         if self.broadcaster:
             self.broadcaster.broadcast_event(event_type, data)
-    
-    def send_to_client(self, client_id: str, event_type: str, data: Dict[str, Any]) -> bool:
+
+    def send_to_client(
+        self, client_id: str, event_type: str, data: Dict[str, Any]
+    ) -> bool:
         """Send an event to a specific client.
-        
-        WHY: The SocketIOServiceInterface requires this method for targeted 
+
+        WHY: The SocketIOServiceInterface requires this method for targeted
         messaging. We delegate to the Socket.IO server's emit method with
         the client's session ID as the room.
-        
+
         Args:
             client_id: ID of the target client
             event_type: Type of event to send
             data: Event data to send
-            
+
         Returns:
             True if message sent successfully
         """
         if not self.core or not self.core.sio:
             return False
-        
+
         try:
             # Socket.IO uses session IDs as room names for individual clients
             # We can send to a specific client by using their session ID as the room
@@ -246,7 +273,7 @@ class SocketIOServer(SocketIOServiceInterface):
                 if self.core.loop:
                     asyncio.run_coroutine_threadsafe(
                         self.core.sio.emit(event_type, data, room=client_id),
-                        self.core.loop
+                        self.core.loop,
                     )
                     return True
             return False
@@ -257,7 +284,7 @@ class SocketIOServer(SocketIOServiceInterface):
     def session_started(self, session_id: str, launch_method: str, working_dir: str):
         """Notify that a session has started."""
         self.session_id = session_id
-        
+
         # Track active session for heartbeat
         self.active_sessions[session_id] = {
             "session_id": session_id,
@@ -267,7 +294,7 @@ class SocketIOServer(SocketIOServiceInterface):
             "launch_method": launch_method,
             "working_dir": working_dir,
         }
-        
+
         if self.broadcaster:
             self.broadcaster.session_started(session_id, launch_method, working_dir)
 
@@ -276,7 +303,7 @@ class SocketIOServer(SocketIOServiceInterface):
         # Remove from active sessions
         if self.session_id and self.session_id in self.active_sessions:
             del self.active_sessions[self.session_id]
-            
+
         if self.broadcaster:
             self.broadcaster.session_ended()
 
@@ -300,7 +327,7 @@ class SocketIOServer(SocketIOServiceInterface):
         if self.session_id and self.session_id in self.active_sessions:
             self.active_sessions[self.session_id]["agent"] = agent
             self.active_sessions[self.session_id]["status"] = status
-            
+
         if self.broadcaster:
             self.broadcaster.agent_delegated(agent, task, status)
 
@@ -344,16 +371,16 @@ class SocketIOServer(SocketIOServiceInterface):
     def is_running(self) -> bool:
         """Check if server is running."""
         return self.core.is_running()
-    
+
     def get_active_sessions(self) -> List[Dict[str, Any]]:
         """Get list of active sessions for heartbeat.
-        
+
         WHY: Provides session information for system heartbeat events.
         """
         # Clean up old sessions (older than 1 hour)
         cutoff_time = datetime.now().timestamp() - 3600
         sessions_to_remove = []
-        
+
         for session_id, session_data in self.active_sessions.items():
             try:
                 start_time = datetime.fromisoformat(session_data["start_time"])
@@ -361,14 +388,13 @@ class SocketIOServer(SocketIOServiceInterface):
                     sessions_to_remove.append(session_id)
             except:
                 pass
-        
+
         for session_id in sessions_to_remove:
             del self.active_sessions[session_id]
-        
+
         # Return list of active sessions
         return list(self.active_sessions.values())
 
-
     # Legacy compatibility properties
     @property
     def sio(self):

claude_mpm/services/socketio_client_manager.py

@@ -15,7 +15,6 @@ WHY this approach:
 
 import asyncio
 import importlib.metadata
-import json
 import socket
 import threading
 import time
@@ -34,6 +33,8 @@ except ImportError:
     requests = None
     socketio = None
 
+import contextlib
+
 from ..core.logger import get_logger
 
 # Get claude-mpm version for compatibility checking
@@ -74,11 +75,10 @@ class ServerInfo:
             # Simple version comparison - in production use proper semver
             if client_version >= "0.7.0":
                 return True, warnings
-            else:
-                warnings.append(
-                    f"Client version {client_version} may not be fully supported"
-                )
-                return False, warnings
+            warnings.append(
+                f"Client version {client_version} may not be fully supported"
+            )
+            return False, warnings
         except Exception as e:
             warnings.append(f"Could not parse version: {e}")
             return False, warnings
@@ -106,7 +106,7 @@ class SocketIOClientManager:
             self.logger.warning("Socket.IO client dependencies not available")
 
     def discover_servers(
-        self, ports: List[int] = None, hosts: List[str] = None
+        self, ports: Optional[List[int]] = None, hosts: Optional[List[str]] = None
     ) -> List[ServerInfo]:
         """Discover available Socket.IO servers.
 
@@ -165,7 +165,7 @@ class SocketIOClientManager:
         return discovered
 
     def find_best_server(
-        self, discovered_servers: List[ServerInfo] = None
+        self, discovered_servers: Optional[List[ServerInfo]] = None
     ) -> Optional[ServerInfo]:
         """Find the best compatible server from discovered servers."""
         if discovered_servers is None:
@@ -272,10 +272,8 @@ class SocketIOClientManager:
         except Exception as e:
             self.logger.error(f"❌ Failed to connect to server {server_info.url}: {e}")
             if self.client:
-                try:
+                with contextlib.suppress(Exception):
                     await self.client.disconnect()
-                except:
-                    pass
                 self.client = None
             return False
 
@@ -408,7 +406,7 @@ class SocketIOClientManager:
                     else:
                         # Too many failed attempts, wait longer
                         self.logger.warning(
-                            f"⏳ Max connection attempts reached, waiting 30s..."
+                            "⏳ Max connection attempts reached, waiting 30s..."
                         )
                         await asyncio.sleep(30)
                         connection_attempts = 0  # Reset after longer wait

claude_mpm/services/subprocess_launcher_service.py

@@ -10,6 +10,7 @@ This service handles:
 Extracted from ClaudeRunner to follow Single Responsibility Principle.
 """
 
+import contextlib
 import os
 import pty
 import select
@@ -40,11 +41,9 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     # Implementation of abstract methods from SubprocessLauncherInterface
 
@@ -206,10 +205,8 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
                 termios.tcsetattr(sys.stdin, termios.TCSADRAIN, original_tty)
 
             # Close PTY
-            try:
+            with contextlib.suppress(Exception):
                 os.close(master_fd)
-            except:
-                pass
 
             # Ensure process is terminated
             if "process" in locals() and process.poll() is None:
@@ -313,9 +310,9 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
         env = os.environ.copy()
         if base_env:
             env.update(base_env)
-        
+
         # Disable telemetry for Claude Code subprocesses
         # This ensures Claude Code doesn't send telemetry data during runtime
         env["DISABLE_TELEMETRY"] = "1"
-        
+
         return env

claude_mpm/services/system_instructions_service.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 """System instructions service for loading and processing system instructions.
 
 This service handles:
@@ -36,11 +34,9 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def load_system_instructions(self, instruction_type: str = "default") -> str:
         """Load and process system instructions from agents/INSTRUCTIONS.md.
@@ -50,7 +46,7 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
 
         Now uses the FrameworkLoader for comprehensive instruction loading including:
         - INSTRUCTIONS.md
-        - WORKFLOW.md  
+        - WORKFLOW.md
         - MEMORY.md
         - Actual PM memories from .claude-mpm/memories/PM.md
         - Agent capabilities
@@ -64,23 +60,28 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
             if self._loaded_instructions is not None:
                 self.logger.debug("Returning cached system instructions")
                 return self._loaded_instructions
-            
+
             # Create FrameworkLoader only once
             if self._framework_loader is None:
                 from claude_mpm.core.framework_loader import FrameworkLoader
+
                 self._framework_loader = FrameworkLoader()
                 self.logger.debug("Created new FrameworkLoader instance")
-            
+
             # Load instructions and cache them
             instructions = self._framework_loader.get_framework_instructions()
-            
+
             if instructions:
                 self._loaded_instructions = instructions
-                self.logger.info("Loaded and cached framework instructions via FrameworkLoader")
+                self.logger.info(
+                    "Loaded and cached framework instructions via FrameworkLoader"
+                )
                 return instructions
-            
+
             # Fallback if FrameworkLoader returns empty
-            self.logger.warning("FrameworkLoader returned empty instructions, using fallback")
+            self.logger.warning(
+                "FrameworkLoader returned empty instructions, using fallback"
+            )
             fallback = "# System Instructions\n\nNo specific system instructions found. Using default behavior."
             self._loaded_instructions = fallback
             return fallback
@@ -177,9 +178,7 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
             cleaned = "\n".join(cleaned_lines)
 
             # Also remove any leading blank lines that might result
-            cleaned = cleaned.lstrip("\n")
-
-            return cleaned
+            return cleaned.lstrip("\n")
 
         except Exception as e:
             self.logger.warning(f"Error stripping metadata comments: {e}")

claude_mpm/services/ticket_manager.py

@@ -6,7 +6,7 @@ class TicketManager:
 
     def create_task(self, *args, **kwargs):
         """Stub method."""
-        return None
+        return
 
     def list_recent_tickets(self, *args, **kwargs):
         """Stub method."""
@@ -14,7 +14,7 @@ class TicketManager:
 
     def get_ticket(self, *args, **kwargs):
         """Stub method."""
-        return None
+        return
 
     def update_task(self, *args, **kwargs):
         """Stub method."""

claude_mpm/services/utility_service.py

@@ -30,11 +30,9 @@ class UtilityService(BaseService, UtilityServiceInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def contains_delegation(self, text: str) -> bool:
         """Check if text contains signs of agent delegation.
@@ -112,7 +110,7 @@ class UtilityService(BaseService, UtilityServiceInterface):
             with open(log_file, "a") as f:
                 f.write(json.dumps(log_entry) + "\n")
 
-        except (OSError, IOError) as e:
+        except OSError as e:
             self.logger.debug(f"IO error logging session event: {e}")
         except Exception as e:
             self.logger.debug(f"Failed to log session event: {e}")
@@ -130,10 +128,7 @@ class UtilityService(BaseService, UtilityServiceInterface):
             return False
 
         # Check for minimum length
-        if len(prompt.strip()) < 3:
-            return False
-
-        return True
+        return not len(prompt.strip()) < 3
 
     def sanitize_filename(self, filename: str) -> str:
         """Sanitize a filename by removing invalid characters.
@@ -174,8 +169,7 @@ class UtilityService(BaseService, UtilityServiceInterface):
 
         if context:
             return f"{context}: {error_type}: {error_msg}"
-        else:
-            return f"{error_type}: {error_msg}"
+        return f"{error_type}: {error_msg}"
 
     def truncate_text(
         self, text: str, max_length: int = 100, suffix: str = "..."
@@ -210,7 +204,7 @@ class UtilityService(BaseService, UtilityServiceInterface):
         pattern = r'(\w+)=(["\']?)([^"\'\s]*)\2'
         matches = re.findall(pattern, text)
 
-        for key, quote, value in matches:
+        for key, _quote, value in matches:
             pairs[key] = value
 
         return pairs
@@ -280,6 +274,4 @@ class UtilityService(BaseService, UtilityServiceInterface):
                 return False, "Path cannot be empty"
             return True, None
         except Exception as e:
-            return False, f"Path validation error: {str(e)}"
-
-
+            return False, f"Path validation error: {e!s}"

claude_mpm/services/version_control/__init__.py

@@ -39,29 +39,29 @@ from .semantic_versioning import (
 )
 
 __all__ = [
-    # Git Operations
-    "GitOperationsManager",
-    "GitBranchInfo",
-    "GitOperationResult",
-    "GitOperationError",
-    # Semantic Versioning
-    "SemanticVersionManager",
-    "SemanticVersion",
-    "VersionBumpType",
-    "VersionMetadata",
-    "ChangeAnalysis",
+    "BranchLifecycleRule",
+    "BranchNamingRule",
     # Branch Strategy
     "BranchStrategyManager",
     "BranchStrategyType",
     "BranchType",
     "BranchWorkflow",
-    "BranchNamingRule",
-    "BranchLifecycleRule",
+    "ChangeAnalysis",
+    "ConflictAnalysis",
+    "ConflictResolution",
     # Conflict Resolution
     "ConflictResolutionManager",
     "ConflictType",
-    "ResolutionStrategy",
     "FileConflict",
-    "ConflictResolution",
-    "ConflictAnalysis",
+    "GitBranchInfo",
+    "GitOperationError",
+    "GitOperationResult",
+    # Git Operations
+    "GitOperationsManager",
+    "ResolutionStrategy",
+    "SemanticVersion",
+    # Semantic Versioning
+    "SemanticVersionManager",
+    "VersionBumpType",
+    "VersionMetadata",
 ]

claude_mpm/services/version_control/branch_strategy.py

@@ -358,9 +358,8 @@ class BranchStrategyManager:
             self.current_strategy = self.strategies[strategy_type]
             self.logger.info(f"Set branch strategy to {strategy_type.value}")
             return True
-        else:
-            self.logger.error(f"Unknown strategy type: {strategy_type}")
-            return False
+        self.logger.error(f"Unknown strategy type: {strategy_type}")
+        return False
 
     def generate_branch_name(
         self,
@@ -395,10 +394,9 @@ class BranchStrategyManager:
             prefix = branch_type.value + "/"
             if ticket_id:
                 return f"{prefix}{ticket_id}"
-            elif description:
+            if description:
                 return f"{prefix}{self._sanitize_branch_name(description)}"
-            else:
-                return f"{prefix}{datetime.now().strftime('%Y%m%d')}"
+            return f"{prefix}{datetime.now().strftime('%Y%m%d')}"
 
         # Generate name based on rule
         if strategy.strategy_type == BranchStrategyType.ISSUE_DRIVEN:
@@ -614,8 +612,7 @@ class BranchStrategyManager:
         # Default merge message
         if ticket_title:
             return f"Merge {branch_name}: {ticket_title}"
-        else:
-            return f"Merge {branch_name}"
+        return f"Merge {branch_name}"
 
     def get_quality_gates(self) -> List[str]:
         """Get quality gates for the current strategy."""