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

claude_mpm/cli/parsers/mcp_parser.py

@@ -0,0 +1,152 @@
+from pathlib import Path
+
+"""
+MCP command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to MCP Gateway management,
+extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: MCP commands handle Model Context Protocol Gateway server
+and tool management with complex subcommand structures.
+"""
+
+import argparse
+
+from ...constants import CLICommands, MCPCommands
+from .base_parser import add_common_arguments
+
+
+def add_mcp_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the MCP subparser with all MCP Gateway management commands.
+
+    WHY: MCP management has multiple complex subcommands for server management,
+    tool registration, and configuration that need their own structures.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured MCP subparser
+    """
+    # MCP command with subcommands
+    mcp_parser = subparsers.add_parser(
+        CLICommands.MCP.value, help="Manage MCP Gateway server and tools"
+    )
+    add_common_arguments(mcp_parser)
+
+    mcp_subparsers = mcp_parser.add_subparsers(
+        dest="mcp_command", help="MCP commands", metavar="SUBCOMMAND"
+    )
+
+    # Install MCP Gateway
+    install_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.INSTALL.value, help="Install and configure MCP Gateway"
+    )
+    install_mcp_parser.add_argument(
+        "--force", action="store_true", help="Force overwrite existing configuration"
+    )
+
+    # Start MCP server
+    start_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.START.value, help="Start the MCP Gateway server"
+    )
+    start_mcp_parser.add_argument(
+        "--mode",
+        choices=["stdio", "standalone"],
+        default="stdio",
+        help="Server mode: stdio for Claude integration, standalone for testing (default: stdio)",
+    )
+    start_mcp_parser.add_argument(
+        "--port",
+        type=int,
+        default=8766,
+        help="Port for standalone mode (default: 8766)",
+    )
+    start_mcp_parser.add_argument(
+        "--config-file", type=Path, help="Path to MCP configuration file"
+    )
+    start_mcp_parser.add_argument(
+        "--test", action="store_true", help="Run in test mode with debug output"
+    )
+    start_mcp_parser.add_argument(
+        "--instructions",
+        action="store_true",
+        help="Show setup instructions instead of running server",
+    )
+    start_mcp_parser.add_argument(
+        "--daemon", action="store_true", help="Run as daemon (not recommended for MCP)"
+    )
+
+    # Stop MCP server
+    stop_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.STOP.value, help="Stop the MCP Gateway server"
+    )
+
+    # MCP status
+    status_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.STATUS.value, help="Check server and tool status"
+    )
+    status_mcp_parser.add_argument(
+        "--verbose", action="store_true", help="Show detailed status information"
+    )
+
+    # List/manage tools
+    tools_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.TOOLS.value, help="List and manage registered tools"
+    )
+    tools_mcp_parser.add_argument(
+        "tool_action",
+        nargs="?",
+        choices=["list", "enable", "disable"],
+        default="list",
+        help="Tool action (default: list)",
+    )
+    tools_mcp_parser.add_argument(
+        "tool_name", nargs="?", help="Tool name for enable/disable actions"
+    )
+    tools_mcp_parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show detailed tool information including schemas",
+    )
+
+    # Register new tool
+    register_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.REGISTER.value, help="Register a new MCP tool"
+    )
+    register_mcp_parser.add_argument("name", help="Tool name")
+    register_mcp_parser.add_argument("description", help="Tool description")
+    register_mcp_parser.add_argument(
+        "--schema-file", type=Path, help="Path to JSON schema file for tool input"
+    )
+    register_mcp_parser.add_argument(
+        "--adapter", help="Path to custom tool adapter module"
+    )
+    register_mcp_parser.add_argument(
+        "--save", action="store_true", help="Save tool to configuration"
+    )
+
+    # Test tool invocation
+    test_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.TEST.value, help="Test MCP tool invocation"
+    )
+    test_mcp_parser.add_argument("tool_name", help="Name of tool to test")
+    test_mcp_parser.add_argument("--args", help="Tool arguments as JSON string")
+    test_mcp_parser.add_argument(
+        "--args-file", type=Path, help="Path to JSON file containing tool arguments"
+    )
+
+    # Manage configuration
+    config_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.CONFIG.value, help="View and manage MCP configuration"
+    )
+    config_mcp_parser.add_argument(
+        "config_action",
+        nargs="?",
+        choices=["view", "edit", "reset"],
+        default="view",
+        help="Configuration action (default: view)",
+    )
+
+    return mcp_parser

claude_mpm/cli/parsers/memory_parser.py

@@ -0,0 +1,138 @@
+"""
+Memory command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to memory management commands,
+extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: Memory commands handle agent memory files and have their own
+subcommand structure that benefits from separation.
+"""
+
+import argparse
+
+from ...constants import CLICommands, MemoryCommands
+from .base_parser import add_common_arguments
+
+
+def add_memory_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the memory subparser with all memory management commands.
+
+    WHY: Memory management has multiple subcommands for initialization,
+    listing, and management that need their own argument structures.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured memory subparser
+    """
+    # Memory command with subcommands
+    memory_parser = subparsers.add_parser(
+        CLICommands.MEMORY.value, help="Manage agent memory files"
+    )
+    add_common_arguments(memory_parser)
+
+    memory_subparsers = memory_parser.add_subparsers(
+        dest="memory_command", help="Memory commands", metavar="SUBCOMMAND"
+    )
+
+    # Init command
+    init_parser = memory_subparsers.add_parser(
+        MemoryCommands.INIT.value,
+        help="Initialize project-specific memories via PM agent",
+    )
+    init_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force initialization even if memories already exist",
+    )
+    init_parser.add_argument(
+        "--template", help="Memory template to use for initialization"
+    )
+
+    # List command
+    list_parser = memory_subparsers.add_parser(
+        MemoryCommands.SHOW.value, help="List available memory files"
+    )
+    list_parser.add_argument(
+        "--type", choices=["project", "user", "system"], help="Filter by memory type"
+    )
+    list_parser.add_argument(
+        "--verbose", action="store_true", help="Show detailed memory information"
+    )
+
+    # View command
+    view_parser = memory_subparsers.add_parser(
+        MemoryCommands.VIEW.value, help="View memory file contents"
+    )
+    view_parser.add_argument("memory_name", help="Name of the memory file to view")
+    view_parser.add_argument(
+        "--raw", action="store_true", help="Show raw memory content without formatting"
+    )
+
+    # Edit command
+    edit_parser = memory_subparsers.add_parser(
+        MemoryCommands.ADD.value, help="Edit memory file"
+    )
+    edit_parser.add_argument("memory_name", help="Name of the memory file to edit")
+    edit_parser.add_argument("--editor", help="Editor to use (overrides default)")
+
+    # Create command
+    create_parser = memory_subparsers.add_parser(
+        MemoryCommands.BUILD.value, help="Create new memory file"
+    )
+    create_parser.add_argument("memory_name", help="Name of the memory file to create")
+    create_parser.add_argument(
+        "--type",
+        choices=["project", "user"],
+        default="project",
+        help="Type of memory to create (default: project)",
+    )
+    create_parser.add_argument("--template", help="Template to use for the new memory")
+    create_parser.add_argument("--content", help="Initial content for the memory file")
+
+    # Delete command
+    delete_parser = memory_subparsers.add_parser(
+        MemoryCommands.CLEAN.value, help="Delete memory file"
+    )
+    delete_parser.add_argument("memory_name", help="Name of the memory file to delete")
+    delete_parser.add_argument(
+        "--force", action="store_true", help="Force deletion without confirmation"
+    )
+    delete_parser.add_argument(
+        "--backup", action="store_true", help="Create backup before deletion"
+    )
+
+    # Sync command
+    sync_parser = memory_subparsers.add_parser(
+        MemoryCommands.OPTIMIZE.value, help="Sync memory files across environments"
+    )
+    sync_parser.add_argument(
+        "--source",
+        choices=["project", "user", "system"],
+        help="Source memory type to sync from",
+    )
+    sync_parser.add_argument(
+        "--target", choices=["project", "user"], help="Target memory type to sync to"
+    )
+    sync_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be synced without actually syncing",
+    )
+
+    # Validate command
+    validate_parser = memory_subparsers.add_parser(
+        MemoryCommands.STATUS.value, help="Validate memory file format and content"
+    )
+    validate_parser.add_argument(
+        "memory_name",
+        nargs="?",
+        help="Name of specific memory file to validate (default: all)",
+    )
+    validate_parser.add_argument(
+        "--strict", action="store_true", help="Use strict validation rules"
+    )
+
+    return memory_parser

