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

claude_mpm/services/agents/memory/memory_format_service.py

@@ -62,7 +62,9 @@ class MemoryFormatService:
             line = line.strip()
             # Skip headers, empty lines, and metadata
             if (
-                not line or line.startswith(("#", "Last Updated:", "**")) or line == "---"
+                not line
+                or line.startswith(("#", "Last Updated:", "**"))
+                or line == "---"
             ):
                 continue
 

claude_mpm/services/cli/agent_cleanup_service.py

@@ -233,10 +233,7 @@ class AgentCleanupService(IAgentCleanupService):
             all_agents = multi_source_service.discover_agents_from_all_sources()
 
             # Detect orphaned agents
-            return multi_source_service.detect_orphaned_agents(
-                agents_dir, all_agents
-            )
-
+            return multi_source_service.detect_orphaned_agents(agents_dir, all_agents)
 
         except Exception as e:
             self.logger.error(f"Error finding orphaned agents: {e}", exc_info=True)

claude_mpm/services/cli/socketio_manager.py

@@ -172,10 +172,18 @@ class SocketIOManager(ISocketIOManager):
 
             # Check if server already running on this port
             if self.is_server_running(target_port):
-                self.logger.info(
-                    f"Socket.IO server already running on port {target_port}"
+                # Verify the server is healthy and responding
+                if self.wait_for_server(target_port, timeout=2):
+                    self.logger.info(
+                        f"Healthy Socket.IO server already running on port {target_port}"
+                    )
+                    return True, self.get_server_info(target_port)
+                # Server exists but not responding, try to clean it up
+                self.logger.warning(
+                    f"Socket.IO server on port {target_port} not responding, attempting cleanup"
                 )
-                return True, self.get_server_info(target_port)
+                self.stop_server(port=target_port, timeout=5)
+                    # Continue with starting a new server
 
             # Ensure dependencies are available
             deps_ok, error_msg = self.ensure_dependencies()
@@ -459,14 +467,37 @@ class SocketIOManager(ISocketIOManager):
         Returns:
             Available port number
         """
-        # Try preferred port first
+        # First check if our Socket.IO server is already running on the preferred port
+        if self.is_server_running(preferred_port):
+            # Check if it's healthy
+            if self.wait_for_server(preferred_port, timeout=2):
+                self.logger.info(
+                    f"Healthy Socket.IO server already running on port {preferred_port}"
+                )
+                return preferred_port
+            self.logger.warning(
+                f"Socket.IO server on port {preferred_port} not responding, will try to restart"
+            )
+
+        # Try preferred port first if available
         if self.port_manager.is_port_available(preferred_port):
             return preferred_port
 
-        # Find alternative port
-        available_port = self.port_manager.get_available_port(preferred_port)
-        self.logger.info(f"Port {preferred_port} unavailable, using {available_port}")
-        return available_port
+        # Find alternative port using the correct method name
+        available_port = self.port_manager.find_available_port(
+            preferred_port=preferred_port, reclaim=True
+        )
+
+        if available_port:
+            self.logger.info(
+                f"Port {preferred_port} unavailable, using {available_port}"
+            )
+            return available_port
+        # If no port found, raise an error
+        raise RuntimeError(
+            f"No available ports in range {self.port_manager.PORT_RANGE.start}-"
+            f"{self.port_manager.PORT_RANGE.stop-1}"
+        )
 
     def ensure_dependencies(self) -> Tuple[bool, Optional[str]]:
         """

claude_mpm/services/cli/startup_checker.py

@@ -177,7 +177,6 @@ class StartupCheckerService(IStartupChecker):
         try:
             # Check Python version
 
-
             # Check for common missing directories
             warnings.extend(self._check_required_directories())
 

claude_mpm/services/core/cache_manager.py

@@ -307,4 +307,3 @@ class CacheManager(ICacheManager):
                 },
                 "fs_cache": self._fs_cache.get_stats() if self._fs_cache else {},
             }
