claude-mpm 3.3.2__py3-none-any.whl → 3.4.2__py3-none-any.whl

claude_mpm/core/simple_runner.py

@@ -13,10 +13,14 @@ import uuid
 try:
     from claude_mpm.services.agent_deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.core.config import Config
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 except ImportError:
     from claude_mpm.services.agent_deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.core.config import Config
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 
 
@@ -76,6 +80,11 @@ class ClaudeRunner:
                 self.ticket_manager = None
                 self.enable_tickets = False
         
+        # Initialize hook service and register memory hooks
+        self.config = Config()
+        self.hook_service = HookService(self.config)
+        self._register_memory_hooks()
+        
         # Load system instructions
         self.system_instructions = self._load_system_instructions()
         
@@ -741,6 +750,58 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
     
+    def _register_memory_hooks(self):
+        """Register memory integration hooks with the hook service.
+        
+        WHY: This activates the memory system by registering hooks that automatically
+        inject agent memory before delegation and extract learnings after delegation.
+        This is the critical connection point between the memory system and the CLI.
+        
+        DESIGN DECISION: We register hooks here instead of in __init__ to ensure
+        all services are initialized first. Hooks are only registered if the memory
+        system is enabled in configuration.
+        """
+        try:
+            # Only register if memory system is enabled
+            if not self.config.get('memory.enabled', True):
+                self.logger.debug("Memory system disabled - skipping hook registration")
+                return
+            
+            # Import hook classes (lazy import to avoid circular dependencies)
+            from claude_mpm.hooks.memory_integration_hook import (
+                MemoryPreDelegationHook,
+                MemoryPostDelegationHook
+            )
+            
+            # Register pre-delegation hook for memory injection
+            pre_hook = MemoryPreDelegationHook(self.config)
+            success = self.hook_service.register_hook(pre_hook)
+            if success:
+                self.logger.info(f"✅ Registered memory pre-delegation hook (priority: {pre_hook.priority})")
+            else:
+                self.logger.warning("❌ Failed to register memory pre-delegation hook")
+            
+            # Register post-delegation hook if auto-learning is enabled
+            if self.config.get('memory.auto_learning', True):  # Default to True now
+                post_hook = MemoryPostDelegationHook(self.config)
+                success = self.hook_service.register_hook(post_hook)
+                if success:
+                    self.logger.info(f"✅ Registered memory post-delegation hook (priority: {post_hook.priority})")
+                else:
+                    self.logger.warning("❌ Failed to register memory post-delegation hook")
+            else:
+                self.logger.info("ℹ️  Auto-learning disabled - skipping post-delegation hook")
+            
+            # Log summary of registered hooks
+            hooks = self.hook_service.list_hooks()
+            pre_count = len(hooks.get('pre_delegation', []))
+            post_count = len(hooks.get('post_delegation', []))
+            self.logger.info(f"📋 Hook Service initialized: {pre_count} pre-delegation, {post_count} post-delegation hooks")
+            
+        except Exception as e:
+            self.logger.error(f"❌ Failed to register memory hooks: {e}")
+            # Don't fail the entire initialization - memory system is optional
+    
     def _launch_subprocess_interactive(self, cmd: list, env: dict):
         """Launch Claude as a subprocess with PTY for interactive mode."""
         import pty

claude_mpm/hooks/builtin/mpm_command_hook.py

@@ -12,11 +12,11 @@ logger = get_logger(__name__)
 
 
 class MpmCommandHook(SubmitHook):
-    """Hook that intercepts /mpm: commands and routes them to the command router."""
+    """Hook that intercepts /mpm commands and routes them to the command router."""
     
     def __init__(self):
         super().__init__(name="mpm_command", priority=1)  # High priority to intercept early
-        self.command_prefix = "/mpm:"
+        self.command_prefix = "/mpm "
         self.command_router_path = self._find_command_router()
     
     def _find_command_router(self) -> Path:
@@ -35,11 +35,11 @@ class MpmCommandHook(SubmitHook):
         return Path(".claude/scripts/command_router.py").resolve()
     
     def execute(self, context: HookContext) -> HookResult:
-        """Check for /mpm: commands and execute them directly."""
+        """Check for /mpm commands and execute them directly."""
         try:
             prompt = context.data.get('prompt', '').strip()
             
