claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -7,14 +7,15 @@ WHY this integration module:
 - Provides clean separation of concerns
 """
 
-import logging
+from datetime import datetime, timezone
 from typing import Optional
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.event_bus import EventBus
 from claude_mpm.services.event_bus.config import get_config
 from claude_mpm.services.event_bus.direct_relay import DirectSocketIORelay
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class EventBusIntegration:
@@ -48,17 +49,16 @@ class EventBusIntegration:
         Returns:
             bool: True if setup successful
         """
-        from datetime import datetime
 
         print(
-            f"[{datetime.now().isoformat()}] EventBusIntegration.setup() called",
+            f"[{datetime.now(timezone.utc).isoformat()}] EventBusIntegration.setup() called",
             flush=True,
         )
 
         if not self.enabled:
             logger.info("EventBus integration disabled by configuration")
             print(
-                f"[{datetime.now().isoformat()}] EventBus integration disabled by configuration",
+                f"[{datetime.now(timezone.utc).isoformat()}] EventBus integration disabled by configuration",
                 flush=True,
             )
             return False
@@ -66,12 +66,13 @@ class EventBusIntegration:
         try:
             # Get EventBus instance
             print(
-                f"[{datetime.now().isoformat()}] Getting EventBus instance...",
+                f"[{datetime.now(timezone.utc).isoformat()}] Getting EventBus instance...",
                 flush=True,
             )
             self.event_bus = EventBus.get_instance()
             print(
-                f"[{datetime.now().isoformat()}] EventBus instance obtained", flush=True
+                f"[{datetime.now(timezone.utc).isoformat()}] EventBus instance obtained",
+                flush=True,
             )
 
             # Apply configuration
@@ -79,31 +80,36 @@ class EventBusIntegration:
 
             # Create direct relay that uses server's broadcaster
             print(
-                f"[{datetime.now().isoformat()}] Creating DirectSocketIORelay...",
+                f"[{datetime.now(timezone.utc).isoformat()}] Creating DirectSocketIORelay...",
                 flush=True,
             )
             if self.server:
                 self.relay = DirectSocketIORelay(self.server)
                 print(
-                    f"[{datetime.now().isoformat()}] DirectSocketIORelay created with server instance",
+                    f"[{datetime.now(timezone.utc).isoformat()}] DirectSocketIORelay created with server instance",
                     flush=True,
                 )
             else:
                 logger.warning("No server instance provided, relay won't work")
                 print(
-                    f"[{datetime.now().isoformat()}] WARNING: No server instance for relay",
+                    f"[{datetime.now(timezone.utc).isoformat()}] WARNING: No server instance for relay",
                     flush=True,
                 )
                 return False
 
             # Start the relay
-            print(f"[{datetime.now().isoformat()}] Starting relay...", flush=True)
+            print(
+                f"[{datetime.now(timezone.utc).isoformat()}] Starting relay...",
+                flush=True,
+            )
             self.relay.start()
-            print(f"[{datetime.now().isoformat()}] Relay started", flush=True)
+            print(
+                f"[{datetime.now(timezone.utc).isoformat()}] Relay started", flush=True
+            )
 
             logger.info("EventBus integration setup complete with DirectSocketIORelay")
             print(
-                f"[{datetime.now().isoformat()}] EventBus integration setup complete with DirectSocketIORelay",
+                f"[{datetime.now(timezone.utc).isoformat()}] EventBus integration setup complete with DirectSocketIORelay",
                 flush=True,
             )
             return True
@@ -111,7 +117,7 @@ class EventBusIntegration:
         except Exception as e:
             logger.error(f"Failed to setup EventBus integration: {e}")
             print(
-                f"[{datetime.now().isoformat()}] Failed to setup EventBus integration: {e}",
+                f"[{datetime.now(timezone.utc).isoformat()}] Failed to setup EventBus integration: {e}",
                 flush=True,
             )
             import traceback

claude_mpm/services/socketio/server/main.py

@@ -13,9 +13,11 @@ import asyncio
 import threading
 import time
 from collections import deque
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set
 
