claude-mpm 3.9.11__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/cli_module/args.py

@@ -2,139 +2,181 @@
 
 import argparse
 from pathlib import Path
-from typing import Dict, Any, Optional, Callable
+from typing import Any, Callable, Dict, Optional
 
 
 class ArgumentRegistry:
     """Registry for managing CLI argument definitions.
-    
+
     This class consolidates argument definitions to reduce duplication
     and simplify the main CLI function.
     """
-    
+
     def __init__(self):
         """Initialize the registry with common argument groups."""
         self._arguments: Dict[str, Dict[str, Any]] = {}
         self._groups: Dict[str, list] = {
-            'global': [],
-            'run': [],
-            'logging': [],
-            'framework': [],
-            'orchestration': []
+            "global": [],
+            "run": [],
+            "logging": [],
+            "framework": [],
+            "orchestration": [],
         }
         self._register_common_arguments()
-    
+
     def _register_common_arguments(self):
         """Register all common argument definitions."""
         # Version argument
-        self.register('version', {
-            'flags': ['--version'],
-            'action': 'version',
-            'help': 'Show version and exit',
-            'groups': ['global']
-        })
-        
+        self.register(
+            "version",
+            {
+                "flags": ["--version"],
+                "action": "version",
+                "help": "Show version and exit",
+                "groups": ["global"],
+            },
+        )
+
         # Logging arguments
-        self.register('debug', {
-            'flags': ['-d', '--debug'],
-            'action': 'store_true',
-            'help': 'Enable debug logging (deprecated, use --logging DEBUG)',
-            'groups': ['logging', 'global']
-        })
-        
-        self.register('logging', {
-            'flags': ['--logging'],
-            'choices': ['OFF', 'INFO', 'DEBUG'],
-            'default': 'OFF',
-            'help': 'Logging level (default: OFF)',
-            'groups': ['logging', 'global']
-        })
-        
-        self.register('log_dir', {
-            'flags': ['--log-dir'],
-            'type': Path,
-            'help': 'Custom log directory (default: ~/.claude-mpm/logs)',
-            'groups': ['logging', 'global']
-        })
-        
+        self.register(
+            "debug",
+            {
+                "flags": ["-d", "--debug"],
+                "action": "store_true",
+                "help": "Enable debug logging (deprecated, use --logging DEBUG)",
+                "groups": ["logging", "global"],
+            },
+        )
+
+        self.register(
+            "logging",
+            {
+                "flags": ["--logging"],
+                "choices": ["OFF", "INFO", "DEBUG"],
+                "default": "OFF",
+                "help": "Logging level (default: OFF)",
+                "groups": ["logging", "global"],
+            },
+        )
+
+        self.register(
+            "log_dir",
+            {
+                "flags": ["--log-dir"],
+                "type": Path,
+                "help": "Custom log directory (default: ~/.claude-mpm/logs)",
+                "groups": ["logging", "global"],
+            },
+        )
+
         # Framework arguments
-        self.register('framework_path', {
-            'flags': ['--framework-path'],
-            'type': Path,
-            'help': 'Path to claude-mpm framework',
-            'groups': ['framework', 'global']
-        })
-        
-        self.register('agents_dir', {
-            'flags': ['--agents-dir'],
-            'type': Path,
-            'help': 'Custom agents directory to use',
-            'groups': ['framework', 'global']
-        })
-        
-        self.register('no_hooks', {
-            'flags': ['--no-hooks'],
-            'action': 'store_true',
-            'help': 'Disable hook service (runs without hooks)',
-            'groups': ['framework', 'global', 'run']
-        })
-        
+        self.register(
+            "framework_path",
+            {
+                "flags": ["--framework-path"],
+                "type": Path,
+                "help": "Path to claude-mpm framework",
+                "groups": ["framework", "global"],
+            },
+        )
+
+        self.register(
+            "agents_dir",
+            {
+                "flags": ["--agents-dir"],
+                "type": Path,
+                "help": "Custom agents directory to use",
+                "groups": ["framework", "global"],
+            },
+        )
+
+        self.register(
+            "no_hooks",
+            {
+                "flags": ["--no-hooks"],
+                "action": "store_true",
+                "help": "Disable hook service (runs without hooks)",
+                "groups": ["framework", "global", "run"],
+            },
+        )
+
         # Run command arguments
