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

claude_mpm/commander/daemon.py

@@ -16,8 +16,10 @@ from .api.app import (
 )
 from .config import DaemonConfig
 from .core.block_manager import BlockManager
+from .env_loader import load_env
 from .events.manager import EventManager
 from .inbox import Inbox
+from .models.events import EventStatus
 from .parsing.output_parser import OutputParser
 from .persistence import EventStore, StateStore
 from .project_session import ProjectSession, SessionState
@@ -28,6 +30,9 @@ from .work.executor import WorkExecutor
 from .work.queue import WorkQueue
 from .workflow.event_handler import EventHandler
 
+# Load environment variables at module import
+load_env()
+
 logger = logging.getLogger(__name__)
 
 
@@ -159,12 +164,16 @@ class CommanderDaemon:
         # Set up signal handlers
         self._setup_signal_handlers()
 
-        # Inject global instances into API app
-        global api_registry, api_tmux, api_event_manager, api_inbox
-        api_registry = self.registry
-        api_tmux = self.orchestrator
-        api_event_manager = self.event_manager
-        api_inbox = self.inbox
+        # Inject daemon instances into API app.state (BEFORE lifespan runs)
+        app.state.registry = self.registry
+        app.state.tmux = self.orchestrator
+        app.state.event_manager = self.event_manager
+        app.state.inbox = self.inbox
+        app.state.work_queues = self.work_queues
+        app.state.daemon_instance = self
+        app.state.session_manager = self.sessions
+        app.state.event_handler = self.event_handler
+        logger.info(f"Injected work_queues dict id: {id(self.work_queues)}")
 
         # Start API server in background
         logger.info(f"Starting API server on {self.config.host}:{self.config.port}")
@@ -257,9 +266,19 @@ class CommanderDaemon:
 
         while self._running:
             try:
-                # TODO: Check for resolved events and resume sessions (Phase 2 Sprint 3)
-                # TODO: Check each ProjectSession for runnable work (Phase 2 Sprint 2)
-                # TODO: Spawn RuntimeExecutors for new work items (Phase 2 Sprint 1)
+                logger.info(f"🔄 Main loop iteration (running={self._running})")
+                logger.info(
+                    f"work_queues dict id: {id(self.work_queues)}, keys: {list(self.work_queues.keys())}"
+                )
+
+                # Check for resolved events and resume sessions
+                await self._check_and_resume_sessions()
+
+                # Check each ProjectSession for runnable work
+                logger.info(
+                    f"Checking for pending work across {len(self.work_queues)} queues"
+                )
+                await self._execute_pending_work()
 
                 # Periodic state persistence
                 current_time = asyncio.get_event_loop().time()
@@ -429,6 +448,117 @@ class CommanderDaemon:
         except Exception as e:
             logger.error(f"Failed to save state: {e}", exc_info=True)
 
