claude-mpm 5.6.17__py3-none-any.whl → 5.6.33__py3-none-any.whl

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -3,15 +3,21 @@
 
 This module provides individual event handlers for different types of
 Claude Code hook events.
+
+Supports Dependency Injection:
+- Optional services can be passed via constructor
+- Lazy loading fallback for services not provided
+- Eliminates runtime imports inside methods
 """
 
+import asyncio
 import os
 import re
 import subprocess  # nosec B404 - subprocess used for safe claude CLI version checking only
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import Any, Callable, Optional
 
 # Import _log helper to avoid stderr writes (which cause hook errors)
 try:
@@ -42,6 +48,13 @@ except ImportError:
         extract_tool_results,
     )
 
+# Import correlation manager with fallback for direct execution
+# WHY at top level: Runtime relative imports fail with "no known parent package" error
+try:
+    from .correlation_manager import CorrelationManager
+except ImportError:
+    from correlation_manager import CorrelationManager
+
 # Debug mode - MUST match hook_handler.py default (false) to prevent stderr writes
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
@@ -54,13 +67,186 @@ except ImportError:
         QUICK_TIMEOUT = 2.0
 
 
+# ============================================================================
+# Optional Dependencies - loaded once at module level for DI
+# ============================================================================
+
+# Log manager (for agent prompt logging)
+_log_manager: Optional[Any] = None
+_log_manager_loaded = False
+
+
+def _get_log_manager() -> Optional[Any]:
+    """Get log manager with lazy loading."""
+    global _log_manager, _log_manager_loaded
+    if not _log_manager_loaded:
+        try:
+            from claude_mpm.core.log_manager import get_log_manager
+
+            _log_manager = get_log_manager()
+        except ImportError:
+            _log_manager = None
+        _log_manager_loaded = True
+    return _log_manager
+
+
+# Config service (for autotodos configuration)
+_config: Optional[Any] = None
+_config_loaded = False
+
+
+def _get_config() -> Optional[Any]:
+    """Get Config with lazy loading."""
+    global _config, _config_loaded
+    if not _config_loaded:
+        try:
+            from claude_mpm.core.config import Config
+
+            _config = Config()
+        except ImportError:
+            _config = None
+        _config_loaded = True
+    return _config
+
+
+# Autotodos function (for pending todos injection)
+_get_pending_todos_fn: Optional[Callable] = None
+_get_pending_todos_loaded = False
+
+
+def _get_pending_todos_func() -> Optional[Callable]:
+    """Get get_pending_todos function with lazy loading."""
+    global _get_pending_todos_fn, _get_pending_todos_loaded
+    if not _get_pending_todos_loaded:
+        try:
+            from claude_mpm.cli.commands.autotodos import get_pending_todos
+
+            _get_pending_todos_fn = get_pending_todos
+        except ImportError:
+            _get_pending_todos_fn = None
+        _get_pending_todos_loaded = True
+    return _get_pending_todos_fn
+
+
+# Delegation detector (for anti-pattern detection)
+_delegation_detector: Optional[Any] = None
+_delegation_detector_loaded = False
+
+
+def _get_delegation_detector_service() -> Optional[Any]:
+    """Get delegation detector with lazy loading."""
+    global _delegation_detector, _delegation_detector_loaded
+    if not _delegation_detector_loaded:
+        try:
+            from claude_mpm.services.delegation_detector import get_delegation_detector
+
+            _delegation_detector = get_delegation_detector()
+        except ImportError:
+            _delegation_detector = None
+        _delegation_detector_loaded = True
+    return _delegation_detector
+
+
+# Event log (for PM violation logging)
+_event_log: Optional[Any] = None
+_event_log_loaded = False
+
+
+def _get_event_log_service() -> Optional[Any]:
+    """Get event log with lazy loading."""
+    global _event_log, _event_log_loaded
+    if not _event_log_loaded:
+        try:
+            from claude_mpm.services.event_log import get_event_log
+
+            _event_log = get_event_log()
+        except ImportError:
+            _event_log = None
+        _event_log_loaded = True
+    return _event_log
+
+
 class EventHandlers:
-    """Collection of event handlers for different Claude Code hook events."""
+    """Collection of event handlers for different Claude Code hook events.
 