+from ....core.enums import ServiceState
+
 try:
     import aiohttp
     import socketio
@@ -107,11 +109,12 @@ class SocketIOServer(SocketIOServiceInterface):
         # Debug logging for EventBus initialization
         self.logger.info("Starting Socket.IO server with EventBus integration...")
         print(
-            f"[{datetime.now().isoformat()}] SocketIOServer.start_sync() called",
+            f"[{datetime.now(timezone.utc).isoformat()}] SocketIOServer.start_sync() called",
             flush=True,
         )
 
-        # Start the core server
+        # CRITICAL: Start the core server first to create sio instance
+        # Event handlers will be registered inside _start_server before accepting connections
         self.core.start_sync()
 
         # Initialize connection manager for robust connection tracking
@@ -163,45 +166,75 @@ class SocketIOServer(SocketIOServiceInterface):
                     self.connection_manager.start_health_monitoring(), self.core.loop
                 )
 
-        # Register events
-        self._register_events()
+        # Register events if not already done in async context
+        if self.core.sio and not self.event_registry:
+            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...",
+            f"[{datetime.now(timezone.utc).isoformat()}] Setting up EventBus integration...",
             flush=True,
         )
-        try:
-            self.eventbus_integration = EventBusIntegration(self)
+
+        # CRITICAL: Ensure broadcaster is fully initialized before setting up EventBus
+        # The relay needs the broadcaster to be ready to relay events
+        if not self.broadcaster:
+            self.logger.error(
+                "Broadcaster not initialized - cannot setup EventBus integration"
+            )
+            print(
+                f"[{datetime.now(timezone.utc).isoformat()}] ERROR: Broadcaster not initialized",
+                flush=True,
+            )
+        else:
             print(
-                f"[{datetime.now().isoformat()}] EventBusIntegration instance created",
+                f"[{datetime.now(timezone.utc).isoformat()}] Broadcaster ready, proceeding with EventBus setup",
                 flush=True,
             )
 
-            if self.eventbus_integration.setup(self.port):
-                self.logger.info("EventBus integration setup successful")
+            try:
+                self.eventbus_integration = EventBusIntegration(self)
                 print(
-                    f"[{datetime.now().isoformat()}] EventBus integration setup successful",
+                    f"[{datetime.now(timezone.utc).isoformat()}] EventBusIntegration instance created",
                     flush=True,
                 )
