claude-mpm 3.7.4__py3-none-any.whl → 3.8.1__py3-none-any.whl

claude_mpm/services/project_analyzer.py

@@ -32,6 +32,7 @@ from collections import defaultdict, Counter
 
 from claude_mpm.core.config import Config
 from claude_mpm.utils.paths import PathResolver
+from claude_mpm.core.interfaces import ProjectAnalyzerInterface
 
 
 @dataclass
@@ -76,7 +77,7 @@ class ProjectCharacteristics:
         return asdict(self)
 
 
-class ProjectAnalyzer:
+class ProjectAnalyzer(ProjectAnalyzerInterface):
     """Analyzes project characteristics for context-aware memory creation.
     
     WHY: Generic agent memories aren't helpful for specific projects. This analyzer
@@ -768,4 +769,96 @@ class ProjectAnalyzer:
                 important_files.append(pattern)
         
         # Remove duplicates and return
-        return list(set(important_files))
+        return list(set(important_files))
+    
+    # ================================================================================
+    # Interface Adapter Methods
+    # ================================================================================
+    # These methods adapt the existing implementation to comply with ProjectAnalyzerInterface
+    
+    def detect_technology_stack(self) -> List[str]:
+        """Detect technologies used in the project.
+        
+        WHY: This adapter method provides interface compliance by extracting
+        technology information from the analyzed project characteristics.
+        
+        Returns:
+            List of detected technologies
+        """
+        characteristics = self.analyze_project()
+        
+        technologies = []
+        technologies.extend(characteristics.languages)
+        technologies.extend(characteristics.frameworks)
+        technologies.extend(characteristics.web_frameworks)
+        technologies.extend(characteristics.databases)
+        
+        # Add package manager as technology
+        if characteristics.package_manager:
+            technologies.append(characteristics.package_manager)
+        
+        # Add build tools
+        technologies.extend(characteristics.build_tools)
+        
+        # Remove duplicates
+        return list(set(technologies))
+    
+    def analyze_code_patterns(self) -> Dict[str, Any]:
+        """Analyze code patterns and conventions.
+        
+        WHY: This adapter method provides interface compliance by extracting
+        pattern information from the project characteristics.
+        
+        Returns:
+            Dictionary of pattern analysis results
+        """
+        characteristics = self.analyze_project()
+        
+        return {
+            "code_conventions": characteristics.code_conventions,
+            "test_patterns": characteristics.test_patterns,
+            "api_patterns": characteristics.api_patterns,
+            "configuration_patterns": characteristics.configuration_patterns,
+            "architecture_type": characteristics.architecture_type
+        }
+    
+    def get_project_structure(self) -> Dict[str, Any]:
+        """Get project directory structure analysis.
+        
+        WHY: This adapter method provides interface compliance by organizing
+        structural information from the project characteristics.
+        
+        Returns:
+            Dictionary representing project structure
+        """
+        characteristics = self.analyze_project()
+        
+        return {
+            "project_name": characteristics.project_name,
+            "main_modules": characteristics.main_modules,
+            "key_directories": characteristics.key_directories,
+            "entry_points": characteristics.entry_points,
+            "documentation_files": characteristics.documentation_files,
+            "important_configs": characteristics.important_configs,
+            "architecture_type": characteristics.architecture_type
+        }
+    
+    def identify_entry_points(self) -> List[Path]:
+        """Identify project entry points.
+        
+        WHY: This adapter method provides interface compliance by converting
+        string entry points to Path objects as expected by the interface.
+        
+        Returns:
+            List of entry point paths
+        """
+        characteristics = self.analyze_project()
+        
+        # Convert string paths to Path objects
+        entry_paths = []
+        for entry_point in characteristics.entry_points:
+            entry_path = self.working_directory / entry_point
+            if entry_path.exists():
+                entry_paths.append(entry_path)
+        
+        return entry_paths

claude_mpm/services/recovery_manager.py

@@ -28,6 +28,11 @@ from datetime import datetime, timezone
 from enum import Enum
 from typing import Any, Dict, List, Optional, Callable, Union
 import json
+from claude_mpm.core.constants import (
+    RetryConfig,
+    TimeoutConfig,
+    PerformanceConfig
+)
 
 from .health_monitor import HealthStatus, HealthCheckResult
 
@@ -112,9 +117,9 @@ class GradedRecoveryStrategy(RecoveryStrategy):
         
         # Configuration with defaults
         self.warning_threshold = self.config.get('warning_threshold', 2)
-        self.critical_threshold = self.config.get('critical_threshold', 1)
-        self.failure_window_seconds = self.config.get('failure_window_seconds', 300)
-        self.min_recovery_interval = self.config.get('min_recovery_interval', 60)
+        self.critical_threshold = self.config.get('critical_threshold', RetryConfig.CRITICAL_THRESHOLD)
+        self.failure_window_seconds = self.config.get('failure_window_seconds', RetryConfig.FAILURE_WINDOW)
+        self.min_recovery_interval = self.config.get('min_recovery_interval', RetryConfig.MIN_RECOVERY_INTERVAL)
         
         # Track recent failures
         self.recent_failures: deque = deque(maxlen=10)
@@ -193,8 +198,9 @@ class CircuitBreaker:
     - Gradually re-enable recovery after failures
     """
     
