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

claude_mpm/cli/commands/dashboard.py

@@ -5,21 +5,20 @@ WHY: This module provides CLI commands for managing the web dashboard interface,
 allowing users to start, stop, check status, and open the dashboard in a browser.
 
 DESIGN DECISIONS:
-- Use DashboardLauncher service for consistent dashboard management
+- Use UnifiedMonitorDaemon for integrated dashboard and monitoring
 - Support both foreground and background operation modes
-- Integrate with SocketIO server for real-time event streaming
+- Integrate with EventBus for real-time event streaming
 - Provide browser auto-opening functionality
 """
 
 import signal
 import sys
-import time
 from typing import Optional
 
 from ...constants import DashboardCommands
-from ...services.cli.dashboard_launcher import DashboardLauncher
+from ...services.cli.unified_dashboard_manager import UnifiedDashboardManager
+from ...services.monitor.daemon import UnifiedMonitorDaemon
 from ...services.port_manager import PortManager
-from ...services.socketio.server.main import SocketIOServer
 from ..shared import BaseCommand, CommandResult
 
 
@@ -28,7 +27,7 @@ class DashboardCommand(BaseCommand):
 
     def __init__(self):
         super().__init__("dashboard")
-        self.dashboard_launcher = DashboardLauncher(self.logger)
+        self.dashboard_manager = UnifiedDashboardManager(self.logger)
         self.port_manager = PortManager()
         self.server = None
 
@@ -71,26 +70,27 @@ class DashboardCommand(BaseCommand):
         port = getattr(args, "port", 8765)
         host = getattr(args, "host", "localhost")
         background = getattr(args, "background", False)
+        use_stable = getattr(args, "stable", True)  # Default to stable server
 
         self.logger.info(
-            f"Starting dashboard on {host}:{port} (background: {background})"
+            f"Starting dashboard on {host}:{port} (background: {background}, stable: {use_stable})"
         )
 
         # Check if dashboard is already running
-        if self.dashboard_launcher.is_dashboard_running(port):
-            dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+        if self.dashboard_manager.is_dashboard_running(port):
+            dashboard_url = self.dashboard_manager.get_dashboard_url(port)
             return CommandResult.success_result(
                 f"Dashboard already running at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},
             )
 
         if background:
-            # Use the dashboard launcher for background mode
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            # Use the unified dashboard manager for background mode
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started at {dashboard_url}",
                     data={
@@ -100,47 +100,45 @@ class DashboardCommand(BaseCommand):
                     },
                 )
             return CommandResult.error_result("Failed to start dashboard in background")
-        # Run in foreground mode - directly start the SocketIO server
+
+        # Run in foreground mode using unified monitor daemon
         try:
-            print(f"Starting dashboard server on {host}:{port}...")
+            self.logger.info("Starting unified monitor daemon with dashboard...")
+            print(f"Starting unified dashboard and monitor on {host}:{port}...")
             print("Press Ctrl+C to stop the server")
+            print(
+                "\n✅ Using unified daemon - includes dashboard, monitoring, and EventBus integration\n"
+            )
 
-            # Create and start the SocketIO server
-            self.server = SocketIOServer(host=host, port=port)
+            # Create and start the unified monitor daemon
+            daemon = UnifiedMonitorDaemon(host=host, port=port, daemon_mode=False)
 
             # Set up signal handlers for graceful shutdown
             def signal_handler(signum, frame):
-                print("\nShutting down dashboard server...")
-                if self.server:
-                    self.server.stop_sync()
+                print("\nShutting down unified monitor daemon...")
+                daemon.stop()
                 sys.exit(0)
 
             signal.signal(signal.SIGINT, signal_handler)
             signal.signal(signal.SIGTERM, signal_handler)
 
-            # Start the server (this starts in background thread)
-            self.server.start_sync()
-
-            # Keep the main thread alive while server is running
-            # The server runs in a background thread, so we need to block here
-            try:
-                while self.server.is_running():
-                    time.sleep(1)
-            except KeyboardInterrupt:
-                # Ctrl+C pressed, stop the server
-                pass
-
-            # Server has stopped or user interrupted
-            if self.server:
-                self.server.stop_sync()
-
-            return CommandResult.success_result("Dashboard server stopped")
+            # Start the daemon (blocking in foreground mode)
+            success = daemon.start()
+            if success:
+                return CommandResult.success_result("Unified monitor daemon stopped")
+            return CommandResult.error_result("Failed to start unified monitor daemon")
 
         except KeyboardInterrupt:
-            print("\nDashboard server stopped by user")
-            return CommandResult.success_result("Dashboard server stopped")
+            print("\nUnified monitor daemon stopped by user")
+            return CommandResult.success_result("Unified monitor daemon stopped")
         except Exception as e:
-            return CommandResult.error_result(f"Failed to start dashboard: {e}")
+            self.logger.error(f"Unified monitor daemon failed: {e}")
+            error_msg = f"Failed to start unified monitor daemon: {e}\n\n"
+            error_msg += "💡 Troubleshooting tips:\n"
+            error_msg += f"  - Check if port {port} is already in use\n"
+            error_msg += "  - Use --debug flag for more details\n"
+            error_msg += "  - Check that all dependencies are installed\n"
+            return CommandResult.error_result(error_msg)
 
     def _stop_dashboard(self, args) -> CommandResult:
         """Stop the dashboard server."""
@@ -148,10 +146,10 @@ class DashboardCommand(BaseCommand):
 
         self.logger.info(f"Stopping dashboard on port {port}")
 
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             return CommandResult.success_result(f"No dashboard running on port {port}")
 
-        if self.dashboard_launcher.stop_dashboard(port):
+        if self.dashboard_manager.stop_dashboard(port):
             return CommandResult.success_result(f"Dashboard stopped on port {port}")
 
         return CommandResult.error_result(f"Failed to stop dashboard on port {port}")
@@ -163,7 +161,7 @@ class DashboardCommand(BaseCommand):
 
         # Check default port first
         default_port = 8765
-        dashboard_running = self.dashboard_launcher.is_dashboard_running(default_port)
+        dashboard_running = self.dashboard_manager.is_dashboard_running(default_port)
 
         status_data = {
             "running": dashboard_running,
@@ -171,17 +169,17 @@ class DashboardCommand(BaseCommand):
         }
 
         if dashboard_running:
-            status_data["url"] = self.dashboard_launcher.get_dashboard_url(default_port)
+            status_data["url"] = self.dashboard_manager.get_dashboard_url(default_port)
 
         # Check all ports if requested
         if show_ports:
             port_status = {}
             for port in range(8765, 8786):
-                is_running = self.dashboard_launcher.is_dashboard_running(port)
+                is_running = self.dashboard_manager.is_dashboard_running(port)
                 port_status[port] = {
                     "running": is_running,
                     "url": (
-                        self.dashboard_launcher.get_dashboard_url(port)
+                        self.dashboard_manager.get_dashboard_url(port)
                         if is_running
                         else None
                     ),
@@ -214,14 +212,14 @@ class DashboardCommand(BaseCommand):
         port = getattr(args, "port", 8765)
 
         # Check if dashboard is running
-        if not self.dashboard_launcher.is_dashboard_running(port):
+        if not self.dashboard_manager.is_dashboard_running(port):
             self.logger.info("Dashboard not running, starting it first...")
             # Start dashboard in background
-            success, browser_opened = self.dashboard_launcher.launch_dashboard(
-                port=port, monitor_mode=True
+            success, browser_opened = self.dashboard_manager.start_dashboard(
+                port=port, background=True, open_browser=True
             )
             if success:
-                dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
+                dashboard_url = self.dashboard_manager.get_dashboard_url(port)
                 return CommandResult.success_result(
                     f"Dashboard started and opened at {dashboard_url}",
                     data={
@@ -232,8 +230,8 @@ class DashboardCommand(BaseCommand):
                 )
             return CommandResult.error_result("Failed to start and open dashboard")
         # Dashboard already running, just open browser
-        dashboard_url = self.dashboard_launcher.get_dashboard_url(port)
-        if self.dashboard_launcher._open_browser(dashboard_url):
+        dashboard_url = self.dashboard_manager.get_dashboard_url(port)
+        if self.dashboard_manager.open_browser(dashboard_url):
             return CommandResult.success_result(
                 f"Opened dashboard at {dashboard_url}",
                 data={"url": dashboard_url, "port": port},

claude_mpm/cli/commands/debug.py

@@ -14,7 +14,7 @@ import contextlib
 import json
 import time
 from collections import defaultdict
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict
 
@@ -216,7 +216,7 @@ def debug_services(args, logger):
                 container = DIContainer.get_instance()
             else:
                 container = DIContainer()
-        except:
+        except Exception:
             # Create a new container if none exists
             container = DIContainer()
             logger.warning("No active container found, created new instance")
@@ -408,7 +408,7 @@ def debug_agents(args, logger):
                             agent_name = agent_file.stem
                             size = agent_file.stat().st_size
                             modified = datetime.fromtimestamp(
-                                agent_file.stat().st_mtime
+                                agent_file.stat().st_mtime, tz=timezone.utc
                             )
                             print(f"   • {agent_name}")
                             print(f"     Size: {size:,} bytes")
@@ -446,7 +446,7 @@ def debug_agents(args, logger):
 
                         # Try to load and analyze memory
                         try:
-                            with open(mem_file) as f:
+                            with mem_file.open() as f:
                                 memory_data = json.load(f)
 
                             entry_count = (
@@ -509,7 +509,7 @@ def debug_agents(args, logger):
                     print(f"   Size: {agent_file.stat().st_size:,} bytes")
 
                     # Read first few lines for type detection
-                    with open(agent_file) as f:
+                    with agent_file.open() as f:
                         lines = f.readlines()[:10]
                         for line in lines:
                             if "role:" in line.lower():
@@ -684,7 +684,7 @@ def debug_hooks(args, logger):
                         hook.execute(test_context)
                         elapsed = time.time() - start
                         times.append(elapsed)
-                    except:
+                    except Exception:
                         pass
 
                 if times:
@@ -693,9 +693,9 @@ def debug_hooks(args, logger):
                     max_time = max(times)
 
                     print(f"\n   {hook.name}:")
-                    print(f"     Average: {avg_time*1000:.2f}ms")
-                    print(f"     Min: {min_time*1000:.2f}ms")
-                    print(f"     Max: {max_time*1000:.2f}ms")
+                    print(f"     Average: {avg_time * 1000:.2f}ms")
+                    print(f"     Min: {min_time * 1000:.2f}ms")
+                    print(f"     Max: {max_time * 1000:.2f}ms")
 
         else:
             # Default: show summary
@@ -767,7 +767,7 @@ def debug_cache(args, logger):
             print(f"   Location: {cache_dir}")
             print(f"   Total Files: {file_count}")
             print(
-                f"   Total Size: {total_size:,} bytes ({total_size/1024/1024:.2f} MB)"
+                f"   Total Size: {total_size:,} bytes ({total_size / 1024 / 1024:.2f} MB)"
             )
 
             print("\n📁 Categories:")
@@ -871,7 +871,7 @@ def debug_cache(args, logger):
 
                 print(f"Location: {cache_dir}")
                 print(f"Files: {file_count}")
-                print(f"Size: {total_size:,} bytes ({total_size/1024/1024:.2f} MB)")
+                print(f"Size: {total_size:,} bytes ({total_size / 1024 / 1024:.2f} MB)")
             else:
                 print("No cache found")
 
@@ -998,22 +998,22 @@ def debug_performance(args, logger):
             # Memory info
             mem = psutil.virtual_memory()
             print("\n💾 Memory:")
-            print(f"   Total: {mem.total/1024/1024/1024:.2f} GB")
-            print(f"   Used: {mem.used/1024/1024/1024:.2f} GB ({mem.percent}%)")
-            print(f"   Available: {mem.available/1024/1024/1024:.2f} GB")
+            print(f"   Total: {mem.total / 1024 / 1024 / 1024:.2f} GB")
+            print(f"   Used: {mem.used / 1024 / 1024 / 1024:.2f} GB ({mem.percent}%)")
+            print(f"   Available: {mem.available / 1024 / 1024 / 1024:.2f} GB")
 
             # Disk info
             disk = psutil.disk_usage("/")
             print("\n💿 Disk:")
-            print(f"   Total: {disk.total/1024/1024/1024:.2f} GB")
-            print(f"   Used: {disk.used/1024/1024/1024:.2f} GB ({disk.percent}%)")
-            print(f"   Free: {disk.free/1024/1024/1024:.2f} GB")
+            print(f"   Total: {disk.total / 1024 / 1024 / 1024:.2f} GB")
+            print(f"   Used: {disk.used / 1024 / 1024 / 1024:.2f} GB ({disk.percent}%)")
+            print(f"   Free: {disk.free / 1024 / 1024 / 1024:.2f} GB")
 
             # Process info
             process = psutil.Process()
             print("\n📦 Current Process:")
             print(f"   PID: {process.pid}")
-            print(f"   Memory: {process.memory_info().rss/1024/1024:.2f} MB")
+            print(f"   Memory: {process.memory_info().rss / 1024 / 1024:.2f} MB")
             print(f"   CPU: {process.cpu_percent()}%")
             print(f"   Threads: {process.num_threads()}")
 
@@ -1075,7 +1075,7 @@ def _profile_memory_operations():
         try:
             memory.add_memory(f"category_{i}", {"data": f"test_{i}"})
             memory.get_memories()
-        except:
+        except Exception:
             pass
 
 

claude_mpm/cli/commands/doctor.py

@@ -11,7 +11,6 @@ DESIGN DECISIONS:
 - Future: Support --fix flag for automatic remediation
 """
 
