claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/hooks/memory_integration_hook.py

@@ -13,16 +13,25 @@ agent outputs because:
 """
 
 import re
-from typing import Dict, Any, List
-from claude_mpm.hooks.base_hook import PreDelegationHook, PostDelegationHook, HookContext, HookResult
+from datetime import datetime
+from typing import Dict, List
+
 from claude_mpm.core.config import Config
-from claude_mpm.core.logger import get_logger
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.core.shared.config_loader import ConfigLoader
+from claude_mpm.hooks.base_hook import (
+    HookContext,
+    HookResult,
+    PostDelegationHook,
+    PreDelegationHook,
+)
 
 logger = get_logger(__name__)
 
 # Try to import memory manager with fallback handling
 try:
-    from claude_mpm.services.agent_memory_manager import AgentMemoryManager
+    from claude_mpm.services.agents.memory import AgentMemoryManager
+
     MEMORY_MANAGER_AVAILABLE = True
 except ImportError as e:
     logger.warning(f"AgentMemoryManager not available: {e}")
@@ -32,33 +41,48 @@ except ImportError as e:
 # Try to import socketio server with fallback handling
 try:
     from claude_mpm.services.socketio_server import get_socketio_server
+
     SOCKETIO_AVAILABLE = True
 except ImportError as e:
     logger.debug(f"SocketIO server not available: {e}")
     SOCKETIO_AVAILABLE = False
     get_socketio_server = None
 
+# Try to import event bus with fallback handling
+try:
+    from claude_mpm.services.event_bus.event_bus import EventBus
+
+    EVENT_BUS_AVAILABLE = True
+except ImportError as e:
+    logger.debug(f"EventBus not available: {e}")
+    EVENT_BUS_AVAILABLE = False
+    EventBus = None
+
 
 class MemoryPreDelegationHook(PreDelegationHook):
     """Inject agent memory into delegation context.
-    
+
     WHY: Agents perform better when they have access to accumulated project knowledge.
     This hook loads agent-specific memory and adds it to the delegation context,
     allowing agents to apply learned patterns and avoid known mistakes.
-    
+
     DESIGN DECISION: Memory is injected as a clearly formatted section in the context
     to ensure agents understand it's their accumulated knowledge, not current task info.
     """
-    
+
     def __init__(self, config: Config = None):
         """Initialize with optional config.
-        
+
         Args:
             config: Optional Config object. If not provided, will create default Config.
         """
         super().__init__(name="memory_pre_delegation", priority=20)
-        self.config = config or Config()
-        
+        if config:
+            self.config = config
+        else:
+            config_loader = ConfigLoader()
+            self.config = config_loader.load_main_config()
+
         # Initialize memory manager only if available
         if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager:
             try:
@@ -69,10 +93,20 @@ class MemoryPreDelegationHook(PreDelegationHook):
         else:
             logger.info("Memory manager not available - hook will be inactive")
             self.memory_manager = None
-    
+
+        # Initialize event bus for observability
+        if EVENT_BUS_AVAILABLE and EventBus:
+            try:
+                self.event_bus = EventBus.get_instance()
+            except Exception as e:
+                logger.debug(f"Failed to get EventBus instance: {e}")
+                self.event_bus = None
+        else:
+            self.event_bus = None
+
     def execute(self, context: HookContext) -> HookResult:
         """Add agent memory to delegation context.
-        
+
         WHY: By loading memory before delegation, agents can reference their
         accumulated knowledge when performing tasks, leading to better outcomes.
         """
@@ -80,27 +114,33 @@ class MemoryPreDelegationHook(PreDelegationHook):
         if not self.memory_manager:
             logger.debug("Memory manager not available - skipping memory injection")
             return HookResult(success=True, data=context.data, modified=False)
-            
+
         try:
             # Extract and normalize agent ID from context
-            agent_name = context.data.get('agent', '')
+            agent_name = context.data.get("agent", "")
             if not agent_name:
                 return HookResult(success=True, data=context.data, modified=False)
-            
+
             # Normalize agent ID (e.g., "Engineer Agent" -> "engineer")
-            agent_id = agent_name.lower().replace(' ', '_').replace('_agent', '').replace('agent', '').strip('_')
-            
+            agent_id = (
+                agent_name.lower()
+                .replace(" ", "_")
+                .replace("_agent", "")
+                .replace("agent", "")
+                .strip("_")
+            )
+
             if agent_id:
                 # Load agent memory
                 memory_content = self.memory_manager.load_agent_memory(agent_id)
-                
+
                 if memory_content and memory_content.strip():
                     # Get existing context data
-                    delegation_context = context.data.get('context', {})
+                    delegation_context = context.data.get("context", {})
                     if isinstance(delegation_context, str):
                         # If context is a string, convert to dict
-                        delegation_context = {'prompt': delegation_context}
-                    
+                        delegation_context = {"prompt": delegation_context}
+
                     # Add memory with clear formatting
                     memory_section = f"""
 AGENT MEMORY - PROJECT-SPECIFIC KNOWLEDGE:
