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

claude_mpm/commander/chat/cli.py

@@ -2,9 +2,11 @@
 
 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,
@@ -19,28 +21,61 @@ 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
     """
-    # Setup logging
+    # Use default config if not provided
+    if config is None:
+        config = CommanderCLIConfig(port=port, state_dir=state_dir)
+
+    # Setup logging - suppress noisy libraries
     logging.basicConfig(
         level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     )
+    # Suppress httpx request logging (very verbose)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
 
     # Initialize components
     logger.info("Initializing Commander...")
@@ -57,8 +92,8 @@ async def run_commander(
     # Try to initialize LLM client (optional)
     llm_client: Optional[OpenRouterClient] = None
     try:
-        config = OpenRouterConfig()
-        llm_client = OpenRouterClient(config)
+        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}")
@@ -68,7 +103,14 @@ async def run_commander(
     output_relay: Optional[OutputRelay] = None
     if llm_client:
         try:
-            summarizer = OutputSummarizer(llm_client)
+            # 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)

claude_mpm/commander/chat/commands.py

@@ -11,12 +11,19 @@ class CommandType(Enum):
     LIST = "list"
     START = "start"
     STOP = "stop"
+    CLOSE = "close"
+    REGISTER = "register"
     CONNECT = "connect"
     DISCONNECT = "disconnect"
+    SAVED = "saved"
+    FORGET = "forget"
     STATUS = "status"
     HELP = "help"
     EXIT = "exit"
     INSTANCES = "instances"  # alias for list
+    MPM_OAUTH = "mpm-oauth"
+    CLEANUP = "cleanup"
+    SEND = "send"
 
 
 @dataclass
@@ -31,27 +38,44 @@ class Command:
 class CommandParser:
     """Parses user input into commands."""
 
-    ALIASES = {
+    # Map slash command names to CommandType
+    SLASH_COMMANDS = {
+        "register": CommandType.REGISTER,
+        "start": CommandType.START,
+        "stop": CommandType.STOP,
+        "close": CommandType.CLOSE,
+        "connect": CommandType.CONNECT,
+        "disconnect": CommandType.DISCONNECT,
+        "switch": CommandType.CONNECT,  # alias for connect
+        "list": CommandType.LIST,
         "ls": CommandType.LIST,
-        "instances": CommandType.LIST,
+        "saved": CommandType.SAVED,
+        "forget": CommandType.FORGET,
+        "status": CommandType.STATUS,
+        "help": CommandType.HELP,
+        "exit": CommandType.EXIT,
         "quit": CommandType.EXIT,
         "q": CommandType.EXIT,
+        "mpm-oauth": CommandType.MPM_OAUTH,
+        "cleanup": CommandType.CLEANUP,
+        "send": CommandType.SEND,
     }
 
     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).
+        Returns None if input is not a slash command (natural language).
+        System commands must start with '/'.
 
         Args:
             input_text: Raw user input.
 
         Returns:
-            Command if input is a built-in command, None otherwise.
+            Command if input is a slash command, None otherwise.
 
         Example:
             >>> parser = CommandParser()
-            >>> cmd = parser.parse("list")
+            >>> cmd = parser.parse("/list")
             >>> cmd.type
             <CommandType.LIST: 'list'>
             >>> parser.parse("tell me about the code")
@@ -60,22 +84,26 @@ class CommandParser:
         if not input_text:
             return None
 
-        parts = input_text.split()
+        # System commands must start with /
+        if not input_text.startswith("/"):
+            return None
+
+        # Remove the leading / and parse
+        cmd_line = input_text[1:]
+        parts = cmd_line.split()
+        if not parts:
+            return None
+
         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]
+        # Check if it's a valid slash command
+        if command_str in self.SLASH_COMMANDS:
+            cmd_type = self.SLASH_COMMANDS[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
+        # Unknown slash command
+        return None
 
     def is_command(self, input_text: str) -> bool:
         """Check if input is a built-in command.