claude-mpm 3.3.0__py3-none-any.whl → 3.4.0__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()
         
@@ -95,7 +104,7 @@ class ClaudeRunner:
             except Exception as e:
                 self.logger.debug(f"Failed to create session log file: {e}")
         
-        # Initialize WebSocket server reference
+        # Initialize Socket.IO server reference
         self.websocket_server = None
     
     def setup_agents(self) -> bool:
@@ -152,13 +161,14 @@ class ClaudeRunner:
     
     def run_interactive(self, initial_context: Optional[str] = None):
         """Run Claude in interactive mode."""
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -171,7 +181,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Get version
@@ -329,13 +339,14 @@ class ClaudeRunner:
         """Run Claude with a single prompt and return success status."""
         start_time = time.time()
         
-        # Start WebSocket server if enabled
+        # Connect to Socket.IO server if enabled
         if self.enable_websocket:
             try:
-                # Lazy import to avoid circular dependencies
-                from claude_mpm.services.websocket_server import WebSocketServer
-                self.websocket_server = WebSocketServer(port=self.websocket_port)
+                # Use Socket.IO client proxy to connect to monitoring server
+                from claude_mpm.services.socketio_server import SocketIOClientProxy
+                self.websocket_server = SocketIOClientProxy(port=self.websocket_port)
                 self.websocket_server.start()
+                self.logger.info("Connected to Socket.IO monitoring server")
                 
                 # Generate session ID
                 session_id = str(uuid.uuid4())
@@ -348,7 +359,7 @@ class ClaudeRunner:
                     working_dir=working_dir
                 )
             except Exception as e:
-                self.logger.warning(f"Failed to start WebSocket server: {e}")
+                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Check for /mpm: commands
@@ -739,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
@@ -31,13 +55,7 @@ except ImportError:
     SOCKETIO_AVAILABLE = False
     socketio = None
 
-# Fallback imports
-try:
-    from ...services.websocket_server import get_server_instance
-    SERVER_AVAILABLE = True
-except ImportError:
-    SERVER_AVAILABLE = False
-    get_server_instance = None
+# No fallback needed - we only use Socket.IO now
 
 
 class ClaudeHookHandler:
@@ -65,14 +83,14 @@ class ClaudeHookHandler:
         self._git_branch_cache = {}
         self._git_branch_cache_time = {}
         
-        # Initialize fallback server instance if available (but don't start it)
-        if SERVER_AVAILABLE:
-            try:
-                self.websocket_server = get_server_instance()
-            except:
-                self.websocket_server = None
-        else:
-            self.websocket_server = None
+        # 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):
         """Track a new agent delegation."""
@@ -113,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.
         
@@ -291,17 +352,6 @@ class ClaudeHookHandler:
                     print(f"Socket.IO emit failed: {e}", file=sys.stderr)
                 # Mark as disconnected so next call will reconnect
                 self.sio_connected = False
-        
-        # Fallback to legacy WebSocket server
-        elif hasattr(self, 'websocket_server') and self.websocket_server:
-            try:
-                # Map to legacy event format
-                legacy_event = f"hook.{event}"
-                self.websocket_server.broadcast_event(legacy_event, data)
-                if DEBUG:
-                    print(f"Emitted legacy event: {legacy_event}", file=sys.stderr)
-            except:
-                pass  # Silent failure
     
     def _handle_user_prompt_fast(self, event):
         """Handle user prompt with comprehensive data capture.
@@ -390,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)
     
@@ -431,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:
@@ -735,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:
@@ -745,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

@@ -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/services/__init__.py

@@ -1,15 +1,33 @@
 """Services for Claude MPM."""
 
-from .ticket_manager import TicketManager
-from .agent_deployment import AgentDeploymentService
-from .agent_memory_manager import AgentMemoryManager, get_memory_manager
-from .hook_service import HookService
+# Use lazy imports to prevent circular dependency issues
+def __getattr__(name):
+    """Lazy import to prevent circular dependencies."""
+    if name == "TicketManager":
+        from .ticket_manager import TicketManager
+        return TicketManager
+    elif name == "AgentDeploymentService":
+        from .agent_deployment import AgentDeploymentService
+        return AgentDeploymentService
+    elif name == "AgentMemoryManager":
+        from .agent_memory_manager import AgentMemoryManager
+        return AgentMemoryManager
+    elif name == "get_memory_manager":
+        from .agent_memory_manager import get_memory_manager
+        return get_memory_manager
+    elif name == "HookService":
+        from .hook_service import HookService
+        return HookService
+    elif name == "ProjectAnalyzer":
+        from .project_analyzer import ProjectAnalyzer
+        return ProjectAnalyzer
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
-# Import other services as needed
 __all__ = [
     "TicketManager",
     "AgentDeploymentService",
     "AgentMemoryManager",
     "get_memory_manager",
     "HookService",
+    "ProjectAnalyzer",
 ]