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

claude_mpm/cli/shared/base_command.py

@@ -0,0 +1,242 @@
+"""
+Base command class to reduce duplication in CLI command implementations.
+"""
+
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ...core.config import Config
+from ...core.logger import get_logger
+from ...core.shared.config_loader import ConfigLoader
+
+
+@dataclass
+class CommandResult:
+    """Standard result structure for CLI commands."""
+
+    success: bool
+    exit_code: int = 0
+    message: Optional[str] = None
+    data: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def success_result(
+        cls, message: Optional[str] = None, data: Optional[Dict[str, Any]] = None
+    ) -> "CommandResult":
+        """Create a success result."""
+        return cls(success=True, exit_code=0, message=message, data=data)
+
+    @classmethod
+    def error_result(
+        cls, message: str, exit_code: int = 1, data: Optional[Dict[str, Any]] = None
+    ) -> "CommandResult":
+        """Create an error result."""
+        return cls(success=False, exit_code=exit_code, message=message, data=data)
+
+
+class BaseCommand(ABC):
+    """
+    Base class for CLI commands to reduce duplication.
+
+    Provides common functionality:
+    - Logger initialization
+    - Configuration loading
+    - Working directory handling
+    - Standard error handling patterns
+    """
+
+    def __init__(self, command_name: str):
+        """
+        Initialize base command.
+
+        Args:
+            command_name: Name of the command for logging
+        """
+        self.command_name = command_name
+        self.logger = get_logger(f"cli.{command_name}")
+        self._config: Optional[Config] = None
+        self._working_dir: Optional[Path] = None
+
+    @property
+    def config(self) -> Config:
+        """Get configuration instance (lazy loaded)."""
+        if self._config is None:
+            config_loader = ConfigLoader()
+            self._config = config_loader.load_main_config()
+        return self._config
+
+    @property
+    def working_dir(self) -> Path:
+        """Get working directory (respects CLAUDE_MPM_USER_PWD)."""
+        if self._working_dir is None:
+            # Use CLAUDE_MPM_USER_PWD if available (when called via shell script)
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
+            self._working_dir = Path(user_pwd)
+        return self._working_dir
+
+    def setup_logging(self, args) -> None:
+        """Setup logging based on command arguments."""
+        import logging
+
+        # Set log level based on arguments
+        if hasattr(args, "debug") and args.debug:
+            logging.getLogger().setLevel(logging.DEBUG)
+        elif hasattr(args, "verbose") and args.verbose:
+            logging.getLogger().setLevel(logging.INFO)
+        elif hasattr(args, "quiet") and args.quiet:
+            logging.getLogger().setLevel(logging.WARNING)
+
+    def load_config(self, args) -> None:
+        """Load configuration from arguments."""
+        config_loader = ConfigLoader()
+        if hasattr(args, "config") and args.config:
+            # Use specific config file with ConfigLoader
+            from ...core.shared.config_loader import ConfigPattern
+
+            pattern = ConfigPattern(
+                filenames=[Path(args.config).name],
+                search_paths=[str(Path(args.config).parent)],
+                env_prefix="CLAUDE_MPM_",
+            )
+            self._config = config_loader.load_config(
+                pattern, cache_key=f"cli_{args.config}"
+            )
+        else:
+            self._config = config_loader.load_main_config()
+
+    def validate_args(self, args) -> Optional[str]:
+        """
+        Validate command arguments.
+
+        Args:
+            args: Parsed command arguments
+
+        Returns:
+            Error message if validation fails, None if valid
+        """
+        # Base validation - subclasses can override
+        return None
+
+    def execute(self, args) -> CommandResult:
+        """
+        Execute the command with standard error handling.
+
+        Args:
+            args: Parsed command arguments
+
+        Returns:
+            CommandResult with execution status
+        """
+        try:
+            # Setup
+            self.setup_logging(args)
+            self.load_config(args)
+
+            # Validate arguments
+            validation_error = self.validate_args(args)
+            if validation_error:
+                return CommandResult.error_result(validation_error)
+
+            # Execute command-specific logic
+            return self.run(args)
+
+        except KeyboardInterrupt:
+            self.logger.info("Command interrupted by user")
+            return CommandResult.error_result(
+                "Operation cancelled by user", exit_code=130
+            )
+
+        except Exception as e:
+            self.logger.error(f"Command failed: {e}", exc_info=True)
+            return CommandResult.error_result(f"Command failed: {e}")
+
+    @abstractmethod
+    def run(self, args) -> CommandResult:
+        """
+        Run the command-specific logic.
+
+        Args:
+            args: Parsed command arguments
+
+        Returns:
+            CommandResult with execution status
+        """
+
+    def print_result(self, result: CommandResult, args) -> None:
+        """
+        Print command result based on output format.
+
+        Args:
+            result: Command result to print
+            args: Command arguments (for format options)
+        """
+        from .output_formatters import format_output
+
+        # Determine output format
+        output_format = getattr(args, "format", "text")
+
+        # Format and print result
+        formatted_output = format_output(result, output_format)
+
+        if hasattr(args, "output") and args.output:
+            # Write to file
+            with args.output.open("w") as f:
+                f.write(formatted_output)
+            self.logger.info(f"Output written to {args.output}")
+        else:
+            # Print to stdout
+            print(formatted_output)
+
+
+class ServiceCommand(BaseCommand):
+    """Base class for commands that work with services."""
+
+    def __init__(self, command_name: str, service_class: type):
+        """
+        Initialize service command.
+
+        Args:
+            command_name: Name of the command
+            service_class: Service class to instantiate
+        """
+        super().__init__(command_name)
+        self.service_class = service_class
+        self._service = None
+
+    @property
+    def service(self):
+        """Get service instance (lazy loaded)."""
+        if self._service is None:
+            self._service = self.service_class()
+        return self._service
+
+
+class AgentCommand(BaseCommand):
+    """Base class for agent-related commands."""
+
+    def get_agent_dir(self, args) -> Path:
+        """Get agent directory from arguments or default."""
+        if hasattr(args, "agent_dir") and args.agent_dir:
+            return args.agent_dir
+
+        # Default to working directory
+        return self.working_dir
+
+    def get_agent_pattern(self, args) -> Optional[str]:
+        """Get agent name pattern from arguments."""
+        return getattr(args, "agent", None)
+
+
+class MemoryCommand(BaseCommand):
+    """Base class for memory-related commands."""
+
+    def get_memory_dir(self, args) -> Path:
+        """Get memory directory from arguments or default."""
+        if hasattr(args, "memory_dir") and args.memory_dir:
+            return args.memory_dir
+
+        # Default to .claude-mpm/memories in working directory
+        return self.working_dir / ".claude-mpm" / "memories"