-        self.register('no_tickets', {
-            'flags': ['--no-tickets'],
-            'action': 'store_true',
-            'help': 'Disable automatic ticket creation',
-            'groups': ['run']
-        })
-        
-        self.register('input', {
-            'flags': ['-i', '--input'],
-            'type': str,
-            'help': 'Input text or file path (for non-interactive mode)',
-            'groups': ['run']
-        })
-        
-        self.register('non_interactive', {
-            'flags': ['--non-interactive'],
-            'action': 'store_true',
-            'help': 'Run in non-interactive mode (read from stdin or --input)',
-            'groups': ['run']
-        })
-        
+        self.register(
+            "no_tickets",
+            {
+                "flags": ["--no-tickets"],
+                "action": "store_true",
+                "help": "Disable automatic ticket creation",
+                "groups": ["run"],
+            },
+        )
+
+        self.register(
+            "input",
+            {
+                "flags": ["-i", "--input"],
+                "type": str,
+                "help": "Input text or file path (for non-interactive mode)",
+                "groups": ["run"],
+            },
+        )
+
+        self.register(
+            "non_interactive",
+            {
+                "flags": ["--non-interactive"],
+                "action": "store_true",
+                "help": "Run in non-interactive mode (read from stdin or --input)",
+                "groups": ["run"],
+            },
+        )
+
         # Orchestration arguments
-        self.register('subprocess', {
-            'flags': ['--subprocess'],
-            'action': 'store_true',
-            'help': 'Use subprocess orchestration for agent delegations',
-            'groups': ['orchestration', 'run']
-        })
-        
-        self.register('interactive_subprocess', {
-            'flags': ['--interactive-subprocess'],
-            'action': 'store_true',
-            'help': 'Use interactive subprocess orchestration with pexpect control',
-            'groups': ['orchestration', 'run']
-        })
-        
-        self.register('todo_hijack', {
-            'flags': ['--todo-hijack'],
-            'action': 'store_true',
-            'help': 'Enable TODO hijacking to transform Claude\'s TODOs into agent delegations',
-            'groups': ['orchestration', 'run']
-        })
-        
+        self.register(
+            "subprocess",
+            {
+                "flags": ["--subprocess"],
+                "action": "store_true",
+                "help": "Use subprocess orchestration for agent delegations",
+                "groups": ["orchestration", "run"],
+            },
+        )
+
+        self.register(
+            "interactive_subprocess",
+            {
+                "flags": ["--interactive-subprocess"],
+                "action": "store_true",
+                "help": "Use interactive subprocess orchestration with pexpect control",
+                "groups": ["orchestration", "run"],
+            },
+        )
+
+        self.register(
+            "todo_hijack",
+            {
+                "flags": ["--todo-hijack"],
+                "action": "store_true",
+                "help": "Enable TODO hijacking to transform Claude's TODOs into agent delegations",
+                "groups": ["orchestration", "run"],
+            },
+        )
+
         # Ticket list arguments
-        self.register('limit', {
-            'flags': ['-n', '--limit'],
-            'type': int,
-            'default': 10,
-            'help': 'Number of tickets to show',
-            'groups': ['tickets']
-        })
-    
+        self.register(
+            "limit",
+            {
+                "flags": ["-n", "--limit"],
+                "type": int,
+                "default": 10,
+                "help": "Number of tickets to show",
+                "groups": ["tickets"],
+            },
+        )
+
     def register(self, name: str, definition: Dict[str, Any]):
         """Register a new argument definition.
-        
+
         Args:
             name: Internal name for the argument
             definition: Dictionary containing argument configuration:
@@ -143,18 +185,21 @@ class ArgumentRegistry:
                 - All other kwargs are passed to add_argument()
         """
         self._arguments[name] = definition
-        
+
         # Add to groups
-        for group in definition.get('groups', []):
+        for group in definition.get("groups", []):
             if group not in self._groups:
                 self._groups[group] = []
             self._groups[group].append(name)