@@ -108,34 +148,58 @@ AGENT MEMORY - PROJECT-SPECIFIC KNOWLEDGE:
 
 INSTRUCTIONS: Review your memory above before proceeding. Apply learned patterns and avoid known mistakes.
 """
-                    
+
                     # Add to context
-                    delegation_context['agent_memory'] = memory_section
-                    
+                    delegation_context["agent_memory"] = memory_section
+
                     # Update the context data
                     updated_data = context.data.copy()
-                    updated_data['context'] = delegation_context
-                    
+                    updated_data["context"] = delegation_context
+
                     logger.info(f"Injected memory for agent '{agent_id}'")
-                    
-                    # Emit Socket.IO event for memory injected
+
+                    # Calculate memory size for observability
+                    memory_size = len(memory_content)
+
+                    # Emit event bus event for observability
+                    if self.event_bus:
+                        try:
+                            # Determine memory source (project or user level)
+                            # This is inferred from the memory manager's behavior
+                            memory_source = (
+                                "runtime"  # Runtime loading from memory manager
+                            )
+
+                            self.event_bus.publish(
+                                "agent.memory.loaded",
+                                {
+                                    "agent_id": agent_id,
+                                    "memory_source": memory_source,
+                                    "memory_size": memory_size,
+                                    "timestamp": datetime.now(datetime.UTC).isoformat(),
+                                },
+                            )
+                        except Exception as event_error:
+                            logger.debug(f"EventBus publish failed: {event_error}")
+
+                    # Emit Socket.IO event for memory injected (legacy compatibility)
                     try:
                         socketio_server = get_socketio_server()
                         # Calculate size of injected content
-                        injected_size = len(memory_section.encode('utf-8'))
+                        injected_size = len(memory_section.encode("utf-8"))
                         socketio_server.memory_injected(agent_id, injected_size)
                     except Exception as ws_error:
                         logger.debug(f"Socket.IO notification failed: {ws_error}")
-                    
+
                     return HookResult(
                         success=True,
                         data=updated_data,
                         modified=True,
-                        metadata={'memory_injected': True, 'agent_id': agent_id}
+                        metadata={"memory_injected": True, "agent_id": agent_id},
                     )
-            
+
             return HookResult(success=True, data=context.data, modified=False)
-                
+
         except Exception as e:
             logger.error(f"Memory injection failed: {e}")
             # Don't fail the delegation if memory injection fails
@@ -143,73 +207,81 @@ INSTRUCTIONS: Review your memory above before proceeding. Apply learned patterns
                 success=True,
                 data=context.data,
                 modified=False,
-                error=f"Memory injection failed: {str(e)}"
+                error=f"Memory injection failed: {e!s}",
             )
 
 
 class MemoryPostDelegationHook(PostDelegationHook):
     """Extract learnings from delegation results using explicit markers.
-    
+
     WHY: Agents produce valuable insights during task execution. This hook
     extracts structured learnings from their outputs using explicit markers,
     building up project-specific knowledge over time.
-    
+
     DESIGN DECISION: We use explicit markers to give agents full control over
     what gets memorized. This is more reliable than pattern matching and allows
     multiple learnings per response. Supports multiple trigger phrases for flexibility.
-    
+
     Supported formats:
     # Add To Memory:
     Type: pattern
     Content: All services use dependency injection for flexibility
     #
-    
+
     # Memorize:
     Type: guideline
     Content: Always validate input parameters before processing
     #
-    
+
     # Remember:
     Type: mistake
     Content: Never hardcode configuration values
     #
     """
-    
+
     def __init__(self, config: Config = None):
         """Initialize with optional config.