-            # Check if this is an /mpm: command
+            # Check if this is an /mpm command
             if not prompt.startswith(self.command_prefix):
                 # Not our command, pass through
                 return HookResult(
@@ -67,7 +67,7 @@ class MpmCommandHook(SubmitHook):
             command = parts[0]
             args = parts[1:]
             
-            logger.info(f"Executing /mpm:{command} with args: {args}")
+            logger.info(f"Executing /mpm {command} with args: {args}")
             
             # Execute command using command router
             try:

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -20,9 +20,33 @@ from datetime import datetime
 from pathlib import Path
 from collections import deque
 
-# Quick environment check
+# Quick environment check - must be defined before any code that might use it
 DEBUG = os.environ.get('CLAUDE_MPM_HOOK_DEBUG', '').lower() == 'true'
 
+# Add imports for memory hook integration with comprehensive error handling
+MEMORY_HOOKS_AVAILABLE = False
+try:
+    # Try to add src to path if not already there (fallback for missing PYTHONPATH)
+    import sys
+    from pathlib import Path
+    src_path = Path(__file__).parent.parent.parent.parent
+    if src_path.exists() and str(src_path) not in sys.path:
+        sys.path.insert(0, str(src_path))
+    
+    from claude_mpm.services.hook_service import HookService
+    from claude_mpm.hooks.memory_integration_hook import (
+        MemoryPreDelegationHook,
+        MemoryPostDelegationHook
+    )
+    from claude_mpm.hooks.base_hook import HookContext, HookType
+    from claude_mpm.core.config import Config
+    MEMORY_HOOKS_AVAILABLE = True
+except Exception as e:
+    # Catch all exceptions to prevent any import errors from breaking the handler
+    if DEBUG:
+        print(f"Memory hooks not available: {e}", file=sys.stderr)
+    MEMORY_HOOKS_AVAILABLE = False
+
 # Socket.IO import
 try:
     import socketio
@@ -59,6 +83,13 @@ class ClaudeHookHandler:
         self._git_branch_cache = {}
         self._git_branch_cache_time = {}
         
+        # Initialize memory hooks if available
+        self.memory_hooks_initialized = False
+        self.pre_delegation_hook = None
+        self.post_delegation_hook = None
+        if MEMORY_HOOKS_AVAILABLE:
+            self._initialize_memory_hooks()
+        
         # No fallback server needed - we only use Socket.IO now
     
     def _track_delegation(self, session_id: str, agent_type: str):
@@ -100,6 +131,49 @@ class ClaudeHookHandler:
         
         return 'unknown'
     
+    def _initialize_memory_hooks(self):
+        """Initialize memory hooks for automatic agent memory management.
+        
+        WHY: This activates the memory system by connecting Claude Code hook events
+        to our memory integration hooks. This enables automatic memory injection
+        before delegations and learning extraction after delegations.
+        
+        DESIGN DECISION: We initialize hooks here in the Claude hook handler because
+        this is where Claude Code events are processed. This ensures memory hooks
+        are triggered at the right times during agent delegation.
+        """
+        try:
+            # Create configuration
+            config = Config()
+            
+            # Only initialize if memory system is enabled
+            if not config.get('memory.enabled', True):
+                if DEBUG:
+                    print("Memory system disabled - skipping hook initialization", file=sys.stderr)
+                return
+            
+            # Initialize pre-delegation hook for memory injection
+            self.pre_delegation_hook = MemoryPreDelegationHook(config)
+            
+            # Initialize post-delegation hook if auto-learning is enabled
+            if config.get('memory.auto_learning', True):  # Default to True now
+                self.post_delegation_hook = MemoryPostDelegationHook(config)
+            
+            self.memory_hooks_initialized = True
+            
+            if DEBUG:
+                hooks_info = []
+                if self.pre_delegation_hook:
+                    hooks_info.append("pre-delegation")
+                if self.post_delegation_hook:
+                    hooks_info.append("post-delegation")
+                print(f"✅ Memory hooks initialized: {', '.join(hooks_info)}", file=sys.stderr)
+                
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Failed to initialize memory hooks: {e}", file=sys.stderr)
+            # Don't fail the entire handler - memory system is optional
+    
     def _get_git_branch(self, working_dir: str = None) -> str:
         """Get git branch for the given directory with caching.
         
@@ -366,6 +440,9 @@ class ClaudeHookHandler:
             session_id = event.get('session_id', '')
             if session_id and agent_type != 'unknown':
                 self._track_delegation(session_id, agent_type)
+            
+            # Trigger memory pre-delegation hook
+            self._trigger_memory_pre_delegation_hook(agent_type, tool_input, session_id)
         
         self._emit_socketio_event('/hook', 'pre_tool', pre_tool_data)
     
@@ -407,6 +484,12 @@ class ClaudeHookHandler:
             'output_size': len(str(result_data.get('output', ''))) if result_data.get('output') else 0
         }
         
+        # Handle Task delegation completion for memory hooks
+        if tool_name == 'Task':
+            session_id = event.get('session_id', '')
+            agent_type = self._get_delegation_agent_type(session_id)
+            self._trigger_memory_post_delegation_hook(agent_type, event, session_id)
+        
         self._emit_socketio_event('/hook', 'post_tool', post_tool_data)
     
     def _extract_tool_parameters(self, tool_name: str, tool_input: dict) -> dict:
@@ -711,6 +794,122 @@ class ClaudeHookHandler:
         # Emit to /hook namespace
         self._emit_socketio_event('/hook', 'subagent_stop', subagent_stop_data)
     
+    def _trigger_memory_pre_delegation_hook(self, agent_type: str, tool_input: dict, session_id: str):
+        """Trigger memory pre-delegation hook for agent memory injection.
+        
+        WHY: This connects Claude Code's Task delegation events to our memory system.
+        When Claude is about to delegate to an agent, we inject the agent's memory
+        into the delegation context so the agent has access to accumulated knowledge.
+        
+        DESIGN DECISION: We modify the tool_input in place to inject memory context.
+        This ensures the agent receives the memory as part of their initial context.
+        """
+        if not self.memory_hooks_initialized or not self.pre_delegation_hook:
+            return
+        
+        try:
+            # Create hook context for memory injection
+            hook_context = HookContext(
+                hook_type=HookType.PRE_DELEGATION,
+                data={
+                    'agent': agent_type,
+                    'context': tool_input,
+                    'session_id': session_id
+                },
+                metadata={
+                    'source': 'claude_hook_handler',
+                    'tool_name': 'Task'
+                },
+                timestamp=datetime.now().isoformat(),
+                session_id=session_id
+            )
+            
+            # Execute pre-delegation hook
+            result = self.pre_delegation_hook.execute(hook_context)
+            
+            if result.success and result.modified and result.data:
+                # Update tool_input with memory-enhanced context
+                enhanced_context = result.data.get('context', {})
+                if enhanced_context and 'agent_memory' in enhanced_context:
+                    # Inject memory into the task prompt/description
+                    original_prompt = tool_input.get('prompt', '')
+                    memory_section = enhanced_context['agent_memory']
+                    
+                    # Prepend memory to the original prompt
+                    enhanced_prompt = f"{memory_section}\n\n{original_prompt}"
+                    tool_input['prompt'] = enhanced_prompt
+                    
+                    if DEBUG:
+                        memory_size = len(memory_section.encode('utf-8'))
+                        print(f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'", file=sys.stderr)
+            
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Memory pre-delegation hook failed: {e}", file=sys.stderr)
+            # Don't fail the delegation - memory is optional
+    
+    def _trigger_memory_post_delegation_hook(self, agent_type: str, event: dict, session_id: str):
+        """Trigger memory post-delegation hook for learning extraction.
+        
+        WHY: This connects Claude Code's Task completion events to our memory system.
+        When an agent completes a task, we extract learnings from the result and
+        store them in the agent's memory for future use.
+        
+        DESIGN DECISION: We extract learnings from both the tool output and any
+        error messages, providing comprehensive context for the memory system.
+        """
+        if not self.memory_hooks_initialized or not self.post_delegation_hook:
+            return
+        
+        try:
+            # Extract result content from the event
+            result_content = ""
+            output = event.get('output', '')
+            error = event.get('error', '')
+            exit_code = event.get('exit_code', 0)
+            
+            # Build result content
+            if output:
+                result_content = str(output)
+            elif error:
+                result_content = f"Error: {str(error)}"
+            else:
+                result_content = f"Task completed with exit code: {exit_code}"
+            
+            # Create hook context for learning extraction
+            hook_context = HookContext(
+                hook_type=HookType.POST_DELEGATION,
+                data={
+                    'agent': agent_type,
+                    'result': {
+                        'content': result_content,
+                        'success': exit_code == 0,
+                        'exit_code': exit_code
+                    },
+                    'session_id': session_id
+                },
+                metadata={
+                    'source': 'claude_hook_handler',
+                    'tool_name': 'Task',
+                    'duration_ms': event.get('duration_ms', 0)
+                },
+                timestamp=datetime.now().isoformat(),
+                session_id=session_id
+            )
+            
+            # Execute post-delegation hook
+            result = self.post_delegation_hook.execute(hook_context)
+            
+            if result.success and result.metadata:
+                learnings_extracted = result.metadata.get('learnings_extracted', 0)
+                if learnings_extracted > 0 and DEBUG:
+                    print(f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'", file=sys.stderr)
+            
+        except Exception as e:
+            if DEBUG:
+                print(f"❌ Memory post-delegation hook failed: {e}", file=sys.stderr)
+            # Don't fail the delegation result - memory is optional
+    
     def __del__(self):
         """Cleanup Socket.IO client on handler destruction."""
         if self.sio_client and self.sio_connected:
@@ -721,9 +920,17 @@ class ClaudeHookHandler:
 
 
 def main():
-    """Entry point."""
-    handler = ClaudeHookHandler()
-    handler.handle()
+    """Entry point with comprehensive error handling."""
+    try:
+        handler = ClaudeHookHandler()
+        handler.handle()
+    except Exception as e:
+        # Always output continue action to not block Claude
+        print(json.dumps({"action": "continue"}))
+        # Log error for debugging
+        if DEBUG:
+            print(f"Hook handler error: {e}", file=sys.stderr)
+        sys.exit(0)  # Exit cleanly even on error
 
 
 if __name__ == "__main__":

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Claude Code hook wrapper for claude-mpm
 
 # Debug log (optional - comment out in production)
@@ -48,5 +48,12 @@ echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/hook
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Running: $PYTHON_CMD $SCRIPT_DIR/hook_handler.py" >> /tmp/hook-wrapper.log
 echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] SOCKETIO_PORT: $CLAUDE_MPM_SOCKETIO_PORT" >> /tmp/hook-wrapper.log
 
-# Run the Python hook handler (now optimized by default)
-exec "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@"
+# Run the Python hook handler with error handling
+# Use exec to replace the shell process, but wrap in error handling
+if ! "$PYTHON_CMD" "$SCRIPT_DIR/hook_handler.py" "$@" 2>/tmp/hook-error.log; then
+    # If the Python handler fails, always return continue to not block Claude
+    echo '{"action": "continue"}'
+    # Log the error for debugging
+    echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/hook-error.log" >> /tmp/hook-wrapper.log
+    exit 0
+fi

claude_mpm/hooks/memory_integration_hook.py

@@ -15,13 +15,29 @@ agent outputs because:
 import re
 from typing import Dict, Any, List
 from claude_mpm.hooks.base_hook import PreDelegationHook, PostDelegationHook, HookContext, HookResult
-from claude_mpm.services.agent_memory_manager import AgentMemoryManager
-from claude_mpm.services.socketio_server import get_socketio_server
 from claude_mpm.core.config import Config
 from claude_mpm.core.logger import get_logger
 
 logger = get_logger(__name__)
 
+# Try to import memory manager with fallback handling
+try:
+    from claude_mpm.services.agent_memory_manager import AgentMemoryManager
+    MEMORY_MANAGER_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"AgentMemoryManager not available: {e}")
+    MEMORY_MANAGER_AVAILABLE = False
+    AgentMemoryManager = None
+
+# 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
+
 
 class MemoryPreDelegationHook(PreDelegationHook):
     """Inject agent memory into delegation context.
@@ -42,7 +58,17 @@ class MemoryPreDelegationHook(PreDelegationHook):
         """
         super().__init__(name="memory_pre_delegation", priority=20)
         self.config = config or Config()
-        self.memory_manager = AgentMemoryManager(self.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: {e}")
+                self.memory_manager = None
+        else:
+            logger.info("Memory manager not available - hook will be inactive")
+            self.memory_manager = None
     
     def execute(self, context: HookContext) -> HookResult:
         """Add agent memory to delegation context.
@@ -50,6 +76,11 @@ class MemoryPreDelegationHook(PreDelegationHook):
         WHY: By loading memory before delegation, agents can reference their
         accumulated knowledge when performing tasks, leading to better outcomes.
         """
+        # If memory manager is not available, skip memory injection
+        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', '')
@@ -152,7 +183,17 @@ class MemoryPostDelegationHook(PostDelegationHook):
         """
         super().__init__(name="memory_post_delegation", priority=80)
         self.config = config or Config()
-        self.memory_manager = AgentMemoryManager(self.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}")
+                self.memory_manager = None
+        else:
+            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 = {
@@ -172,9 +213,14 @@ class MemoryPostDelegationHook(PostDelegationHook):
         WHY: Capturing learnings immediately after task completion ensures we
         don't lose valuable insights that agents discover during execution.
         """
+        # If memory manager is not available, skip learning extraction
+        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', False):
+            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

claude_mpm/scripts/socketio_daemon.py

@@ -43,11 +43,26 @@ def is_running():
         return False
 
 def start_server():
-    """Start the Socket.IO server as a daemon."""
+    """Start the Socket.IO server as a daemon with conflict detection."""
     if is_running():
-        print("Socket.IO server is already running.")
+        print("Socket.IO daemon server is already running.")
+        print(f"Use '{__file__} status' for details")
         return
     
+    # Check for HTTP-managed server conflict
+    try:
+        import requests
+        response = requests.get("http://localhost:8765/health", timeout=1.0)
+        if response.status_code == 200:
+            data = response.json()
+            if 'server_id' in data:
+                print(f"⚠️  HTTP-managed server already running: {data.get('server_id')}")
+                print(f"   Stop it first: socketio_server_manager.py stop --port 8765")
+                print(f"   Or diagnose: socketio_server_manager.py diagnose")
+                return
+    except:
+        pass  # No HTTP server, continue
+    
     ensure_dirs()
     
     # Fork to create daemon
@@ -96,9 +111,10 @@ def start_server():
         signal_handler(signal.SIGINT, None)
 
 def stop_server():
-    """Stop the Socket.IO server."""
+    """Stop the Socket.IO daemon server."""
     if not is_running():
-        print("Socket.IO server is not running.")
+        print("Socket.IO daemon server is not running.")
+        print(f"Check for other servers: socketio_server_manager.py status")
         return
     
     try:
@@ -125,11 +141,12 @@ def stop_server():
         print(f"Error stopping server: {e}")
 
 def status_server():
-    """Check server status."""
+    """Check server status with manager integration info."""
     if is_running():
         with open(PID_FILE) as f:
             pid = int(f.read().strip())
-        print(f"Socket.IO server is running (PID: {pid})")
+        print(f"Socket.IO daemon server is running (PID: {pid})")
+        print(f"PID file: {PID_FILE}")
         
         # Check if port is listening
         try:
@@ -138,13 +155,36 @@ def status_server():
             result = sock.connect_ex(('localhost', 8765))
             sock.close()
             if result == 0:
-                print("Server is listening on port 8765")
+                print("✅ Server is listening on port 8765")
+                print("🔧 Management style: daemon")
             else:
-                print("WARNING: Server process exists but port 8765 is not accessible")
+                print("⚠️ WARNING: Server process exists but port 8765 is not accessible")
+        except:
+            pass
+            
+        # Show management commands
+        print("\n🔧 Management Commands:")
+        print(f"   • Stop: {__file__} stop")
+        print(f"   • Restart: {__file__} restart")
+        
+        # Check for manager conflicts
+        try:
+            import requests
+            response = requests.get("http://localhost:8765/health", timeout=1.0)
+            if response.status_code == 200:
+                data = response.json()
+                if 'server_id' in data and data.get('server_id') != 'daemon-socketio':
+                    print(f"\n⚠️  POTENTIAL CONFLICT: HTTP-managed server also detected")
+                    print(f"   Server ID: {data.get('server_id')}")
+                    print(f"   Use 'socketio_server_manager.py diagnose' to resolve")
         except:
             pass
+            
     else:
-        print("Socket.IO server is not running")
+        print("Socket.IO daemon server is not running")
+        print(f"\n🔧 Start Commands:")
+        print(f"   • Daemon: {__file__} start")
+        print(f"   • HTTP-managed: socketio_server_manager.py start")
 
 def main():
     """Main entry point."""