-    
-    def apply_arguments(self, parser: argparse.ArgumentParser, 
-                       groups: Optional[list] = None,
-                       exclude: Optional[list] = None):
+
+    def apply_arguments(
+        self,
+        parser: argparse.ArgumentParser,
+        groups: Optional[list] = None,
+        exclude: Optional[list] = None,
+    ):
         """Apply argument definitions to a parser.
-        
+
         Args:
             parser: ArgumentParser or subparser to add arguments to
             groups: List of group names to include (None = all)
@@ -170,37 +215,40 @@ class ArgumentRegistry:
             # Remove duplicates while preserving order
             seen = set()
             arg_names = [x for x in arg_names if not (x in seen or seen.add(x))]
-        
+
         # Apply exclusions
         if exclude:
             arg_names = [n for n in arg_names if n not in exclude]
-        
+
         # Add arguments to parser
         for name in arg_names:
             definition = self._arguments[name].copy()
-            flags = definition.pop('flags')
-            definition.pop('groups', None)  # Remove groups from kwargs
-            
+            flags = definition.pop("flags")
+            definition.pop("groups", None)  # Remove groups from kwargs
+
             # Special handling for version
-            if name == 'version' and hasattr(parser, '_version'):
-                definition['version'] = parser._version
-            
+            if name == "version" and hasattr(parser, "_version"):
+                definition["version"] = parser._version
+
             parser.add_argument(*flags, **definition)
-    
+
     def get_argument_groups(self) -> Dict[str, list]:
         """Get all argument groups and their members."""
         return self._groups.copy()
-    
+
     def get_argument_definition(self, name: str) -> Optional[Dict[str, Any]]:
         """Get the definition for a specific argument."""
         return self._arguments.get(name, {}).copy()
-    
-    def create_argument_group(self, parser: argparse.ArgumentParser,
-                            group_name: str,
-                            title: str,
-                            description: Optional[str] = None):
+
+    def create_argument_group(
+        self,
+        parser: argparse.ArgumentParser,
+        group_name: str,
+        title: str,
+        description: Optional[str] = None,
+    ):
         """Create an argument group and add arguments from a named group.
-        
+
         Args:
             parser: Parser to add the group to
             group_name: Name of the argument group in registry
@@ -208,15 +256,15 @@ class ArgumentRegistry:
             description: Optional description for the group
         """
         group = parser.add_argument_group(title, description)
-        
+
         # Get arguments for this group
         arg_names = self._groups.get(group_name, [])
-        
+
         for name in arg_names:
             definition = self._arguments[name].copy()
-            flags = definition.pop('flags')
-            definition.pop('groups', None)
-            
+            flags = definition.pop("flags")
+            definition.pop("groups", None)
+
             group.add_argument(*flags, **definition)
-        
-        return group
+
+        return group

claude_mpm/cli_module/commands.py

@@ -1,19 +1,24 @@
 """Command registry for managing CLI subcommands."""
 
 import argparse
-from typing import Dict, Any, Optional, Callable, List
+from typing import Any, Callable, Dict, List, Optional
+
 from .args import ArgumentRegistry
 
 
 class CommandDefinition:
     """Definition for a CLI command."""
-    
-    def __init__(self, name: str, help_text: str, 
-                 handler: Callable,
-                 argument_groups: Optional[List[str]] = None,
-                 extra_args: Optional[Dict[str, Dict[str, Any]]] = None):
+
+    def __init__(
+        self,
+        name: str,
+        help_text: str,
+        handler: Callable,
+        argument_groups: Optional[List[str]] = None,
+        extra_args: Optional[Dict[str, Dict[str, Any]]] = None,
+    ):
         """Initialize command definition.
-        
+
         Args:
             name: Command name
             help_text: Help text for the command
@@ -30,27 +35,32 @@ class CommandDefinition:
 
 class CommandRegistry:
     """Registry for managing CLI subcommands.
-    
+
     This class simplifies subcommand management and reduces
     complexity in the main CLI function.
     """
-    
+
     def __init__(self, arg_registry: Optional[ArgumentRegistry] = None):
         """Initialize the command registry.
-        
+
         Args:
             arg_registry: ArgumentRegistry instance for applying arguments
         """
         self._commands: Dict[str, CommandDefinition] = {}
         self._arg_registry = arg_registry or ArgumentRegistry()
         self._default_command: Optional[str] = None
-    
-    def register(self, name: str, help_text: str, handler: Callable,
-                 argument_groups: Optional[List[str]] = None,
-                 extra_args: Optional[Dict[str, Dict[str, Any]]] = None,
-                 is_default: bool = False):
+
+    def register(
+        self,
+        name: str,
+        help_text: str,
+        handler: Callable,
+        argument_groups: Optional[List[str]] = None,
+        extra_args: Optional[Dict[str, Dict[str, Any]]] = None,
+        is_default: bool = False,
+    ):
         """Register a new command.
-        
+
         Args:
             name: Command name
             help_text: Help text for the command
@@ -64,59 +74,54 @@ class CommandRegistry:
             help_text=help_text,
             handler=handler,
             argument_groups=argument_groups,
-            extra_args=extra_args
+            extra_args=extra_args,
         )
-        
+
         self._commands[name] = command
-        
+
         if is_default:
             self._default_command = name
-    
-    def setup_subcommands(self, parser: argparse.ArgumentParser) -> argparse._SubParsersAction:
+
+    def setup_subcommands(
+        self, parser: argparse.ArgumentParser
+    ) -> argparse._SubParsersAction:
         """Set up all registered subcommands on the parser.
