claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/cli/commands/monitor.py

@@ -1,328 +1,246 @@
 """
 Monitor command implementation for claude-mpm.
 
-WHY: This module provides CLI commands for managing the Socket.IO monitoring server,
-allowing users to start, stop, restart, and check status of the monitoring infrastructure.
+WHY: This module provides CLI commands for managing the unified monitoring daemon,
+providing a single stable way to launch all monitoring functionality including
+HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hook ingestion.
 
-DESIGN DECISION: We follow the existing CLI pattern using a main function
-that dispatches to specific subcommand handlers, maintaining consistency
-with other command modules like agents.py and memory.py.
+DESIGN DECISIONS:
+- Use UnifiedMonitorDaemon for single stable monitoring service
+- Single port (8765) for all functionality
+- Support both foreground and daemon modes
+- Real AST analysis using CodeTreeAnalyzer
+- Integrated dashboard and Socket.IO server
 """
 
-import sys
-from pathlib import Path
+from typing import Optional
 
-from ...core.logger import get_logger
 from ...constants import MonitorCommands
+from ...services.monitor.daemon import UnifiedMonitorDaemon
+from ..shared import BaseCommand, CommandResult
 
 
-def manage_monitor(args):
-    """
-    Manage Socket.IO monitoring server.
-    
-    WHY: The monitoring server provides real-time insights into Claude MPM sessions,
-    websocket connections, and system performance. This command provides a unified
-    interface for all monitor-related operations.
-    
-    DESIGN DECISION: When no subcommand is provided, we show the server status
-    as the default action, giving users a quick overview of the monitoring system.
-    
-    Args:
-        args: Parsed command line arguments with monitor_command attribute
-    """
-    logger = get_logger("cli")
-    
-    try:
-        # Import ServerManager from socketio_server_manager.py
-        from ...scripts.socketio_server_manager import ServerManager
-        server_manager = ServerManager()
-        
-        if not args.monitor_command:
-            # No subcommand - show help
-            # WHY: Since we removed status, show help instead when no subcommand is provided
-            print("Available monitor commands:")
-            print("  start    - Start the Socket.IO monitoring server")
-            print("  stop     - Stop the Socket.IO monitoring server")
-            print("  restart  - Restart the Socket.IO monitoring server")
-            print("  port <N> - Start/restart on specific port")
-            print()
-            print("Use 'claude-mpm monitor <command> --help' for more information")
-            return 0
-        
-        if args.monitor_command == MonitorCommands.START.value:
-            success = _start_server(args, server_manager)
-            return 0 if success else 1
-        
-        elif args.monitor_command == MonitorCommands.STOP.value:
-            success = _stop_server(args, server_manager)
-            return 0 if success else 1
-        
-        elif args.monitor_command == MonitorCommands.RESTART.value:
-            success = _restart_server(args, server_manager)
-            return 0 if success else 1
-        
-        elif args.monitor_command == MonitorCommands.PORT.value:
-            success = _port_server(args, server_manager)
-            return 0 if success else 1
-        
-        else:
-            logger.error(f"Unknown monitor command: {args.monitor_command}")
-            print(f"Unknown monitor command: {args.monitor_command}")
-            print("Available commands: start, stop, restart, port")
-            return 1
-        
-    except ImportError as e:
-        logger.error(f"Server manager not available: {e}")
-        print("Error: Socket.IO server manager not available")
-        print("This may indicate a missing dependency or installation issue.")
-        return 1
-    except Exception as e:
-        logger.error(f"Error managing monitor: {e}")
-        print(f"Error: {e}")
-        return 1
-    
-    return 0
+class MonitorCommand(BaseCommand):
+    """Monitor command for managing the unified monitoring daemon."""
 
+    def __init__(self):
+        super().__init__("monitor")
+        self.daemon = None
 
