claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/cli/parsers/base_parser.py

@@ -11,11 +11,96 @@ and reduce duplication across command parsers.
 """
 
 import argparse
+import sys
 from typing import List, Optional
 
 from ...constants import CLICommands, CLIPrefix, LogLevel
 
 
+class SuggestingArgumentParser(argparse.ArgumentParser):
+    """
+    Custom ArgumentParser that suggests similar commands on error.
+
+    WHY: Provides better user experience by suggesting corrections for typos
+    and invalid commands instead of just showing an error message.
+
+    DESIGN DECISION: Extends ArgumentParser.error() to add suggestions before
+    exiting. This catches all parser errors including invalid subcommands and
+    invalid options.
+    """
+
+    def error(self, message: str) -> None:
+        """
+        Override error method to add command suggestions.
+
+        Args:
+            message: Error message from argparse
+        """
+        from ..utils import suggest_similar_commands
+
+        # Try to extract the invalid command/option from the error message
+        invalid_value = None
+        valid_choices = []
+
+        # Handle invalid subcommand errors
+        # Format: "argument COMMAND: invalid choice: 'tickts' (choose from ...)"
+        if "invalid choice:" in message:
+            try:
+                # Extract the invalid choice
+                parts = message.split("invalid choice: '")
+                if len(parts) > 1:
+                    invalid_value = parts[1].split("'")[0]
+
+                # Extract valid choices
+                if "(choose from" in message:
+                    choices_part = message.split("(choose from")[1]
+                    # Remove trailing parenthesis and split
+                    choices_str = choices_part.rstrip(")")
+                    # Parse choices - they may be quoted or unquoted
+                    valid_choices = [
+                        c.strip().strip("'\"")
+                        for c in choices_str.split(",")
+                        if c.strip()
+                    ]
+            except (IndexError, ValueError):
+                pass
+
+        # Handle unrecognized arguments (invalid options)
+        # Format: "unrecognized arguments: --verbos"
+        elif "unrecognized arguments:" in message:
+            try:
+                parts = message.split("unrecognized arguments:")
+                if len(parts) > 1:
+                    invalid_value = parts[1].strip().split()[0]
+
+                # Get common options from parser
+                valid_choices = []
+                for action in self._actions:
+                    for option in action.option_strings:
+                        valid_choices.append(option)
+            except (IndexError, ValueError):
+                pass
+
+        # Build error message with suggestions
+        from rich.console import Console
+
+        console = Console(stderr=True)
+
+        console.print(f"\n[red]Error:[/red] {message}\n", style="bold")
+
+        # Add suggestions if we found valid choices
+        if invalid_value and valid_choices:
+            suggestion = suggest_similar_commands(invalid_value, valid_choices)
+            if suggestion:
+                console.print(f"[yellow]{suggestion}[/yellow]\n")
+
+        # Show help hint
+        console.print(f"[dim]Run '{self.prog} --help' for usage information.[/dim]\n")
+
+        # Exit with error code
+        sys.exit(2)
+
+
 def _get_enhanced_version(base_version: str) -> str:
     """
     Get enhanced version string with build number if available.
