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

claude_mpm/cli/commands/memory.py

@@ -16,6 +16,7 @@ import os
 from pathlib import Path
 from typing import Any, Dict
 
+from ...core.enums import OutputFormat
 from ...core.shared.config_loader import ConfigLoader
 from ...services.agents.memory import AgentMemoryManager
 from ...services.cli.memory_crud_service import MemoryCRUDService
@@ -23,6 +24,14 @@ from ...services.cli.memory_output_formatter import MemoryOutputFormatter
 from ..shared.base_command import CommandResult, MemoryCommand
 
 
+def _is_structured_output(args) -> bool:
+    """Check if args specify structured output format (JSON/YAML)."""
+    if hasattr(args, "format"):
+        fmt = str(args.format).lower()
+        return fmt in (OutputFormat.JSON, OutputFormat.YAML)
+    return False
+
+
 class MemoryManagementCommand(MemoryCommand):
     """Memory management command using shared utilities."""
 
@@ -39,7 +48,7 @@ class MemoryManagementCommand(MemoryCommand):
             config_loader = ConfigLoader()
             config = config_loader.load_main_config()
             # Use CLAUDE_MPM_USER_PWD if available, otherwise use current working directory
-            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", os.getcwd())
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
             current_dir = Path(user_pwd)
             self._memory_manager = AgentMemoryManager(config, current_dir)
         return self._memory_manager
@@ -60,6 +69,31 @@ class MemoryManagementCommand(MemoryCommand):
             self._crud_service = MemoryCRUDService(memory_manager=self.memory_manager)
         return self._crud_service
 
+    def _get_output_format(self, args) -> str:
+        """
+        Get output format from args with enum default.
+
+        Args:
+            args: Command arguments
+
+        Returns:
+            Output format string (compatible with both enum and string usage)
+        """
+        return getattr(args, "format", OutputFormat.TEXT)
+
+    def _is_structured_format(self, format_str: str) -> bool:
+        """
+        Check if format is structured (JSON/YAML).
+
+        Args:
+            format_str: Format string to check
+
+        Returns:
+            True if format is JSON or YAML
+        """
+        fmt = str(format_str).lower()
+        return fmt in (OutputFormat.JSON, OutputFormat.YAML)
+
     def validate_args(self, args) -> str:
         """Validate command arguments."""
         # Check if memory command is valid
@@ -104,8 +138,8 @@ class MemoryManagementCommand(MemoryCommand):
             available_commands = list(command_map.keys())
             error_msg = f"Unknown memory command: {args.memory_command}"
 
-            output_format = getattr(args, "format", "text")
-            if output_format in ["json", "yaml"]:
+            output_format = self._get_output_format(args)
+            if self._is_structured_format(output_format):
                 return CommandResult.error_result(
                     error_msg, data={"available_commands": available_commands}
                 )
@@ -120,9 +154,9 @@ class MemoryManagementCommand(MemoryCommand):
     def _show_status(self, args) -> CommandResult:
         """Show memory system status."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # Structured output
                 status_data = self._get_status_data()
                 return CommandResult.success_result(
@@ -175,7 +209,7 @@ class MemoryManagementCommand(MemoryCommand):
     def _show_memories(self, args) -> CommandResult:
         """Show agent memories."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             agent_id = getattr(args, "agent_id", None)
             raw_output = getattr(args, "raw", False)
 
@@ -245,7 +279,7 @@ class MemoryManagementCommand(MemoryCommand):
     def _init_memory(self, args) -> CommandResult:
         """Initialize project-specific memories."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
             # Use CRUD service for initialization task
             result = self.crud_service.init_project_memories()
@@ -255,7 +289,7 @@ class MemoryManagementCommand(MemoryCommand):
                     result.get("error", "Failed to create initialization task")
                 )
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # Return structured task data
                 return CommandResult.success_result(
                     "Memory initialization task created", data=result.get("task_data")
@@ -293,7 +327,7 @@ class MemoryManagementCommand(MemoryCommand):
     def _add_learning(self, args) -> CommandResult:
         """Add learning to agent memory."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
             # Extract arguments
             agent_id = getattr(args, "agent_id", None)