-            else:
-                self.logger.warning("EventBus integration setup failed or disabled")
+
+                if self.eventbus_integration.setup(self.port):
+                    self.logger.info("EventBus integration setup successful")
+                    print(
+                        f"[{datetime.now(timezone.utc).isoformat()}] EventBus integration setup successful",
+                        flush=True,
+                    )
+
+                    # Verify relay is connected and has broadcaster
+                    if (
+                        hasattr(self.eventbus_integration, "relay")
+                        and self.eventbus_integration.relay
+                    ):
+                        relay_stats = self.eventbus_integration.relay.get_stats()
+                        self.logger.info(f"EventBus relay stats: {relay_stats}")
+                        print(
+                            f"[{datetime.now(timezone.utc).isoformat()}] EventBus relay stats: {relay_stats}",
+                            flush=True,
+                        )
+                else:
+                    self.logger.warning("EventBus integration setup failed or disabled")
+                    print(
+                        f"[{datetime.now(timezone.utc).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()}] EventBus integration setup failed or disabled",
+                    f"[{datetime.now(timezone.utc).isoformat()}] Failed to setup EventBus integration: {e}",
                     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
+                import traceback
 
-            traceback.print_exc()
-            self.eventbus_integration = None
+                traceback.print_exc()
+                self.eventbus_integration = None
 
         # Update running state
         self.running = self.core.running
@@ -234,10 +267,16 @@ class SocketIOServer(SocketIOServiceInterface):
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
 
-        # Stop health monitoring in connection handler
+        # Stop event handlers
         if self.event_registry:
             from ..handlers import ConnectionEventHandler
 
+            # DISABLED: File Tree interface removed from dashboard
+            # Stop analysis runner (code analysis handler is disabled)
+            # 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()
@@ -252,6 +291,12 @@ class SocketIOServer(SocketIOServiceInterface):
         handlers in a modular way. Each handler focuses on a specific domain,
         reducing complexity and improving maintainability.
         """
+        if not self.core.sio:
+            self.logger.error(
+                "Cannot register events - Socket.IO server not initialized"
+            )
+            return
+
         # Initialize the event handler registry
         self.event_registry = EventHandlerRegistry(self)
         self.event_registry.initialize()
@@ -265,6 +310,31 @@ class SocketIOServer(SocketIOServiceInterface):
 
         self.logger.info("All Socket.IO events registered via handler system")
 
+    async def _register_events_async(self):
+        """Async version of event registration for calling from async context.
+
+        WHY: This allows us to register events from within the async _start_server
+        method before the server starts accepting connections.
+        """
+        if not self.core.sio:
+            self.logger.error(
+                "Cannot register events - Socket.IO server not initialized"
+            )
+            return
+
+        # Initialize the event handler registry
+        self.event_registry = EventHandlerRegistry(self)
+        self.event_registry.initialize()
+
+        # Register all events from all handlers
+        self.event_registry.register_all_events()
+
+        # Keep handler instances for HTTP endpoint compatibility
+        self.file_handler = self.event_registry.get_handler(FileEventHandler)
+        self.git_handler = self.event_registry.get_handler(GitEventHandler)
+
+        self.logger.info("All Socket.IO events registered via handler system (async)")
+
     # Delegate broadcasting methods to the broadcaster
     def broadcast_event(self, event_type: str, data: Dict[str, Any]):
         """Broadcast an event to all connected clients."""
@@ -314,9 +384,9 @@ class SocketIOServer(SocketIOServiceInterface):
         # Track active session for heartbeat
         self.active_sessions[session_id] = {
             "session_id": session_id,
-            "start_time": datetime.now().isoformat(),
+            "start_time": datetime.now(timezone.utc).isoformat(),
             "agent": "pm",  # Default to PM, will be updated if delegated
-            "status": "active",
+            "status": ServiceState.RUNNING,
             "launch_method": launch_method,
             "working_dir": working_dir,
         }
@@ -404,7 +474,7 @@ class SocketIOServer(SocketIOServiceInterface):
         WHY: Provides session information for system heartbeat events.
         """
         # Clean up old sessions (older than 1 hour)
-        cutoff_time = datetime.now().timestamp() - 3600
+        cutoff_time = datetime.now(timezone.utc).timestamp() - 3600
         sessions_to_remove = []
 
         for session_id, session_data in self.active_sessions.items():
@@ -412,7 +482,7 @@ class SocketIOServer(SocketIOServiceInterface):
                 start_time = datetime.fromisoformat(session_data["start_time"])
                 if start_time.timestamp() < cutoff_time:
                     sessions_to_remove.append(session_id)
-            except:
+            except Exception:
                 pass
 
         for session_id in sessions_to_remove:

claude_mpm/services/socketio_client_manager.py

@@ -18,7 +18,7 @@ import importlib.metadata
 import socket
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
 from claude_mpm.core.constants import NetworkConfig, PerformanceConfig, TimeoutConfig
@@ -59,7 +59,7 @@ class ServerInfo:
             "supported_client_versions", []
         )
         self.compatibility_matrix = response_data.get("compatibility_matrix", {})
-        self.detected_at = datetime.utcnow()
+        self.detected_at = datetime.now(timezone.utc)
 
     @property
     def url(self) -> str:
@@ -161,7 +161,7 @@ class SocketIOClientManager:
                     self.logger.debug(f"Error checking {host}:{port}: {e}")
                     continue
 
