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

claude_mpm/services/socketio/server/core.py

@@ -13,7 +13,7 @@ import asyncio
 import threading
 import time
 from collections import deque
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Set
 
@@ -195,6 +195,9 @@ class SocketIOServerCore:
             # Setup HTTP API endpoints for receiving events from hook handlers
             self._setup_http_api()
 
+            # Setup simple directory API
+            self._setup_directory_api()
+
             # Find and serve static files
             self._setup_static_files()
 
@@ -208,7 +211,7 @@ class SocketIOServerCore:
             await self.site.start()
 
             self.running = True
-            self.stats["start_time"] = datetime.now()
+            self.stats["start_time"] = datetime.now(timezone.utc)
 
             self.logger.info(
                 f"Socket.IO server listening on http://{self.host}:{self.port}"
@@ -390,6 +393,118 @@ class SocketIOServerCore:
         self.app.router.add_post("/api/events", api_events_handler)
         self.logger.info("✅ HTTP API endpoint registered at /api/events")
 
+        # Add working directory endpoint
+        async def working_directory_handler(request):
+            """Handle GET /api/working-directory to provide current working directory."""
+            from pathlib import Path
+
+            try:
+                working_dir = Path.cwd()
+                home_dir = str(Path.home())
+
+                return web.json_response(
+                    {
+                        "working_directory": working_dir,
+                        "home_directory": home_dir,
+                        "process_cwd": working_dir,
+                        "session_id": getattr(self, "session_id", None),
+                    }
+                )
+            except Exception as e:
+                self.logger.error(f"Error getting working directory: {e}")
+                return web.json_response(
+                    {
+                        "working_directory": "/Users/masa/Projects/claude-mpm",
+                        "home_directory": "/Users/masa",
+                        "error": str(e),
+                    },
+                    status=500,
+                )
+
+        self.app.router.add_get("/api/working-directory", working_directory_handler)
+        self.logger.info(
+            "✅ Working directory endpoint registered at /api/working-directory"
+        )
+
+        # Add file reading endpoint for source viewer
+        async def file_read_handler(request):
+            """Handle GET /api/file/read for reading source files."""
+
+            file_path = request.query.get("path", "")
+
+            if not file_path:
+                return web.json_response({"error": "No path provided"}, status=400)
+
+            abs_path = Path(Path(file_path).resolve().expanduser())
+
+            # Security check - ensure file is within the project
+            try:
+                project_root = Path.cwd()
+                if not abs_path.startswith(project_root):
+                    return web.json_response({"error": "Access denied"}, status=403)
+            except Exception:
+                pass
+
+            if not Path(abs_path).exists():
+                return web.json_response({"error": "File not found"}, status=404)
+
+            if not Path(abs_path).is_file():
+                return web.json_response({"error": "Not a file"}, status=400)
+
+            try:
+                # Read file with appropriate encoding
+                encodings = ["utf-8", "latin-1", "cp1252"]
+                content = None
+
+                for encoding in encodings:
+                    try:
+                        with Path(abs_path).open(
+                            encoding=encoding,
+                        ) as f:
+                            content = f.read()
+                        break
+                    except UnicodeDecodeError:
+                        continue
+
+                if content is None:
+                    return web.json_response(
+                        {"error": "Could not decode file"}, status=400
+                    )
+
+                return web.json_response(
+                    {
+                        "path": abs_path,
+                        "name": Path(abs_path).name,
+                        "content": content,
+                        "lines": len(content.splitlines()),
+                        "size": Path(abs_path).stat().st_size,
+                    }
+                )
+
+            except PermissionError:
+                return web.json_response({"error": "Permission denied"}, status=403)
+            except Exception as e:
+                return web.json_response({"error": str(e)}, status=500)
+
+        self.app.router.add_get("/api/file/read", file_read_handler)
+        self.logger.info("✅ File reading API registered at /api/file/read")
+
+    def _setup_directory_api(self):
+        """Setup simple directory listing API.
+
+        WHY: Provides a dead-simple way to list directory contents via HTTP GET
+        without complex WebSocket interactions.
+        """
+        try:
+            from claude_mpm.dashboard.api.simple_directory import register_routes
+
+            register_routes(self.app)
+            self.logger.info(
+                "✅ Simple directory API registered at /api/directory/list"
+            )
+        except Exception as e:
+            self.logger.error(f"Failed to setup directory API: {e}")
+
     def _setup_static_files(self):
         """Setup static file serving for the dashboard."""
         try:
@@ -440,6 +555,26 @@ class SocketIOServerCore:
 
                 self.app.router.add_get("/dashboard", dashboard_handler)
 
+                # Serve simple code view template at /code-simple
+                async def code_simple_handler(request):
+                    code_simple_template = (
+                        self.dashboard_path.parent / "templates" / "code_simple.html"
+                    )
+                    if code_simple_template.exists():
+                        self.logger.debug(
+                            f"Serving code simple template from: {code_simple_template}"
+                        )
+                        return web.FileResponse(code_simple_template)
+                    # Return error if template doesn't exist
+                    self.logger.warning(
+                        f"Code simple template not found at: {code_simple_template}"
+                    )
+                    return web.Response(
+                        text="Simple code view not available", status=404
+                    )
+
+                self.app.router.add_get("/code-simple", code_simple_handler)
+
                 # Serve version.json from dashboard directory
                 async def version_handler(request):
                     version_file = self.dashboard_path / "version.json"
@@ -614,7 +749,9 @@ class SocketIOServerCore:
                 uptime_seconds = 0
                 if self.stats.get("start_time"):
                     uptime_seconds = int(
-                        (datetime.now() - self.stats["start_time"]).total_seconds()
+                        (
+                            datetime.now(timezone.utc) - self.stats["start_time"]
+                        ).total_seconds()
                     )
 
                 # Get active sessions from main server if available
@@ -631,7 +768,7 @@ class SocketIOServerCore:
                 heartbeat_data = {
                     "type": "system",
                     "subtype": "heartbeat",
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "source": "server",
                     "data": {
                         "uptime_seconds": uptime_seconds,

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,7 +109,7 @@ 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,
         )
 
@@ -172,7 +174,7 @@ class SocketIOServer(SocketIOServiceInterface):
         # 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,
         )
 
@@ -183,26 +185,26 @@ class SocketIOServer(SocketIOServiceInterface):
                 "Broadcaster not initialized - cannot setup EventBus integration"
             )
             print(
-                f"[{datetime.now().isoformat()}] ERROR: Broadcaster not initialized",
+                f"[{datetime.now(timezone.utc).isoformat()}] ERROR: Broadcaster not initialized",
                 flush=True,
             )
         else:
             print(
-                f"[{datetime.now().isoformat()}] Broadcaster ready, proceeding with EventBus setup",
+                f"[{datetime.now(timezone.utc).isoformat()}] Broadcaster ready, proceeding with EventBus setup",
                 flush=True,
             )
 
             try:
                 self.eventbus_integration = EventBusIntegration(self)
                 print(
-                    f"[{datetime.now().isoformat()}] EventBusIntegration instance created",
+                    f"[{datetime.now(timezone.utc).isoformat()}] EventBusIntegration instance created",
                     flush=True,
                 )
 
                 if self.eventbus_integration.setup(self.port):
                     self.logger.info("EventBus integration setup successful")
                     print(
-                        f"[{datetime.now().isoformat()}] EventBus integration setup successful",
+                        f"[{datetime.now(timezone.utc).isoformat()}] EventBus integration setup successful",
                         flush=True,
                     )
 
