claude-mpm 4.2.23__py3-none-any.whl → 4.2.25__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.2.23
+4.2.25

claude_mpm/cli/__init__.py

@@ -399,6 +399,16 @@ def _execute_command(command: str, args) -> int:
         result = manage_mpm_init(args)
         return result if result is not None else 0
 
+    # Handle uninstall command with lazy import
+    if command == "uninstall":
+        # Lazy import to avoid loading unless needed
+        from .commands.uninstall import UninstallCommand
+
+        cmd = UninstallCommand()
+        result = cmd.execute(args)
+        # Convert CommandResult to exit code
+        return result.exit_code if result else 0
+
     # Map stable commands to their implementations
     command_map = {
         CLICommands.RUN.value: run_session,

claude_mpm/cli/commands/monitor.py

@@ -93,7 +93,7 @@ class MonitorCommand(BaseCommand):
 
         # 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()
@@ -112,27 +112,29 @@ class MonitorCommand(BaseCommand):
             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},
             )
-        
+
         # 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))
@@ -142,7 +144,7 @@ class MonitorCommand(BaseCommand):
             )
         except:
             pass
-        
+
         return CommandResult.error_result(
             "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
         )

claude_mpm/cli/commands/uninstall.py

@@ -0,0 +1,178 @@
+"""
+Uninstall command for claude-mpm CLI.
+
+WHY: Users need a straightforward way to cleanly uninstall Claude MPM hooks
+and other components without navigating through configuration menus.
+
+DESIGN DECISIONS:
+- Provide clear feedback about what is being removed
+- Preserve user's other Claude settings
+- Support both interactive confirmation and --yes flag
+- Allow selective uninstallation of components
+"""
+
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from ...services.hook_installer_service import HookInstallerService
+from ...utils.console import console as default_console
+from ..shared import BaseCommand, CommandResult
+
+
+class UninstallCommand(BaseCommand):
+    """Handle uninstallation of Claude MPM components."""
+
+    def __init__(self, console: Optional[Console] = None):
+        """Initialize the uninstall command.
+
+        Args:
+            console: Optional Rich console for output.
+        """
+        super().__init__("uninstall")
+        self.console = console or default_console
+        self.hook_service = HookInstallerService()
+
+    def run(self, args) -> CommandResult:
+        """Execute the uninstall command.
+
+        Args:
+            args: Parsed command line arguments.
+
+        Returns:
+            CommandResult indicating success or failure.
+        """
+        try:
+            # Check what component to uninstall
+            if args.component == "hooks" or args.all:
+                return self._uninstall_hooks(args)
+            if args.component == "all":
+                return self._uninstall_all(args)
+            # Default to hooks if no component specified
+            return self._uninstall_hooks(args)
+
+        except Exception as e:
+            self.console.print(f"[red]Error during uninstallation: {e}[/red]")
+            return CommandResult.error_result(str(e))
+
+    def _uninstall_hooks(self, args) -> CommandResult:
+        """Uninstall Claude MPM hooks.
+
+        Args:
+            args: Parsed command line arguments.
+
+        Returns:
+            CommandResult indicating success or failure.
+        """
+        try:
+            # Check if hooks are installed
+            if not self.hook_service.is_hooks_configured():
+                self.console.print(
+                    "[yellow]No Claude MPM hooks are currently installed.[/yellow]"
+                )
+                return CommandResult.success_result("No hooks to uninstall")
+
+            # Get hook status for display
+            status = self.hook_service.get_hook_status()
+
+            # Show what will be removed
+            self.console.print(
+                "\n[cyan]The following Claude MPM hooks will be removed:[/cyan]"
+            )
+            for hook_type, configured in status.get("hook_types", {}).items():
+                if configured:
+                    self.console.print(f"  • {hook_type}")
+
+            # Confirm unless --yes flag is provided
+            if not args.yes:
+                if not Confirm.ask(
+                    "\n[yellow]Do you want to proceed with uninstallation?[/yellow]"
+                ):
+                    self.console.print("[yellow]Uninstallation cancelled.[/yellow]")
+                    return CommandResult.success_result(
+                        "Uninstallation cancelled by user"
+                    )
+
+            # Perform uninstallation
+            self.console.print("\n[cyan]Uninstalling Claude MPM hooks...[/cyan]")
+            success = self.hook_service.uninstall_hooks()
+
+            if success:
+                self.console.print(
+                    Panel(
+                        "[green]✓ Claude MPM hooks have been successfully uninstalled.[/green]\n\n"
+                        "Your other Claude settings have been preserved.",
+                        title="Uninstallation Complete",
+                        border_style="green",
+                    )
+                )
+                return CommandResult.success_result("Hooks uninstalled successfully")
+            self.console.print(
+                "[red]Failed to uninstall hooks. Check the logs for details.[/red]"
+            )
+            return CommandResult.error_result("Failed to uninstall hooks")
+
+        except Exception as e:
+            return CommandResult.error_result(f"Error uninstalling hooks: {e}")
+
+    def _uninstall_all(self, args) -> CommandResult:
+        """Uninstall all Claude MPM components.
+
+        Args:
+            args: Parsed command line arguments.
+
+        Returns:
+            CommandResult indicating success or failure.
+        """
+        # For now, we only have hooks to uninstall
+        # This method can be extended in the future for other components
+        result = self._uninstall_hooks(args)
+
+        # Additional cleanup can be added here
+        # For example: removing agent configurations, cache, etc.
+
+        return result
+
+
+def add_uninstall_parser(subparsers):
+    """Add the uninstall subparser.
+
+    Args:
+        subparsers: The subparsers object from the main parser.
+
+    Returns:
+        The configured uninstall parser.
+    """
+    parser = subparsers.add_parser(
+        "uninstall",
+        help="Uninstall Claude MPM components",
+        description="Remove Claude MPM hooks and other components while preserving other Claude settings",
+    )
+
+    # Component selection
+    parser.add_argument(
+        "component",
+        nargs="?",
+        choices=["hooks", "all"],
+        default="hooks",
+        help="Component to uninstall (default: hooks)",
+    )
+
+    # Confirmation bypass
+    parser.add_argument(
+        "-y", "--yes", action="store_true", help="Skip confirmation prompt"
+    )
+
+    # Force uninstall
+    parser.add_argument(
+        "--force", action="store_true", help="Force uninstallation even if errors occur"
+    )
+
+    # All components
+    parser.add_argument(
+        "--all", action="store_true", help="Uninstall all Claude MPM components"
+    )
+
+    return parser

