claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/hooks/claude_hooks/hook_handler_eventbus.py

@@ -24,6 +24,7 @@ import time
 from collections import deque
 from datetime import datetime
 from pathlib import Path
+from typing import Optional
 
 # Add parent path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
@@ -31,6 +32,7 @@ sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
 # Import EventBus
 try:
     from claude_mpm.services.event_bus import EventBus
+
     EVENTBUS_AVAILABLE = True
 except ImportError:
     EVENTBUS_AVAILABLE = False
@@ -44,16 +46,23 @@ except ImportError:
     class EventNormalizer:
         def normalize(self, event_data, source="hook"):
             """Simple fallback normalizer that returns event as-is."""
-            return type('NormalizedEvent', (), {
-                'to_dict': lambda: {
-                    'event': 'claude_event',
-                    'type': event_data.get('type', 'unknown'),
-                    'subtype': event_data.get('subtype', 'generic'),
-                    'timestamp': event_data.get('timestamp', datetime.now().isoformat()),
-                    'data': event_data.get('data', event_data),
-                    'source': source
-                }
-            })
+            return type(
+                "NormalizedEvent",
+                (),
+                {
+                    "to_dict": lambda: {
+                        "event": "claude_event",
+                        "type": event_data.get("type", "unknown"),
+                        "subtype": event_data.get("subtype", "generic"),
+                        "timestamp": event_data.get(
+                            "timestamp", datetime.now().isoformat()
+                        ),
+                        "data": event_data.get("data", event_data),
+                        "source": source,
+                    }
+                },
+            )
+
 
 # Import constants for configuration
 try:
@@ -63,16 +72,17 @@ except ImportError:
     class TimeoutConfig:
         QUICK_TIMEOUT = 2.0
 
+
 # Import other handler modules
 try:
+    from .event_handlers import EventHandlers
     from .memory_integration import MemoryHookManager
     from .response_tracking import ResponseTrackingManager
-    from .event_handlers import EventHandlers
 except ImportError:
     # Fallback for direct execution
+    from event_handlers import EventHandlers
     from memory_integration import MemoryHookManager
     from response_tracking import ResponseTrackingManager
-    from event_handlers import EventHandlers
 
 # Debug mode is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
@@ -88,74 +98,77 @@ _events_lock = threading.Lock()
 
 class HookHandler:
     """Main hook handler class using EventBus for event emission.
-    
+
     WHY EventBus integration:
     - Replaces direct Socket.IO connections with EventBus publishing
     - Events are published once and consumed by multiple listeners
     - Failures in one consumer don't affect others
     - Simplified testing without Socket.IO dependencies
     """
-    
+
     # Tracking dictionaries with size limits
     MAX_DELEGATION_TRACKING = 100
     MAX_PROMPT_TRACKING = 50
     MAX_CACHE_AGE_SECONDS = 1800  # 30 minutes
-    
+
     def __init__(self):
         """Initialize the hook handler with EventBus."""
         # Initialize EventBus if available
         self.event_bus = EventBus.get_instance() if EVENTBUS_AVAILABLE else None
         self.event_normalizer = EventNormalizer()
-        
+
         # Initialize tracking managers
         self.memory_manager = MemoryHookManager()
         self.response_tracker = ResponseTrackingManager()
         self.event_handlers = EventHandlers(self)
-        
+
         # Delegation tracking
         self.active_delegations = {}
         self.delegation_requests = {}
         self.delegation_history = deque(maxlen=20)
-        
+
         # Prompt tracking
         self.pending_prompts = {}
-        
+
         # Git branch caching
         self._git_branch_cache = {}
         self._git_branch_cache_time = {}
-        
+
         # Session tracking
         self.current_session_id = None
-        
+
         # Cleanup old entries periodically
         self._last_cleanup = time.time()
-        
+
         if self.event_bus:
             logger_msg = "HookHandler initialized with EventBus"
         else:
             logger_msg = "HookHandler initialized (EventBus not available)"
-        
+
         if DEBUG:
             print(f"🚀 {logger_msg}", file=sys.stderr)
