claude-mpm 4.1.7__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/services/cli/dashboard_launcher.py

@@ -134,9 +134,8 @@ class DashboardLauncher(IDashboardLauncher):
         """
         try:
             # Verify dependencies for Socket.IO dashboard
-            if monitor_mode:
-                if not self._verify_socketio_dependencies():
-                    return False, False
+            if monitor_mode and not self._verify_socketio_dependencies():
+                return False, False
 
             self.logger.info(
                 f"Launching dashboard (port: {port}, monitor: {monitor_mode})"

claude_mpm/services/cli/startup_checker.py

@@ -176,17 +176,7 @@ class StartupCheckerService(IStartupChecker):
 
         try:
             # Check Python version
-            import sys
 
-            if sys.version_info < (3, 8):
-                warnings.append(
-                    StartupWarning(
-                        category="environment",
-                        message=f"Python {sys.version_info.major}.{sys.version_info.minor} detected",
-                        suggestion="Python 3.8+ is recommended for optimal performance",
-                        severity="info",
-                    )
-                )
 
             # Check for common missing directories
             warnings.extend(self._check_required_directories())

claude_mpm/services/core/cache_manager.py

@@ -253,7 +253,7 @@ class CacheManager(ICacheManager):
         with self._lock:
             current_time = time.time()
 
-            stats = {
+            return {
                 "capabilities": {
                     "cached": self._capabilities_cache is not None,
                     "age": (
@@ -308,4 +308,3 @@ class CacheManager(ICacheManager):
                 "fs_cache": self._fs_cache.get_stats() if self._fs_cache else {},
             }
 
-            return stats

claude_mpm/services/core/path_resolver.py

@@ -91,10 +91,7 @@ class PathResolver(IPathResolver):
             resolved = path.resolve()
 
             # Check if path exists if required
-            if must_exist and not resolved.exists():
-                return False
-
-            return True
+            return not (must_exist and not resolved.exists())
         except (OSError, ValueError):
             return False
 

claude_mpm/services/core/service_container.py

@@ -244,7 +244,7 @@ class ServiceContainer:
 
         # Check for circular dependencies
         if service_type in self._resolution_stack.stack:
-            raise CircularDependencyError(self._resolution_stack.stack + [service_type])
+            raise CircularDependencyError([*self._resolution_stack.stack, service_type])
 
         try:
             # Add to resolution stack
@@ -287,7 +287,7 @@ class ServiceContainer:
         results = []
 
         with self._lock:
-            for registered_type, descriptor in self._services.items():
+            for registered_type, _descriptor in self._services.items():
                 # Check if registered type is subclass of requested type
                 if self._is_assignable(registered_type, service_type):
                     try:

claude_mpm/services/diagnostics/checks/instructions_check.py

@@ -197,7 +197,6 @@ class InstructionsCheck(BaseDiagnosticCheck):
             )
 
         # Calculate content hashes
-        content_hashes = {}
         content_snippets = defaultdict(list)
 
         for path in files:
@@ -265,7 +264,7 @@ class InstructionsCheck(BaseDiagnosticCheck):
         for description, occurrences in pattern_occurrences.items():
             if len(occurrences) > 1:
                 files_info = []
-                for path, count, snippet in occurrences:
+                for path, count, _snippet in occurrences:
                     rel_path = (
                         path.relative_to(Path.cwd())
                         if Path.cwd() in path.parents or path.parent == Path.cwd()
@@ -374,9 +373,7 @@ class InstructionsCheck(BaseDiagnosticCheck):
                 continue
 
         # Check for Claude Code specific content in INSTRUCTIONS.md
-        instructions_files = [
-            path for path in files if path.name == "INSTRUCTIONS.md"
-        ]
+        instructions_files = [path for path in files if path.name == "INSTRUCTIONS.md"]
         for path in instructions_files:
             try:
                 content = path.read_text(encoding="utf-8")

claude_mpm/services/event_bus/direct_relay.py

@@ -2,6 +2,16 @@
 
 This module provides a relay that connects EventBus directly to the
 Socket.IO server's broadcaster, avoiding the client loopback issue.
+
+IMPORTANT - Claude Event Format:
+Claude sends hook events with these REQUIRED fields:
+- hook_event_name: The event type (UserPromptSubmit, PreToolUse, PostToolUse, etc.)
+- hook_event_type: Usually same as hook_event_name
+- hook_input_data: Contains the actual event data
+- sessionId: Session identifier
+- timestamp: ISO format timestamp
+
+DO NOT use "event" or "type" fields - use "hook_event_name" instead!
 """
 
 import logging
