claude-mpm 5.4.85__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/cli/executor.py

@@ -127,6 +127,14 @@ def execute_command(command: str, args) -> int:
         result = handle_verify(args)
         return result if result is not None else 0
 
+    # Handle commander command with lazy import
+    if command == "commander":
+        # Lazy import to avoid loading unless needed
+        from .commands.commander import handle_commander_command
+
+        result = handle_commander_command(args)
+        return result if result is not None else 0
+
     # Handle skill-source command with lazy import
     if command == "skill-source":
         # Lazy import to avoid loading unless needed
@@ -151,6 +159,14 @@ def execute_command(command: str, args) -> int:
         result = summarize_command(args)
         return result if result is not None else 0
 
+    # Handle oauth command with lazy import
+    if command == "oauth":
+        # Lazy import to avoid loading unless needed
+        from .commands.oauth import manage_oauth
+
+        result = manage_oauth(args)
+        return result if result is not None else 0
+
     # Handle profile command with lazy import
     if command == "profile":
         # Lazy import to avoid loading unless needed
@@ -206,35 +222,127 @@ def execute_command(command: str, args) -> int:
             "status": show_status,
         }
 
-        # Get handler and invoke
+        # Get handler and call it with argument list (same pattern as autotodos)
         handler = handlers.get(subcommand)
         if handler:
-            # Build Click context programmatically
-            import click
+            try:
+                # Build argument list for Click command based on subcommand
+                click_args = []
+
+                # list command: --format, --hook-type
+                if subcommand == "list":
+                    if hasattr(args, "format") and args.format:
+                        click_args.extend(["--format", args.format])
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                # clear command: --hook-type, -y
+                elif subcommand == "clear":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                    if hasattr(args, "yes") and args.yes:
+                        click_args.append("-y")
+                # diagnose command: hook_type (positional argument)
+                elif subcommand == "diagnose":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.append(args.hook_type)
+                # status and summary commands: no options
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
+                return 0
+            except SystemExit as e:
+                return e.code if e.code is not None else 0
+            except Exception as e:
+                print(f"Error: {e}")
+                return 1
+        else:
+            print(f"Unknown hook-errors subcommand: {subcommand}")
+            return 1
 
-            ctx = click.Context(command=handler)
+    # Handle autotodos command with lazy import
+    if command == "autotodos":
+        # Lazy import to avoid loading unless needed
+        from .commands.autotodos import (
+            clear_autotodos,
+            inject_autotodos,
+            list_autotodos,
+            list_pm_violations,
+            scan_delegation_patterns,
+            show_autotodos_status,
+        )
 
-            # Prepare keyword arguments from args
-            kwargs = {}
-            if hasattr(args, "format"):
-                kwargs["format"] = args.format
-            if hasattr(args, "hook_type"):
-                kwargs["hook_type"] = args.hook_type
-            if hasattr(args, "yes"):
-                kwargs["yes"] = args.yes
+        # Get subcommand
+        subcommand = getattr(args, "autotodos_command", "status")
+        if not subcommand:
+            subcommand = "status"
 
+        # Map subcommands to functions
+        handlers = {
+            "list": list_autotodos,
+            "inject": inject_autotodos,
+            "clear": clear_autotodos,
+            "status": show_autotodos_status,
+            "scan": scan_delegation_patterns,
+            "violations": list_pm_violations,
+        }
+
+        # Get handler and call it with standalone_mode=False
+        handler = handlers.get(subcommand)
+        if handler:
             try:
-                # Invoke handler with arguments
-                with ctx:
-                    handler.invoke(ctx, **kwargs)
+                # Build argument list for Click command
+                click_args = []
+
+                if subcommand == "list":
+                    fmt = getattr(args, "format", "table")
+                    click_args = ["--format", fmt]
+                elif subcommand == "inject":
+                    output = getattr(args, "output", None)
+                    if output:
+                        click_args = ["--output", output]
+                elif subcommand == "clear":
+                    error_key = getattr(args, "error_key", None)
+                    event_type = getattr(args, "event_type", "all")
+                    if error_key:
+                        click_args.append("--error-key")
+                        click_args.append(error_key)
+                    if event_type != "all":
+                        click_args.append("--event-type")
+                        click_args.append(event_type)
+                    if getattr(args, "yes", False):
+                        click_args.append("-y")
+                elif subcommand == "scan":
+                    text = getattr(args, "text", None)
+                    file = getattr(args, "file", None)
+                    fmt = getattr(args, "format", "table")
+                    save = getattr(args, "save", False)
+
+                    if text:
+                        click_args.append(text)
+                    if file:
+                        click_args.extend(["--file", file])
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+                    if save:
+                        click_args.append("--save")
+                elif subcommand == "violations":
+                    fmt = getattr(args, "format", "table")
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
                 return 0
             except SystemExit as e:
                 return e.code if e.code is not None else 0
             except Exception as e:
                 print(f"Error: {e}")