-    
+
     def _emit_event(self, event_type: str, data: dict):
         """Emit an event through the EventBus.
-        
+
         WHY this approach:
         - Single point of event emission
         - Consistent event normalization
         - Graceful fallback if EventBus unavailable
         - Easy to add metrics and monitoring
-        
+
         Args:
             event_type: The event type (e.g., 'pre_tool', 'subagent_stop')
             data: The event data
         """
         if not self.event_bus:
             if DEBUG:
-                print(f"EventBus not available, cannot emit: hook.{event_type}", file=sys.stderr)
+                print(
+                    f"EventBus not available, cannot emit: hook.{event_type}",
+                    file=sys.stderr,
+                )
             return
-        
+
         try:
             # Create event data for normalization
             raw_event = {
@@ -164,86 +177,99 @@ class HookHandler:
                 "timestamp": datetime.now().isoformat(),
                 "data": data,
                 "source": "claude_hooks",
-                "session_id": data.get("sessionId", self.current_session_id)
+                "session_id": data.get("sessionId", self.current_session_id),
             }
-            
+
             # Normalize the event
             normalized_event = self.event_normalizer.normalize(raw_event, source="hook")
             event_data = normalized_event.to_dict()
-            
+
             # Publish to EventBus
             success = self.event_bus.publish(f"hook.{event_type}", event_data)
-            
+
             if DEBUG:
                 if success:
-                    print(f"✅ Published to EventBus: hook.{event_type}", file=sys.stderr)
+                    print(
+                        f"✅ Published to EventBus: hook.{event_type}", file=sys.stderr
+                    )
                 else:
-                    print(f"⚠️ EventBus rejected event: hook.{event_type}", file=sys.stderr)
-            
+                    print(
+                        f"⚠️ EventBus rejected event: hook.{event_type}", file=sys.stderr
+                    )
+
             # Log important events
             if DEBUG and event_type in ["subagent_stop", "pre_tool"]:
                 if event_type == "subagent_stop":
                     agent_type = data.get("agent_type", "unknown")
-                    print(f"📤 Published SubagentStop for agent '{agent_type}'", file=sys.stderr)
+                    print(
+                        f"📤 Published SubagentStop for agent '{agent_type}'",
+                        file=sys.stderr,
+                    )
                 elif event_type == "pre_tool" and data.get("tool_name") == "Task":
                     delegation = data.get("delegation_details", {})
                     agent_type = delegation.get("agent_type", "unknown")
-                    print(f"📤 Published Task delegation to agent '{agent_type}'", file=sys.stderr)
-                    
+                    print(
+                        f"📤 Published Task delegation to agent '{agent_type}'",
+                        file=sys.stderr,
+                    )
+
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to publish event hook.{event_type}: {e}", file=sys.stderr)
-    
-    def _get_git_branch(self, working_dir: str = None) -> str:
+                print(
+                    f"❌ Failed to publish event hook.{event_type}: {e}",
+                    file=sys.stderr,
+                )
+
+    def _get_git_branch(self, working_dir: Optional[str] = None) -> str:
         """Get git branch for the given directory with caching."""
         # Use current working directory if not specified
         if not working_dir:
             working_dir = os.getcwd()
-        
+
         # Check cache first (cache for 30 seconds)
         current_time = time.time()
         cache_key = working_dir
-        
+
         if (
             cache_key in self._git_branch_cache
             and cache_key in self._git_branch_cache_time
             and current_time - self._git_branch_cache_time[cache_key] < 30
         ):
             return self._git_branch_cache[cache_key]
-        
+
         # Try to get git branch
         try:
             # Change to the working directory temporarily
             original_cwd = os.getcwd()
             os.chdir(working_dir)
-            
+
             # Run git command to get current branch
             result = subprocess.run(
                 ["git", "branch", "--show-current"],
                 capture_output=True,
                 text=True,
-                timeout=TimeoutConfig.QUICK_TIMEOUT
+                timeout=TimeoutConfig.QUICK_TIMEOUT,
+                check=False,
             )
-            
+
             # Restore original directory
             os.chdir(original_cwd)
-            
+
             if result.returncode == 0 and result.stdout.strip():
                 branch = result.stdout.strip()
                 # Cache the result
                 self._git_branch_cache[cache_key] = branch
                 self._git_branch_cache_time[cache_key] = current_time
                 return branch
-            else:
-                return "unknown"
-                
+            return "unknown"
+
         except Exception:
             return "unknown"