-        
+
         Args:
             config: Optional Config object. If not provided, will create default Config.
         """
         super().__init__(name="memory_post_delegation", priority=80)
-        self.config = config or Config()
-        
+        if config:
+            self.config = config
+        else:
+            config_loader = ConfigLoader()
+            self.config = config_loader.load_main_config()
+
         # Initialize memory manager only if available
         if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager:
             try:
                 self.memory_manager = AgentMemoryManager(self.config)
             except Exception as e:
-                logger.error(f"Failed to initialize AgentMemoryManager in PostDelegationHook: {e}")
+                logger.error(
+                    f"Failed to initialize AgentMemoryManager in PostDelegationHook: {e}"
+                )
                 self.memory_manager = None
         else:
-            logger.info("Memory manager not available - post-delegation hook will be inactive")
+            logger.info(
+                "Memory manager not available - post-delegation hook will be inactive"
+            )
             self.memory_manager = None
-        
+
         # Map of supported types to memory sections
         self.type_mapping = {
-            'pattern': 'pattern',           # Coding Patterns Learned
-            'architecture': 'architecture', # Project Architecture
-            'guideline': 'guideline',      # Implementation Guidelines
-            'mistake': 'mistake',          # Common Mistakes to Avoid
-            'strategy': 'strategy',        # Effective Strategies
-            'integration': 'integration',  # Integration Points
-            'performance': 'performance',  # Performance Considerations
-            'context': 'context'           # Current Technical Context
+            "pattern": "pattern",  # Coding Patterns Learned
+            "architecture": "architecture",  # Project Architecture
+            "guideline": "guideline",  # Implementation Guidelines
+            "mistake": "mistake",  # Common Mistakes to Avoid
+            "strategy": "strategy",  # Effective Strategies
+            "integration": "integration",  # Integration Points
+            "performance": "performance",  # Performance Considerations
+            "context": "context",  # Current Technical Context
         }
-    
+
     def execute(self, context: HookContext) -> HookResult:
         """Extract and store learnings from delegation result.
-        
+
         WHY: Capturing learnings immediately after task completion ensures we
         don't lose valuable insights that agents discover during execution.
         """
@@ -217,62 +289,74 @@ class MemoryPostDelegationHook(PostDelegationHook):
         if not self.memory_manager:
             logger.debug("Memory manager not available - skipping learning extraction")
             return HookResult(success=True, data=context.data, modified=False)
-            
+
         try:
             # Check if auto-learning is enabled
-            if not self.config.get('memory.auto_learning', True):  # Changed default to True
+            if not self.config.get(
+                "memory.auto_learning", True
+            ):  # Changed default to True
                 return HookResult(success=True, data=context.data, modified=False)
-            
+
             # Extract agent ID
-            agent_name = context.data.get('agent', '')
+            agent_name = context.data.get("agent", "")
             if not agent_name:
                 return HookResult(success=True, data=context.data, modified=False)
-            
+
             # Normalize agent ID
-            agent_id = agent_name.lower().replace(' ', '_').replace('_agent', '').replace('agent', '').strip('_')
-            
+            agent_id = (
+                agent_name.lower()
+                .replace(" ", "_")
+                .replace("_agent", "")
+                .replace("agent", "")
+                .strip("_")
+            )
+
             # Check if auto-learning is enabled for this specific agent
-            agent_overrides = self.config.get('memory.agent_overrides', {})
+            agent_overrides = self.config.get("memory.agent_overrides", {})
             agent_config = agent_overrides.get(agent_id, {})
-            if 'auto_learning' in agent_config and not agent_config['auto_learning']:
+            if "auto_learning" in agent_config and not agent_config["auto_learning"]:
                 return HookResult(success=True, data=context.data, modified=False)
-            
+
             # Extract result content
-            result = context.data.get('result', {})
+            result = context.data.get("result", {})
             if isinstance(result, dict):
-                result_text = result.get('content', '') or str(result)
+                result_text = result.get("content", "") or str(result)
             else:
                 result_text = str(result)
-            
+
             if agent_id and result_text:
                 # Extract learnings using patterns
                 learnings = self._extract_learnings(result_text)
-                
+
                 # Store each learning
                 learnings_stored = 0
                 for learning_type, items in learnings.items():
                     for item in items:
                         try:
-                            self.memory_manager.add_learning(agent_id, learning_type, item)
+                            self.memory_manager.add_learning(
+                                agent_id, learning_type, item
+                            )
                             learnings_stored += 1
                         except Exception as e:
                             logger.warning(f"Failed to store learning: {e}")
-                
+
                 if learnings_stored > 0:
-                    logger.info(f"Extracted {learnings_stored} learnings for agent '{agent_id}'")
-                    
+                    logger.info(
+                        f"Extracted {learnings_stored} learnings for agent '{agent_id}'"
+                    )
+
                     return HookResult(
                         success=True,
                         data=context.data,
                         modified=False,
                         metadata={
-                            'learnings_extracted': learnings_stored,
-                            'agent_id': agent_id
-                        }
+                            "learnings_extracted": learnings_stored,
+                            "agent_id": agent_id,
+                        },
                     )
-            
+
             return HookResult(success=True, data=context.data, modified=False)
-                
+
         except Exception as e:
             logger.error(f"Learning extraction failed: {e}")
             # Don't fail the delegation result if learning extraction fails
@@ -280,54 +364,58 @@ class MemoryPostDelegationHook(PostDelegationHook):
                 success=True,
                 data=context.data,
                 modified=False,
-                error=f"Learning extraction failed: {str(e)}"
+                error=f"Learning extraction failed: {e!s}",
             )
-    
+
     def _extract_learnings(self, text: str) -> Dict[str, List[str]]:
         """Extract structured learnings from text using explicit markers.
