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

claude_mpm/cli/commands/uninstall.py

@@ -0,0 +1,176 @@
+"""
+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
+        return self._uninstall_hooks(args)
+
+        # Additional cleanup can be added here
+        # For example: removing agent configurations, cache, etc.
+
+
+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/commands/upgrade.py

@@ -0,0 +1,152 @@
+"""
+Upgrade command implementation for claude-mpm.
+
+WHY: This module provides a manual upgrade command that allows users to check
+for and install the latest version of claude-mpm without waiting for the
+automatic startup check.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Leverage SelfUpgradeService for upgrade functionality
+- Support multiple installation methods (pip, pipx, npm)
+- Skip editable/development installations (must upgrade manually)
+- Provide clear feedback on available updates and upgrade progress
+"""
+
+import asyncio
+
+from ..shared import BaseCommand, CommandResult
+
+
+class UpgradeCommand(BaseCommand):
+    """Upgrade command using shared utilities."""
+
+    def __init__(self):
+        super().__init__("upgrade")
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        # Upgrade command doesn't require specific validation
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the upgrade command."""
+        try:
+            from ...services.self_upgrade_service import (
+                InstallationMethod,
+                SelfUpgradeService,
+            )
+
+            # Create upgrade service
+            upgrade_service = SelfUpgradeService()
+
+            # Check installation method
+            if upgrade_service.installation_method == InstallationMethod.EDITABLE:
+                self.logger.info(
+                    "Editable installation detected - upgrade must be done manually"
+                )
+                print("\n⚠️  Editable Installation Detected")
+                print(
+                    "\nYou are running claude-mpm from an editable installation (development mode)."
+                )
+                print("To upgrade, run:")
+                print("  cd /path/to/claude-mpm")
+                print("  git pull")
+                print("  pip install -e .")
+                return CommandResult.success_result(
+                    "Upgrade information provided for editable installation"
+                )
+
+            # Check for updates
+            print("\n🔍 Checking for updates...")
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                update_info = loop.run_until_complete(
+                    upgrade_service.check_for_update()
+                )
+            finally:
+                loop.close()
+
+            if not update_info or not update_info.get("update_available"):
+                print(
+                    f"\n✅ You are already on the latest version (v{upgrade_service.current_version})"
+                )
+                return CommandResult.success_result("Already on latest version")
+
+            # Display update information
+            current = update_info["current"]
+            latest = update_info["latest"]
+            method = update_info.get("installation_method", "unknown")
+
+            print("\n🎉 New version available!")
+            print(f"   Current: v{current}")
+            print(f"   Latest:  v{latest}")
+            print(f"   Installation method: {method}")
+
+            # Check if --yes flag is set for non-interactive upgrade
+            force_upgrade = getattr(args, "yes", False) or getattr(args, "force", False)
+
+            if not force_upgrade:
+                # Prompt user for confirmation
+                if not upgrade_service.prompt_for_upgrade(update_info):
+                    print("\n⏸️  Upgrade cancelled by user")
+                    return CommandResult.success_result("Upgrade cancelled by user")
+
+            # Perform upgrade
+            success, message = upgrade_service.perform_upgrade(update_info)
+            print(f"\n{message}")
+
+            if success:
+                # Restart after successful upgrade
+                upgrade_service.restart_after_upgrade()
+                # Note: This line won't be reached as restart replaces process
+                return CommandResult.success_result(f"Upgraded to v{latest}")
+            return CommandResult.error_result("Upgrade failed")
+
+        except Exception as e:
+            self.logger.error(f"Error during upgrade: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error during upgrade: {e}")
+
+
+def add_upgrade_parser(subparsers):
+    """
+    Add upgrade command parser.
+
+    WHY: This command helps users check for and install the latest version of
+    claude-mpm without waiting for the automatic startup check.
+
+    Args:
+        subparsers: The subparser action object to add the upgrade command to
+    """
+    parser = subparsers.add_parser(
+        "upgrade",
+        help="Check for and install latest claude-mpm version",
+        description="Check for updates and upgrade claude-mpm to the latest version from PyPI/npm",
+    )
+
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt and upgrade immediately if available",
+    )
+
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force upgrade even if already on latest version (alias for --yes)",
+    )
+
+    return parser
+
+
+def upgrade(args):
+    """
+    Main entry point for upgrade command.
+
+    This function maintains backward compatibility while using the new BaseCommand pattern.
+    """
+    command = UpgradeCommand()
+    result = command.execute(args)
+    return result.exit_code

