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

claude_mpm/cli/shared/argument_patterns.py

@@ -12,98 +12,95 @@ from typing import Any, Dict, List, Optional
 
 class CommonArguments:
     """Registry of common argument patterns used across CLI commands."""
-    
+
     # Logging arguments
     VERBOSE = {
         "flags": ["-v", "--verbose"],
         "action": "store_true",
-        "help": "Enable verbose output"
+        "help": "Enable verbose output",
     }
-    
+
     QUIET = {
         "flags": ["-q", "--quiet"],
-        "action": "store_true", 
-        "help": "Suppress non-error output"
+        "action": "store_true",
+        "help": "Suppress non-error output",
     }
-    
+
     DEBUG = {
         "flags": ["--debug"],
         "action": "store_true",
-        "help": "Enable debug logging"
+        "help": "Enable debug logging",
     }
-    
+
     # Configuration arguments
     CONFIG_FILE = {
         "flags": ["-c", "--config"],
         "type": Path,
-        "help": "Path to configuration file"
+        "help": "Path to configuration file",
     }
-    
+
     CONFIG_DIR = {
         "flags": ["--config-dir"],
         "type": Path,
-        "help": "Configuration directory path"
+        "help": "Configuration directory path",
     }
-    
+
     # Output arguments
     OUTPUT_FORMAT = {
         "flags": ["-f", "--format"],
         "choices": ["json", "yaml", "table", "text"],
         "default": "text",
-        "help": "Output format"
+        "help": "Output format",
     }
-    
+
     OUTPUT_FILE = {
         "flags": ["-o", "--output"],
         "type": Path,
-        "help": "Output file path"
+        "help": "Output file path",
     }
-    
+
     # Common flags
     FORCE = {
         "flags": ["--force"],
         "action": "store_true",
-        "help": "Force operation without confirmation"
+        "help": "Force operation without confirmation",
     }
-    
+
     DRY_RUN = {
         "flags": ["--dry-run"],
         "action": "store_true",
-        "help": "Show what would be done without executing"
+        "help": "Show what would be done without executing",
     }
-    
+
     # Agent-related arguments
-    AGENT_NAME = {
-        "flags": ["--agent"],
-        "help": "Agent name or pattern"
-    }
-    
-    AGENT_DIR = {
-        "flags": ["--agent-dir"],
-        "type": Path,
-        "help": "Agent directory path"
-    }
-    
+    AGENT_NAME = {"flags": ["--agent"], "help": "Agent name or pattern"}
+
+    AGENT_DIR = {"flags": ["--agent-dir"], "type": Path, "help": "Agent directory path"}
+
     # Memory-related arguments
     MEMORY_DIR = {
         "flags": ["--memory-dir"],
         "type": Path,
-        "help": "Memory directory path"
+        "help": "Memory directory path",
     }
 
 
-def add_argument_from_pattern(parser: argparse.ArgumentParser, pattern: Dict[str, Any]) -> None:
+def add_argument_from_pattern(
+    parser: argparse.ArgumentParser, pattern: Dict[str, Any]
+) -> None:
     """Add an argument to parser from a pattern definition."""
     flags = pattern.pop("flags")
     parser.add_argument(*flags, **pattern)
 
 
-def add_common_arguments(parser: argparse.ArgumentParser, 
-                        include: Optional[List[str]] = None,
-                        exclude: Optional[List[str]] = None) -> None:
+def add_common_arguments(
+    parser: argparse.ArgumentParser,
+    include: Optional[List[str]] = None,
+    exclude: Optional[List[str]] = None,
+) -> None:
     """
     Add common arguments to a parser.
-    
+
     Args:
         parser: ArgumentParser to add arguments to
         include: List of argument names to include (if None, includes all)
@@ -111,13 +108,13 @@ def add_common_arguments(parser: argparse.ArgumentParser,
     """
     # Default common arguments
     common_args = ["verbose", "quiet", "debug", "config_file", "output_format"]
-    
+
     if include is not None:
         common_args = [arg for arg in common_args if arg in include]
-    
+
     if exclude is not None:
         common_args = [arg for arg in common_args if arg not in exclude]
-    
+
     # Map argument names to patterns
     arg_patterns = {
         "verbose": CommonArguments.VERBOSE.copy(),
@@ -128,7 +125,7 @@ def add_common_arguments(parser: argparse.ArgumentParser,
         "force": CommonArguments.FORCE.copy(),
         "dry_run": CommonArguments.DRY_RUN.copy(),
     }
-    
+
     for arg_name in common_args:
         if arg_name in arg_patterns:
             add_argument_from_pattern(parser, arg_patterns[arg_name])
@@ -137,13 +134,13 @@ def add_common_arguments(parser: argparse.ArgumentParser,
 def add_logging_arguments(parser: argparse.ArgumentParser) -> None:
     """Add logging-related arguments."""
     group = parser.add_argument_group("logging options")
-    
+
     patterns = [
         CommonArguments.VERBOSE.copy(),
-        CommonArguments.QUIET.copy(), 
-        CommonArguments.DEBUG.copy()
+        CommonArguments.QUIET.copy(),
+        CommonArguments.DEBUG.copy(),
     ]
-    
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)
 
@@ -151,12 +148,9 @@ def add_logging_arguments(parser: argparse.ArgumentParser) -> None:
 def add_config_arguments(parser: argparse.ArgumentParser) -> None:
     """Add configuration-related arguments."""
     group = parser.add_argument_group("configuration options")
-    
-    patterns = [
-        CommonArguments.CONFIG_FILE.copy(),
-        CommonArguments.CONFIG_DIR.copy()
-    ]
-    
+
+    patterns = [CommonArguments.CONFIG_FILE.copy(), CommonArguments.CONFIG_DIR.copy()]
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)
 