claude_mpm/cli/parsers/base_parser.py

@@ -345,6 +345,14 @@ def create_parser(
     except ImportError:
         pass
 
+    # Add uninstall command parser
+    try:
+        from ..commands.uninstall import add_uninstall_parser
+
+        add_uninstall_parser(subparsers)
+    except ImportError:
+        pass
+
     # Add debug command parser
     try:
         from .debug_parser import add_debug_subparser

claude_mpm/services/cli/unified_dashboard_manager.py

@@ -75,8 +75,11 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
         self._lock = threading.Lock()
 
     def start_dashboard(
-        self, port: int = 8765, background: bool = False, open_browser: bool = True,
-        force_restart: bool = False
+        self,
+        port: int = 8765,
+        background: bool = False,
+        open_browser: bool = True,
+        force_restart: bool = False,
     ) -> Tuple[bool, bool]:
         """
         Start the dashboard using unified daemon.
@@ -95,19 +98,23 @@ class UnifiedDashboardManager(IUnifiedDashboardManager):
             daemon = UnifiedMonitorDaemon(
                 host="localhost", port=port, daemon_mode=background
             )
-            
+
             # Check if it's our service running
             is_ours, pid = daemon.lifecycle.is_our_service("localhost")
-            
+
             if is_ours and not force_restart:
                 # Our service is already running, just open browser if needed
-                self.logger.info(f"Our dashboard already running on port {port} (PID: {pid})")
+                self.logger.info(
+                    f"Our dashboard already running on port {port} (PID: {pid})"
+                )
                 browser_opened = False
                 if open_browser:
                     browser_opened = self.open_browser(self.get_dashboard_url(port))
                 return True, browser_opened
-            elif is_ours and force_restart:
-                self.logger.info(f"Force restarting our dashboard on port {port} (PID: {pid})")
+            if is_ours and force_restart:
+                self.logger.info(
+                    f"Force restarting our dashboard on port {port} (PID: {pid})"
+                )
             elif self.is_dashboard_running(port) and not force_restart:
                 # Different service is using the port
                 self.logger.warning(f"Port {port} is in use by a different service")