-        
+
         WHY: We limit learnings to 100 characters to keep memory entries
         concise and actionable. Longer entries tend to be less useful as
         quick reference points.
-        
+
         DESIGN DECISION: Using explicit markers gives agents full control and makes
         extraction reliable. We support multiple memory additions in a single response
         and multiple trigger phrases (Add To Memory, Memorize, Remember) for flexibility.
-        
+
         Args:
             text: The text to extract learnings from
-            
+
         Returns:
             Dictionary mapping learning types to lists of extracted learnings
         """
-        learnings = {learning_type: [] for learning_type in self.type_mapping.keys()}
+        learnings = {learning_type: [] for learning_type in self.type_mapping}
         seen_learnings = set()  # Avoid duplicates
-        
+
         # Pattern to find memory blocks with multiple trigger phrases
         # Matches: # Add To Memory: / # Memorize: / # Remember:\n...\n#
         # Only matches complete blocks with proper closing markers
-        memory_pattern = r'#\s*(?:Add\s+To\s+Memory|Memorize|Remember):\s*\n((?:[^#](?:[^#]|#(?!\s*(?:Add\s+To\s+Memory|Memorize|Remember):))*?)?)\n\s*#\s*$'
-        matches = re.finditer(memory_pattern, text, re.MULTILINE | re.DOTALL | re.IGNORECASE)
-        
+        memory_pattern = r"#\s*(?:Add\s+To\s+Memory|Memorize|Remember):\s*\n((?:[^#](?:[^#]|#(?!\s*(?:Add\s+To\s+Memory|Memorize|Remember):))*?)?)\n\s*#\s*$"
+        matches = re.finditer(
+            memory_pattern, text, re.MULTILINE | re.DOTALL | re.IGNORECASE
+        )
+
         for match in matches:
             block_content = match.group(1).strip()
             logger.debug(f"Found memory block: {block_content[:50]}...")
-            
+
             # Extract type and content from the block
-            type_match = re.search(r'Type:\s*(\w+)', block_content, re.IGNORECASE)
-            content_match = re.search(r'Content:\s*(.+)', block_content, re.IGNORECASE | re.DOTALL)
-            
+            type_match = re.search(r"Type:\s*(\w+)", block_content, re.IGNORECASE)
+            content_match = re.search(
+                r"Content:\s*(.+)", block_content, re.IGNORECASE | re.DOTALL
+            )
+
             if type_match and content_match:
                 learning_type = type_match.group(1).lower().strip()
                 content = content_match.group(1).strip()
-                
+
                 # Clean up multi-line content - take first line if multiple
-                if '\n' in content:
-                    content = content.split('\n')[0].strip()
-                
+                if "\n" in content:
+                    content = content.split("\n")[0].strip()
+
                 # Remove trailing punctuation
-                content = content.rstrip('.!?,;')
-                
+                content = content.rstrip(".!?,;")
+
                 # Validate type is supported
                 if learning_type in self.type_mapping:
                     # Check content length (between 5 and 100 characters)
@@ -337,16 +425,22 @@ class MemoryPostDelegationHook(PostDelegationHook):
                         if normalized not in seen_learnings:
                             learnings[learning_type].append(content)
                             seen_learnings.add(normalized)
-                            logger.debug(f"Extracted learning - Type: {learning_type}, Content: {content}")
+                            logger.debug(
+                                f"Extracted learning - Type: {learning_type}, Content: {content}"
+                            )
                         else:
                             logger.debug(f"Skipping duplicate learning: {content}")
                     else:
-                        logger.debug(f"Skipping learning - invalid length ({len(content)}): {content}")
+                        logger.debug(
+                            f"Skipping learning - invalid length ({len(content)}): {content}"
+                        )
                 else:
-                    logger.warning(f"Unsupported learning type: {learning_type}. Supported types: {list(self.type_mapping.keys())}")
+                    logger.warning(
+                        f"Unsupported learning type: {learning_type}. Supported types: {list(self.type_mapping.keys())}"
+                    )
             else:
-                logger.debug(f"Invalid memory block format - missing Type or Content")
-        
+                logger.debug("Invalid memory block format - missing Type or Content")
+
         # Log summary of extracted learnings
         total_learnings = sum(len(items) for items in learnings.values())
         if total_learnings > 0:
@@ -354,5 +448,5 @@ class MemoryPostDelegationHook(PostDelegationHook):
             for learning_type, items in learnings.items():
                 if items:
                     logger.debug(f"  {learning_type}: {len(items)} items")
-        
-        return learnings
+
+        return learnings

claude_mpm/hooks/session_resume_hook.py

@@ -0,0 +1,121 @@
+"""Session Resume Startup Hook.
+
+WHY: This hook automatically checks for paused sessions on PM startup and displays
+resume context to help users continue their work seamlessly.
+
+DESIGN DECISIONS:
+- Runs automatically on PM startup
+- Non-blocking: doesn't prevent PM from starting if check fails
+- Displays context to stdout for user visibility
+- Integrates with existing session pause/resume infrastructure
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from claude_mpm.core.logger import get_logger
+from claude_mpm.services.cli.session_resume_helper import SessionResumeHelper
+
+logger = get_logger(__name__)
+
+
+class SessionResumeStartupHook:
+    """Hook for automatic session resume detection on PM startup."""
+
+    def __init__(self, project_path: Optional[Path] = None):
+        """Initialize the session resume hook.
+
+        Args:
+            project_path: Project root path (default: current directory)
+        """
+        self.project_path = project_path or Path.cwd()
+        self.resume_helper = SessionResumeHelper(self.project_path)
+        self._session_displayed = False
+
+    def on_pm_startup(self) -> Optional[Dict[str, Any]]:
+        """Execute on PM startup to check for paused sessions.
+
+        Returns:
+            Session data if paused session found, None otherwise
+        """
+        try:
+            # Check if we already displayed a session in this process
+            if self._session_displayed:
+                logger.debug("Session already displayed, skipping")
+                return None
+
+            # Check for paused sessions
+            session_data = self.resume_helper.check_and_display_resume_prompt()
+
+            if session_data:
+                self._session_displayed = True
+                logger.info("Paused session context displayed to user")
+
+            return session_data
+
+        except Exception as e:
+            logger.error(f"Failed to check for paused sessions: {e}", exc_info=True)
+            return None
+
+    def get_session_count(self) -> int:
+        """Get count of paused sessions.
+
+        Returns:
+            Number of paused sessions
+        """
+        try:
+            return self.resume_helper.get_session_count()
+        except Exception as e:
+            logger.error(f"Failed to get session count: {e}")
+            return 0
+
+    def clear_displayed_session(self, session_data: Dict[str, Any]) -> bool:
+        """Clear a session after it has been displayed and user has acknowledged.
+
+        Args:
+            session_data: Session data to clear
+
+        Returns:
+            True if successfully cleared, False otherwise
+        """
+        try:
+            return self.resume_helper.clear_session(session_data)
+        except Exception as e:
+            logger.error(f"Failed to clear session: {e}")
+            return False
+
+
+# Global hook instance
+_session_resume_hook: Optional[SessionResumeStartupHook] = None
+
+
+def get_session_resume_hook(
+    project_path: Optional[Path] = None,
+) -> SessionResumeStartupHook:
+    """Get or create the global session resume hook instance.
+
+    Args:
+        project_path: Project root path (default: current directory)
+
+    Returns:
+        SessionResumeStartupHook instance
+    """
+    global _session_resume_hook
+
+    if _session_resume_hook is None:
+        _session_resume_hook = SessionResumeStartupHook(project_path)
+        logger.debug("Created session resume hook instance")
+
+    return _session_resume_hook
+
+
+def trigger_session_resume_check() -> Optional[Dict[str, Any]]:
+    """Trigger a session resume check (convenience function).
+
+    This is the main entry point for PM startup integration.
+
+    Returns:
+        Session data if found, None otherwise
+    """
+    hook = get_session_resume_hook()
+    return hook.on_pm_startup()