@@ -37,9 +47,12 @@ class DirectSocketIORelay:
             "last_relay_time": None,
         }
         self.debug = logger.isEnabledFor(logging.DEBUG)
+        self.connection_retries = 0
+        self.max_retries = 10
+        self.retry_delay = 1.0  # Start with 1 second
 
     def start(self) -> None:
-        """Start the relay by subscribing to EventBus events."""
+        """Start the relay by subscribing to EventBus events with retry logic."""
         if not self.enabled:
             logger.warning("DirectSocketIORelay is disabled")
             return
@@ -60,12 +73,9 @@ class DirectSocketIORelay:
         # Add debug logging for verification
         logger.info("[DirectRelay] Subscribed to hook.* events on EventBus")
 
-        # Check and log broadcaster availability
-        broadcaster_available = (
-            self.server
-            and hasattr(self.server, "broadcaster")
-            and self.server.broadcaster is not None
-        )
+        # Check and log broadcaster availability with retry logic
+        broadcaster_available = self._check_broadcaster_with_retry()
+
         logger.info(
             f"[DirectRelay] Server broadcaster available: {broadcaster_available}"
         )
@@ -80,14 +90,49 @@ class DirectSocketIORelay:
                 )
             else:
                 logger.warning(
-                    "[DirectRelay] Server broadcaster is None - events will not be relayed!"
+                    "[DirectRelay] Server broadcaster is None after retries - events will not be relayed!"
                 )
 
         logger.info(f"[DirectRelay] EventBus instance: {self.event_bus is not None}")
 
         # Mark as connected after successful subscription
