claude-mpm 5.6.13__py3-none-any.whl → 5.6.14__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.6.13
+5.6.14

claude_mpm/cli/commands/commander.py

@@ -2,25 +2,129 @@
 
 import asyncio
 import logging
+import shutil
+import threading
+import time
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+# ANSI colors
+CYAN = "\033[36m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+YELLOW = "\033[33m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+
+def _get_terminal_width() -> int:
+    """Get terminal width with reasonable bounds."""
+    try:
+        width = shutil.get_terminal_size().columns
+        return max(80, min(width, 120))
+    except Exception:
+        return 100
+
+
+def _get_version() -> str:
+    """Get Commander version."""
+    version_file = Path(__file__).parent.parent.parent / "VERSION"
+    if version_file.exists():
+        return version_file.read_text().strip()
+    return "unknown"
+
+
+def display_commander_banner():
+    """Display Commander-specific startup banner."""
+    width = _get_terminal_width()
+    version = _get_version()
+
+    # Commander ASCII art banner
+    banner = f"""
+{CYAN}╭{'─' * (width - 2)}╮{RESET}
+{CYAN}│{RESET}{BOLD}  ⚡ MPM Commander {RESET}{DIM}v{version}{RESET}{' ' * (width - 24 - len(version))}│
+{CYAN}│{RESET}{DIM}  Multi-Project AI Orchestration{RESET}{' ' * (width - 36)}│
+{CYAN}├{'─' * (width - 2)}┤{RESET}
+{CYAN}│{RESET}  {YELLOW}ALPHA{RESET} - APIs may change                                {' ' * (width - 55)}│
+{CYAN}╰{'─' * (width - 2)}╯{RESET}
+"""
+    print(banner)
+
+
+def _count_cached_agents() -> int:
+    """Count cached agents from ~/.claude-mpm/cache/agents/."""
+    try:
+        cache_agents_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
+        if not cache_agents_dir.exists():
+            return 0
+        # Recursively find all .md files excluding base/README files
+        agent_files = [
+            f
+            for f in cache_agents_dir.rglob("*.md")
+            if f.is_file()
+            and not f.name.startswith(".")
+            and f.name not in ("README.md", "BASE-AGENT.md", "INSTRUCTIONS.md")
+        ]
+        return len(agent_files)
+    except Exception:
+        return 0
+
+
+def _count_cached_skills() -> int:
+    """Count cached skills from ~/.claude-mpm/cache/skills/."""
+    try:
+        cache_skills_dir = Path.home() / ".claude-mpm" / "cache" / "skills"
+        if not cache_skills_dir.exists():
+            return 0
+        # Recursively find all directories containing SKILL.md
+        skill_files = list(cache_skills_dir.rglob("SKILL.md"))
+        return len(skill_files)
+    except Exception:
+        return 0
+
+
+def load_agents_and_skills():
+    """Load agents and skills for Commander sessions."""
+    try:
+        print(f"{DIM}Loading agents...{RESET}", end=" ", flush=True)
+        agent_count = _count_cached_agents()
+        print(f"{GREEN}✓{RESET} {agent_count} agents")
+
+        print(f"{DIM}Loading skills...{RESET}", end=" ", flush=True)
+        skill_count = _count_cached_skills()
+        print(f"{GREEN}✓{RESET} {skill_count} skills")
+
+        return agent_count, skill_count
+    except Exception as e:
+        logger.warning(f"Could not load agents/skills: {e}")
+        print(f"{YELLOW}⚠{RESET} Could not load agents/skills")
+        return 0, 0
+
 
 def handle_commander_command(args) -> int:
-    """Handle the commander command.
+    """Handle the commander command with auto-starting daemon.
 
     Args:
         args: Parsed command line arguments with:
-            - port: Port for internal services (default: 8765)
+            - port: Port for daemon (default: 8765)
+            - host: Host for daemon (default: 127.0.0.1)
             - state_dir: Optional state directory path
             - debug: Enable debug logging
+            - no_chat: Start daemon only without interactive chat
+            - daemon_only: Alias for no_chat
 
     Returns:
         Exit code (0 for success, 1 for error)
     """
     try:
         # Import here to avoid circular dependencies
+        import requests
+
         from claude_mpm.commander.chat.cli import run_commander
+        from claude_mpm.commander.config import DaemonConfig
+        from claude_mpm.commander.daemon import main as daemon_main
 
         # Setup debug logging if requested
         if getattr(args, "debug", False):
@@ -29,11 +133,76 @@ def handle_commander_command(args) -> int:
                 format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             )
 
+        # Display Commander banner
+        display_commander_banner()
+
+        # Load agents and skills
+        load_agents_and_skills()
+
+        print()  # Blank line after loading
+
         # Get arguments
         port = getattr(args, "port", 8765)
+        host = getattr(args, "host", "127.0.0.1")
         state_dir = getattr(args, "state_dir", None)
+        no_chat = getattr(args, "no_chat", False) or getattr(args, "daemon_only", False)
+
+        # Check if daemon already running
+        daemon_running = False
+        try:
+            resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+            if resp.status_code == 200:
+                print(f"{GREEN}✓{RESET} Daemon already running on {host}:{port}")
+                daemon_running = True
+        except (requests.RequestException, requests.ConnectionError):
+            pass
+
+        # Start daemon if not running
+        if not daemon_running:
+            print(
+                f"{DIM}Starting daemon on {host}:{port}...{RESET}", end=" ", flush=True
+            )
+
+            # Create daemon config
+            config_kwargs = {"host": host, "port": port}
+            if state_dir:
+                config_kwargs["state_dir"] = state_dir
+            config = DaemonConfig(**config_kwargs)
+
+            # Start daemon in background thread
+            daemon_thread = threading.Thread(
+                target=lambda: asyncio.run(daemon_main(config)), daemon=True
+            )
+            daemon_thread.start()
+
+            # Wait for daemon to be ready (max 3 seconds)
+            for _ in range(30):
+                time.sleep(0.1)
+                try:
+                    resp = requests.get(f"http://{host}:{port}/api/health", timeout=1)
+                    if resp.status_code == 200:
+                        print(f"{GREEN}✓{RESET}")
+                        daemon_running = True
+                        break
+                except (requests.RequestException, requests.ConnectionError):
+                    pass
+            else:
+                print(f"{RED}✗{RESET} Failed (timeout)")
+                return 1
+
+        # If daemon-only mode, keep running until interrupted
+        if no_chat:
+            print(f"\n{CYAN}Daemon running.{RESET} API at http://{host}:{port}")
+            print(f"{DIM}Press Ctrl+C to stop{RESET}\n")
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                print(f"\n{DIM}Shutting down...{RESET}")
+                return 0
 
-        # Run commander
+        # Launch interactive chat
+        print(f"\n{CYAN}Entering Commander chat...{RESET}\n")
         asyncio.run(run_commander(port=port, state_dir=state_dir))
 
         return 0
@@ -43,4 +212,5 @@ def handle_commander_command(args) -> int:
         return 0
     except Exception as e:
         logger.error(f"Commander error: {e}", exc_info=True)
+        print(f"{RED}Error:{RESET} {e}")
         return 1

claude_mpm/cli/parsers/commander_parser.py

@@ -23,17 +23,21 @@ def add_commander_subparser(subparsers: argparse._SubParsersAction) -> None:
     """
     commander_parser = subparsers.add_parser(
         "commander",
-        help="Interactive Commander mode for managing multiple Claude instances",
+        help="Launch Commander multi-project orchestration (ALPHA)",
         description="""
-Commander Mode - Interactive Instance Management
+Commander Mode - Multi-Project Orchestration (ALPHA)
 
-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
+The commander subcommand auto-starts the Commander daemon (if not already running)
+and launches an interactive REPL for managing multiple Claude Code instances.
 
-Commands:
+Commander provides:
+- Auto-starting daemon that manages project lifecycles
+- Interactive REPL for controlling instances
+- Tmux-based session management
+- Real-time output monitoring
+- REST API for external control (http://127.0.0.1:8765)
+
+REPL Commands:
   list, ls, instances   List active instances
   start <path>          Start new instance at path
     --framework <cc|mpm>  Specify framework (default: cc)
@@ -50,7 +54,16 @@ Natural Language:
   command will be sent to the connected instance as a message.
 
 Examples:
+  # Start daemon and launch interactive chat
   claude-mpm commander
+
+  # Start daemon only (no chat interface)
+  claude-mpm commander --daemon-only
+
+  # Use custom port
+  claude-mpm commander --port 9000
+
+  # In REPL:
   > start ~/myproject --framework cc --name myapp
   > connect myapp
   > Fix the authentication bug in login.py
@@ -81,3 +94,23 @@ Examples:
         action="store_true",
         help="Enable debug logging",
     )
+
+    # Daemon auto-start options
+    commander_parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Daemon host (default: 127.0.0.1)",
+    )
+
+    commander_parser.add_argument(
+        "--no-chat",
+        action="store_true",
+        help="Start daemon only without interactive chat",
+    )
+
+    commander_parser.add_argument(
+        "--daemon-only",
+        action="store_true",
+        help="Alias for --no-chat (start daemon only)",
+    )

claude_mpm/cli/startup.py

@@ -210,7 +210,16 @@ def should_skip_background_services(args, processed_argv):
     return any(cmd in (processed_argv or sys.argv[1:]) for cmd in skip_commands) or (
         hasattr(args, "command")
         and args.command
-        in ["info", "doctor", "config", "mcp", "configure", "hook-errors", "autotodos"]
+        in [
+            "info",
+            "doctor",
+            "config",
+            "mcp",
+            "configure",
+            "hook-errors",
+            "autotodos",
+            "commander",
+        ]
     )
 
 

claude_mpm/cli/startup_display.py

@@ -540,7 +540,8 @@ def should_show_banner(args) -> bool:
         return False
 
     # Check for commands that should skip banner
-    skip_commands = {"info", "doctor", "config", "configure"}
+    # Commander has its own banner, so skip the main MPM banner
+    skip_commands = {"info", "doctor", "config", "configure", "commander"}
     if hasattr(args, "command") and args.command in skip_commands:
         return False
 

claude_mpm/commander/__init__.py

@@ -12,12 +12,18 @@ Key Components:
     - ProjectSession: Per-project lifecycle management
     - InstanceManager: Framework selection and instance lifecycle
     - Frameworks: Claude Code, MPM framework abstractions
+    - Memory: Conversation storage, semantic search, context compression
 
 Example:
     >>> from claude_mpm.commander import ProjectRegistry
     >>> registry = ProjectRegistry()
     >>> project = registry.register("/path/to/project")
     >>> registry.update_state(project.id, ProjectState.WORKING)
+
+    >>> # Memory integration
+    >>> from claude_mpm.commander.memory import MemoryIntegration
+    >>> memory = MemoryIntegration.create()
+    >>> await memory.capture_project_conversation(project)
 """
 
 from claude_mpm.commander.config import DaemonConfig

claude_mpm/commander/adapters/__init__.py

@@ -6,26 +6,55 @@ 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
+
+Available Runtime Adapters:
+- ClaudeCodeAdapter: Vanilla Claude Code CLI
+- AuggieAdapter: Auggie with MCP support
+- CodexAdapter: Codex (limited features)
+- MPMAdapter: Full MPM with agents, hooks, skills, monitoring
+
+Registry:
+- AdapterRegistry: Centralized adapter management with auto-detection
 """
 
-from .base import Capability, ParsedResponse, RuntimeAdapter
+from .auggie import AuggieAdapter
+from .base import (
+    Capability,
+    ParsedResponse,
+    RuntimeAdapter,
+    RuntimeCapability,
+    RuntimeInfo,
+)
 from .claude_code import ClaudeCodeAdapter
+from .codex import CodexAdapter
 from .communication import (
     AdapterResponse,
     AdapterState,
     BaseCommunicationAdapter,
     ClaudeCodeCommunicationAdapter,
 )
+from .mpm import MPMAdapter
+from .registry import AdapterRegistry
+
+# Auto-register all adapters
+AdapterRegistry.register("claude-code", ClaudeCodeAdapter)
+AdapterRegistry.register("auggie", AuggieAdapter)
+AdapterRegistry.register("codex", CodexAdapter)
+AdapterRegistry.register("mpm", MPMAdapter)
 
 __all__ = [
-    # Communication adapters (async I/O)
+    "AdapterRegistry",
     "AdapterResponse",
     "AdapterState",
+    "AuggieAdapter",
     "BaseCommunicationAdapter",
-    # Runtime adapters (parsing)
     "Capability",
     "ClaudeCodeAdapter",
     "ClaudeCodeCommunicationAdapter",
+    "CodexAdapter",
+    "MPMAdapter",
     "ParsedResponse",
     "RuntimeAdapter",
+    "RuntimeCapability",
+    "RuntimeInfo",
 ]

claude_mpm/commander/adapters/auggie.py

@@ -0,0 +1,260 @@
+"""Auggie CLI runtime adapter.
+
+This module implements the RuntimeAdapter interface for Auggie,
+an AI coding assistant with MCP (Model Context Protocol) support.
+"""
+
+import logging
+import re
+import shlex
+from typing import List, Optional, Set
+
+from .base import (
+    Capability,
+    ParsedResponse,
+    RuntimeAdapter,
+    RuntimeCapability,
+    RuntimeInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AuggieAdapter(RuntimeAdapter):
+    """Adapter for Auggie CLI.
+
+    Auggie is an AI coding assistant with support for MCP servers,
+    custom instructions, and various tool capabilities.
+
+    Example:
+        >>> adapter = AuggieAdapter()
+        >>> cmd = adapter.build_launch_command("/home/user/project")
+        >>> print(cmd)
+        cd '/home/user/project' && auggie
+    """
+
+    # Idle detection patterns
+    IDLE_PATTERNS = [
+        r"^>\s*$",  # Simple prompt
+        r"auggie>\s*$",  # Named prompt
+        r"Ready for input",
+        r"What would you like",
+        r"How can I assist",
+    ]
+
+    # Error patterns
+    ERROR_PATTERNS = [
+        r"Error:",
+        r"Failed:",
+        r"Exception:",
+        r"Permission denied",
+        r"not found",
+        r"Traceback \(most recent call last\)",
+        r"FATAL:",
+        r"command not found",
+        r"cannot access",
+    ]
+
+    # Question patterns
+    QUESTION_PATTERNS = [
+        r"Which option",
+        r"Should I proceed",
+        r"Please choose",
+        r"\(y/n\)\?",
+        r"Are you sure",
+        r"Do you want",
+        r"\[Y/n\]",
+        r"\[yes/no\]",
+    ]
+
+    # ANSI escape code pattern
+    ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+    @property
+    def name(self) -> str:
+        """Return the runtime identifier."""
+        return "auggie"
+
+    @property
+    def capabilities(self) -> Set[Capability]:
+        """Return the set of capabilities supported by Auggie."""
+        return {
+            Capability.TOOL_USE,
+            Capability.FILE_EDIT,
+            Capability.FILE_CREATE,
+            Capability.GIT_OPERATIONS,
+            Capability.SHELL_COMMANDS,
+            Capability.COMPLEX_REASONING,
+        }
+
+    @property
+    def runtime_info(self) -> RuntimeInfo:
+        """Return detailed runtime information."""
+        return RuntimeInfo(
+            name="auggie",
+            version=None,  # Version detection could be added
+            capabilities={
+                RuntimeCapability.FILE_READ,
+                RuntimeCapability.FILE_EDIT,
+                RuntimeCapability.FILE_CREATE,
+                RuntimeCapability.BASH_EXECUTION,
+                RuntimeCapability.GIT_OPERATIONS,
+                RuntimeCapability.TOOL_USE,
+                RuntimeCapability.MCP_TOOLS,  # Auggie supports MCP
+                RuntimeCapability.INSTRUCTIONS,
+                RuntimeCapability.COMPLEX_REASONING,
+                RuntimeCapability.AGENT_DELEGATION,  # Auggie now supports agents
+            },
+            command="auggie",
+            supports_agents=True,  # Auggie now supports agent delegation
+            instruction_file=".augment/instructions.md",
+        )
+
+    def build_launch_command(
+        self, project_path: str, agent_prompt: Optional[str] = None
+    ) -> str:
+        """Generate shell command to start Auggie.
+
+        Args:
+            project_path: Absolute path to the project directory
+            agent_prompt: Optional system prompt to configure Auggie
+
+        Returns:
+            Shell command string ready to execute
+
+        Example:
+            >>> adapter = AuggieAdapter()
+            >>> adapter.build_launch_command("/home/user/project")
+            "cd '/home/user/project' && auggie"
+        """
+        quoted_path = shlex.quote(project_path)
+        cmd = f"cd {quoted_path} && auggie"
+
+        if agent_prompt:
+            # Auggie may support --prompt or similar flag
+            # Adjust based on actual Auggie CLI options
+            quoted_prompt = shlex.quote(agent_prompt)
+            cmd += f" --prompt {quoted_prompt}"
+
+        logger.debug(f"Built Auggie launch command: {cmd}")
+        return cmd
+
+    def format_input(self, message: str) -> str:
+        """Prepare message for Auggie's input format."""
+        formatted = message.strip()
+        logger.debug(f"Formatted input: {formatted[:100]}...")
+        return formatted
+
+    def strip_ansi(self, text: str) -> str:
+        """Remove ANSI escape codes from text."""
+        return self.ANSI_ESCAPE.sub("", text)
+
+    def detect_idle(self, output: str) -> bool:
+        """Recognize when Auggie is waiting for input."""
+        if not output:
+            return False
+
+        clean = self.strip_ansi(output)
+        lines = clean.strip().split("\n")
+
+        if not lines:
+            return False
+
+        last_line = lines[-1].strip()
+
+        for pattern in self.IDLE_PATTERNS:
+            if re.search(pattern, last_line):
+                logger.debug(f"Detected idle state with pattern: {pattern}")
+                return True
+
+        return False
+
+    def detect_error(self, output: str) -> Optional[str]:
+        """Recognize error states and extract error message."""
+        clean = self.strip_ansi(output)
+
+        for pattern in self.ERROR_PATTERNS:
+            match = re.search(pattern, clean, re.IGNORECASE)
+            if match:
+                for line in clean.split("\n"):
+                    if re.search(pattern, line, re.IGNORECASE):
+                        error_msg = line.strip()
+                        logger.warning(f"Detected error: {error_msg}")
+                        return error_msg
+
+        return None
+
+    def detect_question(
+        self, output: str
+    ) -> tuple[bool, Optional[str], Optional[List[str]]]:
+        """Detect if Auggie is asking a question."""
+        clean = self.strip_ansi(output)
+
+        for pattern in self.QUESTION_PATTERNS:
+            if re.search(pattern, clean, re.IGNORECASE):
+                lines = clean.strip().split("\n")
+                question = None
+                options = []
+
+                for line in lines:
+                    if re.search(pattern, line, re.IGNORECASE):
+                        question = line.strip()
+
+                    # Look for numbered options
+                    opt_match = re.match(r"^\s*(\d+)[.):]\s*(.+)$", line)
+                    if opt_match:
+                        options.append(opt_match.group(2).strip())
+
+                logger.debug(
+                    f"Detected question: {question}, options: {options if options else 'none'}"
+                )
+                return True, question, options if options else None
+
+        return False, None, None
+
+    def parse_response(self, output: str) -> ParsedResponse:
+        """Extract meaningful content from Auggie output."""
+        if not output:
+            return ParsedResponse(
+                content="",
+                is_complete=False,
+                is_error=False,
+                is_question=False,
+            )
+
+        clean = self.strip_ansi(output)
+        error_msg = self.detect_error(output)
+        is_question, question_text, options = self.detect_question(output)
+        is_complete = self.detect_idle(output)
+
+        response = ParsedResponse(
+            content=clean,
+            is_complete=is_complete,
+            is_error=error_msg is not None,
+            error_message=error_msg,
+            is_question=is_question,
+            question_text=question_text,
+            options=options,
+        )
+
+        logger.debug(
+            f"Parsed response: complete={is_complete}, error={error_msg is not None}, "
+            f"question={is_question}"
+        )
+
+        return response
+
+    def inject_instructions(self, instructions: str) -> Optional[str]:
+        """Return command to inject custom instructions.
+
+        Auggie supports .augment/instructions.md file for custom instructions.
+
+        Args:
+            instructions: Instructions text to inject
+
+        Returns:
+            Command to write instructions file
+        """
+        # Write to .augment/instructions.md
+        escaped = instructions.replace("'", "'\\''")
+        return f"mkdir -p .augment && echo '{escaped}' > .augment/instructions.md"