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

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

claude_mpm/cli/executor.py

@@ -0,0 +1,204 @@
+"""
+CLI Command Executor
+====================
+
+This module handles command execution routing and argument preparation.
+
+Part of cli/__init__.py refactoring to reduce file size and improve modularity.
+"""
+
+from ..constants import CLICommands
+from .commands import (
+    aggregate_command,
+    cleanup_memory,
+    manage_agent_manager,
+    manage_agents,
+    manage_config,
+    manage_configure,
+    manage_debug,
+    manage_mcp,
+    manage_memory,
+    manage_monitor,
+    manage_tickets,
+    run_doctor,
+    run_session,
+    show_info,
+)
+from .commands.analyze_code import manage_analyze_code
+from .commands.dashboard import manage_dashboard
+from .commands.skills import manage_skills
+from .commands.upgrade import upgrade
+
+
+def ensure_run_attributes(args):
+    """
+    Ensure run command attributes exist when defaulting to run.
+
+    WHY: When no command is specified, we default to 'run' but the args object
+    won't have run-specific attributes from the subparser. This function ensures
+    they exist with sensible defaults.
+
+    Args:
+        args: Parsed arguments object to update
+    """
+    # Set defaults for run command attributes
+    args.no_tickets = getattr(args, "no_tickets", False)
+    args.no_hooks = getattr(args, "no_hooks", False)
+    args.intercept_commands = getattr(args, "intercept_commands", False)
+    args.input = getattr(args, "input", None)
+    args.non_interactive = getattr(args, "non_interactive", False)
+    args.no_native_agents = getattr(args, "no_native_agents", False)
+
+    # Handle claude_args - if --resume flag is set, add it to claude_args
+    claude_args = getattr(args, "claude_args", [])
+    if getattr(args, "resume", False):
+        # Add --resume to claude_args if not already present
+        if "--resume" not in claude_args:
+            claude_args = ["--resume", *claude_args]
+    args.claude_args = claude_args
+
+    args.launch_method = getattr(args, "launch_method", "exec")
+    args.websocket = getattr(args, "websocket", False)
+    args.websocket_port = getattr(args, "websocket_port", 8765)
+    # CRITICAL: Include mpm_resume attribute for session resumption
+    args.mpm_resume = getattr(args, "mpm_resume", None)
+    # Also include monitor and force attributes
+    args.monitor = getattr(args, "monitor", False)
+    args.force = getattr(args, "force", False)
+    args.reload_agents = getattr(args, "reload_agents", False)
+    # Include dependency checking attributes
+    args.check_dependencies = getattr(args, "check_dependencies", True)
+    args.force_check_dependencies = getattr(args, "force_check_dependencies", False)
+    args.no_prompt = getattr(args, "no_prompt", False)
+    args.force_prompt = getattr(args, "force_prompt", False)
+
+
+def execute_command(command: str, args) -> int:
+    """
+    Execute the specified command.
+
+    WHY: This function maps command names to their implementations, providing
+    a single place to manage command routing. Experimental commands are imported
+    lazily to avoid loading unnecessary code.
+
+    DESIGN DECISION: run_guarded is imported only when needed to maintain
+    separation between stable and experimental features. Command suggestions
+    are provided for unknown commands to improve user experience.
+
+    Args:
+        command: The command name to execute
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code from the command
+    """
+    # Handle experimental run-guarded command separately with lazy import
+    if command == "run-guarded":
+        # Lazy import to avoid loading experimental code unless needed
+        from .commands.run_guarded import execute_run_guarded
+
+        result = execute_run_guarded(args)
+        return result if result is not None else 0
+
+    # Handle mpm-init command with lazy import
+    if command == "mpm-init":
+        # Lazy import to avoid loading unless needed
+        from .commands.mpm_init_handler import manage_mpm_init
+
+        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
+
+    # Handle verify command with lazy import
+    if command == "verify":
+        # Lazy import to avoid loading unless needed
+        from .commands.verify import handle_verify
+
+        result = handle_verify(args)
+        return result if result is not None else 0
+
+    # Handle auto-configure command with lazy import
+    if command == "auto-configure":
+        # Lazy import to avoid loading unless needed
+        from .commands.auto_configure import AutoConfigureCommand
+
+        cmd = AutoConfigureCommand()
+        result = cmd.run(args)
+        # Convert CommandResult to exit code
+        return result.exit_code if result else 0
+
+    # Handle local-deploy command with lazy import
+    if command == "local-deploy":
+        # Lazy import to avoid loading unless needed
+        from .commands.local_deploy import LocalDeployCommand
+
+        cmd = LocalDeployCommand()
+        result = cmd.run(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,
+        # CLICommands.RUN_GUARDED.value is handled above
+        CLICommands.TICKETS.value: manage_tickets,
+        CLICommands.INFO.value: show_info,
+        CLICommands.AGENTS.value: manage_agents,
+        CLICommands.AGENT_MANAGER.value: manage_agent_manager,
+        CLICommands.MEMORY.value: manage_memory,
+        CLICommands.MONITOR.value: manage_monitor,
+        CLICommands.DASHBOARD.value: manage_dashboard,
+        CLICommands.CONFIG.value: manage_config,
+        CLICommands.CONFIGURE.value: manage_configure,
+        CLICommands.AGGREGATE.value: aggregate_command,
+        CLICommands.ANALYZE_CODE.value: manage_analyze_code,
+        CLICommands.CLEANUP.value: cleanup_memory,
+        CLICommands.MCP.value: manage_mcp,
+        CLICommands.DOCTOR.value: run_doctor,
+        CLICommands.UPGRADE.value: upgrade,
+        CLICommands.SKILLS.value: manage_skills,
+        "debug": manage_debug,  # Add debug command
+        "mpm-init": None,  # Will be handled separately with lazy import
+    }
+
+    # Execute command if found
+    if command in command_map:
+        result = command_map[command](args)
+        # Commands may return None (success) or an exit code
+        return result if result is not None else 0
+
+    # Unknown command - provide suggestions
+    from rich.console import Console
+
+    from .utils import suggest_similar_commands
+
+    console = Console(stderr=True)
+
+    console.print(f"\n[red]Error:[/red] Unknown command: {command}\n", style="bold")
+
+    # Get all valid commands for suggestions
+    all_commands = [
+        *command_map.keys(),
+        "run-guarded",
+        "uninstall",
+        "verify",
+        "auto-configure",
+        "local-deploy",
+    ]
+
+    suggestion = suggest_similar_commands(command, all_commands)
+    if suggestion:
+        console.print(f"[yellow]{suggestion}[/yellow]\n")
+
+    console.print("[dim]Run 'claude-mpm --help' for usage information.[/dim]\n")
+
+    return 1