-def _port_server(args, server_manager):
-    """
-    Start or restart the Socket.IO monitoring server on a specific port.
-    
-    WHY: Users need to be able to start/restart the monitoring server on a specific
-    port, either if no server is running (start) or if a server is already running
-    on a different port (restart).
-    
-    Args:
-        args: Command arguments with required port and optional host
-        server_manager: ServerManager instance
-        
-    Returns:
-        bool: True if server started/restarted successfully, False otherwise
-    """
-    port = args.port
-    host = getattr(args, 'host', 'localhost')
-    
-    print(f"Managing Socket.IO monitoring server on port {port}...")
-    print(f"Target: {host}:{port}")
-    print()
-    
-    try:
-        # Check if there are any running servers
-        running_servers = server_manager.list_running_servers()
-        
-        # Check if server is already running on this port
-        server_on_port = any(server.get('port') == port for server in running_servers)
-        
-        if server_on_port:
-            print(f"Server already running on port {port}. Restarting...")
-            success = server_manager.restart_server(port=port)
-            action = "restarted"
+    def validate_args(self, args) -> Optional[str]:
+        """Validate command arguments."""
+        # Monitor command allows no subcommand (defaults to status)
+        if hasattr(args, "monitor_command") and args.monitor_command:
+            valid_commands = [cmd.value for cmd in MonitorCommands]
+            if args.monitor_command not in valid_commands:
+                return f"Unknown monitor command: {args.monitor_command}. Valid commands: {', '.join(valid_commands)}"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the monitor command using unified monitoring daemon."""
+        try:
+            self.logger.info("Monitor command using unified monitoring daemon")
+
+            # Handle default case (no subcommand) - default to status
+            if not hasattr(args, "monitor_command") or not args.monitor_command:
+                return self._status_monitor(args)
+
+            # Route to specific monitor commands
+            if args.monitor_command == MonitorCommands.START.value:
+                return self._start_monitor(args)
+            if args.monitor_command == MonitorCommands.STOP.value:
+                return self._stop_monitor(args)
+            if args.monitor_command == MonitorCommands.RESTART.value:
+                return self._restart_monitor(args)
+            if args.monitor_command == MonitorCommands.STATUS.value:
+                return self._status_monitor(args)
+
+            return CommandResult.error_result(
+                f"Unknown monitor command: {args.monitor_command}"
+            )
+
+        except Exception as e:
+            self.logger.error(f"Error executing monitor command: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error executing monitor command: {e}")
+
+    def _start_monitor(self, args) -> CommandResult:
+        """Start the unified monitor daemon."""
+        port = getattr(args, "port", None)
+        if port is None:
+            port = 8765  # Default to 8765 for unified monitor
+        host = getattr(args, "host", "localhost")
+
+        # Check for explicit foreground flag first, then background flag
+        # Default to daemon/background mode if neither specified
+        if getattr(args, "foreground", False):
+            daemon_mode = False
+        elif getattr(args, "background", None) is not None:
+            daemon_mode = getattr(args, "background", False)
         else:
-            # Check if servers are running on other ports
-            if running_servers:
-                print("Servers running on other ports:")
-                for server in running_servers:
-                    server_port = server.get('port')
-                    server_id = server.get('server_id', 'unknown')
-                    print(f"  • Server '{server_id}' on port {server_port}")
-                print()
-                print(f"Starting new server on port {port}...")
+            # Default to daemon/background mode
+            daemon_mode = True
+
+        mode_str = "background/daemon" if daemon_mode else "foreground"
+        self.logger.info(
+            f"Starting unified monitor daemon on {host}:{port} (mode: {mode_str})"
+        )
+
+        # Create unified monitor daemon
+        self.daemon = UnifiedMonitorDaemon(
+            host=host, port=port, daemon_mode=daemon_mode
+        )
+
+        # Get force restart flag
+        force_restart = getattr(args, "force", False)
+
+        # Check if already running
+        if self.daemon.lifecycle.is_running() and not force_restart:
+            existing_pid = self.daemon.lifecycle.get_pid()
+            return CommandResult.success_result(
+                f"Unified monitor daemon already running with PID {existing_pid}",
+                data={
+                    "url": f"http://{host}:{port}",
+                    "port": port,
+                    "pid": existing_pid,
+                },
+            )
+
+        # Start the daemon (with force restart if specified)
+        if self.daemon.start(force_restart=force_restart):
+            # For daemon mode, verify it actually started
+            if daemon_mode:
+                # Give it a moment to fully initialize
+                import time
+
+                time.sleep(0.5)
+
+                # Check if it's actually running
+                if not self.daemon.lifecycle.is_running():
+                    return CommandResult.error_result(
+                        "Monitor daemon failed to start. Check ~/.claude-mpm/monitor-daemon.log for details."
+                    )
+
+                # Get the actual PID
+                actual_pid = self.daemon.lifecycle.get_pid()
+                mode_info = f" in background (PID: {actual_pid})"
             else:
-                print("No servers currently running. Starting new server...")
-            
-            success = server_manager.start_server(port=port, host=host, server_id="monitor-server")
-            action = "started"
-        
-        if success:
-            print()
-            print(f"Monitor server {action} successfully on port {port}")
-            print()
-            print("Server management commands:")
-            print(f"  Status:  ps aux | grep socketio")
-            print(f"  Stop:    claude-mpm monitor stop --port {port}")
-            print(f"  Restart: claude-mpm monitor restart --port {port}")
-            print()
-            print(f"WebSocket URL: ws://{host}:{port}")
-        else:
-            print(f"Failed to {action.replace('ed', '')} server on port {port}")
-            print()
-            print("Troubleshooting:")
-            print(f"  • Check if port {port} is available: lsof -i :{port}")
-            print(f"  • Try a different port: claude-mpm monitor port {port + 1}")
-            print("  • Check system resources: free -h && df -h")
-        
-        return success
-        
-    except Exception as e:
-        print(f"Error managing server on port {port}: {e}")
-        print()
-        print("Troubleshooting:")
-        print(f"  • Verify port {port} is valid and available")
-        print("  • Check system resources and permissions")
-        print("  • Try manual start/stop operations")
-        return False
-
-
-def _start_server(args, server_manager):
-    """
-    Start the Socket.IO monitoring server.
-    
-    WHY: Users need to start the monitoring server to enable real-time monitoring
-    of Claude MPM sessions and websocket connections.
-    
-    Args:
-        args: Command arguments with optional port and host
-        server_manager: ServerManager instance
-        
-    Returns:
-        bool: True if server started successfully, False otherwise
-    """
-    port = getattr(args, 'port', 8765)
-    host = getattr(args, 'host', 'localhost')
-    
-    print(f"Starting Socket.IO monitoring server...")
-    print(f"Target: {host}:{port}")
-    print()
-    
-    try:
-        success = server_manager.start_server(port=port, host=host, server_id="monitor-server")
-        
-        if success:
-            print()
-            print("Monitor server management commands:")
-            print(f"  Status: claude-mpm monitor status")
-            print(f"  Stop:   claude-mpm monitor stop")
-            print(f"  Restart: claude-mpm monitor restart")
-            print()
-            print(f"WebSocket URL: ws://{host}:{port}")
-            
-        return success
-        
-    except Exception as e:
-        print(f"Failed to start monitoring server: {e}")
-        print()
-        print("Troubleshooting:")
-        print(f"  • Check if port {port} is available: lsof -i :{port}")
-        print(f"  • Try a different port: claude-mpm monitor start --port {port + 1}")
-        print("  • Check system resources: free -h && df -h")
-        return False
-
-
-def _stop_server(args, server_manager):
-    """
-    Stop the Socket.IO monitoring server.
-    
-    WHY: Users need to stop the monitoring server when it's no longer needed
-    or when troubleshooting connection issues.
-    
-    Args:
-        args: Command arguments with optional port
-        server_manager: ServerManager instance
-        
-    Returns:
-        bool: True if server stopped successfully, False otherwise
-    """
-    port = getattr(args, 'port', None)
-    
-    print("Stopping Socket.IO monitoring server...")
-    
-    try:
-        # If no port specified, try to find running servers and stop them
+                mode_info = " in foreground"
+
+            return CommandResult.success_result(
+                f"Unified monitor daemon started on {host}:{port}{mode_info}",
+                data={"url": f"http://{host}:{port}", "port": port, "mode": mode_str},
+            )
+
+        # Check if error was due to port already in use
+        import socket
+
+        try:
+            test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            test_sock.connect((host, port))
+            test_sock.close()
+            return CommandResult.error_result(
+                f"Port {port} is already in use. Try 'claude-mpm monitor stop' first or use a different port."
+            )
+        except Exception:
+            pass
+
+        return CommandResult.error_result(
+            "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
+        )
+
+    def _stop_monitor(self, args) -> CommandResult:
+        """Stop the unified monitor daemon."""
+        # Don't log here - the daemon will log when it stops
+
+        # Get parameters from args or use defaults
+        port = getattr(args, "port", None)
         if port is None:
-            running_servers = server_manager.list_running_servers()
-            if not running_servers:
-                print("No running servers found to stop")
-                return True
-            
-            # Stop the first server (or all if multiple)
-            success = True
-            for server in running_servers:
-                server_port = server.get('port')
-                server_id = server.get('server_id', 'unknown')
-                print(f"Stopping server '{server_id}' on port {server_port}...")
-                
-                if not server_manager.stop_server(port=server_port):
-                    print(f"Failed to stop server on port {server_port}")
-                    success = False
-            
-            return success
+            port = 8765  # Default to 8765 for unified monitor
+        host = getattr(args, "host", "localhost")
+
+        # Create daemon instance to check status and stop
+        # For stop, we need to know if it was started in daemon mode
+        # We default to daemon mode since that's the usual case
+        daemon_mode = True
+        daemon = UnifiedMonitorDaemon(host=host, port=port, daemon_mode=daemon_mode)
+
+        if not daemon.lifecycle.is_running():
+            return CommandResult.success_result("No unified monitor daemon running")
+
+        # Stop the daemon
+        if daemon.stop():
+            return CommandResult.success_result("Unified monitor daemon stopped")
+        return CommandResult.error_result("Failed to stop unified monitor daemon")
+
+    def _restart_monitor(self, args) -> CommandResult:
+        """Restart the unified monitor daemon."""
+        self.logger.info("Restarting unified monitor daemon")
+
+        # Get parameters from args or use defaults
+        port = getattr(args, "port", None)
+        if port is None:
+            port = 8765  # Default to 8765 for unified monitor
+        host = getattr(args, "host", "localhost")
+
+        # For restart, default to daemon mode (the usual use case)
+        # unless explicitly running in foreground
+        daemon_mode = not getattr(args, "foreground", False)
+
+        # Create daemon instance with proper parameters
+        daemon = UnifiedMonitorDaemon(host=host, port=port, daemon_mode=daemon_mode)
+
+        # Restart the daemon
+        if daemon.restart():
+            return CommandResult.success_result(
+                f"Unified monitor daemon restarted on {host}:{port}"
+            )
+        return CommandResult.error_result("Failed to restart unified monitor daemon")
+
+    def _status_monitor(self, args) -> CommandResult:
+        """Get unified monitor daemon status."""
+
+        # Create daemon instance to check status
+        daemon = UnifiedMonitorDaemon()
+        status_data = daemon.status()
+
+        # Format output message
+        if status_data["running"]:
+            message = f"Unified monitor daemon is running at http://{status_data['host']}:{status_data['port']}"
+            if status_data.get("pid"):
+                message += f" (PID: {status_data['pid']})"
         else:
-            # Stop specific server on given port
-            success = server_manager.stop_server(port=port)
-            
-            if success:
-                print(f"Monitor server stopped on port {port}")
-            else:
-                print(f"Failed to stop server on port {port}")
-                print()
-                print("Troubleshooting:")
-                print(f"  • Check if server is running: claude-mpm monitor status")
-                print(f"  • Try force kill: kill $(lsof -ti :{port})")
-            
-            return success
-        
-    except Exception as e:
-        print(f"Error stopping server: {e}")
-        return False
-
-
-def _restart_server(args, server_manager):
+            message = "Unified monitor daemon is not running"
+
+        return CommandResult.success_result(message, data=status_data)
+
+
+def manage_monitor(args):
     """
