claude-mpm 4.7.4__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/cli/commands/mpm_init_handler.py

@@ -8,6 +8,8 @@ from pathlib import Path
 
 from rich.console import Console
 
+from claude_mpm.core.enums import OperationResult
+
 console = Console()
 
 
@@ -25,6 +27,39 @@ def manage_mpm_init(args):
         # Import the command implementation
         from .mpm_init import MPMInitCommand
 
+        # Handle context subcommands
+        subcommand = getattr(args, "subcommand", None)
+
+        if subcommand in ("context", "resume"):
+            # Show deprecation warning for 'resume'
+            if subcommand == "resume":
+                console.print(
+                    "[yellow]⚠️  Warning: 'resume' is deprecated. Use 'context' instead.[/yellow]"
+                )
+                console.print("[dim]Run: claude-mpm mpm-init context[/dim]\n")
+
+            # Get project path
+            project_path = (
+                Path(args.project_path) if hasattr(args, "project_path") else Path.cwd()
+            )
+
+            # Create command instance
+            command = MPMInitCommand(project_path)
+
+            # Handle context with optional session ID and days
+            result = command.handle_context(
+                session_id=getattr(args, "session_id", None),
+                days=getattr(args, "days", 7),
+            )
+
+            # Return appropriate exit code
+            if result.get("status") in (
+                OperationResult.SUCCESS,
+                OperationResult.CONTEXT_READY,
+            ):
+                return 0
+            return 1
+
         # Handle special flags
         if getattr(args, "list_templates", False):
             # List available templates
@@ -55,7 +90,6 @@ def manage_mpm_init(args):
             "framework": getattr(args, "framework", None),
             "force": getattr(args, "force", False),
             "verbose": getattr(args, "verbose", False),
-            "use_venv": getattr(args, "use_venv", False),
             "ast_analysis": getattr(args, "ast_analysis", True),
             "update_mode": getattr(args, "update", False),
             "review_only": getattr(args, "review", False),
@@ -73,9 +107,9 @@ def manage_mpm_init(args):
         result = command.initialize_project(**init_params)
 
         # Return appropriate exit code
-        if result.get("status") == "success":
+        if result.get("status") == OperationResult.SUCCESS:
             return 0
-        if result.get("status") == "cancelled":
+        if result.get("status") == OperationResult.CANCELLED:
             return 130  # User cancelled
         return 1  # Error
 

claude_mpm/cli/commands/search.py

@@ -16,8 +16,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 
-from claude_mpm.cli.utils import handle_async_errors
-from claude_mpm.services.service_container import get_service_container
+from claude_mpm.services.core.service_container import get_global_container
 
 console = Console()
 
@@ -27,8 +26,9 @@ class MCPSearchInterface:
 
     def __init__(self):
         """Initialize the search interface."""
-        self.container = get_service_container()
+        self.container = get_global_container()
         self.mcp_gateway = None
+        self.vector_search_available = False
 
     async def initialize(self):
         """Initialize the MCP gateway connection."""
@@ -39,10 +39,127 @@ class MCPSearchInterface:
             if not self.mcp_gateway:
                 self.mcp_gateway = MCPGatewayService()
                 await self.mcp_gateway.initialize()
+
+            # Check if vector search is available
+            self.vector_search_available = await self._check_vector_search_available()
+
         except Exception as e:
             console.print(f"[red]Failed to initialize MCP gateway: {e}[/red]")
             raise
 