-    
+
     def _cleanup_old_entries(self):
         """Clean up old entries to prevent memory growth."""
-        cutoff_time = time.time() - self.MAX_CACHE_AGE_SECONDS
-        
+        time.time() - self.MAX_CACHE_AGE_SECONDS
+
         # Clean up delegation tracking dictionaries
         for storage in [self.active_delegations, self.delegation_requests]:
             if len(storage) > self.MAX_DELEGATION_TRACKING:
@@ -252,14 +278,14 @@ class HookHandler:
                 excess = len(storage) - self.MAX_DELEGATION_TRACKING
                 for key in sorted_keys[:excess]:
                     del storage[key]
-        
+
         # Clean up pending prompts
         if len(self.pending_prompts) > self.MAX_PROMPT_TRACKING:
             sorted_keys = sorted(self.pending_prompts.keys())
             excess = len(self.pending_prompts) - self.MAX_PROMPT_TRACKING
             for key in sorted_keys[:excess]:
                 del self.pending_prompts[key]
-        
+
         # Clean up git branch cache
         expired_keys = [
             key
@@ -269,10 +295,10 @@ class HookHandler:
         for key in expired_keys:
             self._git_branch_cache.pop(key, None)
             self._git_branch_cache_time.pop(key, None)
-    
+
     def handle_event(self, event: dict):
         """Process an event from Claude Code.
-        
+
         Args:
             event: The event dictionary from Claude
         """
@@ -281,24 +307,26 @@ class HookHandler:
         if current_time - self._last_cleanup > 300:  # Every 5 minutes
             self._cleanup_old_entries()
             self._last_cleanup = current_time
-        
+
         # Extract event details
         event_type = event.get("type", "")
         event_name = event.get("name", "")
-        
+
         # Update session ID if present
         if "sessionId" in event:
             self.current_session_id = event["sessionId"]
-        
+
         # Detect duplicate events
-        event_signature = f"{event_type}:{event_name}:{json.dumps(event.get('data', ''))[:100]}"
+        event_signature = (
+            f"{event_type}:{event_name}:{json.dumps(event.get('data', ''))[:100]}"
+        )
         with _events_lock:
             if event_signature in _recent_events:
                 if DEBUG:
                     print(f"Skipping duplicate event: {event_type}", file=sys.stderr)
                 return
             _recent_events.append(event_signature)
-        
+
         # Route to appropriate handler
         if event_type == "Start":
             self.event_handlers.handle_start(event)
@@ -321,15 +349,14 @@ class HookHandler:
         elif event_type == "PromptCachingBetaStats":
             # Ignore caching stats events
             pass
-        else:
-            # Log unhandled events in debug mode
-            if DEBUG:
-                print(f"Unhandled event type: {event_type}", file=sys.stderr)
+        # Log unhandled events in debug mode
+        elif DEBUG:
+            print(f"Unhandled event type: {event_type}", file=sys.stderr)
 
 
 def get_handler() -> HookHandler:
     """Get or create the global hook handler instance.
-    
+
     Returns:
         HookHandler: The singleton handler instance
     """
@@ -345,18 +372,18 @@ def main():
     """Main entry point for the hook handler."""
     if DEBUG:
         print("🎯 EventBus Hook Handler starting...", file=sys.stderr)
-    
+
     handler = get_handler()
-    
+
     # Set up signal handling for clean shutdown
     def signal_handler(signum, frame):
         if DEBUG:
             print("\n👋 Hook handler shutting down...", file=sys.stderr)
         sys.exit(0)
-    
+
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-    
+
     # Process events from stdin
     try:
         while True:
@@ -366,15 +393,15 @@ def main():
                 line = sys.stdin.readline()
                 if not line:
                     break
-                
+
                 try:
                     event = json.loads(line.strip())
                     handler.handle_event(event)
-                    
+
                     # Acknowledge event
                     print(json.dumps({"status": "ok"}))
                     sys.stdout.flush()
-                    
+
                 except json.JSONDecodeError as e:
                     if DEBUG:
                         print(f"Invalid JSON: {e}", file=sys.stderr)
@@ -385,7 +412,7 @@ def main():
                         print(f"Error processing event: {e}", file=sys.stderr)
                     print(json.dumps({"status": "error", "message": str(e)}))
                     sys.stdout.flush()
-                    
+
     except KeyboardInterrupt:
         if DEBUG:
             print("\n👋 Hook handler interrupted", file=sys.stderr)
@@ -395,4 +422,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -8,7 +8,7 @@ including pre and post delegation hooks.
 import os
 import sys
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Optional
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
@@ -21,14 +21,12 @@ try:
 
     paths.ensure_in_path()
 
-    from claude_mpm.core.config import Config
     from claude_mpm.core.shared.config_loader import ConfigLoader
     from claude_mpm.hooks.base_hook import HookContext, HookType
     from claude_mpm.hooks.memory_integration_hook import (
         MemoryPostDelegationHook,
         MemoryPreDelegationHook,
     )
-    from claude_mpm.services.hook_service import HookService
 
     MEMORY_HOOKS_AVAILABLE = True
 except Exception as e:
@@ -181,7 +179,7 @@ class MemoryHookManager:
             if output:
                 result_content = str(output)
             elif error:
-                result_content = f"Error: {str(error)}"
+                result_content = f"Error: {error!s}"
             else:
                 result_content = f"Task completed with exit code: {exit_code}"
 

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -10,7 +10,7 @@ import os
 import re
 import sys
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Optional
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
@@ -53,7 +53,6 @@ class ResponseTrackingManager:
         try:
             # Create configuration with optional config file using ConfigLoader
             config_file = os.environ.get("CLAUDE_PM_CONFIG_FILE")
-            from claude_mpm.core.config import Config
             from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
 
             config_loader = ConfigLoader()
@@ -62,9 +61,11 @@ class ResponseTrackingManager:
                 pattern = ConfigPattern(
                     filenames=[os.path.basename(config_file)],
                     search_paths=[os.path.dirname(config_file)],
-                    env_prefix="CLAUDE_MPM_"
+                    env_prefix="CLAUDE_MPM_",
+                )
+                config = config_loader.load_config(
+                    pattern, cache_key=f"response_tracking_{config_file}"
                 )
-                config = config_loader.load_config(pattern, cache_key=f"response_tracking_{config_file}")
             else:
                 config = config_loader.load_main_config()
 
@@ -101,7 +102,9 @@ class ResponseTrackingManager:
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to initialize response tracking: {e}", file=sys.stderr)
+                print(
+                    f"❌ Failed to initialize response tracking: {e}", file=sys.stderr
+                )
             # Don't fail the entire handler - response tracking is optional
 
     def track_agent_response(
@@ -203,11 +206,13 @@ class ResponseTrackingManager:
                     "files_modified": structured_response.get("files_modified", []),
                     "tools_used": structured_response.get("tools_used", []),
                     "remember": structured_response.get("remember"),
-                    "MEMORIES": structured_response.get("MEMORIES"),  # Complete memory replacement
+                    "MEMORIES": structured_response.get(
+                        "MEMORIES"
+                    ),  # Complete memory replacement
                 }
-                
-                # Log if MEMORIES field is present  
-                if "MEMORIES" in structured_response and structured_response["MEMORIES"]:
+
+                # Log if MEMORIES field is present
+                if structured_response.get("MEMORIES"):
                     if DEBUG:
                         memories_count = len(structured_response["MEMORIES"])
                         print(
@@ -247,8 +252,7 @@ class ResponseTrackingManager:
                 )
 
             # Clean up the request data after successful tracking
-            if session_id in delegation_requests:
-                del delegation_requests[session_id]
+            delegation_requests.pop(session_id, None)
 
         except Exception as e:
             if DEBUG:

claude_mpm/hooks/claude_hooks/tool_analysis.py

@@ -5,8 +5,6 @@ This module provides utilities for analyzing tool usage, extracting parameters,
 and assessing security risks.
 """
 
-from typing import Any, Dict, List
-
 
 def extract_tool_parameters(tool_name: str, tool_input: dict) -> dict:
     """Extract relevant parameters based on tool type.
@@ -99,7 +97,7 @@ def extract_tool_parameters(tool_name: str, tool_input: dict) -> dict:
                 "has_in_progress": any(t.get("status") == "in_progress" for t in todos),
                 "has_pending": any(t.get("status") == "pending" for t in todos),
                 "has_completed": any(t.get("status") == "completed" for t in todos),
-                "priorities": list(set(t.get("priority", "medium") for t in todos)),
+                "priorities": list({t.get("priority", "medium") for t in todos}),
             }
         )
 