-

claude_mpm/services/infrastructure/monitoring.py

@@ -30,7 +30,7 @@ For backward compatibility, legacy classes are still available:
 """
 
 # Re-export all components from the modular implementation
-from .monitoring import (  # noqa: F401; New service-based API; Base components; Legacy compatibility
+from .monitoring import (  # noqa: F401
     AdvancedHealthMonitor,
     HealthChecker,
     HealthCheckResult,

claude_mpm/services/socketio/event_normalizer.py

@@ -59,6 +59,7 @@ class EventType(Enum):
     PERFORMANCE = "performance"  # Performance metrics
     CLAUDE = "claude"  # Claude process events
     TEST = "test"  # Test events
+    CODE = "code"  # Code analysis events
     TOOL = "tool"  # Tool events
     SUBAGENT = "subagent"  # Subagent events
 
@@ -351,6 +352,41 @@ class EventNormalizer:
                 event_type.value if isinstance(event_type, EventType) else event_type
             ), subtype
 
+        # Handle colon-separated event names (e.g., "code:analysis:queued", "code:progress")
+        # These are commonly used by the code analysis system
+        if ":" in event_name:
+            parts = event_name.split(":", 2)  # Split into max 3 parts
+            if len(parts) >= 2:
+                type_part = parts[0].lower()
+                # For events like "code:analysis:queued", combine the last parts as subtype
+                # Replace colons with underscores for clean subtypes
+                if len(parts) == 3:
+                    subtype_part = f"{parts[1]}_{parts[2]}"
+                else:
+                    subtype_part = parts[1].replace(":", "_")
+
+                # Map the type part to known types
+                if type_part in [
+                    "code",  # Code analysis events
+                    "hook",
+                    "session",
+                    "file",
+                    "system",
+                    "connection",
+                    "memory",
+                    "git",
+                    "todo",
+                    "ticket",
+                    "agent",
+                    "claude",
+                    "error",
+                    "performance",
+                    "test",
+                    "tool",
+                    "subagent",
+                ]:
+                    return type_part, subtype_part
+
         # Handle dotted event names (e.g., "connection.status", "session.started")
         if "." in event_name:
             parts = event_name.split(".", 1)
@@ -443,6 +479,34 @@ class EventNormalizer:
                 return EventType.MEMORY.value, "injected"
             return EventType.MEMORY.value, "generic"
 
+        # Code analysis events - using underscores for clean subtypes
+        if "code" in event_lower:
+            if "analysis" in event_lower:
+                if "queue" in event_lower:
+                    return EventType.CODE.value, "analysis_queued"
+                if "start" in event_lower:
+                    return EventType.CODE.value, "analysis_start"
+                if "complete" in event_lower:
+                    return EventType.CODE.value, "analysis_complete"
+                if "error" in event_lower:
+                    return EventType.CODE.value, "analysis_error"
+                if "cancel" in event_lower:
+                    return EventType.CODE.value, "analysis_cancelled"
+                return EventType.CODE.value, "analysis_generic"
+            if "progress" in event_lower:
+                return EventType.CODE.value, "progress"
+            if "file" in event_lower:
+                if "discovered" in event_lower:
+                    return EventType.CODE.value, "file_discovered"
+                if "analyzed" in event_lower:
+                    return EventType.CODE.value, "file_analyzed"
+                return EventType.CODE.value, "file_complete"
+            if "directory" in event_lower:
+                return EventType.CODE.value, "directory_discovered"
+            if "node" in event_lower:
+                return EventType.CODE.value, "node_found"
+            return EventType.CODE.value, "generic"
+
         # Default to unknown with lowercase subtype
         return "unknown", event_name.lower() if event_name else ""
 

claude_mpm/services/socketio/handlers/code_analysis.py

@@ -12,11 +12,15 @@ DESIGN DECISIONS:
 - Stream events in real-time to all connected clients
 """
 