-        self.connected = True
-        logger.info("[DirectRelay] Started and subscribed to hook events")
+        self.connected = broadcaster_available
+        logger.info(f"[DirectRelay] Started with connection status: {self.connected}")
+
+    def _check_broadcaster_with_retry(self) -> bool:
+        """Check broadcaster availability with exponential backoff retry.
+
+        Returns:
+            True if broadcaster is available, False after max retries
+        """
+        import time
+
+        retry_delay = self.retry_delay
+
+        for attempt in range(self.max_retries):
+            broadcaster_available = (
+                self.server
+                and hasattr(self.server, "broadcaster")
+                and self.server.broadcaster is not None
+            )
+
+            if broadcaster_available:
+                self.connection_retries = 0  # Reset counter on success
+                return True
+
+            if attempt < self.max_retries - 1:
+                logger.info(
+                    f"[DirectRelay] Broadcaster not ready, retry {attempt + 1}/{self.max_retries} "
+                    f"in {retry_delay:.1f}s"
+                )
+                time.sleep(retry_delay)
+                retry_delay = min(retry_delay * 2, 30.0)  # Exponential backoff, max 30s
+            else:
+                logger.error(
+                    f"[DirectRelay] Broadcaster not available after {self.max_retries} attempts"
+                )
+
+        return False
 
     def _handle_hook_event(self, event_type: str, data: Any):
         """Internal method to handle hook events and broadcast them.
@@ -173,15 +218,48 @@ class DirectSocketIORelay:
 
                     # Use the full event_type (e.g., "hook.pre_tool") as the event name
                     # The normalizer handles dotted names and will extract type and subtype correctly
-                    self.server.broadcaster.broadcast_event(event_type, broadcast_data)
-
-                    self.stats["events_relayed"] += 1
-                    self.stats["last_relay_time"] = datetime.now().isoformat()
-
-                    if self.debug:
-                        logger.debug(
-                            f"[DirectRelay] Broadcasted hook event: {event_type}"
+                    try:
+                        self.server.broadcaster.broadcast_event(
+                            event_type, broadcast_data
+                        )
+                        self.stats["events_relayed"] += 1
+                        self.stats["last_relay_time"] = datetime.now().isoformat()
+
+                        # Reset retry counter on successful broadcast
+                        if self.connection_retries > 0:
+                            self.connection_retries = 0
+                            self.connected = True
+                            logger.info("[DirectRelay] Connection restored")
+
+                        if self.debug:
+                            logger.debug(
+                                f"[DirectRelay] Broadcasted hook event: {event_type}"
+                            )
+                    except Exception as broadcast_error:
+                        logger.error(
+                            f"[DirectRelay] Broadcast failed for {event_type}: {broadcast_error}"
                         )
+                        self.stats["events_failed"] += 1
+
+                        # Try to reconnect if broadcast fails
+                        if self.connection_retries < self.max_retries:
+                            self.connection_retries += 1
+                            self.connected = self._check_broadcaster_with_retry()
+                            if self.connected:
+                                # Retry the broadcast
+                                try:
+                                    self.server.broadcaster.broadcast_event(
+                                        event_type, broadcast_data
+                                    )
+                                    self.stats["events_relayed"] += 1
+                                    self.stats[
+                                        "events_failed"
+                                    ] -= 1  # Undo the failure count
+                                    logger.info(
+                                        f"[DirectRelay] Retry successful for {event_type}"
+                                    )
+                                except:
+                                    pass  # Already counted as failed
                 else:
                     # Enhanced logging when broadcaster is not available
                     logger.warning(
@@ -189,7 +267,7 @@ class DirectSocketIORelay:
                     )
                     if self.server:
                         logger.warning(
-                            f"[DirectRelay] Server exists but broadcaster is None"
+                            "[DirectRelay] Server exists but broadcaster is None"
                         )
                         logger.warning(
                             f"[DirectRelay] Server type: {type(self.server).__name__}"
@@ -202,7 +280,7 @@ class DirectSocketIORelay:
                                 f"[DirectRelay] Broadcaster value: {self.server.broadcaster}"
                             )
                     else:
-                        logger.warning(f"[DirectRelay] Server is None")
+                        logger.warning("[DirectRelay] Server is None")
                     self.stats["events_failed"] += 1
 
         except Exception as e:

claude_mpm/services/infrastructure/monitoring/__init__.py

@@ -24,20 +24,20 @@ from .resources import ResourceMonitorService
 from .service import ServiceHealthService
 
 __all__ = [
-    # New service-based API
-    "ResourceMonitorService",
-    "ProcessHealthService",
-    "ServiceHealthService",
-    "NetworkHealthService",
-    "MonitoringAggregatorService",
-    # Base components
-    "HealthStatus",
-    "HealthMetric",
+    "AdvancedHealthMonitor",
     "HealthCheckResult",
     "HealthChecker",
+    "HealthMetric",
+    # Base components
+    "HealthStatus",
+    "MonitoringAggregatorService",
+    "NetworkConnectivityChecker",
+    "NetworkHealthService",
+    "ProcessHealthService",
     # Legacy compatibility
     "ProcessResourceChecker",
-    "NetworkConnectivityChecker",
+    # New service-based API
+    "ResourceMonitorService",
     "ServiceHealthChecker",
-    "AdvancedHealthMonitor",
+    "ServiceHealthService",
 ]

claude_mpm/services/infrastructure/monitoring.py

@@ -47,22 +47,22 @@ from .monitoring import (  # noqa: F401; New service-based API; Base components;
 )
 
 __all__ = [
-    # New service-based API
-    "ResourceMonitorService",
-    "ProcessHealthService",
-    "ServiceHealthService",
-    "NetworkHealthService",
-    "MonitoringAggregatorService",
-    # Base components
-    "HealthStatus",
-    "HealthMetric",
+    "AdvancedHealthMonitor",
     "HealthCheckResult",
     "HealthChecker",
+    "HealthMetric",
+    # Base components
+    "HealthStatus",
+    "MonitoringAggregatorService",
+    "NetworkConnectivityChecker",
+    "NetworkHealthService",
+    "ProcessHealthService",
     # Legacy compatibility
     "ProcessResourceChecker",
-    "NetworkConnectivityChecker",
+    # New service-based API
+    "ResourceMonitorService",
     "ServiceHealthChecker",
-    "AdvancedHealthMonitor",
+    "ServiceHealthService",
 ]
 
 # Module metadata

claude_mpm/services/project/architecture_analyzer.py

@@ -224,7 +224,7 @@ class ArchitectureAnalyzerService:
         existing_dirs = set()
 
         # Collect all directory names
-        for dirpath, dirnames, _ in self.working_directory.walk():
+        for _dirpath, dirnames, _ in self.working_directory.walk():
             for dirname in dirnames:
                 if not dirname.startswith("."):
                     existing_dirs.add(dirname.lower())

claude_mpm/services/project/dependency_analyzer.py

@@ -171,7 +171,7 @@ class DependencyAnalyzerService:
                 if any(pkg in dep_lower for pkg in db_packages):
                     databases.add(db_name)
 
-        return sorted(list(databases))
+        return sorted(databases)
 
     def detect_testing_frameworks(
         self, dependencies: Optional[List[str]] = None
@@ -201,7 +201,7 @@ class DependencyAnalyzerService:
                         testing_frameworks.add(dep)
                         break
 
-        return sorted(list(testing_frameworks))
+        return sorted(testing_frameworks)
 
     def detect_web_frameworks(self, dependencies: List[str]) -> List[str]:
         """Detect web frameworks from dependencies.
