claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/commander/chat/cli.py

@@ -0,0 +1,146 @@
+"""Commander CLI entry point."""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from claude_mpm.commander.env_loader import load_env
+from claude_mpm.commander.instance_manager import InstanceManager
+from claude_mpm.commander.llm.openrouter_client import (
+    OpenRouterClient,
+    OpenRouterConfig,
+)
+from claude_mpm.commander.llm.summarizer import OutputSummarizer
+from claude_mpm.commander.proxy.formatter import OutputFormatter
+from claude_mpm.commander.proxy.output_handler import OutputHandler
+from claude_mpm.commander.proxy.relay import OutputRelay
+from claude_mpm.commander.session.manager import SessionManager
+from claude_mpm.commander.tmux_orchestrator import TmuxOrchestrator
+
+from .repl import CommanderREPL
+
+# Load environment variables at module import
+load_env()
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CommanderCLIConfig:
+    """Configuration for Commander CLI mode.
+
+    Attributes:
+        summarize_responses: Whether to use LLM to summarize instance responses
+        port: Port for internal services (reserved for future use)
+        state_dir: Directory for state persistence (optional)
+
+    Example:
+        >>> config = CommanderCLIConfig(summarize_responses=False)
+    """
+
+    summarize_responses: bool = True
+    port: int = 8765
+    state_dir: Optional[Path] = None
+
+
+async def run_commander(
+    port: int = 8765,
+    state_dir: Optional[Path] = None,
+    config: Optional[CommanderCLIConfig] = None,
+) -> None:
+    """Run Commander in interactive mode.
+
+    Args:
+        port: Port for internal services (unused currently).
+        state_dir: Directory for state persistence (optional).
+        config: Commander CLI configuration (optional, uses defaults if None).
+
+    Example:
+        >>> asyncio.run(run_commander())
+        # Starts interactive Commander REPL
+        >>> config = CommanderCLIConfig(summarize_responses=False)
+        >>> asyncio.run(run_commander(config=config))
+        # Starts Commander without response summarization
+    """
+    # Use default config if not provided
+    if config is None:
+        config = CommanderCLIConfig(port=port, state_dir=state_dir)
+
+    # Setup logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    # Initialize components
+    logger.info("Initializing Commander...")
+
+    # Create tmux orchestrator
+    orchestrator = TmuxOrchestrator()
+
+    # Create instance manager
+    instance_manager = InstanceManager(orchestrator)
+
+    # Create session manager
+    session_manager = SessionManager()
+
+    # Try to initialize LLM client (optional)
+    llm_client: Optional[OpenRouterClient] = None
+    try:
+        llm_config = OpenRouterConfig()
+        llm_client = OpenRouterClient(llm_config)
+        logger.info("LLM client initialized")
+    except ValueError as e:
+        logger.warning(f"LLM client not available: {e}")
+        logger.warning("Output summarization will be disabled")
+
+    # Create output relay (optional)
+    output_relay: Optional[OutputRelay] = None
+    if llm_client:
+        try:
+            # Only create summarizer if summarize_responses is enabled
+            summarizer = None
+            if config.summarize_responses:
+                summarizer = OutputSummarizer(llm_client)
+                logger.info("Response summarization enabled")
+            else:
+                logger.info("Response summarization disabled")
+
+            handler = OutputHandler(orchestrator, summarizer)
+            formatter = OutputFormatter()
+            output_relay = OutputRelay(handler, formatter)
+            logger.info("Output relay initialized")
+        except Exception as e:
+            logger.warning(f"Output relay setup failed: {e}")
+
+    # Create REPL
+    repl = CommanderREPL(
+        instance_manager=instance_manager,
+        session_manager=session_manager,
+        output_relay=output_relay,
+        llm_client=llm_client,
+    )
+
+    # Run REPL
+    try:
+        await repl.run()
+    except KeyboardInterrupt:
+        logger.info("Commander interrupted by user")
+    except Exception as e:
+        logger.error(f"Commander error: {e}", exc_info=True)
+    finally:
+        # Cleanup
+        logger.info("Shutting down Commander...")
+        if output_relay:
+            await output_relay.stop_all()
+
+
+def main() -> None:
+    """Entry point for command-line execution."""
+    asyncio.run(run_commander())
+
+
+if __name__ == "__main__":
+    main()

claude_mpm/commander/chat/commands.py