@@ -313,7 +347,7 @@ class MemoryManagementCommand(MemoryCommand):
                     result.get("error", "Failed to add learning")
                 )
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # Return structured result
                 return CommandResult.success_result(
                     "Learning added to agent memory", data=result
@@ -333,7 +367,7 @@ class MemoryManagementCommand(MemoryCommand):
     def _clean_memory(self, args) -> CommandResult:
         """Clean up old/unused memory files."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             agent_id = getattr(args, "agent_id", None)
             dry_run = getattr(args, "dry_run", True)
 
@@ -343,7 +377,7 @@ class MemoryManagementCommand(MemoryCommand):
             if not result.get("success"):
                 return CommandResult.error_result(result.get("error", "Cleanup failed"))
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # Return structured cleanup results
                 return CommandResult.success_result(
                     result.get("message", "Memory cleanup completed"), data=result
@@ -384,10 +418,10 @@ class MemoryManagementCommand(MemoryCommand):
     def _optimize_memory(self, args) -> CommandResult:
         """Optimize memory files."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             agent_id = getattr(args, "agent_id", None)
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # For structured output, perform optimization and return results
                 if agent_id:
                     result = self.memory_manager.optimize_memory(agent_id)
@@ -419,9 +453,9 @@ class MemoryManagementCommand(MemoryCommand):
     def _build_memory(self, args) -> CommandResult:
         """Build agent memories from project documentation."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # For structured output, return build results
                 build_data = {
                     "built_memories": [],
@@ -442,9 +476,9 @@ class MemoryManagementCommand(MemoryCommand):
     def _cross_reference_memory(self, args) -> CommandResult:
         """Find cross-references and common patterns."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # For structured output, return cross-reference results
                 crossref_data = {
                     "common_patterns": [],
@@ -465,9 +499,9 @@ class MemoryManagementCommand(MemoryCommand):
     def _route_memory_command(self, args) -> CommandResult:
         """Route memory command to appropriate agent."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 # For structured output, return routing results
                 routing_data = {
                     "routed_to": "memory_agent",
@@ -495,7 +529,7 @@ def manage_memory(args) -> int:
     result = command.execute(args)
 
     # Print result if structured output format is requested
-    if hasattr(args, "format") and args.format in ["json", "yaml"]:
+    if _is_structured_output(args):
         command.print_result(result, args)
 
     return result.exit_code

claude_mpm/cli/commands/monitor.py

@@ -1,31 +1,31 @@
 """
 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.
-The monitor command now delegates to the unified dashboard service for consolidated operation.
+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 DECISIONS:
-- Delegate to dashboard command for unified service architecture
-- Use BaseCommand for consistent CLI patterns
-- Maintain backward compatibility with existing Socket.IO server management
-- Support multiple output formats (json, yaml, table, text)
+- 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
 """
 
 from typing import Optional
 
 from ...constants import MonitorCommands
+from ...services.monitor.daemon import UnifiedMonitorDaemon
 from ..shared import BaseCommand, CommandResult
-from .dashboard import DashboardCommand
 
 
 class MonitorCommand(BaseCommand):
-    """Monitor command that delegates to the unified dashboard service."""
+    """Monitor command for managing the unified monitoring daemon."""
 
     def __init__(self):
         super().__init__("monitor")
-        # Create dashboard command instance for delegation
-        self.dashboard_command = DashboardCommand()
+        self.daemon = None
 
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
@@ -38,25 +38,23 @@ class MonitorCommand(BaseCommand):
         return None
 
     def run(self, args) -> CommandResult:
-        """Execute the monitor command by delegating to dashboard service."""
+        """Execute the monitor command using unified monitoring daemon."""
         try:
-            self.logger.info("Monitor command delegating to unified dashboard service")
+            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_dashboard(args)
+                return self._status_monitor(args)
 
-            # Map monitor commands to dashboard commands
+            # Route to specific monitor commands
             if args.monitor_command == MonitorCommands.START.value:
-                return self._start_dashboard(args)
+                return self._start_monitor(args)
             if args.monitor_command == MonitorCommands.STOP.value:
-                return self._stop_dashboard(args)
+                return self._stop_monitor(args)
             if args.monitor_command == MonitorCommands.RESTART.value:
-                return self._restart_dashboard(args)
+                return self._restart_monitor(args)
             if args.monitor_command == MonitorCommands.STATUS.value:
-                return self._status_dashboard(args)
-            if args.monitor_command == MonitorCommands.PORT.value:
-                return self._start_dashboard_on_port(args)
+                return self._status_monitor(args)
 
             return CommandResult.error_result(
                 f"Unknown monitor command: {args.monitor_command}"
@@ -66,66 +64,164 @@ class MonitorCommand(BaseCommand):
             self.logger.error(f"Error executing monitor command: {e}", exc_info=True)
             return CommandResult.error_result(f"Error executing monitor command: {e}")
 
-    def _start_dashboard(self, args) -> CommandResult:
-        """Start the dashboard service (unified HTTP + Socket.IO)."""
-        self.logger.info("Starting unified dashboard service (HTTP + Socket.IO)")
-        # Set default port to 8765 for unified service and background mode
-        if not hasattr(args, "port") or args.port is None:
-            args.port = 8765
-        # Monitor command defaults to background mode for better UX
-        if not hasattr(args, "background"):
-            args.background = True
+    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:
+            # 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})"
+        )
 
-        return self.dashboard_command._start_dashboard(args)
+        # Create unified monitor daemon
+        self.daemon = UnifiedMonitorDaemon(
+            host=host, port=port, daemon_mode=daemon_mode
+        )
 
-    def _stop_dashboard(self, args) -> CommandResult:
-        """Stop the dashboard service."""
-        self.logger.info("Stopping unified dashboard service")
-        # Use default port if not specified
-        if not hasattr(args, "port") or args.port is None:
-            args.port = 8765
+        # 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,
+                },
+            )
 
-        return self.dashboard_command._stop_dashboard(args)
+        # 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:
+                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},
+            )
 
-    def _restart_dashboard(self, args) -> CommandResult:
-        """Restart the dashboard service."""
-        self.logger.info("Restarting unified dashboard service")
+        # Check if error was due to port already in use
+        import socket
 
-        # Stop first
-        stop_result = self._stop_dashboard(args)
-        if not stop_result.success:
-            self.logger.warning("Failed to stop service for restart, proceeding anyway")
+        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
 
-        # Wait a moment
-        import time
+        return CommandResult.error_result(
+            "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
+        )
 
-        time.sleep(1)
+    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:
+            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")
 
-        # Start again
-        return self._start_dashboard(args)
+    def _status_monitor(self, args) -> CommandResult:
+        """Get unified monitor daemon status."""
 
-    def _status_dashboard(self, args) -> CommandResult:
-        """Get dashboard service status."""
-        return self.dashboard_command._status_dashboard(args)
+        # Create daemon instance to check status
+        daemon = UnifiedMonitorDaemon()
+        status_data = daemon.status()
 
-    def _start_dashboard_on_port(self, args) -> CommandResult:
-        """Start dashboard service on specific port."""
-        self.logger.info(
-            f"Starting dashboard service on port {getattr(args, 'port', 8765)}"
-        )
-        # Ensure background mode for port-specific starts
-        if not hasattr(args, "background"):
-            args.background = True
+        # 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:
+            message = "Unified monitor daemon is not running"
 
-        return self.dashboard_command._start_dashboard(args)
+        return CommandResult.success_result(message, data=status_data)
 
 
 def manage_monitor(args):
     """
     Main entry point for monitor command.
 
-    The monitor command now delegates to the unified dashboard service for consolidated operation.
-    Both dashboard and monitor commands now use the same underlying service on port 8765.
+    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.
     """
     command = MonitorCommand()
     error = command.validate_args(args)
@@ -148,9 +244,3 @@ def manage_monitor(args):
     if result.message:
         print(f"Error: {result.message}")
     return 1
-
-
-# All legacy functions have been removed.
-# The monitor command now delegates to the unified dashboard service.
-# This consolidation provides a single service that handles both HTTP (port 8765)
-# and Socket.IO (also on port 8765) rather than separate services on different ports.

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}")