-    def __init__(self, hook_handler):
-        """Initialize with reference to the main hook handler."""
+    Supports dependency injection for optional services:
+    - log_manager: For agent prompt logging
+    - config: For autotodos configuration
+    - delegation_detector: For anti-pattern detection
+    - event_log: For PM violation logging
+
+    If services are not provided, they are loaded lazily on first use.
+    """
+
+    def __init__(
+        self,
+        hook_handler,
+        *,
+        log_manager: Optional[Any] = None,
+        config: Optional[Any] = None,
+        delegation_detector: Optional[Any] = None,
+        event_log: Optional[Any] = None,
+        get_pending_todos_fn: Optional[Callable] = None,
+    ):
+        """Initialize with reference to the main hook handler and optional services.
+
+        Args:
+            hook_handler: The main ClaudeHookHandler instance
+            log_manager: Optional LogManager for agent prompt logging
+            config: Optional Config for autotodos configuration
+            delegation_detector: Optional DelegationDetector for anti-pattern detection
+            event_log: Optional EventLog for PM violation logging
+            get_pending_todos_fn: Optional function to get pending todos
+        """
         self.hook_handler = hook_handler
 
+        # Store injected services (None means use lazy loading)
+        self._log_manager = log_manager
+        self._config = config
+        self._delegation_detector = delegation_detector
+        self._event_log = event_log
+        self._get_pending_todos_fn = get_pending_todos_fn
+
+    @property
+    def log_manager(self) -> Optional[Any]:
+        """Get log manager (injected or lazy loaded)."""
+        if self._log_manager is not None:
+            return self._log_manager
+        return _get_log_manager()
+
+    @property
+    def config(self) -> Optional[Any]:
+        """Get config (injected or lazy loaded)."""
+        if self._config is not None:
+            return self._config
+        return _get_config()
+
+    @property
+    def delegation_detector(self) -> Optional[Any]:
+        """Get delegation detector (injected or lazy loaded)."""
+        if self._delegation_detector is not None:
+            return self._delegation_detector
+        return _get_delegation_detector_service()
+
+    @property
+    def event_log(self) -> Optional[Any]:
+        """Get event log (injected or lazy loaded)."""
+        if self._event_log is not None:
+            return self._event_log
+        return _get_event_log_service()
+
+    def get_pending_todos(
+        self, max_todos: int = 10, working_dir: Optional[Path] = None
+    ) -> list:
+        """Get pending todos (using injected function or lazy loaded)."""
+        fn = self._get_pending_todos_fn or _get_pending_todos_func()
+        if fn is None:
+            return []
+        try:
+            return fn(max_todos=max_todos, working_dir=working_dir)
+        except Exception:
+            return []
+
     def handle_user_prompt_fast(self, event):
         """Handle user prompt with comprehensive data capture.
 
@@ -189,8 +375,6 @@ class EventHandlers:
 
         # Store tool_call_id using CorrelationManager for cross-process retrieval
         if session_id:
-            from .correlation_manager import CorrelationManager
-
             CorrelationManager.store(session_id, tool_call_id, tool_name)
             if DEBUG:
                 _log(
@@ -317,53 +501,50 @@ class EventHandlers:
         )
 
         # Log agent prompt if LogManager is available
