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

claude_mpm/cli/startup_migrations.py

@@ -0,0 +1,236 @@
+"""
+Startup migrations for claude-mpm.
+
+This module provides a migration registry pattern for automatically fixing
+configuration issues on first startup after an update. Migrations run once
+and are tracked in ~/.claude-mpm/migrations.yaml.
+
+Design Principles:
+- Non-blocking: Failures log warnings but don't stop startup
+- Idempotent: Safe to run multiple times (check before migrate)
+- Tracked: Each migration runs only once per installation
+- Early: Runs before agent sync in startup sequence
+"""
+
+import shutil
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+import yaml
+
+from ..core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class Migration:
+    """Definition of a startup migration."""
+
+    id: str
+    description: str
+    check: Callable[[], bool]  # Returns True if migration is needed
+    migrate: Callable[[], bool]  # Returns True if migration succeeded
+
+
+def _get_migrations_file() -> Path:
+    """Get path to migrations tracking file."""
+    return Path.home() / ".claude-mpm" / "migrations.yaml"
+
+
+def _load_completed_migrations() -> dict:
+    """Load completed migrations from tracking file.
+
+    Returns:
+        Dictionary with completed migrations data.
+    """
+    migrations_file = _get_migrations_file()
+    if not migrations_file.exists():
+        return {"migrations": []}
+
+    try:
+        with open(migrations_file) as f:
+            data = yaml.safe_load(f) or {}
+            return data if "migrations" in data else {"migrations": []}
+    except Exception as e:
+        logger.debug(f"Failed to load migrations file: {e}")
+        return {"migrations": []}
+
+
+def _save_completed_migration(migration_id: str) -> None:
+    """Save a completed migration to tracking file.
+
+    Args:
+        migration_id: The ID of the completed migration.
+    """
+    migrations_file = _get_migrations_file()
+    migrations_file.parent.mkdir(parents=True, exist_ok=True)
+
+    data = _load_completed_migrations()
+
+    # Add new migration entry
+    data["migrations"].append(
+        {"id": migration_id, "completed_at": datetime.now(timezone.utc).isoformat()}
+    )
+
+    try:
+        with open(migrations_file, "w") as f:
+            yaml.safe_dump(data, f, default_flow_style=False)
+    except Exception as e:
+        logger.warning(f"Failed to save migration tracking: {e}")
+
+
+def _is_migration_completed(migration_id: str) -> bool:
+    """Check if a migration has already been completed.
+
+    Args:
+        migration_id: The ID of the migration to check.
+
+    Returns:
+        True if the migration has been completed.
+    """
+    data = _load_completed_migrations()
+    completed_ids = [m.get("id") for m in data.get("migrations", [])]
+    return migration_id in completed_ids
+
+
+# =============================================================================
+# Migration: v5.6.76-cache-dir-rename
+# =============================================================================
+
+
+def _check_cache_dir_rename_needed() -> bool:
+    """Check if cache directory rename is needed.
+
+    Returns:
+        True if ~/.claude-mpm/cache/remote-agents/ exists.
+    """
+    old_cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+    return old_cache_dir.exists()
+
+
+def _migrate_cache_dir_rename() -> bool:
+    """Rename remote-agents cache directory to agents.
+
+    This migration:
+    1. Moves ~/.claude-mpm/cache/remote-agents/ contents to ~/.claude-mpm/cache/agents/
+    2. Removes the old remote-agents directory
+    3. Updates configuration.yaml if it references the old path
+
+    Returns:
+        True if migration succeeded.
+    """
+    old_cache_dir = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+    new_cache_dir = Path.home() / ".claude-mpm" / "cache" / "agents"
+
+    try:
+        # Step 1: Move directory contents
+        if old_cache_dir.exists():
+            # Ensure parent directory exists
+            new_cache_dir.parent.mkdir(parents=True, exist_ok=True)
+
+            if new_cache_dir.exists():
+                # Merge: move contents from old to new
+                for item in old_cache_dir.iterdir():
+                    dest = new_cache_dir / item.name
+                    if not dest.exists():
+                        shutil.move(str(item), str(dest))
+                # Remove old directory after moving contents
+                shutil.rmtree(old_cache_dir, ignore_errors=True)
+            else:
+                # Simple rename if new dir doesn't exist
+                shutil.move(str(old_cache_dir), str(new_cache_dir))
+
+            logger.debug(
+                f"Moved cache directory from {old_cache_dir} to {new_cache_dir}"
+            )
+
+        # Step 2: Update configuration.yaml if needed
+        _update_configuration_cache_path()
+
+        return True
+
+    except Exception as e:
+        logger.warning(f"Cache directory migration failed: {e}")
+        return False
+
+
+def _update_configuration_cache_path() -> None:
+    """Update configuration.yaml to use new cache path if it references old path."""
+    config_file = Path.home() / ".claude-mpm" / "configuration.yaml"
+    if not config_file.exists():
+        return
+
+    try:
+        with open(config_file) as f:
+            content = f.read()
+
+        old_path_pattern = "/.claude-mpm/cache/remote-agents"
+        new_path_pattern = "/.claude-mpm/cache/agents"
+
+        if old_path_pattern in content:
+            updated_content = content.replace(old_path_pattern, new_path_pattern)
+            with open(config_file, "w") as f:
+                f.write(updated_content)
+            logger.debug("Updated configuration.yaml cache_dir path")
+
+    except Exception as e:
+        logger.debug(f"Failed to update configuration.yaml: {e}")
+
+
+# =============================================================================
+# Migration Registry
+# =============================================================================
+
+MIGRATIONS: list[Migration] = [
+    Migration(
+        id="v5.6.76-cache-dir-rename",
+        description="Rename remote-agents cache dir to agents",
+        check=_check_cache_dir_rename_needed,
+        migrate=_migrate_cache_dir_rename,
+    ),
+]
+
+
+def run_migrations() -> None:
+    """Run all pending startup migrations.
+
+    This function:
+    1. Iterates through the migration registry
+    2. Skips already-completed migrations
+    3. Checks if each migration is needed
+    4. Runs the migration if needed
+    5. Tracks completed migrations
+
+    Errors are logged but do not stop startup.
+    """
+    for migration in MIGRATIONS:
+        try:
+            # Skip if already completed
+            if _is_migration_completed(migration.id):
+                continue
+
+            # Check if migration is needed
+            if not migration.check():
+                # Mark as completed even if not needed (condition doesn't apply)
+                _save_completed_migration(migration.id)
+                continue
+
+            # Run the migration
+            print(f"⚙️  Running startup migration: {migration.description}")
+            logger.info(f"Running startup migration: {migration.id}")
+
+            success = migration.migrate()
+
+            if success:
+                _save_completed_migration(migration.id)
+                logger.info(f"Migration {migration.id} completed successfully")
+            else:
+                logger.warning(f"Migration {migration.id} failed")
+
+        except Exception as e:
+            # Non-blocking: log and continue
+            logger.warning(f"Migration {migration.id} error: {e}")
+            continue

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"