-    Restart the Socket.IO monitoring server.
-    
-    WHY: Users need to restart the monitoring server to apply configuration
-    changes or recover from error states.
-    
-    Args:
-        args: Command arguments with optional port
-        server_manager: ServerManager instance
-        
-    Returns:
-        bool: True if server restarted successfully, False otherwise
+    Main entry point for monitor command.
+
+    The monitor command manages the unified monitoring daemon that provides
+    a single stable way to launch all monitoring functionality including
+    HTTP dashboard, Socket.IO events, real AST analysis, and Claude Code hooks.
     """
-    port = getattr(args, 'port', None)
-    
-    print("Restarting Socket.IO monitoring server...")
-    
-    try:
-        # If no port specified, find running servers to restart
-        if port is None:
-            running_servers = server_manager.list_running_servers()
-            if not running_servers:
-                print("No running servers found. Starting new server on default port...")
-                return _start_server(args, server_manager)
-            
-            # Restart the first server found
-            server = running_servers[0]
-            port = server.get('port', 8765)
-            
-        print(f"Using port {port} for restart...")
-        
-        # Use ServerManager's restart method
-        success = server_manager.restart_server(port=port)
-        
-        if success:
-            print(f"Monitor server restarted successfully on port {port}")
-            print()
-            print("Server management commands:")
-            print(f"  Status: claude-mpm monitor status")
-            print(f"  Stop:   claude-mpm monitor stop --port {port}")
-            print(f"  Start:  claude-mpm monitor start --port {port}")
-        else:
-            print(f"Failed to restart server on port {port}")
-            print()
-            print("Troubleshooting:")
-            print("  • Try stopping and starting manually:")
-            print(f"    claude-mpm monitor stop --port {port}")
-            print(f"    claude-mpm monitor start --port {port}")
-            print("  • Check server logs for errors")
-        
-        return success
-        
-    except Exception as e:
-        print(f"Error restarting server: {e}")
-        print()
-        print("Fallback options:")
-        print("  • Manual restart: stop then start")
-        print("  • Check system resources and try again")
-        return False
+    command = MonitorCommand()
+    error = command.validate_args(args)
+
+    if error:
+        command.logger.error(error)
+        print(f"Error: {error}")
+        return 1
+
+    result = command.run(args)
+
+    if result.success:
+        if result.message:
+            print(result.message)
+        if result.data and getattr(args, "verbose", False):
+            import json
+
+            print(json.dumps(result.data, indent=2))
+        return 0
+    if result.message:
+        print(f"Error: {result.message}")
+    return 1

claude_mpm/cli/commands/mpm_init/__init__.py

@@ -0,0 +1,73 @@
+"""MPM initialization command package.
+
+This package provides comprehensive project initialization and update capabilities
+for Claude Code and Claude MPM. It includes:
+
+- Core command class (MPMInitCommand) for orchestrating initialization
+- Click CLI commands for command-line interface
+- Modular components for prompts, display, git analysis, and modes
+- Support for multiple initialization modes (create, update, review, quick-update, catchup)
+
+Main Components:
+- core.py: MPMInitCommand class - main initialization orchestrator
+- mpm_init_cli.py: Click command definitions and CLI entry points
+- prompts.py: Prompt building functions for agent delegation
+- display.py: Display and UI helper functions
+- git_activity.py: Git history analysis and context building
+- modes.py: Mode-specific handlers (review, dry-run, quick-update, etc.)
+
+Public API:
+- MPMInitCommand: Main command class (from core)
+- mpm_init: Click command group (from mpm_init_cli)
+
+Example Usage:
+    # Programmatic usage
+    from claude_mpm.cli.commands.mpm_init import MPMInitCommand
+    command = MPMInitCommand(project_path)
+    result = command.initialize_project()
+
+    # CLI usage (via Click)
+    from claude_mpm.cli.commands.mpm_init import mpm_init
+    # Command is registered with Click and invoked via CLI
+"""
+
+# Import core components for re-export
+from .core import MPMInitCommand
+
+# Import the Click command group - this must be imported from parent level
+# to avoid circular dependencies, as mpm_init_cli imports from core
+# We'll handle this via late import in __all__
+
+__all__ = [
+    # Main command class
+    "MPMInitCommand",
+    "core",
+    # Internal modules (for internal package use)
+    "display",
+    "git_activity",
+    "modes",
+    # Click CLI command (imported via __getattr__ to avoid circular import)
+    "mpm_init",
+    "prompts",
+]
+
+
+def __getattr__(name):
+    """Lazy import to avoid circular dependencies.
+
+    This allows importing mpm_init Click command without importing
+    mpm_init_cli at module load time, which would cause circular imports.
+    """
+    if name == "mpm_init":
+        # Lazy import the Click command group
+        from ..mpm_init_cli import mpm_init as _mpm_init
+
+        return _mpm_init
+
+    # For internal module imports, import them directly
+    if name in ("display", "git_activity", "prompts", "modes", "core"):
+        import importlib
+
+        return importlib.import_module(f".{name}", __package__)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")