claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/parsers/auto_configure_parser.py

@@ -0,0 +1,245 @@
+"""
+Auto-Configuration Parser for Claude MPM CLI
+============================================
+
+WHY: This module provides argument parsing for auto-configuration commands,
+enabling users to customize detection, recommendation, and deployment behavior.
+
+DESIGN DECISION: Follows existing parser patterns in the codebase, using
+add_common_arguments for consistency. Provides sensible defaults while
+allowing full customization.
+
+Part of TSK-0054: Auto-Configuration Feature - Phase 5
+"""
+
+import argparse
+from pathlib import Path
+
+from .base_parser import add_common_arguments
+
+
+def add_auto_configure_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the auto-configure subparser for automated agent configuration.
+
+    WHY: Auto-configuration simplifies onboarding by detecting project toolchain
+    and deploying appropriate agents automatically.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured auto-configure subparser
+    """
+    # Auto-configure command
+    auto_configure_parser = subparsers.add_parser(
+        "auto-configure",
+        help="Auto-configure agents based on project toolchain detection",
+        description="""
+Auto-configure agents for your project based on detected toolchain.
+
+This command analyzes your project to detect languages, frameworks, and
+deployment targets, then recommends and deploys appropriate specialized
+agents automatically.
+
+The command provides safety features including:
+  • Preview mode to see changes before applying
+  • Confidence thresholds to ensure quality matches
+  • Validation gates to block invalid configurations
+  • Rollback on failure to maintain consistency
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Interactive configuration with confirmation
+  claude-mpm auto-configure
+
+  # Preview configuration without deploying
+  claude-mpm auto-configure --preview
+
+  # Auto-approve deployment (for scripts)
+  claude-mpm auto-configure --yes
+
+  # Require 90% confidence for recommendations
+  claude-mpm auto-configure --min-confidence 0.9
+
+  # JSON output for scripting
+  claude-mpm auto-configure --json
+
+  # Configure specific project directory
+  claude-mpm auto-configure --project-path /path/to/project
+        """,
+    )
+    add_common_arguments(auto_configure_parser)
+
+    # Configuration mode
+    mode_group = auto_configure_parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "--preview",
+        "--dry-run",
+        dest="preview",
+        action="store_true",
+        help="Show what would be configured without deploying (preview mode)",
+    )
+    mode_group.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Skip confirmation prompts and deploy automatically",
+    )
+
+    # Configuration options
+    auto_configure_parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.8,
+        metavar="FLOAT",
+        help="Minimum confidence threshold for recommendations (0.0-1.0, default: 0.8)",
+    )
+
+    auto_configure_parser.add_argument(
+        "--project-path",
+        type=Path,
+        metavar="PATH",
+        help="Project path to analyze (default: current directory)",
+    )
+
+    return auto_configure_parser
+
+
+def add_agents_detect_subparser(agents_subparsers) -> argparse.ArgumentParser:
+    """
+    Add the agents detect subparser for toolchain detection.
+
+    WHY: Allows users to see what toolchain is detected without making changes,
+    useful for debugging and verification.
+
+    Args:
+        agents_subparsers: The agents subparsers object
+
+    Returns:
+        The configured detect subparser
+    """
+    detect_parser = agents_subparsers.add_parser(
+        "detect",
+        help="Detect project toolchain without deploying",
+        description="""
+Detect and display project toolchain without making any changes.
+
+This command analyzes your project to detect:
+  • Programming languages and versions
+  • Frameworks and libraries
+  • Deployment targets and platforms
+
+Useful for debugging toolchain detection and verifying what would be
+detected before running auto-configure.
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Detect toolchain in current directory
+  claude-mpm agents detect
+
+  # Detect with verbose output showing evidence
+  claude-mpm agents detect --verbose
+
+  # JSON output for scripting
+  claude-mpm agents detect --json
+
+  # Detect specific project
+  claude-mpm agents detect --project-path /path/to/project
+        """,
+    )
+    add_common_arguments(detect_parser)
+
+    detect_parser.add_argument(
+        "--project-path",
+        type=Path,
+        metavar="PATH",
+        help="Project path to analyze (default: current directory)",
+    )
+
+    return detect_parser
+
+
+def add_agents_recommend_subparser(
+    agents_subparsers,
+) -> argparse.ArgumentParser:
+    """
+    Add the agents recommend subparser for agent recommendations.
+
+    WHY: Allows users to see what agents would be recommended without deploying,
+    useful for reviewing recommendations before committing to deployment.
+
+    Args:
+        agents_subparsers: The agents subparsers object
+
+    Returns:
+        The configured recommend subparser
+    """
+    recommend_parser = agents_subparsers.add_parser(
+        "recommend",
+        help="Show recommended agents without deploying",
+        description="""
+Show recommended agents based on project toolchain without deploying.
+
+This command analyzes your project toolchain and recommends appropriate
+agents with detailed reasoning for each recommendation. No changes are
+made to your project.
+
+Useful for:
+  • Reviewing recommendations before deployment
+  • Understanding why agents are recommended
+  • Adjusting confidence thresholds
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Show recommendations with reasoning
+  claude-mpm agents recommend
+
+  # Require 90% confidence for recommendations
+  claude-mpm agents recommend --min-confidence 0.9
+
+  # JSON output for scripting
+  claude-mpm agents recommend --json
+
+  # Hide detailed reasoning
+  claude-mpm agents recommend --no-reasoning
+
+  # Recommend for specific project
+  claude-mpm agents recommend --project-path /path/to/project
+        """,
+    )
+    add_common_arguments(recommend_parser)
+
+    recommend_parser.add_argument(
+        "--project-path",
+        type=Path,
+        metavar="PATH",
+        help="Project path to analyze (default: current directory)",
+    )
+
+    recommend_parser.add_argument(
+        "--min-confidence",
+        type=float,
+        default=0.8,
+        metavar="FLOAT",
+        help="Minimum confidence threshold for recommendations (0.0-1.0, default: 0.8)",
+    )
+
+    recommend_parser.add_argument(
+        "--show-reasoning",
+        action="store_true",
+        default=True,
+        help="Show detailed reasoning for recommendations (default)",
+    )
+
+    recommend_parser.add_argument(
+        "--no-reasoning",
+        dest="show_reasoning",
+        action="store_false",
+        help="Hide detailed reasoning for recommendations",
+    )
+
+    return recommend_parser

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,13 @@ def create_parser(
     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 +403,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
 
@@ -317,6 +424,20 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .dashboard_parser import add_dashboard_subparser
+
+        add_dashboard_subparser(subparsers)
+    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
 
@@ -338,6 +459,59 @@ 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
+
+        add_debug_subparser(subparsers)
+    except ImportError:
+        pass
+
+    # Add analyze command parser
+    try:
+        from .analyze_parser import add_analyze_subparser
+
+        add_analyze_subparser(subparsers)
+    except ImportError:
+        pass
+
+    # Add analyze-code command parser
+    try:
+        from .analyze_code_parser import AnalyzeCodeParser
+
+        parser_obj = AnalyzeCodeParser()
+        analyze_code_parser = subparsers.add_parser(
+            "analyze-code", help=parser_obj.help_text
+        )
+        parser_obj.add_arguments(analyze_code_parser)
+        analyze_code_parser.set_defaults(command="analyze-code")
+    except ImportError:
+        pass
+
+    # Add mpm-init command parser
+    try:
+        from .mpm_init_parser import add_mpm_init_subparser
+
+        add_mpm_init_subparser(subparsers)
+    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
@@ -357,6 +531,16 @@ def create_parser(
         from ..commands.doctor import add_doctor_parser
 
         add_doctor_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)
     except ImportError:
         # Commands module may not be available during testing or refactoring
         pass

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",
@@ -96,24 +101,38 @@ def add_configure_subparser(subparsers) -> argparse.ArgumentParser:
         help="Import configuration from a file",
     )
 
-    # 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"
+    # Hook management options
+    hooks_group = configure_parser.add_argument_group("hook management")
+    hooks_group.add_argument(
+        "--install-hooks",
+        action="store_true",
+        help="Install Claude MPM hooks for Claude Code integration",
     )
-    display_group.add_argument(
-        "--compact", action="store_true", help="Use compact display mode"
+    hooks_group.add_argument(
+        "--verify-hooks",
+        action="store_true",
+        help="Verify that Claude MPM hooks are properly installed",
+    )
+    hooks_group.add_argument(
+        "--uninstall-hooks",
+        action="store_true",
+        help="Uninstall Claude MPM hooks",
+    )
+    hooks_group.add_argument(
+        "--force",
+        action="store_true",
+        help="Force reinstallation of hooks even if they already exist",
     )
+
+    # Display options
+    display_group = configure_parser.add_argument_group("display options")
     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

claude_mpm/cli/parsers/dashboard_parser.py

@@ -0,0 +1,113 @@
+"""
+Dashboard command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to dashboard management,
+providing a clean interface for starting, stopping, and managing the web dashboard.
+
+DESIGN DECISION: Dashboard commands handle web interface management and
+have their own subcommand structure similar to monitor commands.
+"""
+
+import argparse
+
+from ...constants import CLICommands, DashboardCommands
+from .base_parser import add_common_arguments
+
+
+def add_dashboard_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the dashboard subparser with all dashboard management commands.
+
+    WHY: Dashboard management has multiple subcommands for starting, stopping,
+    checking status, and opening the web interface in a browser.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured dashboard subparser
+    """
+    # Dashboard command with subcommands
+    dashboard_parser = subparsers.add_parser(
+        CLICommands.DASHBOARD.value,
+        help="Manage the web dashboard interface for monitoring and analysis",
+    )
+    add_common_arguments(dashboard_parser)
+
+    dashboard_subparsers = dashboard_parser.add_subparsers(
+        dest="dashboard_command", help="Dashboard commands", metavar="SUBCOMMAND"
+    )
+
+    # Start dashboard
+    start_dashboard_parser = dashboard_subparsers.add_parser(
+        DashboardCommands.START.value,
+        help="Start the web dashboard server",
+    )
+    start_dashboard_parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port to start dashboard on (default: 8765)",
+    )
+    start_dashboard_parser.add_argument(
+        "--host",
+        default="localhost",
+        help="Host to bind to (default: localhost)",
+    )
+    start_dashboard_parser.add_argument(
+        "--background",
+        action="store_true",
+        help="Run dashboard server in background",
+    )
+    start_dashboard_parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't open browser automatically",
+    )
+
+    # Stop dashboard
+    stop_dashboard_parser = dashboard_subparsers.add_parser(
+        DashboardCommands.STOP.value,
+        help="Stop the web dashboard server",
+    )
+    stop_dashboard_parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port of dashboard to stop (default: 8765)",
+    )
+    stop_dashboard_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Stop all running dashboard instances",
+    )
+
+    # Status dashboard
+    status_dashboard_parser = dashboard_subparsers.add_parser(
+        DashboardCommands.STATUS.value,
+        help="Check dashboard server status",
+    )
+    status_dashboard_parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show detailed status information",
+    )
+    status_dashboard_parser.add_argument(
+        "--show-ports",
+        action="store_true",
+        help="Show status of all ports in the range (8765-8785)",
+    )
+
+    # Open dashboard
+    open_dashboard_parser = dashboard_subparsers.add_parser(
+        DashboardCommands.OPEN.value,
+        help="Open the dashboard in a web browser (starts if not running)",
+    )
+    open_dashboard_parser.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        help="Port of dashboard to open (default: 8765)",
+    )
+
+    return dashboard_parser