claude_mpm/cli/parsers/monitor_parser.py

@@ -0,0 +1,124 @@
+"""
+Monitor command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to monitoring server management,
+extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: Monitor commands handle Socket.IO server management and
+have their own subcommand structure.
+"""
+
+import argparse
+
+from ...constants import CLICommands, MonitorCommands
+from .base_parser import add_common_arguments
+
+
+def add_monitor_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the monitor subparser with all monitoring server commands.
+
+    WHY: Monitor management has multiple subcommands for starting, stopping,
+    and managing the Socket.IO monitoring server.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured monitor subparser
+    """
+    # Monitor command with subcommands
+    monitor_parser = subparsers.add_parser(
+        CLICommands.MONITOR.value, help="Manage Socket.IO monitoring server"
+    )
+    add_common_arguments(monitor_parser)
+
+    monitor_subparsers = monitor_parser.add_subparsers(
+        dest="monitor_command", help="Monitor commands", metavar="SUBCOMMAND"
+    )
+
+    # Start monitor
+    start_monitor_parser = monitor_subparsers.add_parser(
+        MonitorCommands.START.value, help="Start Socket.IO monitoring server"
+    )
+    start_monitor_parser.add_argument(
+        "--port", type=int, help="Port to start server on (auto-select if not specified)"
+    )
+    start_monitor_parser.add_argument(
+        "--host", default="localhost", help="Host to bind to (default: localhost)"
+    )
+    start_monitor_parser.add_argument(
+        "--dashboard", action="store_true", help="Enable web dashboard interface"
+    )
+    start_monitor_parser.add_argument(
+        "--dashboard-port",
+        type=int,
+        default=8766,
+        help="Dashboard port (default: 8766)",
+    )
+    start_monitor_parser.add_argument(
+        "--background", action="store_true", help="Run server in background"
+    )
+    start_monitor_parser.add_argument(
+        "--force", action="store_true", 
+        help="Force kill daemon processes to reclaim ports (use with caution)"
+    )
+    start_monitor_parser.add_argument(
+        "--no-reclaim", dest="reclaim", action="store_false", default=True,
+        help="Don't automatically reclaim ports from debug scripts"
+    )
+
+    # Stop monitor
+    stop_monitor_parser = monitor_subparsers.add_parser(
+        MonitorCommands.STOP.value, help="Stop Socket.IO monitoring server"
+    )
+    stop_monitor_parser.add_argument(
+        "--port", type=int, help="Port of server to stop (stops all if not specified)"
+    )
+    stop_monitor_parser.add_argument(
+        "--force", action="store_true", help="Force stop even if clients are connected"
+    )
+
+    # Restart monitor
+    restart_monitor_parser = monitor_subparsers.add_parser(
+        MonitorCommands.RESTART.value, help="Restart Socket.IO monitoring server"
+    )
+    restart_monitor_parser.add_argument(
+        "--port", type=int, help="Port to restart on"
+    )
+    restart_monitor_parser.add_argument(
+        "--host", default="localhost", help="Host to bind to (default: localhost)"
+    )
+
+    # Status monitor
+    status_monitor_parser = monitor_subparsers.add_parser(
+        MonitorCommands.STATUS.value, help="Check monitoring server status"
+    )
+    status_monitor_parser.add_argument(
+        "--verbose", action="store_true", help="Show detailed status information"
+    )
+    status_monitor_parser.add_argument(
+        "--show-ports", action="store_true", 
+        help="Show status of all ports in the range (8765-8785)"
+    )
+
+    # Port monitor (start/restart on specific port)
+    port_monitor_parser = monitor_subparsers.add_parser(
+        MonitorCommands.PORT.value, help="Start/restart monitoring server on specific port"
+    )
+    port_monitor_parser.add_argument(
+        "port", type=int, help="Port number to use"
+    )
+    port_monitor_parser.add_argument(
+        "--host", default="localhost", help="Host to bind to (default: localhost)"
+    )
+    port_monitor_parser.add_argument(
+        "--force", action="store_true", 
+        help="Force kill daemon processes to reclaim port (use with caution)"
+    )
+    port_monitor_parser.add_argument(
+        "--no-reclaim", dest="reclaim", action="store_false", default=True,
+        help="Don't automatically reclaim port from debug scripts"
+    )
+
+    return monitor_parser

claude_mpm/cli/parsers/run_parser.py

@@ -0,0 +1,147 @@
+"""
+Run command parser for claude-mpm CLI.
+
+WHY: This module contains all arguments specific to the run command,
+extracted from the monolithic parser.py for better organization.
+
+DESIGN DECISION: Run command arguments are complex enough to warrant
+their own module, including hook management, ticket creation, and
+interaction modes.
+"""
+
+import argparse
+
+from ...constants import CLICommands
+from .base_parser import add_common_arguments
+
+
+def add_run_arguments(parser: argparse.ArgumentParser) -> None:
+    """
+    Add arguments specific to the run command.
+
+    WHY: The run command has specific arguments for controlling how Claude sessions
+    are executed, including hook management, ticket creation, and interaction modes.
+
+    Args:
+        parser: The argument parser to add arguments to
+    """
+    run_group = parser.add_argument_group("run options")
+
+    run_group.add_argument(
+        "--no-hooks",
+        action="store_true",
+        help="Disable hook service (runs without hooks)",
+    )
+    run_group.add_argument(
+        "--no-tickets", action="store_true", help="Disable automatic ticket creation"
+    )
+    run_group.add_argument(
+        "--intercept-commands",
+        action="store_true",
+        help="Enable command interception in interactive mode (intercepts /mpm: commands)",
+    )
+    run_group.add_argument(
+        "--no-native-agents",
+        action="store_true",
+        help="Disable deployment of Claude Code native agents",
+    )
+    run_group.add_argument(
+        "--launch-method",
+        choices=["exec", "subprocess"],
+        default="exec",
+        help="Method to launch Claude: exec (replace process) or subprocess (child process)",
+    )
+    # Monitor options - consolidated monitoring and management interface
+    run_group.add_argument(
+        "--monitor",
+        action="store_true",
+        help="Enable monitoring and management interface with WebSocket server and dashboard (default port: 8765)",
+    )
+    run_group.add_argument(
+        "--websocket-port",
+        type=int,
+        default=8765,
+        help="WebSocket server port (default: 8765)",
+    )
+    run_group.add_argument(
+        "--force",
+        action="store_true",
+        help="Force operations even with warnings (e.g., large .claude.json file)",
+    )
+    run_group.add_argument(
+        "--resume",
+        type=str,
+        nargs="?",
+        const="last",
+        help="Resume a session (last session if no ID specified, or specific session ID)",
+    )
+
+    # Dependency checking options
+    dep_group = parser.add_argument_group("dependency options")
+    dep_group.add_argument(
+        "--no-check-dependencies",
+        action="store_false",
+        dest="check_dependencies",
+        help="Skip agent dependency checking at startup",
+    )
+    dep_group.add_argument(
+        "--force-check-dependencies",
+        action="store_true",
+        help="Force dependency checking even if cached results exist",
+    )
+    dep_group.add_argument(
+        "--no-prompt",
+        action="store_true",
+        help="Never prompt for dependency installation (non-interactive mode)",
+    )
+    dep_group.add_argument(
+        "--force-prompt",
+        action="store_true",
+        help="Force interactive prompting even in non-TTY environments (use with caution)",
+    )
+
+    # Input/output options
+    io_group = parser.add_argument_group("input/output options")
+    io_group.add_argument(
+        "-i",
+        "--input",
+        type=str,
+        help="Input text or file path (for non-interactive mode)",
+    )
+    io_group.add_argument(
+        "--non-interactive",
+        action="store_true",
+        help="Run in non-interactive mode (read from stdin or --input)",
+    )
+
+    # Claude CLI arguments
+    parser.add_argument(
+        "claude_args",
+        nargs=argparse.REMAINDER,
+        help="Additional arguments to pass to Claude CLI (use -- before Claude args)",
+    )
+
+
+def add_run_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the run subparser to the main parser.
+
+    WHY: This creates the explicit 'run' command subparser with all
+    run-specific arguments.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured run subparser
+    """
+    # Run command (explicit)
+    run_parser = subparsers.add_parser(
+        CLICommands.RUN.value,
+        help="Run orchestrated Claude session (default)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(run_parser)
+    add_run_arguments(run_parser)
+
+    return run_parser