claude-mpm 5.4.96__py3-none-any.whl → 5.6.17__py3-none-any.whl

claude_mpm/commander/chat/cli.py

@@ -0,0 +1,111 @@
+"""Commander CLI entry point."""
+
+import asyncio
+import logging
+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__)
+
+
+async def run_commander(
+    port: int = 8765,
+    state_dir: Optional[Path] = None,
+) -> None:
+    """Run Commander in interactive mode.
+
+    Args:
+        port: Port for internal services (unused currently).
+        state_dir: Directory for state persistence (optional).
+
+    Example:
+        >>> asyncio.run(run_commander())
+        # Starts interactive Commander REPL
+    """
+    # 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:
+        config = OpenRouterConfig()
+        llm_client = OpenRouterClient(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:
+            summarizer = OutputSummarizer(llm_client)
+            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,49 @@
+"""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
+        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
+
+    Example:
+        >>> config = DaemonConfig(port=8765, log_level="DEBUG")
+        >>> config.state_dir
+        PosixPath('/Users/user/.claude-mpm/commander')
+    """
+
+    host: str = "127.0.0.1"
+    port: int = 8765
+    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
+
+    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)

claude_mpm/commander/config_loader.py

@@ -0,0 +1,115 @@
+"""Project configuration loading for MPM Commander.
+
+This module handles loading configuration from a project's .claude-mpm/
+directory, including YAML config files and directory structure validation.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+def load_project_config(project_path: str) -> Optional[Dict[str, Any]]:
+    """Load configuration from project's .claude-mpm/ directory.
+
+    Looks for:
+    - .claude-mpm/configuration.yaml (main config file)
+    - .claude-mpm/agents/ (directory exists check)
+    - .claude-mpm/skills/ (directory exists check)
+    - .claude-mpm/memories/ (directory exists check)
+
+    Args:
+        project_path: Absolute path to project directory
+
+    Returns:
+        Dict with config data and directory flags, or None if no config found.
+        Example structure:
+        {
+            'configuration': {...},  # Parsed YAML config
+            'has_agents': True,
+            'has_skills': False,
+            'has_memories': True,
+        }
+
+    Raises:
+        yaml.YAMLError: If configuration.yaml is malformed
+
+    Example:
+        >>> config = load_project_config("/Users/masa/Projects/my-app")
+        >>> if config:
+        ...     print(f"Agents dir: {config['has_agents']}")
+        ...     print(f"Config: {config.get('configuration', {})}")
+        Agents dir: True
+        Config: {'default_adapter': 'linear', ...}
+    """
+    proj_path = Path(project_path)
+    config_dir = proj_path / ".claude-mpm"
+
+    # Check if .claude-mpm/ directory exists
+    if not config_dir.exists() or not config_dir.is_dir():
+        logger.debug("No .claude-mpm/ directory found in project: %s", project_path)
+        return None
+
+    logger.info("Loading configuration from %s", config_dir)
+
+    result: Dict[str, Any] = {
+        "configuration": {},
+        "has_agents": False,
+        "has_skills": False,
+        "has_memories": False,
+    }
+
+    # Load configuration.yaml if present
+    config_file = config_dir / "configuration.yaml"
+    if config_file.exists() and config_file.is_file():
+        try:
+            with open(config_file, encoding="utf-8") as f:
+                config_data = yaml.safe_load(f)
+                result["configuration"] = config_data or {}
+            logger.info(
+                "Loaded configuration.yaml with %d top-level keys",
+                len(result["configuration"]),
+            )
+        except yaml.YAMLError as e:
+            logger.error(
+                "Failed to parse configuration.yaml in %s: %s",
+                config_dir,
+                e,
+            )
+            raise
+        except Exception as e:
+            logger.warning(
+                "Failed to read configuration.yaml in %s: %s",
+                config_dir,
+                e,
+            )
+            # Continue with empty config
+
+    # Check for subdirectories
+    agents_dir = config_dir / "agents"
+    result["has_agents"] = agents_dir.exists() and agents_dir.is_dir()
+    if result["has_agents"]:
+        logger.debug("Found agents directory: %s", agents_dir)
+
+    skills_dir = config_dir / "skills"
+    result["has_skills"] = skills_dir.exists() and skills_dir.is_dir()
+    if result["has_skills"]:
+        logger.debug("Found skills directory: %s", skills_dir)
+
+    memories_dir = config_dir / "memories"
+    result["has_memories"] = memories_dir.exists() and memories_dir.is_dir()
+    if result["has_memories"]:
+        logger.debug("Found memories directory: %s", memories_dir)
+
+    logger.info(
+        "Project config loaded: agents=%s, skills=%s, memories=%s",
+        result["has_agents"],
+        result["has_skills"],
+        result["has_memories"],
+    )
+
+    return result

claude_mpm/commander/core/__init__.py

@@ -0,0 +1,10 @@
+"""Core coordination components for MPM Commander.
+
+This module provides core components that coordinate between different
+subsystems like events, work execution, and session management.
+"""
+
+from .block_manager import BlockManager
+from .response_manager import ResponseManager, ResponseRoute
+
+__all__ = ["BlockManager", "ResponseManager", "ResponseRoute"]