claude_mpm/cli/commands/verify.py

@@ -0,0 +1,119 @@
+"""
+Verify command for MCP service health checks.
+"""
+
+import argparse
+
+from ...core.logger import get_logger
+from ...services.mcp_service_verifier import MCPServiceVerifier, ServiceStatus
+
+
+def add_parser(subparsers) -> None:
+    """Add the verify command parser."""
+    parser = subparsers.add_parser(
+        "verify",
+        help="Verify MCP services installation and configuration",
+        description="Performs comprehensive health checks on MCP services",
+    )
+
+    parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Attempt to automatically fix detected issues",
+    )
+
+    parser.add_argument(
+        "--service",
+        type=str,
+        help="Verify a specific service only",
+        choices=["mcp-vector-search", "mcp-browser", "mcp-ticketer", "kuzu-memory"],
+    )
+
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results in JSON format",
+    )
+
+    parser.set_defaults(func=handle_verify)
+
+
+def handle_verify(args: argparse.Namespace) -> int:
+    """
+    Handle the verify command.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for issues found)
+    """
+    logger = get_logger(__name__)
+    verifier = MCPServiceVerifier()
+
+    try:
+        # Run verification
+        if args.service:
+            # Verify single service
+            logger.info(f"Verifying {args.service}...")
+            diagnostic = verifier._verify_service(args.service)
+            diagnostics = {args.service: diagnostic}
+
+            # Auto-fix if requested
+            if (
+                args.fix
+                and diagnostic.fix_command
+                and diagnostic.status != ServiceStatus.WORKING
+            ):
+                logger.info(f"Attempting to fix {args.service}...")
+                if verifier._attempt_auto_fix(args.service, diagnostic):
+                    # Re-verify after fix
+                    diagnostic = verifier._verify_service(args.service)
+                    diagnostics = {args.service: diagnostic}
+        else:
+            # Verify all services
+            logger.info("Verifying all MCP services...")
+            diagnostics = verifier.verify_all_services(auto_fix=args.fix)
+
+        # Output results
+        if args.json:
+            import json
+
+            # Convert to JSON-serializable format
+            json_output = {}
+            for name, diag in diagnostics.items():
+                json_output[name] = {
+                    "status": diag.status.value,
+                    "message": diag.message,
+                    "installed_path": diag.installed_path,
+                    "configured_command": diag.configured_command,
+                    "fix_command": diag.fix_command,
+                    "details": diag.details,
+                }
+            print(json.dumps(json_output, indent=2))
+        else:
+            verifier.print_diagnostics(diagnostics)
+
+        # Determine exit code
+        all_working = all(
+            d.status == ServiceStatus.WORKING for d in diagnostics.values()
+        )
+
+        if all_working:
+            logger.info("✅ All verified services are fully operational")
+            return 0
+        issues_count = sum(
+            1 for d in diagnostics.values() if d.status != ServiceStatus.WORKING
+        )
+        logger.warning(f"⚠️ {issues_count} service(s) have issues")
+        return 1
+
+    except Exception as e:
+        logger.error(f"Verification failed: {e}")
+        if args.json:
+            import json
+
+            print(json.dumps({"error": str(e)}, indent=2))
+        else:
+            print(f"\n❌ Verification failed: {e}")
+        return 2