@@ -164,12 +158,12 @@ def add_config_arguments(parser: argparse.ArgumentParser) -> None:
 def add_output_arguments(parser: argparse.ArgumentParser) -> None:
     """Add output-related arguments."""
     group = parser.add_argument_group("output options")
-    
+
     patterns = [
         CommonArguments.OUTPUT_FORMAT.copy(),
-        CommonArguments.OUTPUT_FILE.copy()
+        CommonArguments.OUTPUT_FILE.copy(),
     ]
-    
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)
 
@@ -177,12 +171,9 @@ def add_output_arguments(parser: argparse.ArgumentParser) -> None:
 def add_agent_arguments(parser: argparse.ArgumentParser) -> None:
     """Add agent-related arguments."""
     group = parser.add_argument_group("agent options")
-    
-    patterns = [
-        CommonArguments.AGENT_NAME.copy(),
-        CommonArguments.AGENT_DIR.copy()
-    ]
-    
+
+    patterns = [CommonArguments.AGENT_NAME.copy(), CommonArguments.AGENT_DIR.copy()]
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)
 
@@ -190,11 +181,9 @@ def add_agent_arguments(parser: argparse.ArgumentParser) -> None:
 def add_memory_arguments(parser: argparse.ArgumentParser) -> None:
     """Add memory-related arguments."""
     group = parser.add_argument_group("memory options")
-    
-    patterns = [
-        CommonArguments.MEMORY_DIR.copy()
-    ]
-    
+
+    patterns = [CommonArguments.MEMORY_DIR.copy()]
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)
 
@@ -202,11 +191,8 @@ def add_memory_arguments(parser: argparse.ArgumentParser) -> None:
 def add_operation_arguments(parser: argparse.ArgumentParser) -> None:
     """Add operation control arguments."""
     group = parser.add_argument_group("operation options")
-    
-    patterns = [
-        CommonArguments.FORCE.copy(),
-        CommonArguments.DRY_RUN.copy()
-    ]
-    
+
+    patterns = [CommonArguments.FORCE.copy(), CommonArguments.DRY_RUN.copy()]
+
     for pattern in patterns:
         add_argument_from_pattern(group, pattern)

claude_mpm/cli/shared/base_command.py

@@ -16,19 +16,23 @@ 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":
+    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: Dict[str, Any] = None) -> "CommandResult":
+    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)
 
@@ -36,18 +40,18 @@ class CommandResult:
 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
         """
@@ -55,7 +59,7 @@ class BaseCommand(ABC):
         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)."""
@@ -63,7 +67,7 @@ class BaseCommand(ABC):
             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)."""
@@ -72,54 +76,57 @@ class BaseCommand(ABC):
             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:
+        if hasattr(args, "debug") and args.debug:
             logging.getLogger().setLevel(logging.DEBUG)
-        elif hasattr(args, 'verbose') and args.verbose:
+        elif hasattr(args, "verbose") and args.verbose:
             logging.getLogger().setLevel(logging.INFO)
-        elif hasattr(args, 'quiet') and args.quiet:
+        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:
+        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_"
+                env_prefix="CLAUDE_MPM_",
+            )
+            self._config = config_loader.load_config(
+                pattern, cache_key=f"cli_{args.config}"
             )
-            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
         """
@@ -127,55 +134,56 @@ class BaseCommand(ABC):
             # 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)
-        
+            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')
-        
+        output_format = getattr(args, "format", "text")
+
         # Format and print result
         formatted_output = format_output(result, output_format)
-        
-        if hasattr(args, 'output') and args.output:
+
+        if hasattr(args, "output") and args.output:
             # Write to file
-            with open(args.output, 'w') as f:
+            with open(args.output, "w") as f:
                 f.write(formatted_output)
             self.logger.info(f"Output written to {args.output}")
         else:
@@ -185,11 +193,11 @@ class BaseCommand(ABC):
 
 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
@@ -197,7 +205,7 @@ class ServiceCommand(BaseCommand):
         super().__init__(command_name)
         self.service_class = service_class
         self._service = None
-    
+
     @property
     def service(self):
         """Get service instance (lazy loaded)."""
@@ -208,27 +216,27 @@ class ServiceCommand(BaseCommand):
 
 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:
+        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)
+        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:
+        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"