@@ -144,18 +142,17 @@ def classify_tool_operation(tool_name: str, tool_input: dict) -> str:
     """Classify the type of operation being performed."""
     if tool_name in ["Read", "LS", "Glob", "Grep", "NotebookRead"]:
         return "read"
-    elif tool_name in ["Write", "Edit", "MultiEdit", "NotebookEdit"]:
+    if tool_name in ["Write", "Edit", "MultiEdit", "NotebookEdit"]:
         return "write"
-    elif tool_name == "Bash":
+    if tool_name == "Bash":
         return "execute"
-    elif tool_name in ["WebFetch", "WebSearch"]:
+    if tool_name in ["WebFetch", "WebSearch"]:
         return "network"
-    elif tool_name == "TodoWrite":
+    if tool_name == "TodoWrite":
         return "task_management"
-    elif tool_name == "Task":
+    if tool_name == "Task":
         return "delegation"
-    else:
-        return "other"
+    return "other"
 
 
 def assess_security_risk(tool_name: str, tool_input: dict) -> str:
@@ -174,21 +171,18 @@ def assess_security_risk(tool_name: str, tool_input: dict) -> str:
         ]
         if any(pattern in command for pattern in dangerous_patterns):
             return "high"
-        elif any(word in command for word in ["install", "delete", "format", "kill"]):
+        if any(word in command for word in ["install", "delete", "format", "kill"]):
             return "medium"