claude_mpm/commander/adapters/base.py

@@ -6,7 +6,7 @@ between the TmuxOrchestrator and various AI coding tools (Claude Code, Cursor, e
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, auto
 from typing import List, Optional, Set
 
 
@@ -22,6 +22,56 @@ class Capability(Enum):
     COMPLEX_REASONING = "complex_reasoning"
 
 
+class RuntimeCapability(Enum):
+    """Extended capabilities a runtime may support (MPM-specific features)."""
+
+    FILE_READ = auto()
+    FILE_EDIT = auto()
+    FILE_CREATE = auto()
+    BASH_EXECUTION = auto()
+    GIT_OPERATIONS = auto()
+    TOOL_USE = auto()
+    AGENT_DELEGATION = auto()  # Sub-agent spawning
+    HOOKS = auto()  # Lifecycle hooks
+    INSTRUCTIONS = auto()  # Custom instructions file
+    MCP_TOOLS = auto()  # MCP server integration
+    SKILLS = auto()  # Loadable skills
+    MONITOR = auto()  # Real-time monitoring
+    WEB_SEARCH = auto()
+    COMPLEX_REASONING = auto()
+
+
+@dataclass
+class RuntimeInfo:
+    """Information about a runtime environment.
+
+    Attributes:
+        name: Runtime identifier (e.g., "claude-code", "auggie")
+        version: Optional version string
+        capabilities: Set of RuntimeCapability enums
+        command: CLI command to invoke runtime
+        supports_agents: Whether runtime supports agent delegation
+        instruction_file: Path to instructions file (e.g., "CLAUDE.md")
+
+    Example:
+        >>> info = RuntimeInfo(
+        ...     name="claude-code",
+        ...     version="1.0.0",
+        ...     capabilities={RuntimeCapability.FILE_EDIT, RuntimeCapability.TOOL_USE},
+        ...     command="claude",
+        ...     supports_agents=False,
+        ...     instruction_file="CLAUDE.md"
+        ... )
+    """
+
+    name: str
+    version: Optional[str]
+    capabilities: Set[RuntimeCapability]
+    command: str
+    supports_agents: bool = False
+    instruction_file: Optional[str] = None
+
+
 @dataclass
 class ParsedResponse:
     """Parsed output from a runtime tool.
@@ -189,3 +239,50 @@ class RuntimeAdapter(ABC):
             >>> adapter.name
             'claude-code'
         """
+
+    @property
+    def runtime_info(self) -> Optional[RuntimeInfo]:
+        """Return detailed runtime information.
+
+        Returns:
+            RuntimeInfo with capabilities and configuration, or None if not implemented
+
+        Example:
+            >>> info = adapter.runtime_info
+            >>> if info and RuntimeCapability.AGENT_DELEGATION in info.capabilities:
+            ...     print("Supports agent delegation")
+        """
+        return None
+
+    def inject_instructions(self, instructions: str) -> Optional[str]:
+        """Return command/method to inject custom instructions.
+
+        Args:
+            instructions: Instructions text to inject
+
+        Returns:
+            Command string to inject instructions, or None if not supported
+
+        Example:
+            >>> cmd = adapter.inject_instructions("You are a Python expert")
+            >>> if cmd:
+            ...     # Execute command to inject instructions
+        """
+        return None
+
+    def inject_agent_context(self, agent_id: str, context: dict) -> Optional[str]:
+        """Return command to inject agent context.
+
+        Args:
+            agent_id: Unique identifier for agent
+            context: Context dictionary with agent metadata
+
+        Returns:
+            Command string to inject context, or None if not supported
+
+        Example:
+            >>> cmd = adapter.inject_agent_context("eng-001", {"role": "Engineer"})
+            >>> if cmd:
+            ...     # Execute command to inject context
+        """
+        return None