claude-mpm 5.4.96__py3-none-any.whl → 5.6.3__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
@@ -206,27 +214,33 @@ 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
-
-            ctx = click.Context(command=handler)
+            try:
+                # Build argument list for Click command based on subcommand
+                click_args = []
 
-            # 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
+                # 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
 
-            try:
-                # Invoke handler with arguments
-                with ctx:
-                    handler.invoke(ctx, **kwargs)
+                # 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
@@ -346,6 +360,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

claude_mpm/cli/parsers/base_parser.py

@@ -297,6 +297,16 @@ 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)",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -492,6 +502,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .commander_parser import add_commander_subparser
+
+        add_commander_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Add uninstall command parser
     try:
         from ..commands.uninstall import add_uninstall_parser

claude_mpm/cli/parsers/commander_parser.py

@@ -0,0 +1,83 @@
+"""
+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="Interactive Commander mode for managing multiple Claude instances",
+        description="""
+Commander Mode - Interactive Instance Management
+
+Commander provides an interactive REPL interface for:
+- Starting and stopping Claude Code/MPM instances in tmux
+- Connecting to instances and sending natural language commands
+- Managing multiple concurrent projects
+- Viewing instance status and output
+
+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:
+  claude-mpm commander
+  > 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=8765,
+        help="Port for internal services (default: 8765)",
+    )
+
+    # 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",
+    )

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")

claude_mpm/cli/startup.py

@@ -161,7 +161,25 @@ def setup_early_environment(argv):
     # CRITICAL: Suppress ALL logging by default
     # This catches all loggers (claude_mpm.*, service.*, framework_loader, etc.)
     # This will be overridden by setup_mcp_server_logging() based on user preference
-    logging.getLogger().setLevel(logging.CRITICAL + 1)  # Root logger catches everything
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.CRITICAL + 1)  # Root logger catches everything
+    root_logger.handlers = []  # Remove any handlers
+
+    # Also suppress common module loggers explicitly to prevent handler leakage
+    for logger_name in [
+        "claude_mpm",
+        "path_resolver",
+        "file_loader",
+        "framework_loader",
+        "service",
+        "instruction_loader",
+        "agent_loader",
+        "startup",
+    ]:
+        module_logger = logging.getLogger(logger_name)
+        module_logger.setLevel(logging.CRITICAL + 1)
+        module_logger.handlers = []
+        module_logger.propagate = False
 
     # Process argv
     if argv is None:
@@ -316,7 +334,7 @@ def deploy_output_style_on_startup():
     Deploys all styles:
     - claude-mpm.md (professional mode)
     - claude-mpm-teacher.md (teaching mode)