@@ -214,19 +216,19 @@ class SocketIOServer(SocketIOServiceInterface):
                         relay_stats = self.eventbus_integration.relay.get_stats()
                         self.logger.info(f"EventBus relay stats: {relay_stats}")
                         print(
-                            f"[{datetime.now().isoformat()}] EventBus relay stats: {relay_stats}",
+                            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().isoformat()}] EventBus integration setup failed or disabled",
+                        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()}] Failed to setup EventBus integration: {e}",
+                    f"[{datetime.now(timezone.utc).isoformat()}] Failed to setup EventBus integration: {e}",
                     flush=True,
                 )
                 import traceback
@@ -265,15 +267,15 @@ class SocketIOServer(SocketIOServiceInterface):
             except Exception as e:
                 self.logger.error(f"Error during EventBus teardown: {e}")
 
-        # Stop code analysis handler
+        # Stop event handlers
         if self.event_registry:
-            from ..handlers import CodeAnalysisEventHandler, ConnectionEventHandler
-
-            # Stop analysis runner
-            analysis_handler = self.event_registry.get_handler(CodeAnalysisEventHandler)
-            if analysis_handler and hasattr(analysis_handler, "cleanup"):
-                analysis_handler.cleanup()
+            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"):
@@ -382,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,
         }
@@ -472,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():
@@ -480,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",
+]