claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/cli/shared/error_handling.py

@@ -4,32 +4,32 @@ Common error handling patterns for CLI commands.
 
 import traceback
 from functools import wraps
-from typing import Any, Callable
+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: str = None) -> int:
+
+    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
         """
@@ -37,60 +37,59 @@ class CLIErrorHandler:
         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):
+
+        if isinstance(error, FileNotFoundError):
             self.logger.error(f"File not found: {error}")
             print(f"Error: File not found - {error}")
             return 2
-        
-        elif isinstance(error, PermissionError):
+
+        if isinstance(error, PermissionError):
             self.logger.error(f"Permission denied: {error}")
             print(f"Error: Permission denied - {error}")
             return 13
-        
-        elif isinstance(error, ValueError):
+
+        if 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
-    
+
+        # 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
         """
@@ -103,46 +102,49 @@ class CLIErrorHandler:
 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'):
+                if hasattr(result, "exit_code"):
                     return result.exit_code
-                else:
-                    return 0  # Success
-                    
+                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:
+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
     """
@@ -161,78 +163,80 @@ def safe_execute(func: Callable, *args, error_handler: CLIErrorHandler = 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:
+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')
+        return response in ("y", "yes")
     except (EOFError, KeyboardInterrupt):
         print("\nOperation cancelled.")
         return False

claude_mpm/cli/shared/output_formatters.py

@@ -3,70 +3,71 @@ Output formatting utilities for CLI commands.
 """
 
 import json
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, 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:
+    def format_table(
+        data: Union[List[Dict], Dict], headers: Optional[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, ''))
+                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
+                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."""
@@ -77,69 +78,69 @@ class OutputFormatter:
                     lines.append(f"{key}:")
                     # Indent nested content
                     nested = OutputFormatter.format_text(value)
-                    for line in nested.split('\n'):
+                    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 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'):
+                    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)
+
+        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":
+    if format_type == "yaml":
         return formatter.format_yaml(data)
-    elif format_type == "table":
+    if format_type == "table":
         return formatter.format_table(data, **kwargs)
-    elif format_type == "text":
-        return formatter.format_text(data)
-    else:
-        # Fallback to text format
+    if format_type == "text":
         return formatter.format_text(data)
+    # Fallback to text format
+    return formatter.format_text(data)
 
 
-def format_success_message(message: str, data: Any = None, format_type: str = "text") -> str:
+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
     """
@@ -148,24 +149,25 @@ def format_success_message(message: str, data: Any = None, format_type: str = "t
         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)
+    # 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:
+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
     """
@@ -174,28 +176,29 @@ def format_error_message(message: str, details: Any = None, format_type: str = "
         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)
+    # 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:
+def format_list_output(
+    items: List[Any],
+    title: Optional[str] = None,
+    format_type: str = "text",
+    headers: Optional[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
     """
@@ -203,29 +206,27 @@ def format_list_output(items: List[Any],
         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
-    
+        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":
+
+    if 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)
+
+    # Text format
+    lines = []
+    if title:
+        lines.append(title)
+        lines.append("=" * len(title))
+        lines.append("")
+
+    lines.append(format_output(items, "text"))
+    return "\n".join(lines)