-    - claude-mpm-founders.md (founders mode)
+    - claude-mpm-research.md (research mode - for codebase analysis)
     """
     try:
         from ..core.output_style_manager import OutputStyleManager

claude_mpm/cli/utils.py

@@ -107,7 +107,7 @@ def get_agent_versions_display() -> Optional[str]:
                     base_version_tuple
                 )
                 output_lines.append(f"\n  Base Agent Version:  {base_version_str}")
-        except Exception:
+        except Exception:  # nosec B110 - intentional: version display is optional
             pass
 
         # Check for agents needing migration
@@ -173,8 +173,12 @@ def setup_logging(args) -> object:
     if not hasattr(args, "logging") or args.logging is None:
         args.logging = LogLevel.OFF.value
 
+    # Handle deprecated --verbose flag
+    if hasattr(args, "verbose") and args.verbose and args.logging == LogLevel.OFF.value:
+        args.logging = LogLevel.INFO.value
+
     # Handle deprecated --debug flag
-    if hasattr(args, "debug") and args.debug and args.logging == LogLevel.INFO.value:
+    if hasattr(args, "debug") and args.debug:
         args.logging = LogLevel.DEBUG.value
 
     # Only setup logging if not OFF
@@ -204,7 +208,7 @@ def ensure_directories() -> None:
         from ..init import ensure_directories as init_ensure_directories
 
         init_ensure_directories()
-    except Exception:
+    except Exception:  # nosec B110
         # Continue even if initialization fails
         # The individual commands will handle missing directories as needed
         pass

claude_mpm/commander/__init__.py

@@ -0,0 +1,72 @@
+"""MPM Commander - Multi-Project Orchestration.
+
+This module provides the core infrastructure for managing multiple projects
+with isolated state, work queues, and tool sessions.
+
+Key Components:
+    - ProjectRegistry: Thread-safe project management
+    - Project models: Data structures for state and sessions
+    - TmuxOrchestrator: Tmux session and pane management
+    - Config loading: .claude-mpm/ directory configuration
+    - CommanderDaemon: Main daemon process for orchestration
+    - ProjectSession: Per-project lifecycle management
+    - InstanceManager: Framework selection and instance lifecycle
+    - Frameworks: Claude Code, MPM framework abstractions
+
+Example:
+    >>> from claude_mpm.commander import ProjectRegistry
+    >>> registry = ProjectRegistry()
+    >>> project = registry.register("/path/to/project")
+    >>> registry.update_state(project.id, ProjectState.WORKING)
+"""
+
+from claude_mpm.commander.config import DaemonConfig
+from claude_mpm.commander.config_loader import load_project_config
+from claude_mpm.commander.daemon import CommanderDaemon
+from claude_mpm.commander.frameworks import (
+    BaseFramework,
+    ClaudeCodeFramework,
+    InstanceInfo,
+    MPMFramework,
+)
+from claude_mpm.commander.instance_manager import (
+    FrameworkNotFoundError,
+    InstanceAlreadyExistsError,
+    InstanceManager,
+    InstanceNotFoundError,
+)
+from claude_mpm.commander.models import (
+    Project,
+    ProjectState,
+    ThreadMessage,
+    ToolSession,
+)
+from claude_mpm.commander.project_session import ProjectSession, SessionState
+from claude_mpm.commander.registry import ProjectRegistry
+from claude_mpm.commander.tmux_orchestrator import (
+    TmuxNotFoundError,
+    TmuxOrchestrator,
+)
+
+__all__ = [
+    "BaseFramework",
+    "ClaudeCodeFramework",
+    "CommanderDaemon",
+    "DaemonConfig",
+    "FrameworkNotFoundError",
+    "InstanceAlreadyExistsError",
+    "InstanceInfo",
+    "InstanceManager",
+    "InstanceNotFoundError",
+    "MPMFramework",
+    "Project",
+    "ProjectRegistry",
+    "ProjectSession",
+    "ProjectState",
+    "SessionState",
+    "ThreadMessage",
+    "TmuxNotFoundError",
+    "TmuxOrchestrator",
+    "ToolSession",
+    "load_project_config",
+]

claude_mpm/commander/adapters/__init__.py

@@ -0,0 +1,31 @@
+"""Runtime adapters for MPM Commander.
+
+This package provides adapters for different AI coding tools, allowing
+the TmuxOrchestrator to interface with various runtimes in a uniform way.
+
+Two types of adapters:
+- RuntimeAdapter: Synchronous parsing and state detection
+- CommunicationAdapter: Async I/O and state management
+"""
+
+from .base import Capability, ParsedResponse, RuntimeAdapter
+from .claude_code import ClaudeCodeAdapter
+from .communication import (
+    AdapterResponse,
+    AdapterState,
+    BaseCommunicationAdapter,
+    ClaudeCodeCommunicationAdapter,
+)
+
+__all__ = [
+    # Communication adapters (async I/O)
+    "AdapterResponse",
+    "AdapterState",
+    "BaseCommunicationAdapter",
+    # Runtime adapters (parsing)
+    "Capability",
+    "ClaudeCodeAdapter",
+    "ClaudeCodeCommunicationAdapter",
+    "ParsedResponse",
+    "RuntimeAdapter",
+]

claude_mpm/commander/adapters/base.py

@@ -0,0 +1,191 @@
+"""Base runtime adapter interface for MPM Commander.
+
+This module defines the abstract interface for runtime adapters that bridge
+between the TmuxOrchestrator and various AI coding tools (Claude Code, Cursor, etc.).
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional, Set
+
+
+class Capability(Enum):
+    """Capabilities that a runtime adapter can provide."""
+
+    TOOL_USE = "tool_use"
+    FILE_EDIT = "file_edit"
+    FILE_CREATE = "file_create"
+    GIT_OPERATIONS = "git_operations"
+    SHELL_COMMANDS = "shell_commands"
+    WEB_SEARCH = "web_search"
+    COMPLEX_REASONING = "complex_reasoning"
+
+
+@dataclass
+class ParsedResponse:
+    """Parsed output from a runtime tool.
+
+    Attributes:
+        content: The extracted text content, with ANSI codes removed
+        is_complete: True if tool is waiting for input (idle state)
+        is_error: True if an error was detected in the output
+        error_message: The error message if is_error is True
+        is_question: True if tool is asking a question
+        question_text: The question text if is_question is True
+        options: List of options if presenting a choice
+
+    Example:
+        >>> response = ParsedResponse(
+        ...     content="File created successfully",
+        ...     is_complete=True,
+        ...     is_error=False,
+        ...     error_message=None,
+        ...     is_question=False,
+        ...     question_text=None,
+        ...     options=None
+        ... )
+    """
+
+    content: str
+    is_complete: bool
+    is_error: bool
+    error_message: Optional[str] = None
+    is_question: bool = False
+    question_text: Optional[str] = None
+    options: Optional[List[str]] = None
+
+
+class RuntimeAdapter(ABC):
+    """Abstract base class for runtime adapters.
+
+    A runtime adapter provides the interface between the TmuxOrchestrator
+    and a specific AI coding tool. It handles:
+    - Launching the tool with appropriate settings
+    - Formatting input messages
+    - Detecting tool states (idle, error, questioning)
+    - Parsing tool output into structured responses
+
+    Example:
+        >>> class MyAdapter(RuntimeAdapter):
+        ...     @property
+        ...     def name(self) -> str:
+        ...         return "my-tool"
+        ...
+        ...     def build_launch_command(self, project_path: str) -> str:
+        ...         return f"cd {project_path} && my-tool --interactive"
+    """
+
+    @abstractmethod
+    def build_launch_command(
+        self, project_path: str, agent_prompt: Optional[str] = None
+    ) -> str:
+        """Generate shell command to start the tool.
+
+        Args:
+            project_path: Absolute path to the project directory
+            agent_prompt: Optional system prompt to configure the agent
+
+        Returns:
+            Shell command string ready to execute
+
+        Example:
+            >>> adapter.build_launch_command("/home/user/project", "You are a Python expert")
+            'cd /home/user/project && claude --system-prompt "You are a Python expert"'
+        """
+
+    @abstractmethod
+    def format_input(self, message: str) -> str:
+        """Prepare message for tool's input format.
+
+        Args:
+            message: The user message to send
+
+        Returns:
+            Formatted message ready to send to the tool
+
+        Example:
+            >>> adapter.format_input("Fix the bug in main.py")
+            'Fix the bug in main.py'
+        """
+
+    @abstractmethod
+    def detect_idle(self, output: str) -> bool:
+        """Recognize when tool is waiting for input.
+
+        Args:
+            output: Raw output from the tool (may contain ANSI codes)
+
+        Returns:
+            True if the tool is in an idle state awaiting input
+
+        Example:
+            >>> adapter.detect_idle("Done editing file.\\n> ")
+            True
+            >>> adapter.detect_idle("Processing request...")
+            False
+        """
+
+    @abstractmethod
+    def detect_error(self, output: str) -> Optional[str]:
+        """Recognize error states, return error message if found.
+
+        Args:
+            output: Raw output from the tool
+
+        Returns:
+            Error message string if error detected, None otherwise
+
+        Example:
+            >>> adapter.detect_error("Error: File not found: config.py")
+            'Error: File not found: config.py'
+            >>> adapter.detect_error("File edited successfully")
+            None
+        """
+
+    @abstractmethod
+    def parse_response(self, output: str) -> ParsedResponse:
+        """Extract meaningful content from output.
+
+        This method combines all detection logic (idle, error, questions)
+        into a single structured response.
+
+        Args:
+            output: Raw output from the tool
+
+        Returns:
+            ParsedResponse with all detected states and content
+
+        Example:
+            >>> response = adapter.parse_response("Error: Invalid input\\n> ")
+            >>> response.is_error
+            True
+            >>> response.is_complete
+            True
+        """
+
+    @property
+    @abstractmethod
+    def capabilities(self) -> Set[Capability]:
+        """What this tool can do.
+
+        Returns:
+            Set of Capability enums indicating supported features
+
+        Example:
+            >>> adapter.capabilities
+            {Capability.FILE_EDIT, Capability.TOOL_USE}
+        """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Runtime identifier.
+
+        Returns:
+            Unique name for this runtime adapter
+
+        Example:
+            >>> adapter.name
+            'claude-code'
+        """