claude_mpm/cli/shared/error_handling.py

@@ -0,0 +1,242 @@
+"""
+Common error handling patterns for CLI commands.
+"""
+
+import traceback
+from functools import wraps
+from typing import Any, Callable, Optional
+
+from ...core.logger import get_logger
+
+
+class CLIErrorHandler:
+    """Centralized error handling for CLI commands."""
+
+    def __init__(self, command_name: str):
+        """
+        Initialize error handler.
+
+        Args:
+            command_name: Name of the command for logging context
+        """
+        self.command_name = command_name
+        self.logger = get_logger(f"cli.{command_name}")
+
+    def handle_error(self, error: Exception, context: Optional[str] = None) -> int:
+        """
+        Handle an error with appropriate logging and user feedback.
+
+        Args:
+            error: The exception that occurred
+            context: Additional context about when the error occurred
+
+        Returns:
+            Appropriate exit code
+        """
+        # Build error message
+        error_msg = str(error)
+        if context:
+            error_msg = f"{context}: {error_msg}"
+
+        # Determine error type and appropriate response
+        if isinstance(error, KeyboardInterrupt):
+            self.logger.info("Operation cancelled by user")
+            print("\nOperation cancelled by user.")
+            return 130  # Standard exit code for SIGINT
+
+        if isinstance(error, FileNotFoundError):
+            self.logger.error(f"File not found: {error}")
+            print(f"Error: File not found - {error}")
+            return 2
+
+        if isinstance(error, PermissionError):
+            self.logger.error(f"Permission denied: {error}")
+            print(f"Error: Permission denied - {error}")
+            return 13
+
+        if isinstance(error, ValueError):
+            self.logger.error(f"Invalid value: {error}")
+            print(f"Error: Invalid value - {error}")
+            return 22
+
+        # Generic error handling
+        self.logger.error(f"Command failed: {error}", exc_info=True)
+        print(f"Error: {error_msg}")
+
+        # Show traceback in debug mode
+        if self.logger.isEnabledFor(10):  # DEBUG level
+            traceback.print_exc()
+
+        return 1
+
+    def handle_validation_error(self, message: str) -> int:
+        """
+        Handle validation errors.
+
+        Args:
+            message: Validation error message
+
+        Returns:
+            Exit code for validation errors
+        """
+        self.logger.error(f"Validation error: {message}")
+        print(f"Error: {message}")
+        return 22  # Invalid argument exit code
+
+    def handle_config_error(self, error: Exception) -> int:
+        """
+        Handle configuration-related errors.
+
+        Args:
+            error: Configuration error
+
+        Returns:
+            Exit code for configuration errors
+        """
+        self.logger.error(f"Configuration error: {error}")
+        print(f"Configuration Error: {error}")
+        print("Please check your configuration file and try again.")
+        return 78  # Configuration error exit code
+
+
+def handle_cli_errors(command_name: str):
+    """
+    Decorator to add standard error handling to CLI command functions.
+
+    Args:
+        command_name: Name of the command for error context
+
+    Returns:
+        Decorated function with error handling
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> int:
+            error_handler = CLIErrorHandler(command_name)
+
+            try:
+                result = func(*args, **kwargs)
+
+                # Handle different return types
+                if isinstance(result, int):
+                    return result
+                if hasattr(result, "exit_code"):
+                    return result.exit_code
+                return 0  # Success
+
+            except Exception as e:
+                return error_handler.handle_error(e)
+
+        return wrapper
+
+    return decorator
+
+
+def safe_execute(
+    func: Callable, *args, error_handler: CLIErrorHandler = None, **kwargs
+) -> Any:
+    """
+    Safely execute a function with error handling.
+
+    Args:
+        func: Function to execute
+        *args: Function arguments
+        error_handler: Optional error handler
+        **kwargs: Function keyword arguments
+
+    Returns:
+        Function result or None if error occurred
+    """
+    try:
+        return func(*args, **kwargs)
+    except Exception as e:
+        if error_handler:
+            error_handler.handle_error(e)
+        else:
+            # Fallback error handling
+            logger = get_logger("cli.safe_execute")
+            logger.error(f"Error executing {func.__name__}: {e}", exc_info=True)
+        return None
+
+
+def validate_file_exists(file_path: str, error_handler: CLIErrorHandler = None) -> bool:
+    """
+    Validate that a file exists.
+
+    Args:
+        file_path: Path to validate
+        error_handler: Optional error handler
+
+    Returns:
+        True if file exists, False otherwise
+    """
+    from pathlib import Path
+
+    path = Path(file_path)
+    if not path.exists():
+        message = f"File does not exist: {file_path}"
+        if error_handler:
+            error_handler.handle_validation_error(message)
+        return False
+
+    if not path.is_file():
+        message = f"Path is not a file: {file_path}"
+        if error_handler:
+            error_handler.handle_validation_error(message)
+        return False
+
+    return True
+
+
+def validate_directory_exists(
+    dir_path: str, error_handler: CLIErrorHandler = None
+) -> bool:
+    """
+    Validate that a directory exists.
+
+    Args:
+        dir_path: Directory path to validate
+        error_handler: Optional error handler
+
+    Returns:
+        True if directory exists, False otherwise
+    """
+    from pathlib import Path
+
+    path = Path(dir_path)
+    if not path.exists():
+        message = f"Directory does not exist: {dir_path}"
+        if error_handler:
+            error_handler.handle_validation_error(message)
+        return False
+
+    if not path.is_dir():
+        message = f"Path is not a directory: {dir_path}"
+        if error_handler:
+            error_handler.handle_validation_error(message)
+        return False
+
+    return True
+
+
+def confirm_operation(message: str, force: bool = False) -> bool:
+    """
+    Ask user for confirmation unless force flag is set.
+
+    Args:
+        message: Confirmation message
+        force: If True, skip confirmation
+
+    Returns:
+        True if operation should proceed
+    """
+    if force:
+        return True
+
+    try:
+        response = input(f"{message} (y/N): ").strip().lower()
+        return response in ("y", "yes")
+    except (EOFError, KeyboardInterrupt):
+        print("\nOperation cancelled.")
+        return False