claude-mpm 4.0.23__py3-none-any.whl → 4.0.28__py3-none-any.whl

claude_mpm/cli/shared/command_base.py

@@ -0,0 +1,234 @@
+"""
+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: str = None, data: 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: 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", os.getcwd())
+            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
+        """
+        pass
+    
+    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 open(args.output, '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,238 @@
+"""
+Common error handling patterns for CLI commands.
+"""
+
+import traceback
+from functools import wraps
+from typing import Any, Callable
+
+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: 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
+        
+        elif isinstance(error, FileNotFoundError):
+            self.logger.error(f"File not found: {error}")
+            print(f"Error: File not found - {error}")
+            return 2
+        
+        elif isinstance(error, PermissionError):
+            self.logger.error(f"Permission denied: {error}")
+            print(f"Error: Permission denied - {error}")
+            return 13
+        
+        elif isinstance(error, ValueError):
+            self.logger.error(f"Invalid value: {error}")
+            print(f"Error: Invalid value - {error}")
+            return 22
+        
+        else:
+            # 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
+                elif hasattr(result, 'exit_code'):
+                    return result.exit_code
+                else:
+                    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

claude_mpm/cli/shared/output_formatters.py

@@ -0,0 +1,231 @@
+"""
+Output formatting utilities for CLI commands.
+"""
+
+import json
+from typing import Any, Dict, List, Union
+
+import yaml
+
+
+class OutputFormatter:
+    """Handles formatting output in different formats."""
+    
+    @staticmethod
+    def format_json(data: Any, indent: int = 2) -> str:
+        """Format data as JSON."""
+        return json.dumps(data, indent=indent, default=str)
+    
+    @staticmethod
+    def format_yaml(data: Any) -> str:
+        """Format data as YAML."""
+        return yaml.dump(data, default_flow_style=False, sort_keys=False)
+    
+    @staticmethod
+    def format_table(data: Union[List[Dict], Dict], headers: List[str] = None) -> str:
+        """Format data as a simple table."""
+        if not data:
+            return "No data to display"
+        
+        # Handle single dict
+        if isinstance(data, dict):
+            data = [data]
+        
+        # Auto-detect headers if not provided
+        if headers is None and data:
+            headers = list(data[0].keys())
+        
+        if not headers:
+            return "No data to display"
+        
+        # Calculate column widths
+        col_widths = {}
+        for header in headers:
+            col_widths[header] = len(header)
+            for row in data:
+                value = str(row.get(header, ''))
+                col_widths[header] = max(col_widths[header], len(value))
+        
+        # Build table
+        lines = []
+        
+        # Header row
+        header_row = " | ".join(header.ljust(col_widths[header]) for header in headers)
+        lines.append(header_row)
+        
+        # Separator row
+        separator = " | ".join("-" * col_widths[header] for header in headers)
+        lines.append(separator)
+        
+        # Data rows
+        for row in data:
+            data_row = " | ".join(
+                str(row.get(header, '')).ljust(col_widths[header]) 
+                for header in headers
+            )
+            lines.append(data_row)
+        
+        return "\n".join(lines)
+    
+    @staticmethod
+    def format_text(data: Any) -> str:
+        """Format data as human-readable text."""
+        if isinstance(data, dict):
+            lines = []
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    lines.append(f"{key}:")
+                    # Indent nested content
+                    nested = OutputFormatter.format_text(value)
+                    for line in nested.split('\n'):
+                        if line.strip():
+                            lines.append(f"  {line}")
+                else:
+                    lines.append(f"{key}: {value}")
+            return "\n".join(lines)
+        
+        elif isinstance(data, list):
+            if not data:
+                return "No items"
+            
+            lines = []
+            for i, item in enumerate(data):
+                if isinstance(item, dict):
+                    lines.append(f"Item {i + 1}:")
+                    nested = OutputFormatter.format_text(item)
+                    for line in nested.split('\n'):
+                        if line.strip():
+                            lines.append(f"  {line}")
+                else:
+                    lines.append(f"- {item}")
+            return "\n".join(lines)
+        
+        else:
+            return str(data)
+
+
+def format_output(data: Any, format_type: str = "text", **kwargs) -> str:
+    """
+    Format data according to the specified format.
+    
+    Args:
+        data: Data to format
+        format_type: Output format ('json', 'yaml', 'table', 'text')
+        **kwargs: Additional formatting options
+        
+    Returns:
+        Formatted string
+    """
+    formatter = OutputFormatter()
+    
+    if format_type == "json":
+        return formatter.format_json(data, **kwargs)
+    elif format_type == "yaml":
+        return formatter.format_yaml(data)
+    elif format_type == "table":
+        return formatter.format_table(data, **kwargs)
+    elif format_type == "text":
+        return formatter.format_text(data)
+    else:
+        # Fallback to text format
+        return formatter.format_text(data)
+
+
+def format_success_message(message: str, data: Any = None, format_type: str = "text") -> str:
+    """
+    Format a success message with optional data.
+    
+    Args:
+        message: Success message
+        data: Optional data to include
+        format_type: Output format
+        
+    Returns:
+        Formatted success message
+    """
+    if format_type in ("json", "yaml"):
+        result = {"success": True, "message": message}
+        if data is not None:
+            result["data"] = data
+        return format_output(result, format_type)
+    else:
+        # Text format
+        lines = [f"✓ {message}"]
+        if data is not None:
+            lines.append("")
+            lines.append(format_output(data, format_type))
+        return "\n".join(lines)
+
+
+def format_error_message(message: str, details: Any = None, format_type: str = "text") -> str:
+    """
+    Format an error message with optional details.
+    
+    Args:
+        message: Error message
+        details: Optional error details
+        format_type: Output format
+        
+    Returns:
+        Formatted error message
+    """
+    if format_type in ("json", "yaml"):
+        result = {"success": False, "error": message}
+        if details is not None:
+            result["details"] = details
+        return format_output(result, format_type)
+    else:
+        # Text format
+        lines = [f"✗ {message}"]
+        if details is not None:
+            lines.append("")
+            lines.append(format_output(details, format_type))
+        return "\n".join(lines)
+
+
+def format_list_output(items: List[Any], 
+                      title: str = None,
+                      format_type: str = "text",
+                      headers: List[str] = None) -> str:
+    """
+    Format a list of items for output.
+    
+    Args:
+        items: List of items to format
+        title: Optional title for the list
+        format_type: Output format
+        headers: Optional headers for table format
+        
+    Returns:
+        Formatted list output
+    """
+    if not items:
+        empty_msg = f"No {title.lower() if title else 'items'} found"
+        if format_type in ("json", "yaml"):
+            return format_output({"items": [], "message": empty_msg}, format_type)
+        else:
+            return empty_msg
+    
+    if format_type in ("json", "yaml"):
+        result = {"items": items}
+        if title:
+            result["title"] = title
+        return format_output(result, format_type)
+    
+    elif format_type == "table":
+        output = ""
+        if title:
+            output += f"{title}\n{'=' * len(title)}\n\n"
+        output += format_output(items, "table", headers=headers)
+        return output
+    
+    else:
+        # Text format
+        lines = []
+        if title:
+            lines.append(title)
+            lines.append("=" * len(title))
+            lines.append("")
+        
+        lines.append(format_output(items, "text"))
+        return "\n".join(lines)