claude-mpm 5.6.4__py3-none-any.whl → 5.6.30__py3-none-any.whl

claude_mpm/cli/startup.py

@@ -34,13 +34,13 @@ def sync_hooks_on_startup(quiet: bool = False) -> bool:
         installer = HookInstaller()
 
         # Show brief status (hooks sync is fast)
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             print("Syncing Claude Code hooks...", end=" ", flush=True)
 
         # Reinstall hooks (force=True ensures update)
         success = installer.install_hooks(force=True)
 
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             if success:
                 print("✓")
             else:
@@ -49,7 +49,7 @@ def sync_hooks_on_startup(quiet: bool = False) -> bool:
         return success
 
     except Exception as e:
-        if not quiet:
+        if not quiet and sys.stdout.isatty():
             print("(error)")
         # Log but don't fail startup
         from ..core.logger import get_logger
@@ -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",
+        ]
     )
 
 
@@ -271,11 +280,13 @@ def deploy_bundled_skills():
         if deployment_result.get("deployed"):
             # Show simple feedback for deployed skills
             deployed_count = len(deployment_result["deployed"])
-            print(f"✓ Bundled skills ready ({deployed_count} deployed)", flush=True)
+            if sys.stdout.isatty():
+                print(f"✓ Bundled skills ready ({deployed_count} deployed)", flush=True)
             logger.info(f"Skills: Deployed {deployed_count} skill(s)")
         elif not deployment_result.get("errors"):
             # No deployment needed, skills already present