@@ -343,7 +343,7 @@ class DependencyAnalyzerService:
             for dep in all_deps:
                 dep_lower = dep.lower()
                 # Check for database packages
-                for db_name, db_packages in self.DATABASE_PACKAGES.items():
+                for _db_name, db_packages in self.DATABASE_PACKAGES.items():
                     if any(pkg in dep_lower for pkg in db_packages):
                         dependencies["databases"].append(dep)
 
@@ -407,7 +407,7 @@ class DependencyAnalyzerService:
                     dep_lower = dep.lower()
 
                     # Check databases
-                    for db_name, db_packages in self.DATABASE_PACKAGES.items():
+                    for _db_name, db_packages in self.DATABASE_PACKAGES.items():
                         if any(pkg in dep_lower for pkg in db_packages):
                             dependencies["databases"].append(dep)
 

claude_mpm/services/project/language_analyzer.py

@@ -109,7 +109,7 @@ class LanguageAnalyzerService:
             if files:
                 languages.add(lang)
 
-        return sorted(list(languages))
+        return sorted(languages)
 
     def detect_primary_language(
         self, file_counts: Optional[Dict[str, int]] = None
@@ -229,7 +229,7 @@ class LanguageAnalyzerService:
         """Count files by extension in the project."""
         counts = Counter()
 
-        for ext in self.FILE_EXTENSIONS.keys():
+        for ext in self.FILE_EXTENSIONS:
             files = list(self.working_directory.rglob(f"*{ext}"))
             # Filter out vendor directories
             files = [
@@ -249,7 +249,7 @@ class LanguageAnalyzerService:
         """Get a sample of source files for analysis."""
         source_files = []
 
-        for ext in self.FILE_EXTENSIONS.keys():
+        for ext in self.FILE_EXTENSIONS:
             files = list(self.working_directory.rglob(f"*{ext}"))
             # Filter out vendor directories
             files = [

claude_mpm/services/project/metrics_collector.py

@@ -166,7 +166,7 @@ class MetricsCollectorService:
 
         for file_path in self._iter_code_files():
             try:
-                size = file_path.stat().st_size
+                file_path.stat().st_size
                 lines = len(
                     file_path.read_text(encoding="utf-8", errors="ignore").splitlines()
                 )
@@ -377,7 +377,7 @@ class MetricsCollectorService:
 
         # Count directories
         dir_count = 0
-        for dirpath, dirnames, _ in self.working_directory.walk():
+        for _dirpath, dirnames, _ in self.working_directory.walk():
             dirnames[:] = [d for d in dirnames if d not in self.EXCLUDE_DIRS]
             dir_count += len(dirnames)
 
@@ -404,7 +404,4 @@ class MetricsCollectorService:
     def _should_analyze_file(self, file_path: Path) -> bool:
         """Check if a file should be analyzed."""
         # Skip files in excluded directories
-        for part in file_path.parts:
-            if part in self.EXCLUDE_DIRS:
-                return False
-        return True
+        return all(part not in self.EXCLUDE_DIRS for part in file_path.parts)

claude_mpm/services/socketio/handlers/__init__.py

@@ -7,6 +7,7 @@ and maintainability.
 """
 
 from .base import BaseEventHandler
+from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -16,6 +17,7 @@ from .registry import EventHandlerRegistry
 
 __all__ = [
     "BaseEventHandler",
+    "CodeAnalysisEventHandler",
     "ConnectionEventHandler",
     "EventHandlerRegistry",
     "FileEventHandler",

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -0,0 +1,170 @@
+"""
+Code Analysis Event Handler for Socket.IO
+==========================================
+
+WHY: Handles code analysis requests from the dashboard, managing the analysis
+runner subprocess and streaming results back to connected clients.
+
+DESIGN DECISIONS:
+- Single analysis runner instance per server
+- Queue multiple requests for sequential processing
+- Support cancellation of running analysis
+- Stream events in real-time to all connected clients
+"""
+
+import uuid
+from typing import Any, Dict
+
+from ....core.logging_config import get_logger
+from ....dashboard.analysis_runner import CodeAnalysisRunner
+from .base import BaseEventHandler
+
+
+class CodeAnalysisEventHandler(BaseEventHandler):
+    """Handles code analysis events from dashboard clients.
+
+    WHY: Provides a clean interface between the dashboard UI and the
+    code analysis subprocess, managing requests and responses.
+    """
+
+    def __init__(self, server):
+        """Initialize the code analysis event handler.
+
+        Args:
+            server: The SocketIOServer instance
+        """
+        super().__init__(server)
+        self.logger = get_logger(__name__)
+        self.analysis_runner = None
+
+    def initialize(self):
+        """Initialize the analysis runner."""
+        if not self.analysis_runner:
+            self.analysis_runner = CodeAnalysisRunner(self.server)
+            self.analysis_runner.start()
+            self.logger.info("Code analysis runner initialized")
+
+    def cleanup(self):
+        """Cleanup the analysis runner on shutdown."""
+        if self.analysis_runner:
+            self.analysis_runner.stop()
+            self.analysis_runner = None
+            self.logger.info("Code analysis runner stopped")
+
+    def get_events(self) -> Dict[str, Any]:
+        """Get the events this handler manages.
+
+        Returns:
+            Dictionary mapping event names to handler methods
+        """
+        return {
+            "code:analyze:request": self.handle_analyze_request,
+            "code:analyze:cancel": self.handle_cancel_request,
+            "code:analyze:status": self.handle_status_request,
+        }
+
+    def register_events(self) -> None:
+        """Register Socket.IO event handlers.
+
+        WHY: Required by BaseEventHandler to register events with the Socket.IO server.
+        """
+        events = self.get_events()
+        for event_name, handler_method in events.items():
+            self.server.core.sio.on(event_name, handler_method)
+            self.logger.info(f"Registered event handler: {event_name}")
+
+    async def handle_analyze_request(self, sid: str, data: Dict[str, Any]):
+        """Handle code analysis request from client.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data containing path and options
+        """
+        self.logger.info(f"Code analysis requested from {sid}: {data}")
+
+        # Initialize runner if needed
+        if not self.analysis_runner:
+            self.initialize()
+
+        # Validate request
+        path = data.get("path")
+        if not path:
+            await self.server.sio.emit(
+                "code:analysis:error",
+                {
+                    "message": "Path is required for analysis",
+                    "request_id": data.get("request_id"),
+                },
+                room=sid,
+            )
+            return
+
+        # Generate request ID if not provided
+        request_id = data.get("request_id") or str(uuid.uuid4())
+
+        # Extract options
+        languages = data.get("languages")
+        max_depth = data.get("max_depth")
+        ignore_patterns = data.get("ignore_patterns")
+
+        # Queue analysis request
+        success = self.analysis_runner.request_analysis(
+            request_id=request_id,
+            path=path,
+            languages=languages,
+            max_depth=max_depth,
+            ignore_patterns=ignore_patterns,
+        )
+
+        if success:
+            # Send acknowledgment to requesting client
+            await self.server.sio.emit(
+                "code:analysis:accepted",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    "message": "Analysis request queued",
+                },
+                room=sid,
+            )
+        else:
+            # Send error if request failed
+            await self.server.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "message": "Failed to queue analysis request",
+                },
+                room=sid,
+            )
+
+    async def handle_cancel_request(self, sid: str, data: Dict[str, Any]):
+        """Handle analysis cancellation request.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data (may contain request_id)
+        """
+        self.logger.info(f"Analysis cancellation requested from {sid}")
+
+        # Cancel current analysis
+        self.analysis_runner.cancel_current()
+
+        # Send confirmation
+        await self.server.sio.emit(
+            "code:analysis:cancelled",
+            {"message": "Analysis cancelled", "request_id": data.get("request_id")},
+            room=sid,
+        )
+
+    async def handle_status_request(self, sid: str, data: Dict[str, Any]):
+        """Handle status request from client.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data (unused)
+        """
+        status = self.analysis_runner.get_status()
+
+        # Send status to requesting client
+        await self.server.sio.emit("code:analysis:status", status, room=sid)

claude_mpm/services/socketio/handlers/registry.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
 
     from ..server import SocketIOServer
 
+from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -37,6 +38,7 @@ class EventHandlerRegistry:
         HookEventHandler,  # Hook events for session tracking
         GitEventHandler,  # Git operations
         FileEventHandler,  # File operations
+        CodeAnalysisEventHandler,  # Code analysis for dashboard
         ProjectEventHandler,  # Project management (future)
         MemoryEventHandler,  # Memory management (future)
     ]