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

claude_mpm/hooks/claude_hooks/installer.py

@@ -149,7 +149,7 @@ main() {
         if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Claude MPM not found, continuing..." >> /tmp/claude-mpm-hook.log
         fi
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 
@@ -176,7 +176,7 @@ main() {
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/claude-mpm-hook-error.log" >> /tmp/claude-mpm-hook.log
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Error: $(cat /tmp/claude-mpm-hook-error.log 2>/dev/null | head -5)" >> /tmp/claude-mpm-hook.log
         fi
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 
@@ -203,10 +203,14 @@ main "$@"
         import logging
 
         self.logger = logging.getLogger(__name__)
-        self.claude_dir = Path.home() / ".claude"
+        # Use project-level paths, NEVER global ~/.claude/settings.json
+        # This ensures hooks are scoped to the current project only
+        self.project_root = Path.cwd()
+        self.claude_dir = self.project_root / ".claude"
         self.hooks_dir = self.claude_dir / "hooks"  # Kept for backward compatibility
-        # Use settings.json for hooks (Claude Code reads from this file)
-        self.settings_file = self.claude_dir / "settings.json"
+        # Use settings.local.json for project-level hook settings
+        # Claude Code reads project-level settings from .claude/settings.local.json
+        self.settings_file = self.claude_dir / "settings.local.json"
         # There is no legacy settings file - this was a bug where both pointed to same file
         # Setting to None to disable cleanup that was deleting freshly installed hooks
         self.old_settings_file = None
@@ -601,40 +605,98 @@ main "$@"
         # Hook configuration for each event type
         hook_command = {"type": "command", "command": str(hook_script_path.absolute())}
 
+        def is_our_hook(cmd: dict) -> bool:
+            """Check if a hook command belongs to claude-mpm."""
+            if cmd.get("type") != "command":
+                return False
+            command = cmd.get("command", "")
+            return "claude-hook-handler.sh" in command or command.endswith(
+                "claude-mpm-hook.sh"
+            )
+
+        def merge_hooks_for_event(
+            existing_hooks: list, new_hook_command: dict, use_matcher: bool = True
+        ) -> list:
+            """Merge new hook command into existing hooks without duplication.
+
+            Args:
+                existing_hooks: Current hooks configuration for an event type
+                new_hook_command: The claude-mpm hook command to add
+                use_matcher: Whether to include matcher: "*" in the config
+
+            Returns:
+                Updated hooks list with our hook merged in
+            """
+            # Check if our hook already exists in any existing hook config
+            our_hook_exists = False
+
+            for hook_config in existing_hooks:
+                if "hooks" in hook_config and isinstance(hook_config["hooks"], list):
+                    for hook in hook_config["hooks"]:
+                        if is_our_hook(hook):
+                            # Update existing hook command path (in case it changed)
+                            hook["command"] = new_hook_command["command"]
+                            our_hook_exists = True
+                            break
+                if our_hook_exists:
+                    break
+
+            if our_hook_exists:
+                # Our hook already exists, just return the updated list
+                return existing_hooks
+
+            # Our hook doesn't exist - need to add it
+            # Strategy: Add our hook to the first "*" matcher config, or create new config
+            added = False
+
+            for hook_config in existing_hooks:
+                # Check if this config has matcher: "*" (or no matcher for simple events)
+                matcher = hook_config.get("matcher")
+                if matcher == "*" or (not use_matcher and matcher is None):
+                    # Add our hook to this config's hooks array
+                    if "hooks" not in hook_config:
+                        hook_config["hooks"] = []
+                    hook_config["hooks"].append(new_hook_command)
+                    added = True
+                    break
+
+            if not added:
+                # No suitable config found, create a new one
+                if use_matcher:
+                    new_config = {"matcher": "*", "hooks": [new_hook_command]}
+                else:
+                    new_config = {"hooks": [new_hook_command]}
+                existing_hooks.append(new_config)
+
+            return existing_hooks
+
         # Tool-related events need a matcher string
         tool_events = ["PreToolUse", "PostToolUse"]
         for event_type in tool_events:
-            settings["hooks"][event_type] = [
-                {
-                    "matcher": "*",  # String value to match all tools
-                    "hooks": [hook_command],
-                }
-            ]
+            existing = settings["hooks"].get(event_type, [])
+            settings["hooks"][event_type] = merge_hooks_for_event(
+                existing, hook_command, use_matcher=True
+            )
 
         # Simple events (no subtypes, no matcher needed)
         simple_events = ["Stop", "SubagentStop", "SubagentStart"]
         for event_type in simple_events:
-            settings["hooks"][event_type] = [
-                {
-                    "hooks": [hook_command],
-                }
-            ]
+            existing = settings["hooks"].get(event_type, [])
+            settings["hooks"][event_type] = merge_hooks_for_event(
+                existing, hook_command, use_matcher=False
+            )
 
         # SessionStart needs matcher for subtypes (startup, resume)
-        settings["hooks"]["SessionStart"] = [
-            {
-                "matcher": "*",  # Match all SessionStart subtypes
-                "hooks": [hook_command],
-            }
-        ]
+        existing = settings["hooks"].get("SessionStart", [])
+        settings["hooks"]["SessionStart"] = merge_hooks_for_event(
+            existing, hook_command, use_matcher=True
+        )
 
         # UserPromptSubmit needs matcher for potential subtypes
-        settings["hooks"]["UserPromptSubmit"] = [
-            {
-                "matcher": "*",
-                "hooks": [hook_command],
-            }
-        ]
+        existing = settings["hooks"].get("UserPromptSubmit", [])
+        settings["hooks"]["UserPromptSubmit"] = merge_hooks_for_event(
+            existing, hook_command, use_matcher=True
+        )
 
         # Fix statusLine command to handle both output style schemas
         self._fix_status_line(settings)

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -67,7 +67,7 @@ from datetime import datetime, timezone
 from typing import Optional
 
 # Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Memory hooks integration
 MEMORY_HOOKS_AVAILABLE = False

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -22,7 +22,7 @@ except ImportError:
 
 
 # Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Response tracking integration
 # NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading

claude_mpm/hooks/claude_hooks/services/__init__.py

@@ -3,13 +3,34 @@
 # Use HTTP-based connection manager for stable dashboard communication
 # from .connection_manager import ConnectionManagerService  # Old SocketIO-based
 from .connection_manager_http import ConnectionManagerService  # New HTTP-based
+from .container import HookServiceContainer, get_container
 from .duplicate_detector import DuplicateEventDetector
+from .protocols import (
+    IAutoPauseHandler,
+    IConnectionManager,
+    IDuplicateDetector,
+    IEventHandlers,
+    IMemoryHookManager,
+    IResponseTrackingManager,
+    IStateManager,
+    ISubagentProcessor,
+)
 from .state_manager import StateManagerService
 from .subagent_processor import SubagentResponseProcessor
 
 __all__ = [
     "ConnectionManagerService",
     "DuplicateEventDetector",
+    "HookServiceContainer",
+    "IAutoPauseHandler",
+    "IConnectionManager",
+    "IDuplicateDetector",
+    "IEventHandlers",
+    "IMemoryHookManager",
+    "IResponseTrackingManager",
+    "IStateManager",
+    "ISubagentProcessor",
     "StateManagerService",
     "SubagentResponseProcessor",
+    "get_container",
 ]

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -29,8 +29,8 @@ except ImportError:
         pass  # Silent fallback
 
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Debug mode - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Import extracted modules with fallback for direct execution
 try:

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -28,8 +28,8 @@ except ImportError:
         pass  # Silent fallback
 
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Debug mode - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Import requests for HTTP POST communication
 try:

claude_mpm/hooks/claude_hooks/services/container.py

@@ -0,0 +1,310 @@
+"""Dependency Injection container for hook handler services.
+
+This module provides a DI container that manages service instantiation,
+lazy initialization, and service overriding for testing.
+
+WHY DI Container:
+- Centralized service management
+- Lazy initialization reduces startup overhead
+- Easy testing through service overriding
+- Clear dependency graph
+- Thread-safe singleton pattern
+"""
+
+import threading
+from typing import Any, Optional, TypeVar
+
+# Import service protocols for type hints
+from .protocols import (
+    IAutoPauseHandler,
+    IConnectionManager,
+    IDuplicateDetector,
+    IEventHandlers,
+    IMemoryHookManager,
+    IResponseTrackingManager,
+    IStateManager,
+    ISubagentProcessor,
+)
+
+T = TypeVar("T")
+
+
+class HookServiceContainer:
+    """Dependency injection container for hook handler services.
+
+    Features:
+    - Lazy initialization of services
+    - Thread-safe singleton pattern
+    - Service overriding for testing
+    - Automatic dependency resolution
+
+    Usage:
+        # Normal usage (services created lazily)
+        container = HookServiceContainer()
+        state_manager = container.get_state_manager()
+
+        # Testing usage (override services)
+        container = HookServiceContainer()
+        container.override_state_manager(mock_state_manager)
+        state_manager = container.get_state_manager()  # Returns mock
+
+        # Reset overrides
+        container.reset_overrides()
+    """
+
+    # Thread-safe singleton
+    _instance: Optional["HookServiceContainer"] = None
+    _lock = threading.Lock()
+
+    def __new__(cls) -> "HookServiceContainer":
+        """Thread-safe singleton pattern."""
+        if cls._instance is None:
+            with cls._lock:
+                # Double-check locking pattern
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self) -> None:
+        """Initialize container if not already initialized."""
+        if getattr(self, "_initialized", False):
+            return
+
+        # Service instances (lazily initialized)
+        self._state_manager: Optional[IStateManager] = None
+        self._connection_manager: Optional[IConnectionManager] = None
+        self._duplicate_detector: Optional[IDuplicateDetector] = None
+        self._response_tracking_manager: Optional[IResponseTrackingManager] = None
+        self._memory_hook_manager: Optional[IMemoryHookManager] = None
+        self._subagent_processor: Optional[ISubagentProcessor] = None
+        self._auto_pause_handler: Optional[IAutoPauseHandler] = None
+        self._event_handlers: Optional[IEventHandlers] = None
+
+        # Override factories for testing
+        self._overrides: dict[str, Any] = {}
+
+        # Lock for lazy initialization
+        self._init_lock = threading.Lock()
+
+        self._initialized = True
+
+    # =========================================================================
+    # Lazy Service Getters
+    # =========================================================================
+
+    def get_state_manager(self) -> IStateManager:
+        """Get or create StateManagerService instance."""
+        if "state_manager" in self._overrides:
+            return self._overrides["state_manager"]
+
+        if self._state_manager is None:
+            with self._init_lock:
+                if self._state_manager is None:
+                    from .state_manager import StateManagerService
+
+                    self._state_manager = StateManagerService()
+        return self._state_manager
+
+    def get_connection_manager(self) -> IConnectionManager:
+        """Get or create ConnectionManagerService instance."""
+        if "connection_manager" in self._overrides:
+            return self._overrides["connection_manager"]
+
+        if self._connection_manager is None:
+            with self._init_lock:
+                if self._connection_manager is None:
+                    from .connection_manager_http import ConnectionManagerService
+
+                    self._connection_manager = ConnectionManagerService()
+        return self._connection_manager
+
+    def get_duplicate_detector(self) -> IDuplicateDetector:
+        """Get or create DuplicateEventDetector instance."""
+        if "duplicate_detector" in self._overrides:
+            return self._overrides["duplicate_detector"]
+
+        if self._duplicate_detector is None:
+            with self._init_lock:
+                if self._duplicate_detector is None:
+                    from .duplicate_detector import DuplicateEventDetector
+
+                    self._duplicate_detector = DuplicateEventDetector()
+        return self._duplicate_detector
+
+    def get_response_tracking_manager(self) -> IResponseTrackingManager:
+        """Get or create ResponseTrackingManager instance."""
+        if "response_tracking_manager" in self._overrides:
+            return self._overrides["response_tracking_manager"]
+
+        if self._response_tracking_manager is None:
+            with self._init_lock:
+                if self._response_tracking_manager is None:
+                    from ..response_tracking import ResponseTrackingManager
+
+                    self._response_tracking_manager = ResponseTrackingManager()
+        return self._response_tracking_manager
+
+    def get_memory_hook_manager(self) -> IMemoryHookManager:
+        """Get or create MemoryHookManager instance."""
+        if "memory_hook_manager" in self._overrides:
+            return self._overrides["memory_hook_manager"]
+
+        if self._memory_hook_manager is None:
+            with self._init_lock:
+                if self._memory_hook_manager is None:
+                    from ..memory_integration import MemoryHookManager
+
+                    self._memory_hook_manager = MemoryHookManager()
+        return self._memory_hook_manager
+
+    def get_auto_pause_handler(self) -> Optional[IAutoPauseHandler]:
+        """Get or create AutoPauseHandler instance.
+
+        Returns None if initialization fails (auto-pause is optional).
+        """
+        if "auto_pause_handler" in self._overrides:
+            return self._overrides["auto_pause_handler"]
+
+        if self._auto_pause_handler is None:
+            with self._init_lock:
+                if self._auto_pause_handler is None:
+                    try:
+                        from ..auto_pause_handler import AutoPauseHandler
+
+                        self._auto_pause_handler = AutoPauseHandler()
+                    except Exception:
+                        # Auto-pause is optional
+                        self._auto_pause_handler = None
+        return self._auto_pause_handler
+
+    def get_subagent_processor(
+        self,
+        state_manager: Optional[IStateManager] = None,
+        response_tracking_manager: Optional[IResponseTrackingManager] = None,
+        connection_manager: Optional[IConnectionManager] = None,
+    ) -> ISubagentProcessor:
+        """Get or create SubagentResponseProcessor instance.
+
+        Args:
+            state_manager: Optional override for state manager
+            response_tracking_manager: Optional override for response tracking
+            connection_manager: Optional override for connection manager
+        """
+        if "subagent_processor" in self._overrides:
+            return self._overrides["subagent_processor"]
+
+        if self._subagent_processor is None:
+            with self._init_lock:
+                if self._subagent_processor is None:
+                    from .subagent_processor import SubagentResponseProcessor
+
+                    # Use provided dependencies or get from container
+                    sm = state_manager or self.get_state_manager()
+                    rtm = (
+                        response_tracking_manager
+                        or self.get_response_tracking_manager()
+                    )
+                    cm = connection_manager or self.get_connection_manager()
+
+                    self._subagent_processor = SubagentResponseProcessor(sm, rtm, cm)
+        return self._subagent_processor
+
+    def get_event_handlers(self, hook_handler: Any = None) -> IEventHandlers:
+        """Get or create EventHandlers instance.
+
+        Args:
+            hook_handler: The ClaudeHookHandler instance for backward compatibility.
+                         In the future, this will be replaced with proper DI.
+        """
+        if "event_handlers" in self._overrides:
+            return self._overrides["event_handlers"]
+
+        if self._event_handlers is None:
+            with self._init_lock:
+                if self._event_handlers is None:
+                    from ..event_handlers import EventHandlers
+
+                    if hook_handler is None:
+                        raise ValueError(
+                            "hook_handler is required to create EventHandlers"
+                        )
+                    self._event_handlers = EventHandlers(hook_handler)
+        return self._event_handlers
+
+    # =========================================================================
+    # Service Override Methods (for testing)
+    # =========================================================================
+
+    def override_state_manager(self, service: IStateManager) -> None:
+        """Override state manager with a mock or custom implementation."""
+        self._overrides["state_manager"] = service
+
+    def override_connection_manager(self, service: IConnectionManager) -> None:
+        """Override connection manager with a mock or custom implementation."""
+        self._overrides["connection_manager"] = service
+
+    def override_duplicate_detector(self, service: IDuplicateDetector) -> None:
+        """Override duplicate detector with a mock or custom implementation."""
+        self._overrides["duplicate_detector"] = service
+
+    def override_response_tracking_manager(
+        self, service: IResponseTrackingManager
+    ) -> None:
+        """Override response tracking manager with a mock or custom implementation."""
+        self._overrides["response_tracking_manager"] = service
+
+    def override_memory_hook_manager(self, service: IMemoryHookManager) -> None:
+        """Override memory hook manager with a mock or custom implementation."""
+        self._overrides["memory_hook_manager"] = service
+
+    def override_subagent_processor(self, service: ISubagentProcessor) -> None:
+        """Override subagent processor with a mock or custom implementation."""
+        self._overrides["subagent_processor"] = service
+
+    def override_auto_pause_handler(self, service: Optional[IAutoPauseHandler]) -> None:
+        """Override auto-pause handler with a mock or custom implementation."""
+        self._overrides["auto_pause_handler"] = service
+
+    def override_event_handlers(self, service: IEventHandlers) -> None:
+        """Override event handlers with a mock or custom implementation."""
+        self._overrides["event_handlers"] = service
+
+    def reset_overrides(self) -> None:
+        """Reset all service overrides."""
+        self._overrides.clear()
+
+    def reset_all(self) -> None:
+        """Reset all services and overrides.
+
+        Useful for testing to ensure clean state between tests.
+        """
+        self._state_manager = None
+        self._connection_manager = None
+        self._duplicate_detector = None
+        self._response_tracking_manager = None
+        self._memory_hook_manager = None
+        self._subagent_processor = None
+        self._auto_pause_handler = None
+        self._event_handlers = None
+        self._overrides.clear()
+
+    @classmethod
+    def reset_singleton(cls) -> None:
+        """Reset the singleton instance.
+
+        USE WITH CAUTION: This is primarily for testing.
+        """
+        with cls._lock:
+            if cls._instance is not None:
+                cls._instance.reset_all()
+            cls._instance = None
+
+
+def get_container() -> HookServiceContainer:
+    """Get the global HookServiceContainer singleton.
+
+    Returns:
+        The singleton HookServiceContainer instance.
+    """
+    return HookServiceContainer()