@@ -0,0 +1,96 @@
+"""Built-in Commander chat commands."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class CommandType(Enum):
+    """Built-in command types."""
+
+    LIST = "list"
+    START = "start"
+    STOP = "stop"
+    CONNECT = "connect"
+    DISCONNECT = "disconnect"
+    STATUS = "status"
+    HELP = "help"
+    EXIT = "exit"
+    INSTANCES = "instances"  # alias for list
+
+
+@dataclass
+class Command:
+    """Parsed command with args."""
+
+    type: CommandType
+    args: list[str]
+    raw: str
+
+
+class CommandParser:
+    """Parses user input into commands."""
+
+    ALIASES = {
+        "ls": CommandType.LIST,
+        "instances": CommandType.LIST,
+        "quit": CommandType.EXIT,
+        "q": CommandType.EXIT,
+    }
+
+    def parse(self, input_text: str) -> Optional[Command]:
+        """Parse input into a Command.
+
+        Returns None if input is not a built-in command (natural language).
+
+        Args:
+            input_text: Raw user input.
+
+        Returns:
+            Command if input is a built-in command, None otherwise.
+
+        Example:
+            >>> parser = CommandParser()
+            >>> cmd = parser.parse("list")
+            >>> cmd.type
+            <CommandType.LIST: 'list'>
+            >>> parser.parse("tell me about the code")
+            None
+        """
+        if not input_text:
+            return None
+
+        parts = input_text.split()
+        command_str = parts[0].lower()
+        args = parts[1:] if len(parts) > 1 else []
+
+        # Check if it's an alias
+        if command_str in self.ALIASES:
+            cmd_type = self.ALIASES[command_str]
+            return Command(type=cmd_type, args=args, raw=input_text)
+
+        # Check if it's a direct command
+        try:
+            cmd_type = CommandType(command_str)
+            return Command(type=cmd_type, args=args, raw=input_text)
+        except ValueError:
+            # Not a built-in command
+            return None
+
+    def is_command(self, input_text: str) -> bool:
+        """Check if input is a built-in command.
+
+        Args:
+            input_text: Raw user input.
+
+        Returns:
+            True if input is a built-in command, False otherwise.
+
+        Example:
+            >>> parser = CommandParser()
+            >>> parser.is_command("list")
+            True
+            >>> parser.is_command("tell me about the code")
+            False
+        """
+        return self.parse(input_text) is not None

claude_mpm/commander/chat/repl.py

@@ -0,0 +1,310 @@
+"""Commander chat REPL interface."""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+
+from claude_mpm.commander.instance_manager import InstanceManager
+from claude_mpm.commander.llm.openrouter_client import OpenRouterClient
+from claude_mpm.commander.proxy.relay import OutputRelay
+from claude_mpm.commander.session.manager import SessionManager
+
+from .commands import Command, CommandParser, CommandType
+
+
+class CommanderREPL:
+    """Interactive REPL for Commander mode."""
+
+    def __init__(
+        self,
+        instance_manager: InstanceManager,
+        session_manager: SessionManager,
+        output_relay: Optional[OutputRelay] = None,
+        llm_client: Optional[OpenRouterClient] = None,
+    ):
+        """Initialize REPL.
+
+        Args:
+            instance_manager: Manages Claude instances.
+            session_manager: Manages chat session state.
+            output_relay: Optional relay for instance output.
+            llm_client: Optional OpenRouter client for chat.
+        """
+        self.instances = instance_manager
+        self.session = session_manager
+        self.relay = output_relay
+        self.llm = llm_client
+        self.parser = CommandParser()
+        self._running = False
+
+    async def run(self) -> None:
+        """Start the REPL loop."""
+        self._running = True
+        self._print_welcome()
+
+        # Setup history file
+        history_path = Path.home() / ".claude-mpm" / "commander_history"
+        history_path.parent.mkdir(parents=True, exist_ok=True)
+
+        prompt = PromptSession(history=FileHistory(str(history_path)))
+
+        while self._running:
+            try:
+                user_input = await asyncio.to_thread(prompt.prompt, self._get_prompt())
+                await self._handle_input(user_input.strip())
+            except KeyboardInterrupt:
+                continue
+            except EOFError:
+                break
+
+        self._print("\nGoodbye!")
+
+    async def _handle_input(self, input_text: str) -> None:
+        """Handle user input - command or natural language.
+
+        Args:
+            input_text: User input string.
+        """
+        if not input_text:
+            return
+
+        # Check if it's a built-in command
+        command = self.parser.parse(input_text)
+        if command:
+            await self._execute_command(command)
+        else:
+            # Natural language - send to connected instance
+            await self._send_to_instance(input_text)
+
+    async def _execute_command(self, cmd: Command) -> None:
+        """Execute a built-in command.
+
+        Args:
+            cmd: Parsed command.
+        """
+        handlers = {
+            CommandType.LIST: self._cmd_list,
+            CommandType.START: self._cmd_start,
+            CommandType.STOP: self._cmd_stop,
+            CommandType.CONNECT: self._cmd_connect,
+            CommandType.DISCONNECT: self._cmd_disconnect,
+            CommandType.STATUS: self._cmd_status,
+            CommandType.HELP: self._cmd_help,
+            CommandType.EXIT: self._cmd_exit,
+        }
+        handler = handlers.get(cmd.type)
+        if handler:
+            await handler(cmd.args)
+
+    async def _cmd_list(self, args: list[str]) -> None:
+        """List active instances."""
+        instances = self.instances.list_instances()
+        if not instances:
+            self._print("No active instances.")
+        else:
+            self._print("Active instances:")
+            for inst in instances:
+                status = (
+                    "→" if inst.name == self.session.context.connected_instance else " "
+                )
+                git_info = f" [{inst.git_branch}]" if inst.git_branch else ""
+                self._print(
+                    f"  {status} {inst.name} ({inst.framework}){git_info} - {inst.project_path}"
+                )
+
+    async def _cmd_start(self, args: list[str]) -> None:
+        """Start a new instance: start <path> [--framework cc|mpm] [--name name]."""
+        if not args:
+            self._print("Usage: start <path> [--framework cc|mpm] [--name name]")
+            return
+
+        # Parse arguments
+        project_path = Path(args[0]).expanduser().resolve()
+        framework = "cc"  # default
+        name = project_path.name  # default
+
+        # Parse optional flags
+        i = 1
+        while i < len(args):
+            if args[i] == "--framework" and i + 1 < len(args):
+                framework = args[i + 1]
+                i += 2
+            elif args[i] == "--name" and i + 1 < len(args):
+                name = args[i + 1]
+                i += 2
+            else:
+                i += 1
+
+        # Validate path
+        if not project_path.exists():
+            self._print(f"Error: Path does not exist: {project_path}")
+            return
+
+        if not project_path.is_dir():
+            self._print(f"Error: Path is not a directory: {project_path}")
+            return
+
+        # Start instance
+        try:
+            instance = await self.instances.start_instance(
+                name, project_path, framework
+            )
+            self._print(f"Started instance '{name}' ({framework}) at {project_path}")
+            self._print(f"Tmux: {instance.tmux_session}:{instance.pane_target}")
+        except Exception as e:
+            self._print(f"Error starting instance: {e}")
+
+    async def _cmd_stop(self, args: list[str]) -> None:
+        """Stop an instance: stop <name>."""
+        if not args:
+            self._print("Usage: stop <instance-name>")
+            return
+
+        name = args[0]
+
+        try:
+            await self.instances.stop_instance(name)
+            self._print(f"Stopped instance '{name}'")
+
+            # Disconnect if we were connected
+            if self.session.context.connected_instance == name:
+                self.session.disconnect()
+        except Exception as e:
+            self._print(f"Error stopping instance: {e}")
+
+    async def _cmd_connect(self, args: list[str]) -> None:
+        """Connect to an instance: connect <name>."""
+        if not args:
+            self._print("Usage: connect <instance-name>")
+            return
+
+        name = args[0]
+        inst = self.instances.get_instance(name)
+        if not inst:
+            self._print(f"Instance '{name}' not found")
+            return
+
+        self.session.connect_to(name)
+        self._print(f"Connected to {name}")
+
+    async def _cmd_disconnect(self, args: list[str]) -> None:
+        """Disconnect from current instance."""
+        if not self.session.context.is_connected:
+            self._print("Not connected to any instance")
+            return
+
+        name = self.session.context.connected_instance
+        self.session.disconnect()
+        self._print(f"Disconnected from {name}")
+
+    async def _cmd_status(self, args: list[str]) -> None:
+        """Show status of current session."""
+        if self.session.context.is_connected:
+            name = self.session.context.connected_instance
+            inst = self.instances.get_instance(name)
+            if inst:
+                self._print(f"Connected to: {name}")
+                self._print(f"  Framework: {inst.framework}")
+                self._print(f"  Project: {inst.project_path}")
+                if inst.git_branch:
+                    self._print(f"  Git: {inst.git_branch} ({inst.git_status})")
+                self._print(f"  Tmux: {inst.tmux_session}:{inst.pane_target}")
+            else:
+                self._print(f"Connected to: {name} (instance no longer exists)")
+        else:
+            self._print("Not connected to any instance")
+
+        self._print(f"Messages in history: {len(self.session.context.messages)}")
+
+    async def _cmd_help(self, args: list[str]) -> None:
+        """Show help message."""
+        help_text = """
+Commander 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 this 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 ~/myproject --framework cc --name myapp
+  connect myapp
+  Fix the authentication bug in login.py
+  disconnect
+  exit
+"""
+        self._print(help_text)
+
+    async def _cmd_exit(self, args: list[str]) -> None:
+        """Exit the REPL."""
+        self._running = False
+
+    async def _send_to_instance(self, message: str) -> None:
+        """Send natural language to connected instance.
+
+        Args:
+            message: User message to send.
+        """
+        if not self.session.context.is_connected:
+            self._print("Not connected to any instance. Use 'connect <name>' first.")
+            return
+
+        name = self.session.context.connected_instance
+        inst = self.instances.get_instance(name)
+        if not inst:
+            self._print(f"Instance '{name}' no longer exists")
+            self.session.disconnect()
+            return
+
+        self._print(f"[Sending to {name}...]")
+        await self.instances.send_to_instance(name, message)
+        self.session.add_user_message(message)
+
+        # Wait for and display response
+        if self.relay:
+            try:
+                output = await self.relay.get_latest_output(
+                    name, inst.pane_target, context=message
+                )
+                self._print(f"\n[Response from {name}]:\n{output}")
+                self.session.add_assistant_message(output)
+            except Exception as e:
+                self._print(f"\n[Error getting response: {e}]")
+
+    def _get_prompt(self) -> str:
+        """Get prompt string based on connection state.
+
+        Returns:
+            Prompt string for input.
+        """
+        if self.session.context.is_connected:
+            return f"Commander ({self.session.context.connected_instance})> "
+        return "Commander> "
+
+    def _print(self, msg: str) -> None:
+        """Print message to console.
+
+        Args:
+            msg: Message to print.
+        """
+        print(msg)
+
+    def _print_welcome(self) -> None:
+        """Print welcome message."""
+        print("╔══════════════════════════════════════════╗")
+        print("║  MPM Commander - Interactive Mode        ║")
+        print("╚══════════════════════════════════════════╝")
+        print("Type 'help' for commands, or natural language to chat.")
+        print()

claude_mpm/commander/config.py

@@ -0,0 +1,51 @@
+"""Daemon configuration for MPM Commander.
+
+This module defines configuration structures for the Commander daemon,
+including server settings, resource limits, and persistence options.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class DaemonConfig:
+    """Configuration for Commander daemon.
+
+    Attributes:
+        host: API server bind address
+        port: API server port (default: 8766 from NetworkPorts.COMMANDER_DEFAULT)
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        state_dir: Directory for state persistence
+        max_projects: Maximum concurrent projects
+        healthcheck_interval: Healthcheck interval in seconds
+        save_interval: State persistence interval in seconds
+        poll_interval: Event polling interval in seconds
+        summarize_responses: Whether to use LLM to summarize instance responses
+
+    Example:
+        >>> config = DaemonConfig(port=8766, log_level="DEBUG")
+        >>> config.state_dir
+        PosixPath('/Users/user/.claude-mpm/commander')
+    """
+
+    host: str = "127.0.0.1"
+    port: int = 8766  # Default commander port (from network_config.NetworkPorts.COMMANDER_DEFAULT)
+    log_level: str = "INFO"
+    state_dir: Path = Path.home() / ".claude-mpm" / "commander"
+    max_projects: int = 10
+    healthcheck_interval: int = 30
+    save_interval: int = 30
+    poll_interval: float = 2.0
+    summarize_responses: bool = True
+
+    def __post_init__(self):
+        """Ensure state_dir is a Path object and create if needed."""
+        if isinstance(self.state_dir, str):
+            self.state_dir = Path(self.state_dir)
+
+        # Expand user home directory
+        self.state_dir = self.state_dir.expanduser()
+
+        # Create state directory if it doesn't exist
+        self.state_dir.mkdir(parents=True, exist_ok=True)