-        self.last_discovery = datetime.utcnow()
+        self.last_discovery = datetime.now(timezone.utc)
         return discovered
 
     def find_best_server(
@@ -323,7 +323,7 @@ class SocketIOClientManager:
         try:
             event_data = {
                 "type": event_type,
-                "timestamp": datetime.utcnow().isoformat() + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat() + "Z",
                 "data": data,
                 "client_version": self.client_version,
             }

claude_mpm/services/subprocess_launcher_service.py

@@ -22,6 +22,7 @@ import tty
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.services.core.interfaces import SubprocessLauncherInterface
 
 
@@ -62,9 +63,17 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
         try:
             env = kwargs.get("env", self.prepare_subprocess_environment())
             self.launch_subprocess_interactive(command, env)
-            return {"status": "launched", "command": command, "method": "interactive"}
+            return {
+                "status": OperationResult.SUCCESS,
+                "command": command,
+                "method": "interactive",
+            }
         except Exception as e:
-            return {"status": "failed", "error": str(e), "command": command}
+            return {
+                "status": OperationResult.FAILED,
+                "error": str(e),
+                "command": command,
+            }
 
     async def launch_subprocess_async(
         self, command: List[str], **kwargs
@@ -109,7 +118,7 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
         # For now, return unknown status
         return {
             "process_id": process_id,
-            "status": "unknown",
+            "status": OperationResult.UNKNOWN,
             "message": "Process tracking not implemented",
         }
 
@@ -160,7 +169,7 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
             # Notify WebSocket clients
             if self.websocket_server:
                 self.websocket_server.claude_status_changed(
-                    status="running",
+                    status=ServiceState.RUNNING,
                     pid=process.pid,
                     message="Claude subprocess started",
                 )
@@ -195,7 +204,7 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
             # Notify WebSocket clients
             if self.websocket_server:
                 self.websocket_server.claude_status_changed(
-                    status="stopped",
+                    status=ServiceState.STOPPED,
                     message=f"Claude subprocess exited with code {process.returncode}",
                 )
 
@@ -268,16 +277,11 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
         Returns:
             True if subprocess mode with PTY is available
         """
-        try:
-            # Check if we can import required modules
-            import pty
-            import select
-            import termios
-            import tty
-
-            return True
-        except ImportError:
-            return False
+        import importlib.util
+
+        # Check if we can import required modules
+        required = ["pty", "select", "termios", "tty"]
+        return all(importlib.util.find_spec(mod) is not None for mod in required)
 
     def create_subprocess_command(
         self, base_cmd: List[str], additional_args: Optional[List[str]] = None

claude_mpm/services/system_instructions_service.py

@@ -10,7 +10,7 @@ Extracted from ClaudeRunner to follow Single Responsibility Principle.
 """
 
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import List, Optional, Tuple
 
 from claude_mpm.config.paths import paths
@@ -126,7 +126,7 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
 
             # Replace current date
             if "{{CURRENT_DATE}}" in base_pm_content:
-                current_date = datetime.now().strftime("%Y-%m-%d")
+                current_date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
                 base_pm_content = base_pm_content.replace(
                     "{{CURRENT_DATE}}", current_date
                 )

claude_mpm/services/ticket_services/formatter_service.py

@@ -278,7 +278,7 @@ class TicketFormatterService:
         Returns:
             Formatted info message
         """
-        return f"ℹ️ {info}"
+        return f"[INFO]️ {info}"
 
     def format_warning(self, warning: str) -> str:
         """

claude_mpm/services/ticket_services/validation_service.py

@@ -11,17 +11,17 @@ DESIGN DECISIONS:
 - Provides sanitization for user inputs
 """
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
 
 
 class TicketValidationService:
     """Service for validating ticket inputs."""
 
     # Valid ticket types
-    VALID_TYPES = ["task", "issue", "epic", "bug", "feature", "story"]
+    VALID_TYPES: ClassVar[list] = ["task", "issue", "epic", "bug", "feature", "story"]
 
     # Valid ticket statuses
-    VALID_STATUSES = [
+    VALID_STATUSES: ClassVar[list] = [
         "open",
         "in_progress",
         "ready",
@@ -34,10 +34,10 @@ class TicketValidationService:
     ]
 
     # Valid priorities
-    VALID_PRIORITIES = ["low", "medium", "high", "critical"]
+    VALID_PRIORITIES: ClassVar[list] = ["low", "medium", "high", "critical"]
 
     # Valid workflow states
-    VALID_WORKFLOW_STATES = [
+    VALID_WORKFLOW_STATES: ClassVar[list] = [
         "todo",
         "in_progress",
         "ready",

claude_mpm/services/unified/__init__.py

@@ -0,0 +1,65 @@
+"""
+Unified Services Module for Phase 2 Service Consolidation
+=========================================================
+
+This module implements the strategy pattern framework for consolidating
+Claude MPM's 314 service files into approximately 180 more maintainable services.
+
+Architecture:
+- Base service interfaces for common service patterns
+- Strategy pattern for pluggable behavior
+- Backward compatibility layer for existing services
+- Feature flags for gradual migration
+
+Components:
+- interfaces.py: Core service interfaces (IDeploymentService, IAnalyzerService, etc.)
+- strategies.py: Strategy pattern framework with plugin registry
+- migration.py: Migration utilities and backward compatibility
+- Unified service implementations for major service categories
+"""
+
+from .interfaces import (
+    IAnalyzerService,
+    IConfigurationService,
+    IDeploymentService,
+    ServiceCapability,
+    ServiceMetadata,
+)
+from .migration import (
+    FeatureFlag,
+    MigrationStatus,
+    ServiceMapper,
+    create_compatibility_wrapper,
+)
+from .strategies import (
+    AnalyzerStrategy,
+    ConfigStrategy,
+    DeploymentStrategy,
+    StrategyRegistry,
+)
+from .unified_analyzer import UnifiedAnalyzer
+from .unified_config import UnifiedConfigManager
+from .unified_deployment import UnifiedDeploymentService
+
+__all__ = [
+    "AnalyzerStrategy",
+    "ConfigStrategy",
+    # Strategies
+    "DeploymentStrategy",
+    "FeatureFlag",
+    "IAnalyzerService",
+    "IConfigurationService",
+    # Interfaces
+    "IDeploymentService",
+    "MigrationStatus",
+    "ServiceCapability",
+    # Migration
+    "ServiceMapper",
+    "ServiceMetadata",
+    "StrategyRegistry",
+    "UnifiedAnalyzer",
+    "UnifiedConfigManager",
+    # Unified Services
+    "UnifiedDeploymentService",
+    "create_compatibility_wrapper",
+]

claude_mpm/services/unified/analyzer_strategies/__init__.py

@@ -0,0 +1,44 @@
+"""
+Concrete Analyzer Strategy Implementations
+==========================================
+
+This module provides concrete implementations of the AnalyzerStrategy base class,
+consolidating functionality from multiple analyzer services with 70-80% code duplication.
+
+Consolidates:
+- enhanced_analyzer.py (1,118 LOC)
+- project_analyzer.py (815 LOC)
+- structure_analyzer.py (703 LOC)
+- code_analyzer.py (385 LOC)
+- dependency_analyzer.py (326 LOC)
+- file_analyzer.py (247 LOC)
+- project_report_generator.py (121 LOC)
+
+Total: 3,715 LOC → ~1,200 LOC (68% reduction)
+
+Author: Claude MPM Development Team
+Created: 2025-01-26
+"""
+
+from .code_analyzer import CodeAnalyzerStrategy
+from .dependency_analyzer import DependencyAnalyzerStrategy
+from .performance_analyzer import PerformanceAnalyzerStrategy
+from .security_analyzer import SecurityAnalyzerStrategy
+from .structure_analyzer import StructureAnalyzerStrategy
+
+__all__ = [
+    "CodeAnalyzerStrategy",
+    "DependencyAnalyzerStrategy",
+    "PerformanceAnalyzerStrategy",
+    "SecurityAnalyzerStrategy",
+    "StructureAnalyzerStrategy",
+]
+
+# Strategy registry for automatic discovery
+ANALYZER_STRATEGIES = {
+    "code": CodeAnalyzerStrategy,
+    "dependency": DependencyAnalyzerStrategy,
+    "structure": StructureAnalyzerStrategy,
+    "security": SecurityAnalyzerStrategy,
+    "performance": PerformanceAnalyzerStrategy,
+}