claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -9,7 +9,8 @@ import os
 import re
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # Import tool analysis with fallback for direct execution
@@ -77,7 +78,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "is_command": prompt.startswith("/"),
             "contains_code": "```" in prompt
             or "python" in prompt.lower()
@@ -101,7 +102,7 @@ class EventHandlers:
             if session_id:
                 self.hook_handler.pending_prompts[session_id] = {
                     "prompt": prompt,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "working_directory": working_dir,
                 }
                 if DEBUG:
@@ -150,7 +151,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "parameter_count": len(tool_input) if isinstance(tool_input, dict) else 0,
             "is_file_operation": tool_name
             in ["Write", "Edit", "MultiEdit", "Read", "LS", "Glob"],
@@ -249,7 +250,7 @@ class EventHandlers:
             "session_id": session_id,
             "prompt": tool_input.get("prompt", ""),
             "description": tool_input.get("description", ""),
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "hook_event_name": "SubagentStart",  # For dashboard compatibility
         }
         self.hook_handler._emit_socketio_event(
@@ -277,18 +278,18 @@ class EventHandlers:
                     "session_id": session_id,
                     "delegation_context": {
                         "description": tool_input.get("description", ""),
-                        "timestamp": datetime.now().isoformat(),
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
                     },
                 }
 
                 # Log the agent prompt asynchronously
                 try:
                     loop = asyncio.get_running_loop()