+                import traceback
+
+                traceback.print_exc()
                 return 1
         else:
-            print(f"Unknown hook-errors subcommand: {subcommand}")
+            print(f"Unknown autotodos subcommand: {subcommand}")
             return 1
 
     # Map stable commands to their implementations
@@ -260,6 +368,7 @@ def execute_command(command: str, args) -> int:
         CLICommands.SKILLS.value: manage_skills,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
+        "commander": None,  # Will be handled separately with lazy import
     }
 
     # Execute command if found
@@ -287,6 +396,9 @@ def execute_command(command: str, args) -> int:
         "local-deploy",
         "skill-source",
         "agent-source",
+        "hook-errors",
+        "autotodos",
+        "oauth",
     ]
 
     suggestion = suggest_similar_commands(command, all_commands)

claude_mpm/cli/helpers.py

@@ -30,7 +30,7 @@ def is_interactive_session() -> bool:
 
 def should_skip_config_check(command: str | None) -> bool:
     """Check if command should skip configuration check."""
-    skip_commands = ["configure", "doctor", "info", "mcp", "config"]
+    skip_commands = ["configure", "doctor", "info", "mcp", "config", "oauth"]
     return command in skip_commands if command else False
 
 

claude_mpm/cli/parsers/base_parser.py

@@ -125,7 +125,7 @@ def _get_enhanced_version(base_version: str) -> str:
 
         if enhanced and enhanced != base_version:
             return enhanced
-    except Exception:
+    except Exception:  # nosec B110
         # If anything fails, fall back to base version
         pass
 
@@ -297,6 +297,22 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force refresh agents and skills from remote repos, bypassing ETag cache",
     )