claude_mpm/cli/helpers.py

@@ -0,0 +1,105 @@
+"""
+CLI Helper Utilities
+====================
+
+This module provides helper functions for the CLI, including configuration
+checks and user prompts.
+
+Part of cli/__init__.py refactoring to reduce file size and improve modularity.
+"""
+
+import sys
+from pathlib import Path
+
+
+def has_configuration_file() -> bool:
+    """Check if any configuration file exists in standard locations."""
+    config_paths = [
+        Path.cwd() / ".claude-mpm" / "configuration.yaml",
+        Path.cwd() / ".claude-mpm" / "configuration.yml",
+        Path.home() / ".claude-mpm" / "configuration.yaml",
+        Path.home() / ".claude-mpm" / "configuration.yml",
+    ]
+    return any(path.exists() for path in config_paths)
+
+
+def is_interactive_session() -> bool:
+    """Check if running in an interactive terminal."""
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def should_skip_config_check(command: str | None) -> bool:
+    """Check if command should skip configuration check."""
+    skip_commands = ["configure", "doctor", "info", "mcp", "config"]
+    return command in skip_commands if command else False
+
+
+def prompt_for_configuration() -> bool:
+    """Prompt user to run configuration wizard.
+
+    Returns:
+        bool: True if user wants to configure, False otherwise
+    """
+    from rich.console import Console as RichConsole
+    from rich.prompt import Confirm
+
+    console = RichConsole()
+
+    console.print()
+    console.print("[yellow]⚙️  Configuration Recommended[/yellow]")
+    console.print()
+    console.print("Claude MPM works best with proper configuration.")
+    console.print("The configurator helps you:")
+    console.print("  • Enable/disable MCP services (ticketer, browser, vector-search)")
+    console.print("  • Configure hook services (monitor, dashboard)")
+    console.print("  • Select system agents to use")
+    console.print()
+
+    return Confirm.ask("Would you like to run the configurator now?", default=True)
+
+
+def handle_missing_configuration():
+    """Handle missing configuration file by prompting user to configure.
+
+    WHY: Centralizes the logic for handling missing configuration files,
+    keeping main() cleaner and more focused.
+    """
+    if is_interactive_session():
+        # Interactive: Offer to run configurator
+        if prompt_for_configuration():
+            from rich.console import Console as RichConsole
+
+            # Import configure command only when needed
+            from .commands.configure import ConfigureCommand
+
+            console = RichConsole()
+            config_cmd = ConfigureCommand()
+            try:
+                config_cmd.execute({})
+                console.print(
+                    "\n[green]✓[/green] Configuration complete! "
+                    "Continuing with command...\n"
+                )
+            except Exception as e:
+                console.print(f"\n[yellow]⚠[/yellow] Configuration error: {e}")
+                console.print(
+                    "[yellow]Continuing with default configuration...\n[/yellow]"
+                )
+        else:
+            from rich.console import Console as RichConsole
+
+            console = RichConsole()
+            console.print("\n[dim]Using default configuration.[/dim]")
+            console.print(
+                "[dim]Run 'claude-mpm configure' anytime to set up your "
+                "preferences.\n[/dim]"
+            )
+    else:
+        # Non-interactive: Log message only
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.info(
+            "Configuration file not found, using defaults. "
+            "Run 'claude-mpm configure' to customize."
+        )

claude_mpm/cli/interactive/__init__.py

@@ -0,0 +1,21 @@
+"""Interactive CLI modules for Claude MPM.
+
+This package contains interactive user interfaces and wizards for various
+Claude MPM operations, providing user-friendly alternatives to command-line
+arguments.
+"""
+
+from .agent_wizard import (
+    AgentWizard,
+    run_interactive_agent_manager,
+    run_interactive_agent_wizard,
+)
+from .skills_wizard import SkillsWizard, discover_and_link_runtime_skills
+
+__all__ = [
+    "AgentWizard",
+    "SkillsWizard",
+    "discover_and_link_runtime_skills",
+    "run_interactive_agent_manager",
+    "run_interactive_agent_wizard",
+]