-    def __init__(self, failure_threshold: int = 5, timeout_seconds: int = 300, 
-                 success_threshold: int = 3):
+    def __init__(self, failure_threshold: int = RetryConfig.FAILURE_THRESHOLD, 
+                 timeout_seconds: int = RetryConfig.CIRCUIT_TIMEOUT, 
+                 success_threshold: int = RetryConfig.SUCCESS_THRESHOLD):
         """Initialize circuit breaker.
         
         Args:
@@ -338,9 +344,9 @@ class RecoveryManager:
         # Initialize circuit breaker
         circuit_config = self.config.get('circuit_breaker', {})
         self.circuit_breaker = CircuitBreaker(
-            failure_threshold=circuit_config.get('failure_threshold', 5),
-            timeout_seconds=circuit_config.get('timeout_seconds', 300),
-            success_threshold=circuit_config.get('success_threshold', 3)
+            failure_threshold=circuit_config.get('failure_threshold', RetryConfig.FAILURE_THRESHOLD),
+            timeout_seconds=circuit_config.get('timeout_seconds', RetryConfig.CIRCUIT_TIMEOUT),
+            success_threshold=circuit_config.get('success_threshold', RetryConfig.SUCCESS_THRESHOLD)
         )
         
         # Initialize recovery strategy
@@ -451,7 +457,7 @@ class RecoveryManager:
         
         finally:
             self.recovery_in_progress = False
-            duration_ms = (time.time() - start_time) * 1000
+            duration_ms = (time.time() - start_time) * PerformanceConfig.SECONDS_TO_MS
             
             # Create recovery event
             event = RecoveryEvent(

claude_mpm/services/socketio/__init__.py

@@ -0,0 +1,25 @@
+"""Socket.IO service module.
+
+WHY: This module provides the modular Socket.IO server implementation
+with separated event handlers for improved maintainability.
+"""
+
+from .handlers import (
+    BaseEventHandler,
+    ConnectionEventHandler,
+    ProjectEventHandler,
+    MemoryEventHandler,
+    FileEventHandler,
+    GitEventHandler,
+    EventHandlerRegistry,
+)
+
+__all__ = [
+    "BaseEventHandler",
+    "ConnectionEventHandler",
+    "ProjectEventHandler",
+    "MemoryEventHandler",
+    "FileEventHandler",
+    "GitEventHandler",
+    "EventHandlerRegistry",
+]

claude_mpm/services/socketio/handlers/__init__.py

@@ -0,0 +1,25 @@
+"""Socket.IO event handlers module.
+
+WHY: This module provides a modular, maintainable structure for Socket.IO event handling,
+replacing the monolithic _register_events() method with focused handler classes.
+Each handler class manages a specific domain of functionality, improving testability
+and maintainability.
+"""
+
+from .base import BaseEventHandler
+from .connection import ConnectionEventHandler
+from .project import ProjectEventHandler
+from .memory import MemoryEventHandler
+from .file import FileEventHandler
+from .git import GitEventHandler
+from .registry import EventHandlerRegistry
+
+__all__ = [
+    "BaseEventHandler",
+    "ConnectionEventHandler",
+    "ProjectEventHandler",
+    "MemoryEventHandler",
+    "FileEventHandler",
+    "GitEventHandler",
+    "EventHandlerRegistry",
+]

claude_mpm/services/socketio/handlers/base.py

@@ -0,0 +1,121 @@
+"""Base event handler class for Socket.IO events.
+
+WHY: This provides common functionality for all event handlers, including
+logging, error handling, and access to the server instance. All handler
+classes inherit from this to ensure consistent behavior.
+"""
+
+import logging
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
+from datetime import datetime
+from logging import Logger
+
+from ....core.logger import get_logger
+from ....core.typing_utils import EventName, EventData, SocketId
+
+if TYPE_CHECKING:
+    from ..server import SocketIOServer
+    import socketio
+
+
+class BaseEventHandler:
+    """Base class for Socket.IO event handlers.
+    
+    WHY: Provides common functionality and structure for all event handlers,
+    ensuring consistent error handling, logging, and server access patterns.
+    Each handler focuses on a specific domain while sharing common infrastructure.
+    """
+    
+    def __init__(self, server: 'SocketIOServer') -> None:
+        """Initialize the base handler.
+        
+        Args:
+            server: The SocketIOServer instance that owns this handler
+        """
+        self.server: 'SocketIOServer' = server
+        self.sio: 'socketio.AsyncServer' = server.sio
+        self.logger: Logger = get_logger(self.__class__.__name__)
+        self.clients: Dict[SocketId, Dict[str, Any]] = server.clients
+        self.event_history: List[Dict[str, Any]] = server.event_history
+    
+    def register_events(self) -> None:
+        """Register all events handled by this handler.
+        
+        WHY: This method must be implemented by each handler subclass
+        to register its specific events with the Socket.IO server.
+        """
+        raise NotImplementedError("Subclasses must implement register_events()")
+    
+    async def emit_to_client(self, sid: SocketId, event: EventName, data: EventData) -> None:
+        """Emit an event to a specific client.
+        
+        WHY: Centralizes client communication with consistent error handling
+        and logging for debugging connection issues.
+        
+        Args:
+            sid: Socket.IO session ID of the client
+            event: Event name to emit
+            data: Data to send with the event
+        """
+        try:
+            await self.sio.emit(event, data, room=sid)
+            self.logger.debug(f"Sent {event} to client {sid}")
+        except Exception as e:
+            self.logger.error(f"Failed to emit {event} to client {sid}: {e}")
+            import traceback
+            self.logger.error(f"Stack trace: {traceback.format_exc()}")
+    
+    async def broadcast_event(self, event: EventName, data: EventData, skip_sid: Optional[SocketId] = None) -> None:
+        """Broadcast an event to all connected clients.
+        
+        WHY: Provides consistent broadcasting with optional exclusion
+        of the originating client.
+        
+        Args:
+            event: Event name to broadcast
+            data: Data to send with the event
+            skip_sid: Optional session ID to skip
+        """
+        try:
+            if skip_sid:
+                await self.sio.emit(event, data, skip_sid=skip_sid)
+            else:
+                await self.sio.emit(event, data)
+            self.logger.debug(f"Broadcasted {event} to all clients")
+        except Exception as e:
+            self.logger.error(f"Failed to broadcast {event}: {e}")
+    
+    def add_to_history(self, event_type: str, data: EventData) -> None:
+        """Add an event to the server's event history.
+        
+        WHY: Maintains a history of events for new clients to receive
+        when they connect, ensuring they have context.
+        
+        Args:
+            event_type: Type of the event
+            data: Event data
+        """
+        event = {
+            "type": event_type,
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "data": data
+        }
+        self.event_history.append(event)
+        self.logger.debug(f"Added {event_type} to history (total: {len(self.event_history)})")
+    
+    def log_error(self, operation: str, error: Exception, context: Optional[Dict[str, Any]] = None) -> None:
+        """Log an error with context.
+        
+        WHY: Provides consistent error logging with context information
+        for debugging issues in production.
+        
+        Args:
+            operation: Description of the operation that failed
+            error: The exception that occurred
+            context: Optional context information
+        """
+        self.logger.error(f"Error in {operation}: {error}")
+        if context:
+            self.logger.error(f"Context: {context}")
+        import traceback
+        self.logger.error(f"Stack trace: {traceback.format_exc()}")

claude_mpm/services/socketio/handlers/connection.py

@@ -0,0 +1,198 @@
+"""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 Optional, List, Dict, Any, Set
+
+from .base import BaseEventHandler
+from ....core.typing_utils import SocketId, EventData, ClaudeStatus
+
+
+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
+            })