+    run_group.add_argument(
+        "--chrome",
+        action="store_true",
+        help="Enable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--no-chrome",
+        action="store_true",
+        help="Disable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--mcp",
+        type=str,
+        metavar="SERVICES",
+        help="Comma-separated list of MCP services to enable for this session (e.g., --mcp kuzu-memory,mcp-ticketer)",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -492,6 +508,20 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .commander_parser import add_commander_subparser
+
+        add_commander_subparser(subparsers)
+    except ImportError:
+        pass
+
+    try:
+        from .oauth_parser import add_oauth_subparser
+
+        add_oauth_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Add uninstall command parser
     try:
         from ..commands.uninstall import add_uninstall_parser
@@ -607,6 +637,59 @@ def create_parser(
             help="Skip confirmation prompts",
         )
 
+        # Add autotodos command for auto-generating todos from hook errors
+        autotodos_parser = subparsers.add_parser(
+            "autotodos",
+            help="Auto-generate todos from hook errors and delegation patterns",
+        )
+        autotodos_parser.add_argument(
+            "autotodos_command",
+            nargs="?",
+            choices=["list", "inject", "clear", "status", "scan", "violations"],
+            help="AutoTodos subcommand",
+        )
+        autotodos_parser.add_argument(
+            "text",
+            nargs="?",
+            help="Text to scan for delegation patterns (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--format",
+            choices=["table", "json"],
+            default="table",
+            help="Output format for list/scan commands",
+        )
+        autotodos_parser.add_argument(
+            "--output",
+            help="Output file path for inject command",
+        )
+        autotodos_parser.add_argument(
+            "--error-key",
+            help="Specific error key to clear",
+        )
+        autotodos_parser.add_argument(
+            "--event-type",
+            choices=["error", "violation", "all"],
+            default="all",
+            help="Type of events to clear (clear command only)",
+        )
+        autotodos_parser.add_argument(
+            "--file",
+            "-f",
+            help="Scan text from file (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--save",
+            action="store_true",
+            help="Save detections to event log (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "-y",
+            "--yes",
+            action="store_true",
+            help="Skip confirmation prompts",
+        )
+
         # Add summarize command
         from ..commands.summarize import add_summarize_parser
 

claude_mpm/cli/parsers/commander_parser.py

@@ -0,0 +1,116 @@
+"""
+Commander parser module for claude-mpm CLI.
+
+WHY: This module provides the commander subcommand for interactive instance management
+and chat interface.
+
+DESIGN DECISION: Uses subparser pattern consistent with other commands (run, agents, etc.)
+to provide a clean interface for Commander mode.
+"""
+
+import argparse
+from pathlib import Path
+
+
+def add_commander_subparser(subparsers: argparse._SubParsersAction) -> None:
+    """
+    Add commander subcommand parser.
+
+    WHY: Provides interactive mode for managing and chatting with multiple Claude instances.
+
+    Args:
+        subparsers: The subparsers object to add the commander parser to
+    """
+    commander_parser = subparsers.add_parser(
+        "commander",
+        help="Launch Commander multi-project orchestration (ALPHA)",
+        description="""
+Commander Mode - Multi-Project Orchestration (ALPHA)
+
+The commander subcommand auto-starts the Commander daemon (if not already running)
+and launches an interactive REPL for managing multiple Claude Code instances.
+
+Commander provides:
+- Auto-starting daemon that manages project lifecycles
+- Interactive REPL for controlling instances
+- Tmux-based session management
+- Real-time output monitoring
+- REST API for external control (http://127.0.0.1:8765)
+
+REPL Commands:
+  list, ls, instances   List active instances
+  start <path>          Start new instance at path
+    --framework <cc|mpm>  Specify framework (default: cc)
+    --name <name>         Specify instance name (default: dir name)
+  stop <name>           Stop an instance
+  connect <name>        Connect to an instance
+  disconnect            Disconnect from current instance
+  status                Show current session status
+  help                  Show help message
+  exit, quit, q         Exit Commander
+
+Natural Language:
+  When connected to an instance, any input that is not a built-in
+  command will be sent to the connected instance as a message.
+
+Examples:
+  # Start daemon and launch interactive chat
+  claude-mpm commander
+
+  # Start daemon only (no chat interface)
+  claude-mpm commander --daemon-only
+
+  # Use custom port
+  claude-mpm commander --port 9000
+
+  # In REPL:
+  > start ~/myproject --framework cc --name myapp
+  > connect myapp
+  > Fix the authentication bug in login.py
+  > disconnect
+  > exit
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # Optional: Port for internal services
+    commander_parser.add_argument(
+        "--port",
+        type=int,
+        default=8766,  # NetworkPorts.COMMANDER_DEFAULT
+        help="Port for internal services (default: 8766)",
+    )
+
+    # Optional: State directory
+    commander_parser.add_argument(
+        "--state-dir",
+        type=Path,
+        help="Directory for state persistence (optional)",
+    )
+
+    # Debug mode
+    commander_parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+
+    # Daemon auto-start options
+    commander_parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Daemon host (default: 127.0.0.1)",
+    )
+
+    commander_parser.add_argument(
+        "--no-chat",
+        action="store_true",
+        help="Start daemon only without interactive chat",
+    )
+
+    commander_parser.add_argument(
+        "--daemon-only",
+        action="store_true",
+        help="Alias for --no-chat (start daemon only)",
+    )

claude_mpm/cli/parsers/mcp_parser.py

@@ -192,4 +192,83 @@ def add_mcp_subparser(subparsers) -> argparse.ArgumentParser:
         "--force", action="store_true", help="Force overwrite existing configuration"
     )
 
+    # =========================================================================
+    # Service Management Commands (enable/disable/list)
+    # =========================================================================
+
+    # Enable MCP service
+    enable_parser = mcp_subparsers.add_parser(
+        MCPCommands.ENABLE.value,
+        help="Enable an MCP service in configuration",
+    )
+    enable_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to enable (e.g., kuzu-memory, mcp-github)",
+    )
+    enable_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Prompt for required credentials interactively",
+    )
+    enable_parser.add_argument(
+        "--env",
+        "-e",
+        action="append",
+        metavar="KEY=VALUE",
+        help="Set environment variable (can be used multiple times)",
+    )
+    enable_parser.add_argument(
+        "--global",
+        dest="use_global",
+        action="store_true",
+        help="Enable in global ~/.claude.json instead of project .mcp.json",
+    )
+
+    # Disable MCP service
+    disable_parser = mcp_subparsers.add_parser(
+        MCPCommands.DISABLE.value,
+        help="Disable an MCP service from configuration",
+    )
+    disable_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to disable",
+    )
+    disable_parser.add_argument(
+        "--global",
+        dest="use_global",
+        action="store_true",
+        help="Disable in global ~/.claude.json instead of project .mcp.json",
+    )
+
+    # List MCP services
+    list_parser = mcp_subparsers.add_parser(
+        MCPCommands.LIST.value,
+        help="List MCP services (available and enabled)",
+    )
+    list_parser.add_argument(
+        "--available",
+        "-a",
+        action="store_true",
+        help="Show all available services from registry",
+    )
+    list_parser.add_argument(
+        "--enabled",
+        "-e",
+        action="store_true",
+        help="Show only enabled services",
+    )
+    list_parser.add_argument(
+        "--global",
+        dest="use_global",
+        action="store_true",
+        help="Check global ~/.claude.json instead of project .mcp.json",
+    )
+    list_parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed service information",
+    )
+
     return mcp_parser

claude_mpm/cli/parsers/oauth_parser.py

@@ -0,0 +1,165 @@
+"""
+OAuth command parser for claude-mpm CLI.
+
+WHY: This module provides the oauth command with subcommands for
+managing OAuth authentication for MCP services that require OAuth2 flows.
+
+DESIGN DECISION: 'oauth' provides comprehensive OAuth management including
+listing OAuth-capable services, setup, status, token revocation, and refresh.
+"""
+
+import argparse
+
+from .base_parser import add_common_arguments
+
+
+def add_oauth_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the oauth subparser with all OAuth management subcommands.
+
+    WHY: 'oauth' provides comprehensive OAuth management for MCP services
+    that require OAuth2 authentication flows.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured oauth subparser
+    """
+    # OAuth command with subcommands
+    oauth_parser = subparsers.add_parser(
+        "oauth",
+        help="Manage OAuth authentication for MCP services",
+        description="""
+Manage OAuth authentication for MCP services.
+
+Available commands:
+  list              List OAuth-capable MCP services
+  setup <service>   Set up OAuth authentication for a service
+  status <service>  Show OAuth token status for a service
+  revoke <service>  Revoke OAuth tokens for a service
+  refresh <service> Refresh OAuth tokens for a service
+
+Examples:
+  claude-mpm oauth list
+  claude-mpm oauth setup workspace-mcp
+  claude-mpm oauth status workspace-mcp
+  claude-mpm oauth revoke workspace-mcp
+  claude-mpm oauth refresh workspace-mcp
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(oauth_parser)
+
+    # Add subcommands
+    oauth_subparsers = oauth_parser.add_subparsers(
+        dest="oauth_command", help="OAuth commands", metavar="SUBCOMMAND"
+    )
+
+    # List subcommand
+    list_parser = oauth_subparsers.add_parser(
+        "list",
+        help="List OAuth-capable MCP services",
+        description="List all MCP services that support OAuth authentication.",
+    )
+    add_common_arguments(list_parser)
+    list_parser.add_argument(
+        "--format",
+        choices=["table", "json"],
+        default="table",
+        help="Output format (default: table)",
+    )
+
+    # Setup subcommand
+    setup_parser = oauth_subparsers.add_parser(
+        "setup",
+        help="Set up OAuth authentication for a service",
+        description="""
+Set up OAuth authentication for an MCP service.
+
+This command initiates the OAuth2 flow by:
+1. Looking for credentials in .env.local, .env, or environment variables
+2. Prompting for credentials if not found
+3. Opening a browser for user authentication
+4. Starting a local callback server to receive the OAuth redirect
+5. Storing the tokens securely for future use
+
+Required environment variables (checked in order):
+  1. .env.local file (highest priority)
+  2. .env file
+  3. Environment variables
+
+For Google OAuth services:
+  GOOGLE_OAUTH_CLIENT_ID     - Your OAuth client ID
+  GOOGLE_OAUTH_CLIENT_SECRET - Your OAuth client secret
+
+Get credentials from: https://console.cloud.google.com/apis/credentials
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(setup_parser)
+    setup_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to authenticate (e.g., workspace-mcp)",
+    )
+    setup_parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't open browser automatically, just print the URL",
+    )
+    setup_parser.add_argument(
+        "--port",
+        type=int,
+        default=8085,
+        help="Port for the OAuth callback server (default: 8085)",
+    )
+
+    # Status subcommand
+    status_parser = oauth_subparsers.add_parser(
+        "status",
+        help="Show OAuth token status for a service",
+        description="Display the current OAuth token status including validity and expiration.",
+    )
+    add_common_arguments(status_parser)
+    status_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to check",
+    )
+    status_parser.add_argument(
+        "--format",
+        choices=["table", "json"],
+        default="table",
+        help="Output format (default: table)",
+    )
+
+    # Revoke subcommand
+    revoke_parser = oauth_subparsers.add_parser(
+        "revoke",
+        help="Revoke OAuth tokens for a service",
+        description="Revoke and delete stored OAuth tokens for a service.",
+    )
+    add_common_arguments(revoke_parser)
+    revoke_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to revoke tokens for",
+    )
+    revoke_parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+
+    # Refresh subcommand
+    refresh_parser = oauth_subparsers.add_parser(
+        "refresh",
+        help="Refresh OAuth tokens for a service",
+        description="Refresh the OAuth tokens using the stored refresh token.",
+    )
+    add_common_arguments(refresh_parser)
+    refresh_parser.add_argument(
+        "service_name",
+        help="Name of the MCP service to refresh tokens for",
+    )
+
+    return oauth_parser

claude_mpm/cli/parsers/run_parser.py

@@ -85,6 +85,16 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Pass --resume flag to Claude Code to resume the last conversation",
     )
+    run_group.add_argument(
+        "--chrome",
+        action="store_true",
+        help="Enable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--no-chrome",
+        action="store_true",
+        help="Disable Claude in Chrome integration (passed to Claude Code)",
+    )
 
     # Dependency checking options
     dep_group = parser.add_argument_group("dependency options")