+    async def _check_and_resume_sessions(self) -> None:
+        """Check for resolved events and resume paused sessions.
+
+        Iterates through all paused sessions, checks if their blocking events
+        have been resolved, and resumes execution if ready.
+        """
+        for project_id, session in list(self.sessions.items()):
+            # Skip non-paused sessions
+            if session.state != SessionState.PAUSED:
+                continue
+
+            # Check if pause reason (event ID) is resolved
+            if not session.pause_reason:
+                logger.warning(f"Session {project_id} paused with no reason, resuming")
+                await session.resume()
+                continue
+
+            # Check if event is resolved
+            event = self.event_manager.get(session.pause_reason)
+            if event and event.status == EventStatus.RESOLVED:
+                logger.info(
+                    f"Event {event.id} resolved, resuming session for {project_id}"
+                )
+                await session.resume()
+
+                # Unblock any work items that were blocked by this event
+                if project_id in self.work_executors:
+                    executor = self.work_executors[project_id]
+                    queue = self.work_queues[project_id]
+
+                    # Find work items blocked by this event
+                    blocked_items = [
+                        item
+                        for item in queue.list()
+                        if item.state.value == "blocked"
+                        and item.metadata.get("block_reason") == event.id
+                    ]
+
+                    for item in blocked_items:
+                        await executor.handle_unblock(item.id)
+                        logger.info(f"Unblocked work item {item.id}")
+
+    async def _execute_pending_work(self) -> None:
+        """Execute pending work for all ready sessions.
+
+        Scans all work queues for pending work. For projects with work but no session,
+        auto-creates a session. Then executes the next available work item via WorkExecutor.
+        """
+        # First pass: Auto-create and start sessions for projects with pending work
+        for project_id, queue in list(self.work_queues.items()):
+            logger.info(
+                f"Checking queue for {project_id}: pending={queue.pending_count}"
+            )
+            # Skip if no pending work
+            if queue.pending_count == 0:
+                continue
+
+            # Auto-create session if needed
+            if project_id not in self.sessions:
+                try:
+                    logger.info(
+                        f"Auto-creating session for project {project_id} with pending work"
+                    )
+                    session = self.get_or_create_session(project_id)
+
+                    # Start the session so it's ready for work
+                    if session.state.value == "idle":
+                        logger.info(f"Auto-starting session for {project_id}")
+                        await session.start()
+                except Exception as e:
+                    logger.error(
+                        f"Failed to auto-create/start session for {project_id}: {e}",
+                        exc_info=True,
+                    )
+                    continue
+
+        # Second pass: Execute work for ready sessions
+        for project_id, session in list(self.sessions.items()):
+            # Skip sessions that aren't ready for work
+            if not session.is_ready():
+                continue
+
+            # Skip if no work queue exists
+            if project_id not in self.work_queues:
+                continue
+
+            # Get work executor for project
+            executor = self.work_executors.get(project_id)
+            if not executor:
+                logger.warning(
+                    f"No work executor found for project {project_id}, skipping"
+                )
+                continue
+
+            # Check if there's work available
+            queue = self.work_queues[project_id]
+            if queue.pending_count == 0:
+                continue
+
+            # Try to execute next work item
+            try:
+                # Pass the session's active pane for execution
+                executed = await executor.execute_next(pane_target=session.active_pane)
+                if executed:
+                    logger.info(f"Started work execution for project {project_id}")
+            except Exception as e:
+                logger.error(
+                    f"Error executing work for project {project_id}: {e}",
+                    exc_info=True,
+                )
+
 
 async def main(config: Optional[DaemonConfig] = None) -> None:
     """Main entry point for running the daemon.

claude_mpm/commander/env_loader.py

@@ -0,0 +1,59 @@
+"""Environment variable loader for Commander.
+
+This module handles automatic loading of .env and .env.local files
+at Commander startup. Environment files are loaded with the following precedence:
+1. Existing environment variables (not overridden)
+2. .env.local (local overrides)
+3. .env (defaults)
+
+Example:
+    >>> from claude_mpm.commander.env_loader import load_env
+    >>> load_env()
+    # Automatically loads .env.local and .env from project root
+"""
+
+import logging
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+
+def load_env() -> None:
+    """Load environment variables from .env and .env.local files.
+
+    Searches for .env and .env.local in the project root directory
+    (parent of src/claude_mpm). Files are loaded with override=False,
+    meaning existing environment variables take precedence.
+
+    Precedence (highest to lowest):
+    1. Existing environment variables
+    2. .env.local
+    3. .env
+
+    Example:
+        >>> load_env()
+        # Loads .env.local and .env if they exist
+    """
+    # Find project root (parent of src/claude_mpm)
+    # Current file: src/claude_mpm/commander/env_loader.py
+    # Project root: ../../../ (3 levels up)
+    current_file = Path(__file__)
+    project_root = current_file.parent.parent.parent.parent
+
+    # Try loading .env.local first (higher priority)
+    env_local = project_root / ".env.local"
+    if env_local.exists():
+        load_dotenv(env_local, override=False)
+        logger.debug(f"Loaded environment from {env_local}")
+
+    # Then load .env (lower priority)
+    env_file = project_root / ".env"
+    if env_file.exists():
+        load_dotenv(env_file, override=False)
+        logger.debug(f"Loaded environment from {env_file}")
+
+    # Log if neither file exists
+    if not env_local.exists() and not env_file.exists():
+        logger.debug("No .env or .env.local files found in project root")

claude_mpm/commander/memory/__init__.py

@@ -0,0 +1,45 @@
+"""Conversation memory system for Commander.
+
+This module provides semantic search, storage, and context compression
+for all Claude Code instance conversations.
+
+Key Components:
+    - ConversationStore: CRUD operations for conversations
+    - EmbeddingService: Generate vector embeddings
+    - SemanticSearch: Query conversations semantically
+    - ContextCompressor: Summarize conversations for context
+    - EntityExtractor: Extract files, functions, errors
+
+Example:
+    >>> from claude_mpm.commander.memory import (
+    ...     ConversationStore,
+    ...     EmbeddingService,
+    ...     SemanticSearch,
+    ...     ContextCompressor,
+    ... )
+    >>> store = ConversationStore()
+    >>> embeddings = EmbeddingService()
+    >>> search = SemanticSearch(store, embeddings)
+    >>> results = await search.search("how did we fix the login bug?")
+"""
+
+from .compression import ContextCompressor
+from .embeddings import EmbeddingService
+from .entities import Entity, EntityExtractor, EntityType
+from .integration import MemoryIntegration
+from .search import SearchResult, SemanticSearch
+from .store import Conversation, ConversationMessage, ConversationStore
+
+__all__ = [
+    "ContextCompressor",
+    "Conversation",
+    "ConversationMessage",
+    "ConversationStore",
+    "EmbeddingService",
+    "Entity",
+    "EntityExtractor",
+    "EntityType",
+    "MemoryIntegration",
+    "SearchResult",
+    "SemanticSearch",
+]

claude_mpm/commander/memory/compression.py

@@ -0,0 +1,347 @@
+"""Context compression and conversation summarization.
+
+Compresses long conversations into concise summaries for efficient context
+loading when resuming sessions or searching past work.
+"""
+
+import logging
+from typing import List, Optional
+
+from ..llm.openrouter_client import OpenRouterClient
+from .store import Conversation, ConversationMessage
+
+logger = logging.getLogger(__name__)
+
+
+class ContextCompressor:
+    """Compress conversations into summaries for context loading.
+
+    Uses cheap LLM (mistral-small) to generate summaries of conversations
+    and compress multiple conversations into context strings.
+
+    Attributes:
+        client: OpenRouterClient for LLM requests
+        summary_threshold: Minimum messages to trigger summarization
+        max_context_tokens: Maximum tokens for compressed context
+
+    Example:
+        >>> compressor = ContextCompressor(client)
+        >>> summary = await compressor.summarize(messages)
+        >>> context = await compressor.compress_for_context(
+        ...     conversations,
+        ...     max_tokens=4000
+        ... )
+    """
+
+    def __init__(
+        self,
+        client: OpenRouterClient,
+        summary_threshold: int = 10,
+        max_context_tokens: int = 4000,
+    ):
+        """Initialize context compressor.
+
+        Args:
+            client: OpenRouterClient for LLM requests
+            summary_threshold: Minimum messages to summarize
+            max_context_tokens: Maximum tokens for context string
+        """
+        self.client = client
+        self.summary_threshold = summary_threshold
+        self.max_context_tokens = max_context_tokens
+
+        logger.info(
+            "ContextCompressor initialized (threshold: %d msgs, max_tokens: %d)",
+            summary_threshold,
+            max_context_tokens,
+        )
+
+    async def summarize(
+        self,
+        messages: List[ConversationMessage],
+        focus: Optional[str] = None,
+    ) -> str:
+        """Generate summary of conversation messages.
+
+        Args:
+            messages: List of messages to summarize
+            focus: Optional focus area (e.g., "bug fixes", "API changes")
+
+        Returns:
+            Concise summary (2-4 sentences)
+
+        Example:
+            >>> summary = await compressor.summarize(messages)
+            >>> print(summary)
+            "Fixed login authentication bug in src/auth.py by updating token validation..."
+        """
+        if len(messages) < 2:
+            # Too short to summarize
+            return messages[0].content if messages else ""
+
+        # Build conversation text
+        conversation_text = self._format_messages(messages)
+
+        # Build summarization prompt
+        if focus:
+            prompt = f"""Summarize the following conversation, focusing on: {focus}
+
+Conversation:
+{conversation_text}
+
+Provide a concise summary (2-4 sentences) that captures:
+1. What was the main task or problem
+2. What actions were taken
+3. What was the outcome or current status
+4. Any important files, functions, or errors mentioned
+
+Summary:"""
+        else:
+            prompt = f"""Summarize the following conversation in 2-4 sentences.
+
+Conversation:
+{conversation_text}
+
+Focus on:
+1. What was the main task or problem
+2. What actions were taken
+3. What was the outcome or current status
+
+Summary:"""
+
+        messages_for_llm = [{"role": "user", "content": prompt}]
+
+        system = (
+            "You are a technical summarization assistant. "
+            "Provide clear, concise summaries of development conversations. "
+            "Focus on actionable information and key outcomes."
+        )
+
+        summary = await self.client.chat(messages_for_llm, system=system)
+        logger.debug(
+            "Generated summary (%d chars) from %d messages", len(summary), len(messages)
+        )
+
+        return summary.strip()
+
+    async def compress_for_context(
+        self,
+        conversations: List[Conversation],
+        max_tokens: Optional[int] = None,
+        prioritize_recent: bool = True,
+    ) -> str:
+        """Compress multiple conversations into context string.
+
+        Prioritizes recent conversations and uses summaries for older ones
+        to fit within token budget.
+
+        Args:
+            conversations: List of conversations to compress
+            max_tokens: Maximum tokens (default: self.max_context_tokens)
+            prioritize_recent: Whether to prioritize recent conversations
+
+        Returns:
+            Compressed context string ready for LLM input
+
+        Example:
+            >>> context = await compressor.compress_for_context(
+            ...     conversations,
+            ...     max_tokens=4000
+            ... )
+            >>> print(f"Context: {len(context)} chars")
+        """
+        if max_tokens is None:
+            max_tokens = self.max_context_tokens
+
+        # Sort by recency if prioritizing
+        if prioritize_recent:
+            conversations = sorted(
+                conversations, key=lambda c: c.updated_at, reverse=True
+            )
+
+        # Build context incrementally
+        context_parts = []
+        current_tokens = 0
+
+        for conv in conversations:
+            # Use summary if available, else generate one
+            if conv.summary:
+                summary_text = conv.summary
+            elif len(conv.messages) >= self.summary_threshold:
+                # Generate summary on-the-fly
+                summary_text = await self.summarize(conv.messages)
+            else:
+                # Use full conversation for short ones
+                summary_text = conv.get_full_text()
+
+            # Format conversation section
+            section = self._format_conversation_section(conv, summary_text)
+            section_tokens = len(section) // 4  # Rough approximation
+
+            # Check if adding this would exceed budget
+            if current_tokens + section_tokens > max_tokens:
+                # Try to fit summary only
+                short_summary = summary_text.split(". ")[0] + "."
+                short_section = self._format_conversation_section(conv, short_summary)
+                short_tokens = len(short_section) // 4
+
+                if current_tokens + short_tokens <= max_tokens:
+                    context_parts.append(short_section)
+                    current_tokens += short_tokens
+                else:
+                    # Can't fit any more, stop
+                    break
+            else:
+                context_parts.append(section)
+                current_tokens += section_tokens
+
+        context = "\n\n---\n\n".join(context_parts)
+
+        logger.info(
+            "Compressed %d conversations into context (%d chars, ~%d tokens)",
+            len(context_parts),
+            len(context),
+            current_tokens,
+        )
+
+        return context
+
+    def needs_summarization(self, messages: List[ConversationMessage]) -> bool:
+        """Check if conversation needs summarization.
+
+        Args:
+            messages: List of messages to check
+
+        Returns:
+            True if message count exceeds threshold
+
+        Example:
+            >>> if compressor.needs_summarization(messages):
+            ...     summary = await compressor.summarize(messages)
+        """
+        return len(messages) >= self.summary_threshold
+
+    def _format_messages(
+        self,
+        messages: List[ConversationMessage],
+        max_messages: Optional[int] = None,
+    ) -> str:
+        """Format messages as text for summarization.
+
+        Args:
+            messages: Messages to format
+            max_messages: Maximum messages to include
+
+        Returns:
+            Formatted conversation text
+        """
+        if max_messages:
+            messages = messages[:max_messages]
+
+        lines = []
+        for msg in messages:
+            # Format: ROLE: content
+            lines.append(f"{msg.role.upper()}: {msg.content}")
+
+        return "\n\n".join(lines)
+
+    def _format_conversation_section(
+        self, conversation: Conversation, summary: str
+    ) -> str:
+        """Format conversation section for context string.
+
+        Args:
+            conversation: Conversation to format
+            summary: Summary or full text
+
+        Returns:
+            Formatted section with metadata
+        """
+        # Format timestamp
+        timestamp = conversation.updated_at.strftime("%Y-%m-%d %H:%M")
+
+        # Build section
+        return f"""## Conversation: {conversation.id}
+**Project:** {conversation.project_id}
+**Instance:** {conversation.instance_name}
+**Updated:** {timestamp}
+**Messages:** {conversation.message_count}
+
+{summary}"""
+
+    async def auto_summarize_conversation(
+        self, conversation: Conversation
+    ) -> Optional[str]:
+        """Automatically summarize conversation if needed.
+
+        Checks if conversation needs summarization and generates one if so.
+        Updates the conversation's summary field but does NOT save to store.
+
+        Args:
+            conversation: Conversation to summarize
+
+        Returns:
+            Summary if generated, None if not needed
+
+        Example:
+            >>> summary = await compressor.auto_summarize_conversation(conv)
+            >>> if summary:
+            ...     conv.summary = summary
+            ...     await store.save(conv)
+        """
+        if not self.needs_summarization(conversation.messages):
+            logger.debug(
+                "Conversation %s too short to summarize (%d messages)",
+                conversation.id,
+                len(conversation.messages),
+            )
+            return None
+
+        if conversation.summary:
+            logger.debug("Conversation %s already has summary", conversation.id)
+            return conversation.summary
+
+        # Generate summary
+        summary = await self.summarize(conversation.messages)
+        logger.info("Auto-generated summary for conversation %s", conversation.id)
+
+        return summary
+
+    async def update_summary_if_stale(
+        self,
+        conversation: Conversation,
+        message_threshold: int = 5,
+    ) -> Optional[str]:
+        """Update summary if conversation has grown significantly.
+
+        Args:
+            conversation: Conversation to check
+            message_threshold: New messages required to trigger update
+
+        Returns:
+            Updated summary if regenerated, None otherwise
+
+        Example:
+            >>> updated = await compressor.update_summary_if_stale(conv)
+            >>> if updated:
+            ...     conv.summary = updated
+            ...     await store.save(conv)
+        """
+        if not conversation.summary:
+            # No existing summary, generate one
+            return await self.auto_summarize_conversation(conversation)
+
+        # Check if conversation has grown significantly
+        # (Simple heuristic: if more than threshold messages since last summarization)
+        # In practice, you'd track when summary was generated
+        if len(conversation.messages) < self.summary_threshold + message_threshold:
+            return None
+
+        # Regenerate summary
+        logger.info(
+            "Regenerating stale summary for conversation %s (%d messages)",
+            conversation.id,
+            len(conversation.messages),
+        )
+
+        return await self.summarize(conversation.messages)