-        
+
         Args:
             parser: Main argument parser
-            
+
         Returns:
             The subparsers object
         """
-        subparsers = parser.add_subparsers(
-            dest="command",
-            help="Available commands"
-        )
-        
+        subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
         for name, command in self._commands.items():
             # Create subparser
-            subparser = subparsers.add_parser(
-                name,
-                help=command.help_text
-            )
-            
+            subparser = subparsers.add_parser(name, help=command.help_text)
+
             # Apply argument groups
             if command.argument_groups:
                 self._arg_registry.apply_arguments(
-                    subparser,
-                    groups=command.argument_groups
+                    subparser, groups=command.argument_groups
                 )
-            
+
             # Apply extra arguments
             for arg_name, arg_config in command.extra_args.items():
-                flags = arg_config.pop('flags', [f'--{arg_name.replace("_", "-")}'])
+                flags = arg_config.pop("flags", [f'--{arg_name.replace("_", "-")}'])
                 subparser.add_argument(*flags, **arg_config)
-            
+
             # Store handler reference
             subparser.set_defaults(_handler=command.handler)
-        
+
         return subparsers
-    
+
     def execute_command(self, args: argparse.Namespace, **kwargs) -> Any:
         """Execute the appropriate command handler.
-        
+
         Args:
             args: Parsed command line arguments
             **kwargs: Additional keyword arguments to pass to handler
-            
+
         Returns:
             Result from the command handler
         """
@@ -125,7 +130,7 @@ class CommandRegistry:
         if not command_name and self._default_command:
             command_name = self._default_command
             args.command = command_name
-            
+
             # Apply default command's argument defaults
             command = self._commands.get(command_name)
             if command:
@@ -133,14 +138,18 @@ class CommandRegistry:
                 for group in command.argument_groups:
                     for arg_name in self._arg_registry._groups.get(group, []):
                         if not hasattr(args, arg_name):
-                            definition = self._arg_registry.get_argument_definition(arg_name)
-                            if definition and 'default' in definition:
-                                setattr(args, arg_name, definition['default'])
-                            elif definition and definition.get('action') == 'store_true':
+                            definition = self._arg_registry.get_argument_definition(
+                                arg_name
+                            )
+                            if definition and "default" in definition:
+                                setattr(args, arg_name, definition["default"])
+                            elif (
+                                definition and definition.get("action") == "store_true"
+                            ):
                                 setattr(args, arg_name, False)
-        
+
         # Get command handler
-        if hasattr(args, '_handler'):
+        if hasattr(args, "_handler"):
             handler = args._handler
         else:
             command = self._commands.get(command_name)
@@ -148,18 +157,18 @@ class CommandRegistry:
                 handler = command.handler
             else:
                 return None
-        
+
         # Execute handler
         return handler(args, **kwargs)
-    
+
     def get_command_names(self) -> List[str]:
         """Get list of all registered command names."""
         return list(self._commands.keys())
-    
+
     def get_default_command(self) -> Optional[str]:
         """Get the default command name."""
         return self._default_command
-    
+
     def has_command(self, name: str) -> bool:
         """Check if a command is registered."""
         return name in self._commands
@@ -167,37 +176,37 @@ class CommandRegistry:
 
 def register_standard_commands(registry: CommandRegistry):
     """Register the standard claude-mpm commands.
-    
+
     This function registers all the standard commands that claude-mpm
     supports, reducing the setup code in main().
-    
+
     Args:
         registry: CommandRegistry instance to register commands with
     """
     # Import handlers (these would be refactored from cli.py)
-    from ..cli import run_session, list_tickets, show_info
-    
+    from ..cli import list_tickets, run_session, show_info
+
     # Register run command (default)
     registry.register(
-        name='run',
-        help_text='Run orchestrated Claude session (default)',
+        name="run",
+        help_text="Run orchestrated Claude session (default)",
         handler=run_session,
-        argument_groups=['run', 'orchestration'],
-        is_default=True
+        argument_groups=["run", "orchestration"],
+        is_default=True,
     )
-    
+
     # Register tickets command
     registry.register(
-        name='tickets',
-        help_text='List recent tickets',
+        name="tickets",
+        help_text="List recent tickets",
         handler=list_tickets,
-        argument_groups=['tickets']
+        argument_groups=["tickets"],
     )
-    
+
     # Register info command
     registry.register(
-        name='info',
-        help_text='Show framework and configuration info',
+        name="info",
+        help_text="Show framework and configuration info",
         handler=show_info,
-        argument_groups=[]  # No specific arguments needed
-    )
+        argument_groups=[],  # No specific arguments needed
+    )