-        else:
-            return "low"
-    elif tool_name in ["Write", "Edit", "MultiEdit"]:
+        return "low"
+    if tool_name in ["Write", "Edit", "MultiEdit"]:
         file_path = tool_input.get("file_path", "")
         # Check for system file modifications
         if any(path in file_path for path in ["/etc/", "/usr/", "/var/", "/sys/"]):
             return "high"
-        elif file_path.startswith("/"):
+        if file_path.startswith("/"):
             return "medium"
-        else:
-            return "low"
-    else:
         return "low"
+    return "low"
 
 
 def extract_tool_results(event: dict) -> dict:

claude_mpm/hooks/memory_integration_hook.py

@@ -13,7 +13,7 @@ agent outputs because:
 """
 
 import re
-from typing import Any, Dict, List
+from typing import Dict, List
 
 from claude_mpm.core.config import Config
 from claude_mpm.core.logger import get_logger
@@ -162,7 +162,7 @@ INSTRUCTIONS: Review your memory above before proceeding. Apply learned patterns
                 success=True,
                 data=context.data,
                 modified=False,
-                error=f"Memory injection failed: {str(e)}",
+                error=f"Memory injection failed: {e!s}",
             )
 
 
@@ -319,7 +319,7 @@ class MemoryPostDelegationHook(PostDelegationHook):
                 success=True,
                 data=context.data,
                 modified=False,
-                error=f"Learning extraction failed: {str(e)}",
+                error=f"Learning extraction failed: {e!s}",
             )
 
     def _extract_learnings(self, text: str) -> Dict[str, List[str]]:
@@ -339,7 +339,7 @@ class MemoryPostDelegationHook(PostDelegationHook):
         Returns:
             Dictionary mapping learning types to lists of extracted learnings
         """
-        learnings = {learning_type: [] for learning_type in self.type_mapping.keys()}
+        learnings = {learning_type: [] for learning_type in self.type_mapping}
         seen_learnings = set()  # Avoid duplicates
 
         # Pattern to find memory blocks with multiple trigger phrases
@@ -394,7 +394,7 @@ class MemoryPostDelegationHook(PostDelegationHook):
                         f"Unsupported learning type: {learning_type}. Supported types: {list(self.type_mapping.keys())}"
                     )
             else:
-                logger.debug(f"Invalid memory block format - missing Type or Content")
+                logger.debug("Invalid memory block format - missing Type or Content")
 
         # Log summary of extracted learnings
         total_learnings = sum(len(items) for items in learnings.values())

claude_mpm/hooks/tool_call_interceptor.py

@@ -6,7 +6,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logger import get_logger
-from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookResult, HookType
+from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookType
 
 logger = get_logger(__name__)