-                    asyncio.create_task(
+                    _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()
@@ -309,23 +310,25 @@ class EventHandlers:
         """Get git branch for the given directory with caching."""
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
-        # Check cache first (cache for 30 seconds)
-        current_time = datetime.now().timestamp()
+        # Check cache first (cache for 300 seconds = 5 minutes)
+        # WHY 5 minutes: Git branches rarely change during development sessions,
+        # reducing subprocess overhead significantly without staleness issues
+        current_time = datetime.now(timezone.utc).timestamp()
         cache_key = working_dir
 
         if (
             cache_key in self.hook_handler._git_branch_cache
             and cache_key in self.hook_handler._git_branch_cache_time
-            and current_time - self.hook_handler._git_branch_cache_time[cache_key] < 30
+            and current_time - self.hook_handler._git_branch_cache_time[cache_key] < 300
         ):
             return self.hook_handler._git_branch_cache[cache_key]
 
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch
@@ -390,14 +393,16 @@ class EventHandlers:
             "status": (
                 "success"
                 if exit_code == 0
-                else "blocked" if exit_code == 2 else "error"
+                else "blocked"
+                if exit_code == 2
+                else "error"
             ),
             "duration_ms": duration,
             "result_summary": result_data,
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "has_output": bool(result_data.get("output")),
             "has_error": bool(result_data.get("error")),
             "output_size": (
@@ -448,7 +453,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "is_user_input_request": "input" in message.lower()
             or "waiting" in message.lower(),
             "is_error_notification": "error" in message.lower()
@@ -492,7 +497,7 @@ class EventHandlers:
         """Extract metadata from stop event."""
         working_dir = event.get("cwd", "")
         return {
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "working_directory": working_dir,
             "git_branch": (
                 self._get_git_branch(working_dir) if working_dir else "Unknown"
@@ -639,7 +644,7 @@ class EventHandlers:
                     "has_error": reason in ["error", "timeout", "failed", "blocked"],
                     "working_directory": working_dir,
                     "git_branch": git_branch,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "event_type": "subagent_stop",
                     "reason": reason,
                     "original_request_timestamp": request_info.get("timestamp"),
@@ -715,7 +720,7 @@ class EventHandlers:
             "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "contains_code": "```" in response_text,
             "contains_json": "```json" in response_text,
             "hook_event_name": "AssistantResponse",  # Explicitly set for dashboard

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -3,7 +3,7 @@
 
 This handler uses a service-oriented architecture with:
 - StateManagerService: Manages state and delegation tracking
-- ConnectionManagerService: Handles SocketIO and EventBus connections
+- ConnectionManagerService: Handles SocketIO connections with HTTP fallback
 - SubagentResponseProcessor: Processes complex subagent responses
 - DuplicateEventDetector: Detects and filters duplicate events
 
@@ -25,7 +25,7 @@ import signal
 import subprocess
 import sys
 import threading
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional, Tuple
 
 # Import extracted modules with fallback for direct execution
@@ -73,19 +73,10 @@ DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 Conditional imports with graceful fallbacks for testing and modularity.
 
 WHY conditional imports:
-- EventBus is optional for basic hook functionality
 - Tests may not have full environment setup
 - Allows hooks to work in minimal configurations
 - Graceful degradation when dependencies unavailable
 """
-# Import EventBus availability flag for backward compatibility with tests
-try:
-    from claude_mpm.services.event_bus import EventBus
-
-    EVENTBUS_AVAILABLE = True
-except ImportError:
-    EVENTBUS_AVAILABLE = False
-    EventBus = None
 
 # Import get_connection_pool for backward compatibility with tests
 try:
@@ -241,7 +232,6 @@ class ClaudeHookHandler:
 
         # Backward compatibility properties for tests
         self.connection_pool = self.connection_manager.connection_pool
-        self.event_bus = self.connection_manager.event_bus
 
         # Expose state manager properties for backward compatibility
         self.active_delegations = self.state_manager.active_delegations
@@ -294,7 +284,7 @@ class ClaudeHookHandler:
             if self.duplicate_detector.is_duplicate(event):
                 if DEBUG:
                     print(
-                        f"[{datetime.now().isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
+                        f"[{datetime.now(timezone.utc).isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
                         file=sys.stderr,
                     )
                 # Still need to output continue for this invocation
@@ -307,7 +297,7 @@ class ClaudeHookHandler:
             if DEBUG:
                 hook_type = event.get("hook_event_name", "unknown")
                 print(
-                    f"\n[{datetime.now().isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})",
+                    f"\n[{datetime.now(timezone.utc).isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})",
                     file=sys.stderr,
                 )
 
@@ -321,11 +311,12 @@ class ClaudeHookHandler:
                     )
 
             # Route event to appropriate handler
-            self._route_event(event)
+            # Handlers can optionally return modified input for PreToolUse events
+            modified_input = self._route_event(event)
 
             # Always continue execution (only if not already sent)
             if not _continue_sent:
-                self._continue_execution()
+                self._continue_execution(modified_input)
                 _continue_sent = True
 
         except Exception:
@@ -386,7 +377,7 @@ class ClaudeHookHandler:
                 print(f"Error reading hook event: {e}", file=sys.stderr)
             return None
 
-    def _route_event(self, event: dict) -> None:
+    def _route_event(self, event: dict) -> Optional[dict]:
         """
         Route event to appropriate handler based on type.
 
@@ -395,6 +386,9 @@ class ClaudeHookHandler:
 
         Args:
             event: Hook event dictionary
+
+        Returns:
+            Modified input for PreToolUse events (v2.0.30+), None otherwise
         """
         # Try multiple field names for compatibility
         hook_type = (
@@ -426,23 +420,36 @@ class ClaudeHookHandler:
         handler = event_handlers.get(hook_type)
         if handler:
             try:
-                handler(event)
+                # Handlers can optionally return modified input
+                result = handler(event)
+                # Only PreToolUse handlers should return modified input
+                if hook_type == "PreToolUse" and result is not None:
+                    return result
             except Exception as e:
                 if DEBUG:
                     print(f"Error handling {hook_type}: {e}", file=sys.stderr)
 
+        return None
+
     def handle_subagent_stop(self, event: dict):
         """Delegate subagent stop processing to the specialized processor."""
         self.subagent_processor.process_subagent_stop(event)
 
-    def _continue_execution(self) -> None:
+    def _continue_execution(self, modified_input: Optional[dict] = None) -> None:
         """
-        Send continue action to Claude.
+        Send continue action to Claude with optional input modification.
 
         WHY: Centralized response ensures consistent format
         and makes it easier to add response modifications.
+
+        Args:
+            modified_input: Modified tool parameters for PreToolUse hooks (v2.0.30+)
         """
-        print(json.dumps({"action": "continue"}))
+        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}))
+        else:
+            print(json.dumps({"action": "continue"}))
 
     # Delegation methods for compatibility with event_handlers
     def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
@@ -471,7 +478,7 @@ class ClaudeHookHandler:
         if hasattr(self, "connection_manager") and self.connection_manager:
             try:
                 self.connection_manager.cleanup()
-            except:
+            except Exception:
                 pass  # Ignore cleanup errors during destruction
 
 

claude_mpm/hooks/claude_hooks/installer.py

@@ -37,7 +37,7 @@ find_claude_mpm() {
             cmd_path=$(readlink -f "$cmd_path")
         fi
         # Extract the base directory (usually site-packages or venv)
-        local base_dir=$(python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+        local base_dir=$(python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
         if [ -n "$base_dir" ]; then
             echo "$base_dir"
             return 0
@@ -71,7 +71,7 @@ try:
     import claude_mpm
     import os
     # Get the package directory
-    pkg_dir = os.path.dirname(claude_mpm.__file__)
+    pkg_dir = Path(claude_mpm.__file__).parent
     # Check if we're in a development install (src directory)
     if 'src' in pkg_dir:
         # Go up to find the project root
@@ -81,11 +81,11 @@ try:
             project_root = os.sep.join(parts[:src_idx])
             print(project_root)
         else:
-            print(os.path.dirname(os.path.dirname(pkg_dir)))
+            print(Path(os.path.dirname(pkg_dir).parent))
     else:
         # Installed package - just return the package location
-        print(os.path.dirname(pkg_dir))
-except:
+        print(Path(pkg_dir).parent)
+except Exception:
     pass
 " 2>/dev/null)
 
@@ -99,7 +99,7 @@ except:
     for path_dir in $PATH; do
         if [ -f "$path_dir/claude-mpm" ]; then
             # Found claude-mpm executable, try to find its package
-            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
             if [ -n "$pkg_dir" ]; then
                 echo "$pkg_dir"
                 return 0
@@ -192,6 +192,8 @@ main "$@"
 
     # Minimum Claude Code version required for hook monitoring
     MIN_CLAUDE_VERSION = "1.0.92"
+    # Minimum version for PreToolUse input modification support
+    MIN_PRETOOL_MODIFY_VERSION = "2.0.30"
 
     def __init__(self):
         """Initialize the hook installer."""
@@ -292,6 +294,42 @@ main "$@"
 
         return (True, f"Claude Code {version} is compatible with hook monitoring.")
 
+    def supports_pretool_modify(self) -> bool:
+        """
+        Check if the installed Claude Code version supports PreToolUse input modification.
+
+        PreToolUse input modification was added in Claude Code v2.0.30.
+
+        Returns:
+            True if version supports input modification, False otherwise
+        """
+        version = self.get_claude_version()
+
+        if version is None:
+            return False
+
+        def parse_version(v: str) -> List[int]:
+            """Parse semantic version string to list of integers."""
+            try:
+                return [int(x) for x in v.split(".")]
+            except (ValueError, AttributeError):
+                return [0]
+
+        current = parse_version(version)
+        required = parse_version(self.MIN_PRETOOL_MODIFY_VERSION)
+
+        # Compare versions
+        for i in range(max(len(current), len(required))):
+            curr_part = current[i] if i < len(current) else 0
+            req_part = required[i] if i < len(required) else 0
+
+            if curr_part < req_part:
+                return False
+            if curr_part > req_part:
+                return True
+
+        return True
+
     def get_hook_script_path(self) -> Path:
         """Get the path to the hook handler script based on installation method.
 
@@ -339,8 +377,8 @@ main "$@"
 
         # Make sure it's executable
         if script_path.exists():
-            st = os.stat(script_path)
-            os.chmod(script_path, st.st_mode | stat.S_IEXEC)
+            st = Path(script_path).stat()
+            Path(script_path).chmod(st.st_mode | stat.S_IEXEC)
             self._hook_script_path = script_path
             return script_path
 
@@ -428,7 +466,7 @@ main "$@"
             return
 
         try:
-            with open(self.old_settings_file) as f:
+            with self.old_settings_file.open() as f:
                 old_settings = json.load(f)
 
             # Remove hooks section if present
@@ -437,7 +475,7 @@ main "$@"
                 self.logger.info(f"Removing hooks from {self.old_settings_file}")
 
                 # Write back the cleaned settings
-                with open(self.old_settings_file, "w") as f:
+                with self.old_settings_file.open("w") as f:
                     json.dump(old_settings, f, indent=2)
 
                 self.logger.info(f"Cleaned up hooks from {self.old_settings_file}")
@@ -450,7 +488,7 @@ main "$@"
 
         # Load existing settings.json or create new
         if self.settings_file.exists():
-            with open(self.settings_file) as f:
+            with self.settings_file.open() as f:
                 settings = json.load(f)
             self.logger.info(f"Found existing Claude settings at {self.settings_file}")
         else:
@@ -490,7 +528,7 @@ main "$@"
             ]
 
         # Write settings to settings.json
-        with open(self.settings_file, "w") as f:
+        with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)
 
         self.logger.info(f"Updated Claude settings at {self.settings_file}")
@@ -564,7 +602,7 @@ main "$@"
             issues.append(f"Claude settings file not found at {self.settings_file}")
         else:
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
 
                 if "hooks" not in settings:
@@ -588,9 +626,9 @@ main "$@"
                 issues.append(f"Invalid Claude settings JSON: {e}")
 
         # Check if claude-mpm is accessible
-        try:
-            import claude_mpm
-        except ImportError:
+        import importlib.util
+
+        if importlib.util.find_spec("claude_mpm") is None:
             issues.append("claude-mpm package not found in Python environment")
 
         is_valid = len(issues) == 0
@@ -615,7 +653,7 @@ main "$@"
             # Remove from Claude settings (both old and new locations)
             for settings_path in [self.settings_file, self.old_settings_file]:
                 if settings_path.exists():
-                    with open(settings_path) as f:
+                    with settings_path.open() as f:
                         settings = json.load(f)
 
                     if "hooks" in settings:
@@ -655,7 +693,7 @@ main "$@"
                             del settings["hooks"]
 
                         # Write back settings
-                        with open(settings_path, "w") as f:
+                        with settings_path.open("w") as f:
                             json.dump(settings, f, indent=2)
 
                         self.logger.info(f"Removed hooks from {settings_path}")
@@ -677,6 +715,7 @@ main "$@"
         # Check version compatibility
         claude_version = self.get_claude_version()
         is_compatible, version_message = self.is_version_compatible()
+        pretool_modify_supported = self.supports_pretool_modify()
 
         is_valid, issues = self.verify_hooks()
 
@@ -701,6 +740,12 @@ main "$@"
             "version_compatible": is_compatible,
             "version_message": version_message,
             "deployment_type": "deployment-root",  # New field to indicate new architecture
+            "pretool_modify_supported": pretool_modify_supported,  # v2.0.30+ feature
+            "pretool_modify_message": (
+                f"PreToolUse input modification supported (v{claude_version})"
+                if pretool_modify_supported
+                else f"PreToolUse input modification requires Claude Code {self.MIN_PRETOOL_MODIFY_VERSION}+ (current: {claude_version or 'unknown'})"
+            ),
         }
 
         # Check Claude settings for hook configuration
@@ -709,18 +754,18 @@ main "$@"
 
         if self.settings_file.exists():
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
                     if "hooks" in settings:
                         status["configured_events"] = list(settings["hooks"].keys())
                         configured_in_local = True
-            except:
+            except Exception:
                 pass
 
         # Also check old settings file
         if self.old_settings_file.exists():
             try:
-                with open(self.old_settings_file) as f:
+                with self.old_settings_file.open() as f:
                     old_settings = json.load(f)
                     if "hooks" in old_settings:
                         status["old_file_has_hooks"] = True
@@ -728,7 +773,7 @@ main "$@"
                             status["warning"] = (
                                 "Hooks found in settings.local.json but Claude Code reads from settings.json"
                             )
-            except:
+            except Exception:
                 pass
 
         status["settings_location"] = (

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -7,7 +7,7 @@ including pre and post delegation hooks.
 
 import os
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 # Debug mode
@@ -122,7 +122,7 @@ class MemoryHookManager:
                     "session_id": session_id,
                 },
                 metadata={"source": "claude_hook_handler", "tool_name": "Task"},
-                timestamp=datetime.now().isoformat(),
+                timestamp=datetime.now(timezone.utc).isoformat(),
                 session_id=session_id,
             )
 
@@ -200,7 +200,7 @@ class MemoryHookManager:
                     "tool_name": "Task",
                     "duration_ms": event.get("duration_ms", 0),
                 },
-                timestamp=datetime.now().isoformat(),
+                timestamp=datetime.now(timezone.utc).isoformat(),
                 session_id=session_id,
             )