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

claude_mpm/commander/adapters/claude_code.py

@@ -9,7 +9,13 @@ import re
 import shlex
 from typing import List, Optional, Set
 
-from .base import Capability, ParsedResponse, RuntimeAdapter
+from .base import (
+    Capability,
+    ParsedResponse,
+    RuntimeAdapter,
+    RuntimeCapability,
+    RuntimeInfo,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -96,6 +102,31 @@ class ClaudeCodeAdapter(RuntimeAdapter):
             Capability.COMPLEX_REASONING,
         }
 
+    @property
+    def runtime_info(self) -> RuntimeInfo:
+        """Return detailed runtime information."""
+        return RuntimeInfo(
+            name="claude-code",
+            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.WEB_SEARCH,
+                RuntimeCapability.COMPLEX_REASONING,
+                RuntimeCapability.AGENT_DELEGATION,  # Claude Code supports Task tool
+                RuntimeCapability.HOOKS,  # Claude Code supports hooks
+                RuntimeCapability.SKILLS,  # Claude Code can load skills
+                RuntimeCapability.MONITOR,  # Can be monitored
+            },
+            command="claude",
+            supports_agents=True,  # Claude Code supports agent delegation
+            instruction_file="CLAUDE.md",
+        )
+
     def build_launch_command(
         self, project_path: str, agent_prompt: Optional[str] = None
     ) -> str:

claude_mpm/commander/adapters/codex.py