-import logging
 import sys
 from pathlib import Path
 
@@ -61,6 +60,7 @@ def add_doctor_parser(subparsers):
             "filesystem",
             "claude",
             "agents",
+            "agent-sources",
             "mcp",
             "monitor",
             "common",
@@ -80,6 +80,15 @@ def add_doctor_parser(subparsers):
 
     parser.add_argument("--output", "-o", type=Path, help="Save output to file")
 
+    parser.add_argument(
+        "--output-file",
+        nargs="?",
+        const=".",
+        type=Path,
+        default=None,
+        help="Save report to file (default: mpm-doctor-report.md when used without path)",
+    )
+
     parser.set_defaults(func=doctor_command)
 
 
@@ -108,13 +117,35 @@ def doctor_command(args):
         Exit code (0 for success, 1 for warnings, 2 for errors)
     """
     # Configure logging
-    logger = logging.getLogger(__name__)
+    from datetime import datetime, timezone
+
+    from claude_mpm.core.logging_utils import get_logger
+
+    logger = get_logger(__name__)
+
+    # Handle output file parameter - support both --output and --output-file
+    output_file = args.output or args.output_file
+    if output_file is not None:
+        # If output_file is specified without a path, use default with timestamp
+        if str(output_file) == ".":
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+            output_file = Path(f"mpm-doctor-report-{timestamp}.md")
+        elif not str(output_file).endswith((".md", ".json", ".txt")):
+            # Add .md extension if no extension provided
+            output_file = Path(str(output_file) + ".md")
+
+        # Create parent directories if needed
+        output_file = output_file.absolute()
+        output_file.parent.mkdir(parents=True, exist_ok=True)
 
     # Determine output format
     if args.json:
         output_format = "json"
     elif args.markdown:
         output_format = "markdown"
+    elif output_file:
+        # Force markdown format when writing to file (unless json specified)
+        output_format = "json" if str(output_file).endswith(".json") else "markdown"
     else:
         output_format = "terminal"
 
@@ -152,17 +183,29 @@ def doctor_command(args):
     reporter = DoctorReporter(use_color=not args.no_color, verbose=args.verbose)
 
     # Output results
-    if args.output:
+    if output_file:
         # Save to file
         try:
             import sys
 
             original_stdout = sys.stdout
-            with open(args.output, "w") as f:
+            with output_file.open("w") as f:
                 sys.stdout = f
                 reporter.report(summary, format=output_format)
             sys.stdout = original_stdout
-            print(f"Report saved to: {args.output}")
+            print(f"✅ Report saved to: {output_file}")
+
+            # Also print brief summary to terminal
+            if summary.error_count > 0:
+                print(
+                    f"❌ {summary.error_count} error(s) found - see report for details"
+                )
+            elif summary.warning_count > 0:
+                print(
+                    f"⚠️  {summary.warning_count} warning(s) found - see report for details"
+                )
+            else:
+                print("✅ System is healthy!")
         except Exception as e:
             logger.error(f"Failed to save report: {e}")
             print(f"❌ Failed to save report: {e!s}")
@@ -187,13 +230,14 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Claude MPM Doctor")
     parser.add_argument("--verbose", "-v", action="store_true")
     parser.add_argument("--json", action="store_true")
+    parser.add_argument("--markdown", action="store_true")
     parser.add_argument("--fix", action="store_true")
     parser.add_argument("--no-color", action="store_true")
     parser.add_argument("--checks", nargs="+")
     parser.add_argument("--parallel", action="store_true")
+    parser.add_argument("--output", "-o", type=Path)
+    parser.add_argument("--output-file", type=Path)
 
     args = parser.parse_args()
-    args.markdown = False
-    args.output = None
 
     sys.exit(doctor_command(args))