-        try:
-            from claude_mpm.core.log_manager import get_log_manager
-
-            log_manager = get_log_manager()
-
-            # Prepare prompt content
-            prompt_content = tool_input.get("prompt", "")
-            if not prompt_content:
-                prompt_content = tool_input.get("description", "")
-
-            if prompt_content:
-                import asyncio
-
-                # Prepare metadata
-                metadata = {
-                    "agent_type": agent_type,
-                    "agent_id": f"{agent_type}_{session_id}",
-                    "session_id": session_id,
-                    "delegation_context": {
-                        "description": tool_input.get("description", ""),
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                }
+        # Uses injected log_manager or lazy-loaded module-level instance
+        log_manager = self.log_manager
+        if log_manager is not None:
+            try:
+                # Prepare prompt content
+                prompt_content = tool_input.get("prompt", "")
+                if not prompt_content:
+                    prompt_content = tool_input.get("description", "")
+
+                if prompt_content:
+                    # Prepare metadata
+                    metadata = {
+                        "agent_type": agent_type,
+                        "agent_id": f"{agent_type}_{session_id}",
+                        "session_id": session_id,
+                        "delegation_context": {
+                            "description": tool_input.get("description", ""),
+                            "timestamp": datetime.now(timezone.utc).isoformat(),
+                        },
+                    }
 
-                # Log the agent prompt asynchronously
-                try:
-                    loop = asyncio.get_running_loop()
-                    _task = asyncio.create_task(
-                        log_manager.log_prompt(
-                            f"agent_{agent_type}", prompt_content, metadata
-                        )
-                    )  # Fire-and-forget logging (ephemeral hook process)
-                except RuntimeError:
-                    # No running loop, create one
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                    loop.run_until_complete(
-                        log_manager.log_prompt(
-                            f"agent_{agent_type}", prompt_content, metadata
+                    # Log the agent prompt asynchronously
+                    try:
+                        loop = asyncio.get_running_loop()
+                        _task = asyncio.create_task(
+                            log_manager.log_prompt(
+                                f"agent_{agent_type}", prompt_content, metadata
+                            )
+                        )  # Fire-and-forget logging (ephemeral hook process)
+                    except RuntimeError:
+                        # No running loop, create one
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        loop.run_until_complete(
+                            log_manager.log_prompt(
+                                f"agent_{agent_type}", prompt_content, metadata
+                            )
                         )
-                    )
 
+                    if DEBUG:
+                        _log(f"  - Agent prompt logged for {agent_type}")
+            except Exception as e:
                 if DEBUG:
-                    _log(f"  - Agent prompt logged for {agent_type}")
-        except Exception as e:
-            if DEBUG:
-                _log(f"  - Could not log agent prompt: {e}")
+                    _log(f"  - Could not log agent prompt: {e}")
 
     def _get_git_branch(self, working_dir: Optional[str] = None) -> str:
         """Get git branch for the given directory with caching."""
@@ -447,8 +628,6 @@ class EventHandlers:
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
 
         # Retrieve tool_call_id using CorrelationManager for cross-process correlation
-        from .correlation_manager import CorrelationManager
-
         tool_call_id = CorrelationManager.retrieve(session_id) if session_id else None
         if DEBUG and tool_call_id:
             _log(
@@ -600,8 +779,6 @@ class EventHandlers:
                         warning = auto_pause.emit_threshold_warning(threshold_crossed)
                         # CRITICAL: Never write to stderr unconditionally - causes hook errors
                         # Use _log() instead which only writes to file if DEBUG=true
-                        from . import _log
-
                         _log(f"⚠️  Auto-pause threshold crossed: {warning}")
 
                         if DEBUG:
@@ -957,32 +1134,33 @@ class EventHandlers:
         }
 
         # Auto-inject pending autotodos if enabled
-        try:
-            from pathlib import Path
-
-            from claude_mpm.cli.commands.autotodos import get_pending_todos
-            from claude_mpm.core.config import Config
-
-            config = Config()
-            auto_inject_enabled = config.get("autotodos.auto_inject_on_startup", True)
-            max_todos = config.get("autotodos.max_todos_per_session", 10)
+        # Uses injected config and get_pending_todos or lazy-loaded instances
+        config = self.config
+        if config is not None:
+            try:
+                auto_inject_enabled = config.get(
+                    "autotodos.auto_inject_on_startup", True
+                )
+                max_todos = config.get("autotodos.max_todos_per_session", 10)
 
-            if auto_inject_enabled:
-                # Pass working directory from event to avoid Path.cwd() issues
-                working_dir_param = None
-                if working_dir:
-                    working_dir_param = Path(working_dir)
+                if auto_inject_enabled:
+                    # Pass working directory from event to avoid Path.cwd() issues
+                    working_dir_param = None
+                    if working_dir:
+                        working_dir_param = Path(working_dir)
 
-                pending_todos = get_pending_todos(
-                    max_todos=max_todos, working_dir=working_dir_param
-                )
-                if pending_todos:
-                    session_start_data["pending_autotodos"] = pending_todos
-                    session_start_data["autotodos_count"] = len(pending_todos)
-                    _log(f"  - Auto-injected {len(pending_todos)} pending autotodos")
-        except Exception as e:  # nosec B110
-            # Auto-injection is optional - continue if it fails
-            _log(f"  - Failed to auto-inject autotodos: {e}")
+                    pending_todos = self.get_pending_todos(
+                        max_todos=max_todos, working_dir=working_dir_param
+                    )
+                    if pending_todos:
+                        session_start_data["pending_autotodos"] = pending_todos
+                        session_start_data["autotodos_count"] = len(pending_todos)
+                        _log(
+                            f"  - Auto-injected {len(pending_todos)} pending autotodos"
+                        )
+            except Exception as e:  # nosec B110
+                # Auto-injection is optional - continue if it fails
+                _log(f"  - Failed to auto-inject autotodos: {e}")
 
         # Debug logging
         _log(f"Hook handler: Processing SessionStart - session: '{session_id}'")
@@ -1058,11 +1236,12 @@ class EventHandlers:
         - Delegation patterns = PM doing something WRONG → pm.violation (error)
         - Script failures = Something BROKEN → autotodo.error (todo)
         """
-        # Only scan if delegation detector is available
-        try:
-            from claude_mpm.services.delegation_detector import get_delegation_detector
-            from claude_mpm.services.event_log import get_event_log
-        except ImportError:
+        # Only scan if delegation detector and event log are available
+        # Uses injected services or lazy-loaded module-level instances
+        detector = self.delegation_detector
+        event_log_service = self.event_log
+
+        if detector is None or event_log_service is None:
             if DEBUG:
                 _log("Delegation detector or event log not available")
             return
@@ -1071,22 +1250,16 @@ class EventHandlers:
         if not response_text:
             return
 
-        # Get the delegation detector
-        detector = get_delegation_detector()
-
         # Detect delegation patterns
         detections = detector.detect_user_delegation(response_text)
 
         if not detections:
             return  # No patterns detected
 
-        # Get event log for violation recording
-        event_log = get_event_log()
-
         # Create PM violation events (NOT autotodos)
         for detection in detections:
             # Create event log entry as pm.violation
-            event_log.append_event(
+            event_log_service.append_event(
                 event_type="pm.violation",
                 payload={
                     "violation_type": "delegation_anti_pattern",

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -38,6 +38,7 @@ try:
     from .services import (
         ConnectionManagerService,
         DuplicateEventDetector,
+        HookServiceContainer,
         StateManagerService,
         SubagentResponseProcessor,
     )
@@ -55,10 +56,26 @@ except ImportError:
     from services import (
         ConnectionManagerService,
         DuplicateEventDetector,
+        HookServiceContainer,
         StateManagerService,
         SubagentResponseProcessor,
     )
 
+# Import CorrelationManager with fallback (used in _route_event cleanup)
+# WHY at top level: Runtime relative imports fail with "no known parent package" error
+try:
+    from .correlation_manager import CorrelationManager
+except ImportError:
+    try:
+        from correlation_manager import CorrelationManager
+    except ImportError:
+        # Fallback: create a no-op class if module unavailable
+        class CorrelationManager:
+            @staticmethod
+            def cleanup_old():
+                pass
+
+
 """
 Debug mode configuration for hook processing.
 
@@ -228,35 +245,69 @@ class ClaudeHookHandler:
     - Each service handles a specific responsibility
     - Easier to test, maintain, and extend
     - Reduced complexity in main handler class
+
+    Supports Dependency Injection:
+    - Pass a HookServiceContainer to override default services
+    - Useful for testing with mock services
+    - Maintains backward compatibility when no container is provided
     """
 
-    def __init__(self):
-        # Initialize services
-        self.state_manager = StateManagerService()
-        self.connection_manager = ConnectionManagerService()
-        self.duplicate_detector = DuplicateEventDetector()
+    def __init__(self, container: Optional[HookServiceContainer] = None):
+        """Initialize hook handler with optional DI container.
 
-        # Initialize extracted managers
-        self.memory_hook_manager = MemoryHookManager()
-        self.response_tracking_manager = ResponseTrackingManager()
-        self.event_handlers = EventHandlers(self)
+        Args:
+            container: Optional HookServiceContainer for dependency injection.
+                      If None, services are created directly (backward compatible).
+        """
+        # Use container if provided, otherwise create services directly
+        if container is not None:
+            # DI mode: get services from container
+            self._container = container
+            self.state_manager = container.get_state_manager()
+            self.connection_manager = container.get_connection_manager()
+            self.duplicate_detector = container.get_duplicate_detector()
+            self.memory_hook_manager = container.get_memory_hook_manager()
+            self.response_tracking_manager = container.get_response_tracking_manager()
+            self.auto_pause_handler = container.get_auto_pause_handler()
+
+            # Event handlers need reference to this handler (circular, but contained)
+            self.event_handlers = EventHandlers(self)
+
+            # Subagent processor with injected dependencies
+            self.subagent_processor = container.get_subagent_processor(
+                self.state_manager,
+                self.response_tracking_manager,
+                self.connection_manager,
+            )
+        else:
+            # Backward compatible mode: create services directly
+            self._container = None
+            self.state_manager = StateManagerService()
+            self.connection_manager = ConnectionManagerService()
+            self.duplicate_detector = DuplicateEventDetector()
+
+            # Initialize extracted managers
+            self.memory_hook_manager = MemoryHookManager()
+            self.response_tracking_manager = ResponseTrackingManager()
+            self.event_handlers = EventHandlers(self)
+
+            # Initialize subagent processor with dependencies
+            self.subagent_processor = SubagentResponseProcessor(
+                self.state_manager,
+                self.response_tracking_manager,
+                self.connection_manager,
+            )
 
-        # Initialize subagent processor with dependencies
-        self.subagent_processor = SubagentResponseProcessor(
-            self.state_manager, self.response_tracking_manager, self.connection_manager
-        )
+            # Initialize auto-pause handler
+            try:
+                self.auto_pause_handler = AutoPauseHandler()
+            except Exception as e:
+                self.auto_pause_handler = None
+                _log(f"Auto-pause initialization failed: {e}")
 
-        # Initialize auto-pause handler
-        try:
-            self.auto_pause_handler = AutoPauseHandler()
-            # Pass reference to ResponseTrackingManager so it can call auto_pause
-            if hasattr(self, "response_tracking_manager"):
-                self.response_tracking_manager.auto_pause_handler = (
-                    self.auto_pause_handler
-                )
-        except Exception as e:
-            self.auto_pause_handler = None
-            _log(f"Auto-pause initialization failed: {e}")
+        # Link auto-pause handler to response tracking manager
+        if self.auto_pause_handler and hasattr(self, "response_tracking_manager"):
+            self.response_tracking_manager.auto_pause_handler = self.auto_pause_handler
 
         # Backward compatibility properties for tests
         # Note: HTTP-based connection manager doesn't use connection_pool
@@ -329,8 +380,6 @@ class ClaudeHookHandler:
             if self.state_manager.increment_events_processed():
                 self.state_manager.cleanup_old_entries()
                 # Also cleanup old correlation files
-                from .correlation_manager import CorrelationManager
-
                 CorrelationManager.cleanup_old()
                 _log(
                     f"🧹 Performed cleanup after {self.state_manager.events_processed} events"
@@ -496,11 +545,11 @@ class ClaudeHookHandler:
         if modified_input is not None:
             # Claude Code v2.0.30+ supports modifying PreToolUse tool inputs
             print(
-                json.dumps({"action": "continue", "tool_input": modified_input}),
+                json.dumps({"continue": True, "tool_input": modified_input}),
                 flush=True,
             )
         else:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
 
     # Delegation methods for compatibility with event_handlers
     def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
@@ -673,7 +722,7 @@ def main():
         # This prevents errors on older Claude Code versions
         if version:
             _log(f"Skipping hook processing due to version incompatibility ({version})")
-        print(json.dumps({"action": "continue"}), flush=True)
+        print(json.dumps({"continue": True}), flush=True)
         sys.exit(0)
 
     def cleanup_handler(signum=None, frame=None):
@@ -682,7 +731,7 @@ def main():
         _log(f"Hook handler cleanup (pid: {os.getpid()}, signal: {signum})")
         # Only output continue if we haven't already (i.e., if interrupted by signal)
         if signum is not None and not _continue_printed:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
             _continue_printed = True
             sys.exit(0)
 
@@ -715,7 +764,7 @@ def main():
     except Exception as e:
         # Only output continue if not already printed
         if not _continue_printed:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
             _continue_printed = True
         # Log error for debugging
         _log(f"Hook handler error: {e}")
@@ -727,5 +776,5 @@ if __name__ == "__main__":
         main()
     except Exception:
         # Catastrophic failure (import error, etc.) - always output valid JSON
-        print(json.dumps({"action": "continue"}), flush=True)
+        print(json.dumps({"continue": True}), flush=True)
         sys.exit(0)