-            print("✓ Bundled skills ready", flush=True)
+            if sys.stdout.isatty():
+                print("✓ Bundled skills ready", flush=True)
 
         if deployment_result.get("errors"):
             logger.warning(
@@ -309,7 +320,8 @@ def discover_and_link_runtime_skills():
 
         discover_skills()
         # Show simple success feedback
-        print("✓ Runtime skills linked", flush=True)
+        if sys.stdout.isatty():
+            print("✓ Runtime skills linked", flush=True)
     except Exception as e:
         # Import logger here to avoid circular imports
         from ..core.logger import get_logger
@@ -364,7 +376,8 @@ def deploy_output_style_on_startup():
 
         if all_up_to_date:
             # Show feedback that output styles are ready
-            print("✓ Output styles ready", flush=True)
+            if sys.stdout.isatty():
+                print("✓ Output styles ready", flush=True)
             return
 
         # Deploy all styles using the manager
@@ -374,7 +387,8 @@ def deploy_output_style_on_startup():
         deployed_count = sum(1 for success in results.values() if success)
 
         if deployed_count > 0:
-            print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
+            if sys.stdout.isatty():
+                print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
         else:
             # Deployment failed - log but don't fail startup
             from ..core.logger import get_logger
@@ -469,6 +483,94 @@ def _cleanup_orphaned_agents(deploy_target: Path, deployed_agents: list[str]) ->
     return removed_count
 
 
+def _save_deployment_state_after_reconciliation(
+    agent_result, project_path: Path
+) -> None:
+    """Save deployment state after reconciliation to prevent duplicate deployment.
+
+    WHY: After perform_startup_reconciliation() deploys agents to .claude/agents/,
+    we need to save a deployment state file so that ClaudeRunner.setup_agents()
+    can detect agents are already deployed and skip redundant deployment.
+
+    This prevents the "✓ Deployed 31 native agents" duplicate deployment that
+    occurs when setup_agents() doesn't know reconciliation already ran.
+
+    Args:
+        agent_result: DeploymentResult from perform_startup_reconciliation()
+        project_path: Project root directory
+
+    DESIGN DECISION: Use same state file format as ClaudeRunner._save_deployment_state()
+    Located at: .claude-mpm/cache/deployment_state.json
+
+    State file format:
+    {
+        "version": "5.6.13",
+        "agent_count": 15,
+        "deployment_hash": "sha256:...",
+        "deployed_at": 1234567890.123
+    }
+    """
+    import hashlib
+    import json
+    import time
+
+    from ..core.logger import get_logger
+
+    logger = get_logger("cli")
+
+    try:
+        # Get version from package
+        from claude_mpm import __version__
+
+        # Path to state file (matches ClaudeRunner._get_deployment_state_path())
+        state_file = project_path / ".claude-mpm" / "cache" / "deployment_state.json"
+        agents_dir = project_path / ".claude" / "agents"
+
+        # Count deployed agents
+        if agents_dir.exists():
+            agent_count = len(list(agents_dir.glob("*.md")))
+        else:
+            agent_count = 0
+
+        # Calculate deployment hash (matches ClaudeRunner._calculate_deployment_hash())
+        # CRITICAL: Must match exact hash algorithm used in ClaudeRunner
+        # Hashes filename + file content (not mtime) for consistency
+        deployment_hash = ""
+        if agents_dir.exists():
+            agent_files = sorted(agents_dir.glob("*.md"))
+            hash_obj = hashlib.sha256()
+            for agent_file in agent_files:
+                # Include filename and content in hash (matches ClaudeRunner)
+                hash_obj.update(agent_file.name.encode())
+                try:
+                    hash_obj.update(agent_file.read_bytes())
+                except Exception as e:
+                    logger.debug(f"Error reading {agent_file} for hash: {e}")
+
+            deployment_hash = hash_obj.hexdigest()
+
+        # Create state data
+        state_data = {
+            "version": __version__,
+            "agent_count": agent_count,
+            "deployment_hash": deployment_hash,
+            "deployed_at": time.time(),
+        }
+
+        # Ensure directory exists
+        state_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write state file
+        state_file.write_text(json.dumps(state_data, indent=2))
+        logger.debug(
+            f"Saved deployment state after reconciliation: {agent_count} agents"
+        )
+
+    except Exception as e:
+        # Non-critical error - log but don't fail startup
+        logger.debug(f"Failed to save deployment state: {e}")
+
+
 def sync_remote_agents_on_startup(force_sync: bool = False):
     """
     Synchronize agent templates from remote sources on startup.
@@ -631,6 +733,12 @@ def sync_remote_agents_on_startup(force_sync: bool = False):
                     )
                     print("   Run with --verbose for detailed error information.\n")
 
+                # Save deployment state to prevent duplicate deployment in ClaudeRunner
+                # This ensures setup_agents() skips deployment since we already reconciled
+                _save_deployment_state_after_reconciliation(
+                    agent_result=agent_result, project_path=project_path
+                )
+
             except Exception as e:
                 # Deployment failure shouldn't block startup
                 from ..core.logger import get_logger
@@ -1187,9 +1295,11 @@ def verify_and_show_pm_skills():
         if result.verified:
             # Show verified status with count
             total_required = len(REQUIRED_PM_SKILLS)
-            print(
-                f"✓ PM skills: {total_required}/{total_required} verified", flush=True
-            )
+            if sys.stdout.isatty():
+                print(
+                    f"✓ PM skills: {total_required}/{total_required} verified",
+                    flush=True,
+                )
         else:
             # Show warning with details
             missing_count = len(result.missing_skills)
@@ -1208,13 +1318,15 @@ def verify_and_show_pm_skills():
             if "Auto-repaired" in result.message:
                 # Auto-repair succeeded
                 total_required = len(REQUIRED_PM_SKILLS)
-                print(
-                    f"✓ PM skills: {total_required}/{total_required} verified (auto-repaired)",
-                    flush=True,
-                )
+                if sys.stdout.isatty():
+                    print(
+                        f"✓ PM skills: {total_required}/{total_required} verified (auto-repaired)",
+                        flush=True,
+                    )
             else:
                 # Auto-repair failed or not attempted
-                print(f"⚠ PM skills: {status}", flush=True)
+                if sys.stdout.isatty():
+                    print(f"⚠ PM skills: {status}", flush=True)
 
                 # Log warnings for debugging
                 from ..core.logger import get_logger
@@ -1413,7 +1525,9 @@ def check_mcp_auto_configuration():
         from ..services.mcp_gateway.auto_configure import check_and_configure_mcp
 
         # Show progress feedback - this operation can take 10+ seconds
-        print("Checking MCP configuration...", end="", flush=True)
+        # Only show progress message in TTY mode to avoid interfering with Claude Code's status display
+        if sys.stdout.isatty():
+            print("Checking MCP configuration...", end="", flush=True)
 
         # This function handles all the logic:
         # - Checks if already configured
@@ -1424,11 +1538,17 @@ def check_mcp_auto_configuration():
         check_and_configure_mcp()
 
         # Clear the "Checking..." message by overwriting with spaces
-        print("\r" + " " * 30 + "\r", end="", flush=True)
+        # Only use carriage return clearing if stdout is a real TTY
+        if sys.stdout.isatty():
+            print("\r" + " " * 30 + "\r", end="", flush=True)
+        # In non-TTY mode, don't print anything - the "Checking..." message will just remain on its line
 
     except Exception as e:
         # Clear progress message on error
-        print("\r" + " " * 30 + "\r", end="", flush=True)
+        # Only use carriage return clearing if stdout is a real TTY
+        if sys.stdout.isatty():
+            print("\r" + " " * 30 + "\r", end="", flush=True)
+        # In non-TTY mode, don't print anything - the "Checking..." message will just remain on its line
 
         # Non-critical - log but don't fail
         from ..core.logger import get_logger

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"