+    async def _check_vector_search_available(self) -> bool:
+        """Check if mcp-vector-search is available and offer installation if not."""
+        import importlib.util
+
+        # Check if package is installed
+        spec = importlib.util.find_spec("mcp_vector_search")
+        if spec is not None:
+            return True
+
+        # Package not found - offer installation
+        console.print("\n[yellow]⚠️  mcp-vector-search not found[/yellow]")
+        console.print("This package enables semantic code search (optional feature).")
+        console.print("\nInstallation options:")
+        console.print("  1. Install via pip (recommended for this project)")
+        console.print("  2. Install via pipx (isolated, system-wide)")
+        console.print("  3. Skip (use traditional grep/glob instead)")
+
+        try:
+            choice = input("\nChoose option (1/2/3) [3]: ").strip() or "3"
+
+            if choice == "1":
+                return await self._install_via_pip()
+            if choice == "2":
+                return await self._install_via_pipx()
+            console.print(
+                "[dim]Continuing with fallback search methods (grep/glob)[/dim]"
+            )
+            return False
+
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Installation cancelled, using fallback methods[/dim]")
+            return False
+
+    async def _install_via_pip(self) -> bool:
+        """Install mcp-vector-search via pip."""
+        import subprocess
+
+        try:
+            console.print("\n[cyan]📦 Installing mcp-vector-search via pip...[/cyan]")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "mcp-vector-search"],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                console.print(
+                    "[green]✓ Successfully installed mcp-vector-search[/green]"
+                )
+                return True
+
+            error_msg = result.stderr.strip() if result.stderr else "Unknown error"
+            console.print(f"[red]✗ Installation failed: {error_msg}[/red]")
+            return False
+
+        except subprocess.TimeoutExpired:
+            console.print("[red]✗ Installation timed out[/red]")
+            return False
+        except Exception as e:
+            console.print(f"[red]✗ Installation error: {e}[/red]")
+            return False
+
+    async def _install_via_pipx(self) -> bool:
+        """Install mcp-vector-search via pipx."""
+        import subprocess
+
+        try:
+            # Check if pipx is available
+            pipx_check = subprocess.run(
+                ["pipx", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            if pipx_check.returncode != 0:
+                console.print("[red]✗ pipx is not installed[/red]")
+                console.print("Install pipx first: python -m pip install pipx")
+                return False
+
+            console.print("\n[cyan]📦 Installing mcp-vector-search via pipx...[/cyan]")
+            result = subprocess.run(
+                ["pipx", "install", "mcp-vector-search"],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                console.print(
+                    "[green]✓ Successfully installed mcp-vector-search[/green]"
+                )
+                return True
+
+            error_msg = result.stderr.strip() if result.stderr else "Unknown error"
+            console.print(f"[red]✗ Installation failed: {error_msg}[/red]")
+            return False
+
+        except FileNotFoundError:
+            console.print("[red]✗ pipx command not found[/red]")
+            console.print("Install pipx first: python -m pip install pipx")
+            return False
+        except subprocess.TimeoutExpired:
+            console.print("[red]✗ Installation timed out[/red]")
+            return False
+        except Exception as e:
+            console.print(f"[red]✗ Installation error: {e}[/red]")
+            return False
+
     async def search_code(
         self,
         query: str,
@@ -125,6 +242,12 @@ class MCPSearchInterface:
         if not self.mcp_gateway:
             await self.initialize()
 
+        # Check if vector search is available
+        if not self.vector_search_available:
+            return {
+                "error": "mcp-vector-search is not available. Use traditional grep/glob tools instead, or run command again to install."
+            }
+
         try:
             return await self.mcp_gateway.call_tool(tool_name, params)
         except Exception as e:
@@ -196,7 +319,6 @@ def display_search_results(results: Dict[str, Any], output_format: str = "rich")
 @click.option("--focus", multiple=True, help="Focus areas (with --context)")
 @click.option("--force", is_flag=True, help="Force reindexing (with --index)")
 @click.option("--json", "output_json", is_flag=True, help="Output results as JSON")
-@handle_async_errors
 async def search_command(
     query: Optional[str],
     similar: Optional[str],
@@ -228,8 +350,24 @@ async def search_command(
     output_format = "json" if output_json else "rich"
 
     try:
+        # Show first-time usage tips if vector search is available
+        if search.vector_search_available and not (index or status):
+            console.print(
+                "\n[dim]💡 Tip: Vector search provides semantic code understanding.[/dim]"
+            )
+            console.print(
+                "[dim]   Run with --index first to index your project.[/dim]\n"
+            )
+
         # Handle different operation modes
         if index:
+            if not search.vector_search_available:
+                console.print("[red]✗ mcp-vector-search is required for indexing[/red]")
+                console.print(
+                    "[dim]Install it or use traditional grep/glob for search[/dim]"
+                )
+                sys.exit(1)
+
             console.print("[cyan]Indexing project...[/cyan]")
             result = await search.index_project(
                 force=force, file_extensions=list(extensions) if extensions else None
@@ -239,10 +377,23 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif status:
+            if not search.vector_search_available:
+                console.print(
+                    "[red]✗ mcp-vector-search is required for status check[/red]"
+                )
+                console.print("[dim]Install it to use vector search features[/dim]")
+                sys.exit(1)
+
             result = await search.get_status()
             display_search_results(result, output_format)
 
         elif similar:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Similarity search requires mcp-vector-search[/dim]")
+                console.print("[dim]Falling back to basic file search...[/dim]")
+                sys.exit(1)
+
             result = await search.search_similar(
                 file_path=similar,
                 function_name=function,
@@ -252,6 +403,12 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif context:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Context search requires mcp-vector-search[/dim]")
+                console.print("[dim]Try using grep for text-based search instead[/dim]")
+                sys.exit(1)
+
             result = await search.search_context(
                 description=context,
                 focus_areas=list(focus) if focus else None,
@@ -260,6 +417,15 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif query:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Code search requires mcp-vector-search[/dim]")
+                console.print(
+                    "\n[cyan]Alternative: Use grep for pattern matching:[/cyan]"
+                )
+                console.print(f"  grep -r '{query}' .")
+                sys.exit(1)
+
             result = await search.search_code(
                 query=query,
                 limit=limit,

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/executor.py

@@ -0,0 +1,202 @@
+"""
+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.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,
+        "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