@@ -111,15 +196,18 @@ def create_main_parser(
     WHY: This creates the foundation parser that other modules will extend
     with their specific subcommands and arguments.
 
+    DESIGN DECISION: Uses SuggestingArgumentParser to provide helpful suggestions
+    for typos and invalid commands, improving user experience.
+
     Args:
         prog_name: The program name to use
         version: The version string to display
 
     Returns:
-        Configured ArgumentParser instance ready for subparser addition
+        Configured SuggestingArgumentParser instance ready for subparser addition
     """
-    # Main parser
-    parser = argparse.ArgumentParser(
+    # Main parser with suggestion support
+    parser = SuggestingArgumentParser(
         prog=prog_name,
         description=f"Claude Multi-Agent Project Manager v{version} - Orchestrate Claude with agent delegation and ticket tracking",
         epilog="By default, runs an orchestrated Claude session. Use 'claude-mpm' for interactive mode or 'claude-mpm -i \"prompt\"' for non-interactive mode.\n\nTo pass arguments to Claude CLI, use -- separator: claude-mpm run -- --model sonnet --temperature 0.1",
@@ -199,6 +287,11 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force operations even with warnings (e.g., large .claude.json file)",
     )
+    run_group.add_argument(
+        "--reload-agents",
+        action="store_true",
+        help="Force rebuild of all system agents by deleting local claude-mpm agents",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -296,6 +389,34 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .source_parser import add_source_subparser
+
+        add_source_subparser(subparsers)
+    except ImportError:
+        pass
+
+    try:
+        from .skill_source_parser import add_skill_source_subparser
+
+        add_skill_source_subparser(subparsers)
+    except ImportError:
+        pass
+
+    try:
+        from .agent_source_parser import add_agent_source_subparser
+
+        add_agent_source_subparser(subparsers)
+    except ImportError:
+        pass
+
+    try:
+        from .auto_configure_parser import add_auto_configure_subparser
+
+        add_auto_configure_subparser(subparsers)
+    except ImportError:
+        pass
+
     try:
         from .memory_parser import add_memory_subparser
 
@@ -303,6 +424,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .skills_parser import add_skills_subparser
+
+        add_skills_subparser(subparsers)
+    except ImportError:
+        pass
+
     try:
         from .config_parser import add_config_subparser
 
@@ -324,6 +452,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .local_deploy_parser import add_local_deploy_arguments
+
+        add_local_deploy_arguments(subparsers)
+    except ImportError:
+        pass
+
     try:
         from .mcp_parser import add_mcp_subparser
 
@@ -345,6 +480,14 @@ def create_parser(
     except ImportError:
         pass
 
+    # Add uninstall command parser
+    try:
+        from ..commands.uninstall import add_uninstall_parser
+
+        add_uninstall_parser(subparsers)
+    except ImportError:
+        pass
+
     # Add debug command parser
     try:
         from .debug_parser import add_debug_subparser
@@ -382,6 +525,14 @@ def create_parser(
     except ImportError:
         pass
 
+    # Add search command parser
+    try:
+        from .search_parser import add_search_subparser
+
+        add_search_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Import and add additional command parsers from commands module
     try:
         from ..commands.aggregate import add_aggregate_parser
@@ -401,6 +552,48 @@ def create_parser(
         from ..commands.doctor import add_doctor_parser
 
         add_doctor_parser(subparsers)
+
+        from ..commands.postmortem import add_postmortem_parser
+
+        add_postmortem_parser(subparsers)
+
+        # Add upgrade command
+        from ..commands.upgrade import add_upgrade_parser
+
+        add_upgrade_parser(subparsers)
+
+        # Add verify command for MCP service verification
+        from ..commands.verify import add_parser as add_verify_parser
+
+        add_verify_parser(subparsers)
+
+        # Add hook-errors command for managing hook error memory
+        hook_errors_parser = subparsers.add_parser(
+            "hook-errors",
+            help="Manage hook error memory and diagnostics",
+        )
+        hook_errors_parser.add_argument(
+            "hook_errors_command",
+            nargs="?",
+            choices=["list", "summary", "clear", "diagnose", "status"],
+            help="Hook errors subcommand",
+        )
+        hook_errors_parser.add_argument(
+            "--format",
+            choices=["table", "json"],
+            default="table",
+            help="Output format for list command",
+        )
+        hook_errors_parser.add_argument(
+            "--hook-type",
+            help="Filter by specific hook type",
+        )
+        hook_errors_parser.add_argument(
+            "-y",
+            "--yes",
+            action="store_true",
+            help="Skip confirmation prompts",
+        )
     except ImportError:
         # Commands module may not be available during testing or refactoring
         pass

claude_mpm/cli/parsers/config_parser.py

@@ -1,27 +1,26 @@
-from pathlib import Path
-
 """
 Config command parser for claude-mpm CLI.
 
-WHY: This module contains all arguments specific to configuration management,
-extracted from the monolithic parser.py for better organization.
+WHY: This module provides the config command which is synonymous with configure.
+Both launch the interactive configuration TUI.
 
-DESIGN DECISION: Configuration commands handle validation and management
-of claude-mpm settings and warrant their own module.
+DESIGN DECISION: 'config' and 'configure' are aliases - both commands provide
+identical functionality through the interactive configuration interface.
 """
 
 import argparse
 
-from ...constants import CLICommands, ConfigCommands
+from ...constants import CLICommands
 from .base_parser import add_common_arguments
 
 
 def add_config_subparser(subparsers) -> argparse.ArgumentParser:
     """
-    Add the config subparser with all configuration management commands.
+    Add the config subparser (alias for configure).
 
-    WHY: Configuration management has multiple subcommands for validation,
-    viewing, and editing that need their own argument structures.
+    WHY: 'config' and 'configure' are synonymous commands that both launch
+    the interactive configuration interface. This provides a consistent
+    parser setup matching the configure command.
 
     Args:
         subparsers: The subparsers object from the main parser
@@ -29,57 +28,111 @@ def add_config_subparser(subparsers) -> argparse.ArgumentParser:
     Returns:
         The configured config subparser
     """
-    # Config command with subcommands
+    # Config command - alias for configure (interactive configuration)
     config_parser = subparsers.add_parser(
-        CLICommands.CONFIG.value, help="Validate and manage configuration"
+        CLICommands.CONFIG.value,
+        help="Interactive configuration interface for managing agents and behaviors (alias for 'configure')",
+        description="Launch an interactive Rich-based menu for configuring claude-mpm agents, templates, and behavior files",
     )
+
+    # Add common arguments
     add_common_arguments(config_parser)
 
-    config_subparsers = config_parser.add_subparsers(
-        dest="config_command", help="Config commands", metavar="SUBCOMMAND"
+    # Configuration scope options
+    scope_group = config_parser.add_argument_group("configuration scope")
+    scope_group.add_argument(
+        "--scope",
+        choices=["project", "user"],
+        default="project",
+        help="Configuration scope to manage (default: project)",
     )
 
-    # Validate config
-    validate_config_parser = config_subparsers.add_parser(
-        ConfigCommands.VALIDATE.value, help="Validate configuration files"
+    # Direct navigation options (skip main menu)
+    nav_group = config_parser.add_argument_group("direct navigation")
+    nav_group.add_argument(
+        "--agents", action="store_true", help="Jump directly to agent management"
     )
-    validate_config_parser.add_argument(
-        "--config-file",
-        type=Path,
-        help="Specific config file to validate (default: all)",
+    nav_group.add_argument(
+        "--templates", action="store_true", help="Jump directly to template editing"
+    )
+    nav_group.add_argument(
+        "--behaviors",
+        action="store_true",
+        help="Jump directly to behavior file management",
     )
-    validate_config_parser.add_argument(
-        "--strict", action="store_true", help="Use strict validation rules"
+    nav_group.add_argument(
+        "--startup",
+        action="store_true",
+        help="Configure startup services and agents",
     )
-    validate_config_parser.add_argument(
-        "--fix",
+    nav_group.add_argument(
+        "--version-info",
         action="store_true",
-        help="Attempt to fix validation errors automatically",
+        help="Display version information and exit",
+    )
+
+    # Non-interactive options
+    noninteractive_group = config_parser.add_argument_group("non-interactive options")
+    noninteractive_group.add_argument(
+        "--list-agents", action="store_true", help="List all available agents and exit"
+    )
+    noninteractive_group.add_argument(
+        "--enable-agent",
+        type=str,
+        metavar="AGENT_NAME",
+        help="Enable a specific agent and exit",
+    )
+    noninteractive_group.add_argument(
+        "--disable-agent",
+        type=str,
+        metavar="AGENT_NAME",
+        help="Disable a specific agent and exit",
+    )
+    noninteractive_group.add_argument(
+        "--export-config",
+        type=str,
+        metavar="FILE",
+        help="Export current configuration to a file",
+    )
+    noninteractive_group.add_argument(
+        "--import-config",
+        type=str,
+        metavar="FILE",
+        help="Import configuration from a file",
     )
 
-    # View config
-    view_config_parser = config_subparsers.add_parser(
-        ConfigCommands.VIEW.value, help="View current configuration"
+    # Hook management options
+    hooks_group = config_parser.add_argument_group("hook management")
+    hooks_group.add_argument(
+        "--install-hooks",
+        action="store_true",
+        help="Install Claude MPM hooks for Claude Code integration",
     )
-    view_config_parser.add_argument(
-        "--section", help="Specific configuration section to view"
+    hooks_group.add_argument(
+        "--verify-hooks",
+        action="store_true",
+        help="Verify that Claude MPM hooks are properly installed",
     )
-    view_config_parser.add_argument(
-        "--format",
-        choices=["yaml", "json", "table"],
-        default="yaml",
-        help="Output format (default: yaml)",
+    hooks_group.add_argument(
+        "--uninstall-hooks",
+        action="store_true",
+        help="Uninstall Claude MPM hooks",
     )
-    view_config_parser.add_argument(
-        "--show-defaults", action="store_true", help="Include default values in output"
+    hooks_group.add_argument(
+        "--force",
+        action="store_true",
+        help="Force reinstallation of hooks even if they already exist",
     )
 
-    # Status config
-    status_config_parser = config_subparsers.add_parser(
-        ConfigCommands.STATUS.value, help="Show configuration status"
+    # Display options
+    display_group = config_parser.add_argument_group("display options")
+    display_group.add_argument(
+        "--no-colors",
+        action="store_true",
+        help="Disable colored output in the interface",
     )
-    status_config_parser.add_argument(
-        "--verbose", action="store_true", help="Show detailed status information"
+    display_group.add_argument(
+        "--compact", action="store_true", help="Use compact display mode"
     )
 
     return config_parser

claude_mpm/cli/parsers/configure_parser.py

@@ -25,11 +25,11 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
     Returns:
         The configured configure subparser
     """
-    # Configure command - interactive TUI configuration
+    # Configure command - interactive configuration
     configure_parser = subparsers.add_parser(
         CLICommands.CONFIGURE.value,
-        help="Interactive terminal-based configuration interface for managing agents and behaviors",
-        description="Launch an interactive Rich-based TUI for configuring claude-mpm agents, templates, and behavior files",
+        help="Interactive configuration interface for managing agents and behaviors",
+        description="Launch an interactive Rich-based menu for configuring claude-mpm agents, templates, and behavior files",
     )
 
     # Add common arguments
@@ -58,6 +58,11 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
         action="store_true",
         help="Jump directly to behavior file management",
     )
+    nav_group.add_argument(
+        "--startup",
+        action="store_true",
+        help="Configure startup services and agents",
+    )
     nav_group.add_argument(
         "--version-info",
         action="store_true",
@@ -122,21 +127,12 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
     # Display options
     display_group = configure_parser.add_argument_group("display options")
     display_group.add_argument(
-        "--no-colors", action="store_true", help="Disable colored output in the TUI"
-    )
-    display_group.add_argument(
-        "--compact", action="store_true", help="Use compact display mode"
-    )
-    display_group.add_argument(
-        "--force-rich",
+        "--no-colors",
         action="store_true",
-        help="Force use of Rich menu interface instead of full-screen Textual TUI",
+        help="Disable colored output in the interface",
     )
     display_group.add_argument(
-        "--no-textual",
-        dest="use_textual",
-        action="store_false",
-        help="Disable Textual TUI and use Rich menu interface",
+        "--compact", action="store_true", help="Use compact display mode"
     )
 
     return configure_parser