claude-mpm 4.13.2__py3-none-any.whl → 4.18.2__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."""
 
@@ -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/mpm_init.py

@@ -20,6 +20,7 @@ from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Prompt
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 # Import new services
@@ -102,7 +103,11 @@ class MPMInitCommand:
             if catchup:
                 data = self._catchup()
                 self._display_catchup(data)
-                return {"status": "success", "mode": "catchup", "catchup_data": data}
+                return {
+                    "status": OperationResult.SUCCESS,
+                    "mode": "catchup",
+                    "catchup_data": data,
+                }
 
             if quick_update:
                 return self._run_quick_update_mode(
@@ -139,7 +144,7 @@ class MPMInitCommand:
                         return self._run_review_mode()
                     else:
                         return {
-                            "status": "cancelled",
+                            "status": OperationResult.CANCELLED,
                             "message": "Initialization cancelled",
                         }
 
@@ -152,7 +157,7 @@ class MPMInitCommand:
                 pre_check_result = self._run_pre_initialization_checks(
                     organize_files, skip_archive, has_existing
                 )
-                if pre_check_result.get("status") == "error":
+                if pre_check_result.get("status") == OperationResult.ERROR:
                     return pre_check_result
 
             # Build the delegation prompt
@@ -195,7 +200,7 @@ class MPMInitCommand:
                 progress.update(task, description=complete_desc)
 
             # Post-processing for update mode
-            if update_mode and result.get("status") == "success":
+            if update_mode and result.get("status") == OperationResult.SUCCESS:
                 self._handle_update_post_processing()
 
             return result
@@ -203,7 +208,7 @@ class MPMInitCommand:
         except Exception as e:
             logger.error(f"Failed to initialize project: {e}")
             console.print(f"[red]❌ Error: {e}[/red]")
-            return {"status": "error", "message": str(e)}
+            return {"status": OperationResult.ERROR, "message": str(e)}
 
     def _find_claude_mpm_script(self) -> Path:
         """Find the claude-mpm script location."""
@@ -484,7 +489,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         )
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "mode": "review",
             "structure_report": structure_report,
             "documentation_analysis": doc_analysis,
@@ -576,7 +581,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "[dim]Tip: Use `/mpm-init --review` for non-git projects.[/dim]\n"
             )
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": "Quick update requires a git repository",
             }
 
@@ -589,7 +594,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "[dim]Tip: Use `/mpm-init` to create initial documentation.[/dim]\n"
             )
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": "Quick update requires existing CLAUDE.md",
             }
 
@@ -631,7 +636,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "\n[cyan]ℹ️  Non-interactive mode: Report displayed, no changes made.[/cyan]"
             )
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": False,
@@ -659,7 +664,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
             )
 
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": True,
@@ -667,13 +672,16 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         if choice == "2":
             console.print("\n[cyan]Report generated - no changes made[/cyan]")
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": False,
             }
         console.print("\n[yellow]Quick update cancelled[/yellow]")
-        return {"status": "cancelled", "message": "Quick update cancelled"}
+        return {
+            "status": OperationResult.CANCELLED,
+            "message": "Quick update cancelled",
+        }
 
     def _catchup(self) -> Dict[str, Any]:
         """Get recent commit history for PM context.
@@ -1150,7 +1158,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         console.print("\n[dim]Run without --dry-run to execute these changes.[/dim]\n")
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "mode": "dry_run",
             "actions_planned": actions_planned,
             "message": "Dry run completed - no changes made",
@@ -1208,7 +1216,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
             console.print()
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "checks_passed": checks_passed,
             "warnings": warnings,
         }
@@ -1412,7 +1420,7 @@ preserving valuable project-specific information while refreshing standard secti
             # Check result - be more lenient with return codes
             if result.returncode == 0 or (self.project_path / "CLAUDE.md").exists():
                 response = {
-                    "status": "success",
+                    "status": OperationResult.SUCCESS,
                     "message": "Project initialized successfully",
                     "files_created": [],
                     "files_updated": [],
@@ -1450,7 +1458,7 @@ preserving valuable project-specific information while refreshing standard secti
 
             logger.error(f"claude-mpm run failed: {error_msg}")
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": f"Initialization failed: {error_msg}",
             }
 
@@ -1459,10 +1467,10 @@ preserving valuable project-specific information while refreshing standard secti
             console.print(
                 "[red]Error: claude-mpm command not found. Ensure Claude MPM is properly installed.[/red]"
             )
-            return {"status": "error", "message": "claude-mpm not found"}
+            return {"status": OperationResult.ERROR, "message": "claude-mpm not found"}
         except Exception as e:
             logger.error(f"Initialization failed: {e}")
-            return {"status": "error", "message": str(e)}
+            return {"status": OperationResult.ERROR, "message": str(e)}
 
     def handle_context(
         self,
@@ -1516,7 +1524,7 @@ preserving valuable project-specific information while refreshing standard secti
                 "[dim]Ensure this is a git repository with commit history.[/dim]\n"
             )
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": git_analysis["error"],
             }
 
@@ -1526,7 +1534,7 @@ preserving valuable project-specific information while refreshing standard secti
             )
             console.print("[dim]Try increasing the --days parameter.[/dim]\n")
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": f"No git activity in last {days} days",
             }
 
@@ -1541,7 +1549,7 @@ preserving valuable project-specific information while refreshing standard secti
         console.print("\n" + "=" * 80 + "\n")
 
         return {
-            "status": "context_ready",
+            "status": OperationResult.CONTEXT_READY,
             "git_analysis": git_analysis,
             "research_prompt": research_prompt,
             "recommendation": "PM should delegate this prompt to Research agent",
@@ -1677,7 +1685,7 @@ Keep it concise (<1000 words) but actionable.
 
     def _display_results(self, result: Dict, verbose: bool):
         """Display initialization results."""
-        if result["status"] == "success":
+        if result["status"] == OperationResult.SUCCESS:
             console.print("\n[green]✅ Project Initialization Complete![/green]\n")
 
             # Display files created
@@ -1877,7 +1885,7 @@ def mpm_init(
         )
 
         # Exit with appropriate code
-        if result["status"] == "success":
+        if result["status"] == OperationResult.SUCCESS:
             sys.exit(0)
         else:
             sys.exit(1)
@@ -1928,7 +1936,10 @@ def context_command(session_id, days, project_path):
 
         result = command.handle_context(session_id=session_id, days=days)
 
-        if result["status"] == "success" or result["status"] == "context_ready":
+        if (
+            result["status"] == OperationResult.SUCCESS
+            or result["status"] == OperationResult.CONTEXT_READY
+        ):
             sys.exit(0)
         else:
             sys.exit(1)
@@ -1977,7 +1988,10 @@ def resume_session(session_id, days, project_path):
         command = MPMInitCommand(Path(project_path))
         result = command.handle_context(session_id=session_id, days=days)
 
-        if result["status"] == "success" or result["status"] == "context_ready":
+        if (
+            result["status"] == OperationResult.SUCCESS
+            or result["status"] == OperationResult.CONTEXT_READY
+        ):
             sys.exit(0)
         else:
             sys.exit(1)

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()
 
 
@@ -51,7 +53,10 @@ def manage_mpm_init(args):
             )
 
             # Return appropriate exit code
-            if result.get("status") in ("success", "context_ready"):
+            if result.get("status") in (
+                OperationResult.SUCCESS,
+                OperationResult.CONTEXT_READY,
+            ):
                 return 0
             return 1
 
@@ -102,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/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