+import asyncio
 import uuid
+from pathlib import Path
 from typing import Any, Dict
 
 from ....core.logging_config import get_logger
 from ....dashboard.analysis_runner import CodeAnalysisRunner
+from ....tools.code_tree_analyzer import CodeTreeAnalyzer
+from ....tools.code_tree_events import CodeTreeEventEmitter
 from .base import BaseEventHandler
 
 
@@ -36,6 +40,7 @@ class CodeAnalysisEventHandler(BaseEventHandler):
         super().__init__(server)
         self.logger = get_logger(__name__)
         self.analysis_runner = None
+        self.code_analyzer = None  # For lazy loading operations
 
     def initialize(self):
         """Initialize the analysis runner."""
@@ -58,9 +63,14 @@ class CodeAnalysisEventHandler(BaseEventHandler):
             Dictionary mapping event names to handler methods
         """
         return {
+            # Legacy full analysis
             "code:analyze:request": self.handle_analyze_request,
             "code:analyze:cancel": self.handle_cancel_request,
             "code:analyze:status": self.handle_status_request,
+            # Lazy loading operations
+            "code:discover:top_level": self.handle_discover_top_level,
+            "code:discover:directory": self.handle_discover_directory,
+            "code:analyze:file": self.handle_analyze_file,
         }
 
     def register_events(self) -> None:
@@ -168,3 +178,442 @@ class CodeAnalysisEventHandler(BaseEventHandler):
 
         # Send status to requesting client
         await self.server.sio.emit("code:analysis:status", status, room=sid)
+
+    async def handle_discover_top_level(self, sid: str, data: Dict[str, Any]):
+        """Handle top-level directory discovery request for lazy loading.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data containing path and options
+        """
+        self.logger.info(f"Top-level discovery requested from {sid}: {data}")
+
+        # Get path - this MUST be an absolute path from the frontend
+        path = data.get("path")
+        if not path:
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": "Path is required for top-level discovery",
+                    "request_id": data.get("request_id"),
+                },
+                room=sid,
+            )
+            return
+
+        # CRITICAL: Never use "." or allow relative paths
+        # The frontend must send the absolute working directory
+        if path in (".", "..", "/") or not Path(path).is_absolute():
+            self.logger.warning(f"Invalid path for discovery: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Invalid path for discovery: {path}. Must be an absolute path.",
+                    "request_id": data.get("request_id"),
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        # SECURITY: Validate the requested path
+        # Allow access to the explicitly chosen working directory and its subdirectories
+        requested_path = Path(path).absolute()
+
+        # For now, we trust the frontend to send valid paths
+        # In production, you might want to maintain a server-side list of allowed directories
+        # or implement a more sophisticated permission system
+
+        # Basic sanity checks are done below after creating the Path object
+
+        ignore_patterns = data.get("ignore_patterns", [])
+        request_id = data.get("request_id")
+
+        try:
+            # Create analyzer if needed
+            if not self.code_analyzer:
+                # Create a custom emitter that sends to Socket.IO
+                emitter = CodeTreeEventEmitter(use_stdout=False)
+                # Override emit method to send to Socket.IO
+                original_emit = emitter.emit
+
+                def socket_emit(
+                    event_type: str, event_data: Dict[str, Any], batch: bool = False
+                ):
+                    # Keep the original event format with colons - frontend expects this!
+                    # The frontend listens for 'code:directory:discovered' not 'code.directory.discovered'
+
+                    # Special handling for 'info' events - they should be passed through directly
+                    if event_type == "info":
+                        # INFO events for granular tracking
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                "info", {"request_id": request_id, **event_data}
+                            )
+                        )
+                    else:
+                        # Regular code analysis events
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                event_type, {"request_id": request_id, **event_data}
+                            )
+                        )
+                    # Call original for stats tracking
+                    original_emit(event_type, event_data, batch)
+
+                emitter.emit = socket_emit
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+
+            # Use the provided path as-is - the frontend sends the absolute path
+            # Make sure we're using an absolute path
+            directory = Path(path)
+
+            # Validate that the path exists and is a directory
+            if not directory.exists():
+                await self.server.core.sio.emit(
+                    "code:analysis:error",
+                    {
+                        "request_id": request_id,
+                        "path": path,
+                        "error": f"Directory does not exist: {path}",
+                    },
+                    room=sid,
+                )
+                return
+
+            if not directory.is_dir():
+                await self.server.core.sio.emit(
+                    "code:analysis:error",
+                    {
+                        "request_id": request_id,
+                        "path": path,
+                        "error": f"Path is not a directory: {path}",
+                    },
+                    room=sid,
+                )
+                return
+
+            # Log what we're actually discovering
+            self.logger.info(
+                f"Discovering top-level contents of: {directory.absolute()}"
+            )
+
+            result = self.code_analyzer.discover_top_level(directory, ignore_patterns)
+
+            # Send result to client with correct event name for top level discovery
+            await self.server.core.sio.emit(
+                "code:top_level:discovered",
+                {
+                    "request_id": request_id,
+                    "path": str(directory),
+                    "items": result.get("children", []),
+                    "stats": {
+                        "files": len(
+                            [
+                                c
+                                for c in result.get("children", [])
+                                if c.get("type") == "file"
+                            ]
+                        ),
+                        "directories": len(
+                            [
+                                c
+                                for c in result.get("children", [])
+                                if c.get("type") == "directory"
+                            ]
+                        ),
+                    },
+                },
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error discovering top level: {e}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    "error": str(e),
+                },
+                room=sid,
+            )
+
+    async def handle_discover_directory(self, sid: str, data: Dict[str, Any]):
+        """Handle directory discovery request for lazy loading.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data containing directory path
+        """
+        self.logger.info(f"Directory discovery requested from {sid}: {data}")
+
+        path = data.get("path")
+        ignore_patterns = data.get("ignore_patterns", [])
+        request_id = data.get("request_id")
+
+        if not path:
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "error": "Path is required",
+                },
+                room=sid,
+            )
+            return
+
+        # CRITICAL SECURITY FIX: Add path validation to prevent filesystem traversal
+        # The same validation logic as handle_discover_top_level
+        if path in (".", "..", "/") or not Path(path).is_absolute():
+            self.logger.warning(f"Invalid path for directory discovery: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Invalid path for discovery: {path}. Must be an absolute path.",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        # SECURITY: Validate the requested path
+        # Allow access to the explicitly chosen working directory and its subdirectories
+        requested_path = Path(path).absolute()
+
+        # For now, we trust the frontend to send valid paths
+        # In production, you might want to maintain a server-side list of allowed directories
+        # or implement a more sophisticated permission system
+
+        # Basic sanity checks
+        if not requested_path.exists():
+            self.logger.warning(f"Path does not exist: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Path does not exist: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        if not requested_path.is_dir():
+            self.logger.warning(f"Path is not a directory: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Path is not a directory: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        try:
+            # Ensure analyzer exists
+            if not self.code_analyzer:
+                emitter = CodeTreeEventEmitter(use_stdout=False)
+                # Override emit method to send to Socket.IO
+                original_emit = emitter.emit
+
+                def socket_emit(
+                    event_type: str, event_data: Dict[str, Any], batch: bool = False
+                ):
+                    # Keep the original event format with colons - frontend expects this!
+                    # The frontend listens for 'code:directory:discovered' not 'code.directory.discovered'
+
+                    # Special handling for 'info' events - they should be passed through directly
+                    if event_type == "info":
+                        # INFO events for granular tracking
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                "info", {"request_id": request_id, **event_data}
+                            )
+                        )
+                    else:
+                        # Regular code analysis events
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                event_type, {"request_id": request_id, **event_data}
+                            )
+                        )
+                    original_emit(event_type, event_data, batch)
+
+                emitter.emit = socket_emit
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+
+            # Discover directory
+            result = self.code_analyzer.discover_directory(path, ignore_patterns)
+
+            # Log what we're sending
+            self.logger.info(
+                f"Discovery result for {path}: {len(result.get('children', []))} children found"
+            )
+            self.logger.debug(f"Full result: {result}")
+
+            # Send result with correct event name (using colons, not dots!)
+            await self.server.core.sio.emit(
+                "code:directory:discovered",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    **result,
+                },
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error discovering directory {path}: {e}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    "error": str(e),
+                },
+                room=sid,
+            )
+
+    async def handle_analyze_file(self, sid: str, data: Dict[str, Any]):
+        """Handle file analysis request for lazy loading.
+
+        Args:
+            sid: Socket ID of the requesting client
+            data: Request data containing file path
+        """
+        self.logger.info(f"File analysis requested from {sid}: {data}")
+
+        path = data.get("path")
+        request_id = data.get("request_id")
+        show_hidden_files = data.get("show_hidden_files", False)
+
+        if not path:
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "error": "Path is required",
+                },
+                room=sid,
+            )
+            return
+
+        # CRITICAL SECURITY FIX: Add path validation to prevent filesystem traversal
+        if path in (".", "..", "/") or not Path(path).is_absolute():
+            self.logger.warning(f"Invalid path for file analysis: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Invalid path for analysis: {path}. Must be an absolute path.",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        # SECURITY: Validate the requested file path
+        # Allow access to files within the explicitly chosen working directory
+        requested_path = Path(path).absolute()
+
+        # Basic sanity checks
+        if not requested_path.exists():
+            self.logger.warning(f"File does not exist: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"File does not exist: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        if not requested_path.is_file():
+            self.logger.warning(f"Path is not a file: {path}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "error": f"Path is not a file: {path}",
+                    "request_id": request_id,
+                    "path": path,
+                },
+                room=sid,
+            )
+            return
+
+        try:
+            # Ensure analyzer exists
+            if not self.code_analyzer:
+                emitter = CodeTreeEventEmitter(use_stdout=False)
+                # Override emit method to send to Socket.IO
+                original_emit = emitter.emit
+
+                def socket_emit(
+                    event_type: str, event_data: Dict[str, Any], batch: bool = False
+                ):
+                    # Keep the original event format with colons - frontend expects this!
+                    # The frontend listens for 'code:file:analyzed' not 'code.file.analyzed'
+
+                    # Special handling for 'info' events - they should be passed through directly
+                    if event_type == "info":
+                        # INFO events for granular tracking
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                "info", {"request_id": request_id, **event_data}
+                            )
+                        )
+                    else:
+                        # Regular code analysis events
+                        loop = asyncio.get_event_loop()
+                        loop.create_task(
+                            self.server.core.sio.emit(
+                                event_type, {"request_id": request_id, **event_data}
+                            )
+                        )
+                    original_emit(event_type, event_data, batch)
+
+                emitter.emit = socket_emit
+                # Initialize CodeTreeAnalyzer with emitter keyword argument
+                self.logger.info("Creating CodeTreeAnalyzer")
+                self.code_analyzer = CodeTreeAnalyzer(emitter=emitter)
+
+            # Analyze file
+            result = self.code_analyzer.analyze_file(path)
+
+            # Send result with correct event name (using colons, not dots!)
+            await self.server.core.sio.emit(
+                "code:file:analyzed",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    **result,
+                },
+                room=sid,
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error analyzing file {path}: {e}")
+            await self.server.core.sio.emit(
+                "code:analysis:error",
+                {
+                    "request_id": request_id,
+                    "path": path,
+                    "error": str(e),
+                },
+                room=sid,
+            )