claude-mpm 5.5.0__py3-none-any.whl → 5.6.2__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.4.105
+5.6.2

claude_mpm/cli/commands/commander.py

@@ -0,0 +1,46 @@
+"""Commander command handler for CLI."""
+
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def handle_commander_command(args) -> int:
+    """Handle the commander command.
+
+    Args:
+        args: Parsed command line arguments with:
+            - port: Port for internal services (default: 8765)
+            - state_dir: Optional state directory path
+            - debug: Enable debug logging
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Import here to avoid circular dependencies
+        from claude_mpm.commander.chat.cli import run_commander
+
+        # Setup debug logging if requested
+        if getattr(args, "debug", False):
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            )
+
+        # Get arguments
+        port = getattr(args, "port", 8765)
+        state_dir = getattr(args, "state_dir", None)
+
+        # Run commander
+        asyncio.run(run_commander(port=port, state_dir=state_dir))
+
+        return 0
+
+    except KeyboardInterrupt:
+        logger.info("Commander interrupted by user")
+        return 0
+    except Exception as e:
+        logger.error(f"Commander error: {e}", exc_info=True)
+        return 1

claude_mpm/cli/commands/run.py

@@ -13,7 +13,7 @@ DESIGN DECISIONS:
 - Support multiple output formats (json, yaml, table, text)
 """
 
-import subprocess
+import subprocess  # nosec B404 - required for process management
 import sys
 from datetime import datetime, timezone
 from typing import Optional
@@ -489,6 +489,18 @@ class RunCommand(BaseCommand):
         if hasattr(args, "claude_args") and args.claude_args:
             claude_args.extend(args.claude_args)
 
+        # Add --resume if flag is set
+        if getattr(args, "resume", False) and "--resume" not in claude_args:
+            claude_args.insert(0, "--resume")
+
+        # Add --chrome if flag is set
+        if getattr(args, "chrome", False) and "--chrome" not in claude_args:
+            claude_args.insert(0, "--chrome")
+
+        # Add --no-chrome if flag is set
+        if getattr(args, "no_chrome", False) and "--no-chrome" not in claude_args:
+            claude_args.insert(0, "--no-chrome")
+
         # Create runner
         runner = ClaudeRunner(
             enable_tickets=enable_tickets,
@@ -553,7 +565,7 @@ class RunCommand(BaseCommand):
                 wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
                 if wrapper_path.exists():
                     print("Starting interactive session with command interception...")
-                    subprocess.run([sys.executable, str(wrapper_path)], check=False)
+                    subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
                 else:
                     self.logger.warning(
                         "Interactive wrapper not found, falling back to normal mode"
@@ -907,6 +919,26 @@ def run_session_legacy(args):
         else:
             logger.info("[INFO]️ --resume already in claude_args")
 
+    # Add --chrome to claude_args if the flag is set
+    chrome_flag_present = getattr(args, "chrome", False)
+    if chrome_flag_present:
+        logger.info("📌 --chrome flag detected in args")
+        if "--chrome" not in raw_claude_args:
+            raw_claude_args = ["--chrome", *raw_claude_args]
+            logger.info("✅ Added --chrome to claude_args")
+        else:
+            logger.info("ℹ️ --chrome already in claude_args")
+
+    # Add --no-chrome to claude_args if the flag is set
+    no_chrome_flag_present = getattr(args, "no_chrome", False)
+    if no_chrome_flag_present:
+        logger.info("📌 --no-chrome flag detected in args")
+        if "--no-chrome" not in raw_claude_args:
+            raw_claude_args = ["--no-chrome", *raw_claude_args]
+            logger.info("✅ Added --no-chrome to claude_args")
+        else:
+            logger.info("ℹ️ --no-chrome already in claude_args")
+
     # Filter out claude-mpm specific flags before passing to Claude CLI
     logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
@@ -1044,7 +1076,7 @@ def run_session_legacy(args):
         wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
         if wrapper_path.exists():
             print("Starting interactive session with command interception...")
-            subprocess.run([sys.executable, str(wrapper_path)], check=False)
+            subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
         else:
             logger.warning("Interactive wrapper not found, falling back to normal mode")
             runner.run_interactive(context)

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
@@ -352,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/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'
+        """