@@ -0,0 +1,237 @@
+"""Codex CLI runtime adapter.
+
+This module implements the RuntimeAdapter interface for Codex,
+an AI coding assistant (limited support currently).
+"""
+
+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 CodexAdapter(RuntimeAdapter):
+    """Adapter for Codex CLI.
+
+    Codex is an AI coding assistant. This adapter provides basic support,
+    with limited capabilities compared to Claude Code or MPM.
+
+    Note:
+        Agent delegation and advanced features not yet supported.
+
+    Example:
+        >>> adapter = CodexAdapter()
+        >>> cmd = adapter.build_launch_command("/home/user/project")
+        >>> print(cmd)
+        cd '/home/user/project' && codex
+    """
+
+    # Idle detection patterns
+    IDLE_PATTERNS = [
+        r"^>\s*$",  # Simple prompt
+        r"codex>\s*$",  # Named prompt
+        r"Ready",
+        r"Waiting for input",
+    ]
+
+    # Error patterns
+    ERROR_PATTERNS = [
+        r"Error:",
+        r"Failed:",
+        r"Exception:",
+        r"Permission denied",
+        r"not found",
+        r"Traceback",
+        r"FATAL:",
+    ]
+
+    # Question patterns
+    QUESTION_PATTERNS = [
+        r"Which option",
+        r"Should I proceed",
+        r"Please choose",
+        r"\(y/n\)\?",
+        r"Are you sure",
+        r"\[Y/n\]",
+    ]
+
+    # ANSI escape code pattern
+    ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+    @property
+    def name(self) -> str:
+        """Return the runtime identifier."""
+        return "codex"
+
+    @property
+    def capabilities(self) -> Set[Capability]:
+        """Return the set of capabilities supported by Codex."""
+        return {
+            Capability.TOOL_USE,
+            Capability.FILE_EDIT,
+            Capability.FILE_CREATE,
+            Capability.SHELL_COMMANDS,
+            Capability.COMPLEX_REASONING,
+        }
+
+    @property
+    def runtime_info(self) -> RuntimeInfo:
+        """Return detailed runtime information."""
+        return RuntimeInfo(
+            name="codex",
+            version=None,  # Version detection could be added
+            capabilities={
+                RuntimeCapability.FILE_READ,
+                RuntimeCapability.FILE_EDIT,
+                RuntimeCapability.FILE_CREATE,
+                RuntimeCapability.BASH_EXECUTION,
+                RuntimeCapability.TOOL_USE,
+                RuntimeCapability.COMPLEX_REASONING,
+            },
+            command="codex",
+            supports_agents=False,  # No agent support
+            instruction_file=None,  # No custom instructions support
+        )
+
+    def build_launch_command(
+        self, project_path: str, agent_prompt: Optional[str] = None
+    ) -> str:
+        """Generate shell command to start Codex.
+
+        Args:
+            project_path: Absolute path to the project directory
+            agent_prompt: Optional system prompt (may not be supported)
+
+        Returns:
+            Shell command string ready to execute
+
+        Example:
+            >>> adapter = CodexAdapter()
+            >>> adapter.build_launch_command("/home/user/project")
+            "cd '/home/user/project' && codex"
+        """
+        quoted_path = shlex.quote(project_path)
+        cmd = f"cd {quoted_path} && codex"
+
+        # Note: Codex may not support custom prompts
+        # Adjust based on actual Codex CLI capabilities
+        if agent_prompt:
+            logger.warning("Codex may not support custom prompts")
+
+        logger.debug(f"Built Codex launch command: {cmd}")
+        return cmd
+
+    def format_input(self, message: str) -> str:
+        """Prepare message for Codex'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 Codex 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 Codex 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 Codex 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

claude_mpm/commander/adapters/example_usage.py

@@ -0,0 +1,310 @@
+"""Example usage of multi-runtime adapter architecture.
+
+This module demonstrates how to use the adapter registry and
+individual adapters for different AI coding runtimes.
+"""
+
+import logging
+from typing import Optional
+
+from claude_mpm.commander.adapters import (
+    AdapterRegistry,
+    AuggieAdapter,
+    ClaudeCodeAdapter,
+    CodexAdapter,
+    MPMAdapter,
+    RuntimeAdapter,
+    RuntimeCapability,
+)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def example_registry_usage() -> None:
+    """Demonstrate adapter registry usage."""
+    print("\n" + "=" * 60)
+    print("ADAPTER REGISTRY USAGE")
+    print("=" * 60 + "\n")
+
+    # List all registered adapters
+    registered = AdapterRegistry.list_registered()
+    print(f"Registered adapters: {registered}")
+
+    # Detect available runtimes on system
+    available = AdapterRegistry.detect_available()
+    print(f"Available runtimes: {available}")
+
+    # Get default adapter (best available)
+    default_adapter = AdapterRegistry.get_default()
+    if default_adapter:
+        print(f"\nDefault adapter: {default_adapter.name}")
+        print(f"Capabilities: {default_adapter.capabilities}")
+    else:
+        print("\nNo adapters available on this system")
+
+    # Get specific adapter
+    mpm_adapter = AdapterRegistry.get("mpm")
+    if mpm_adapter:
+        print(f"\nMPM adapter available: {mpm_adapter.name}")
+    else:
+        print("\nMPM adapter not available")
+
+    # Check if specific runtime is available
+    if AdapterRegistry.is_available("claude-code"):
+        print("\nClaude Code is available")
+    else:
+        print("\nClaude Code is NOT available")
+
+
+def example_adapter_capabilities() -> None:
+    """Demonstrate checking adapter capabilities."""
+    print("\n" + "=" * 60)
+    print("ADAPTER CAPABILITIES")
+    print("=" * 60 + "\n")
+
+    adapters = [
+        ClaudeCodeAdapter(),
+        AuggieAdapter(),
+        CodexAdapter(),
+        MPMAdapter(),
+    ]
+
+    for adapter in adapters:
+        print(f"\n{adapter.name.upper()} Adapter:")
+        print(
+            f"  Command: {adapter.runtime_info.command if adapter.runtime_info else 'N/A'}"
+        )
+
+        # Check for specific capabilities
+        info = adapter.runtime_info
+        if info:
+            print(f"  Supports agents: {info.supports_agents}")
+            print(f"  Instruction file: {info.instruction_file or 'None'}")
+
+            # Check for advanced features
+            if RuntimeCapability.AGENT_DELEGATION in info.capabilities:
+                print("  ✓ Agent delegation supported")
+            else:
+                print("  ✗ Agent delegation NOT supported")
+
+            if RuntimeCapability.HOOKS in info.capabilities:
+                print("  ✓ Lifecycle hooks supported")
+            else:
+                print("  ✗ Lifecycle hooks NOT supported")
+
+            if RuntimeCapability.MCP_TOOLS in info.capabilities:
+                print("  ✓ MCP tools supported")
+            else:
+                print("  ✗ MCP tools NOT supported")
+
+            if RuntimeCapability.SKILLS in info.capabilities:
+                print("  ✓ Skills supported")
+            else:
+                print("  ✗ Skills NOT supported")
+
+            if RuntimeCapability.MONITOR in info.capabilities:
+                print("  ✓ Real-time monitoring supported")
+            else:
+                print("  ✗ Real-time monitoring NOT supported")
+
+
+def example_build_commands() -> None:
+    """Demonstrate building launch commands."""
+    print("\n" + "=" * 60)
+    print("BUILD LAUNCH COMMANDS")
+    print("=" * 60 + "\n")
+
+    project_path = "/home/user/my-project"
+    agent_prompt = "You are a Python expert specializing in FastAPI and async code."
+
+    adapters = [
+        ClaudeCodeAdapter(),
+        AuggieAdapter(),
+        CodexAdapter(),
+        MPMAdapter(),
+    ]
+
+    for adapter in adapters:
+        print(f"\n{adapter.name.upper()}:")
+
+        # Basic launch command
+        cmd = adapter.build_launch_command(project_path)
+        print(f"  Basic: {cmd}")
+
+        # With agent prompt
+        cmd_with_prompt = adapter.build_launch_command(project_path, agent_prompt)
+        print(f"  With prompt: {cmd_with_prompt}")
+
+
+def example_inject_instructions() -> None:
+    """Demonstrate injecting custom instructions."""
+    print("\n" + "=" * 60)
+    print("INJECT CUSTOM INSTRUCTIONS")
+    print("=" * 60 + "\n")
+
+    instructions = """You are a senior Python engineer.
+Follow PEP 8 strictly.
+Write comprehensive tests for all code.
+Use type hints everywhere."""
+
+    adapters = [
+        ClaudeCodeAdapter(),
+        AuggieAdapter(),
+        CodexAdapter(),
+        MPMAdapter(),
+    ]
+
+    for adapter in adapters:
+        print(f"\n{adapter.name.upper()}:")
+
+        cmd = adapter.inject_instructions(instructions)
+        if cmd:
+            print(f"  Command: {cmd}")
+        else:
+            print("  Not supported")
+
+
+def example_inject_agent_context() -> None:
+    """Demonstrate injecting agent context."""
+    print("\n" + "=" * 60)
+    print("INJECT AGENT CONTEXT")
+    print("=" * 60 + "\n")
+
+    agent_id = "eng-001"
+    context = {
+        "role": "Engineer",
+        "specialty": "Backend Python",
+        "task": "Implement API endpoints",
+    }
+
+    adapters = [
+        ClaudeCodeAdapter(),
+        AuggieAdapter(),
+        CodexAdapter(),
+        MPMAdapter(),
+    ]
+
+    for adapter in adapters:
+        print(f"\n{adapter.name.upper()}:")
+
+        cmd = adapter.inject_agent_context(agent_id, context)
+        if cmd:
+            print(f"  Command: {cmd[:100]}...")
+        else:
+            print("  Not supported")
+
+
+def example_parse_response() -> None:
+    """Demonstrate parsing runtime output."""
+    print("\n" + "=" * 60)
+    print("PARSE RUNTIME OUTPUT")
+    print("=" * 60 + "\n")
+
+    # Simulate different output scenarios
+    outputs = {
+        "idle": "File created successfully.\n> ",
+        "error": "Error: File not found: config.py\n> ",
+        "question": "Should I proceed with the changes? (y/n)?",
+        "processing": "Processing your request...",
+    }
+
+    adapter = ClaudeCodeAdapter()
+
+    for scenario, output in outputs.items():
+        print(f"\n{scenario.upper()}:")
+        parsed = adapter.parse_response(output)
+        print(f"  Content: {parsed.content[:50]}...")
+        print(f"  Is complete: {parsed.is_complete}")
+        print(f"  Is error: {parsed.is_error}")
+        print(f"  Is question: {parsed.is_question}")
+        if parsed.error_message:
+            print(f"  Error message: {parsed.error_message}")
+        if parsed.question_text:
+            print(f"  Question: {parsed.question_text}")
+
+
+def example_runtime_selection() -> None:
+    """Demonstrate selecting runtime based on requirements."""
+    print("\n" + "=" * 60)
+    print("RUNTIME SELECTION LOGIC")
+    print("=" * 60 + "\n")
+
+    def select_runtime(
+        needs_agents: bool = False, needs_mcp: bool = False
+    ) -> Optional[RuntimeAdapter]:
+        """Select appropriate runtime based on requirements."""
+        # Get all available adapters
+        available = AdapterRegistry.detect_available()
+
+        # Filter by requirements
+        for name in available:
+            adapter = AdapterRegistry.get(name)
+            if not adapter or not adapter.runtime_info:
+                continue
+
+            info = adapter.runtime_info
+
+            # Check agent requirement
+            if needs_agents and not info.supports_agents:
+                continue
+
+            # Check MCP requirement
+            if needs_mcp and RuntimeCapability.MCP_TOOLS not in info.capabilities:
+                continue
+
+            # Found suitable runtime
+            return adapter
+
+        return None
+
+    # Example 1: Need agent delegation
+    print("Requirement: Agent delegation")
+    adapter = select_runtime(needs_agents=True)
+    if adapter:
+        print(f"  Selected: {adapter.name}")
+    else:
+        print("  No suitable runtime found")
+
+    # Example 2: Need MCP tools
+    print("\nRequirement: MCP tools")
+    adapter = select_runtime(needs_mcp=True)
+    if adapter:
+        print(f"  Selected: {adapter.name}")
+    else:
+        print("  No suitable runtime found")
+
+    # Example 3: Need both
+    print("\nRequirement: Agent delegation + MCP tools")
+    adapter = select_runtime(needs_agents=True, needs_mcp=True)
+    if adapter:
+        print(f"  Selected: {adapter.name}")
+    else:
+        print("  No suitable runtime found")
+
+
+def main() -> None:
+    """Run all examples."""
+    print("\n" + "#" * 60)
+    print("# MULTI-RUNTIME ADAPTER ARCHITECTURE EXAMPLES")
+    print("#" * 60)
+
+    # Run all examples
+    example_registry_usage()
+    example_adapter_capabilities()
+    example_build_commands()
+    example_inject_instructions()
+    example_inject_agent_context()
+    example_parse_response()
+    example_runtime_selection()
+
+    print("\n" + "#" * 60)
+    print("# EXAMPLES COMPLETE")
+    print("#" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    main()