claude-mpm 3.9.11__py3-none-any.whl → 4.0.4__py3-none-any.whl

claude_mpm/hooks/tool_call_interceptor.py

@@ -1,92 +1,95 @@
 """Tool call interceptor for claude-mpm hook system."""
 
 import asyncio
-import json
-from typing import Dict, Any, Optional, List
-from datetime import datetime
 from collections import defaultdict
+from datetime import datetime
+from typing import Any, Dict, List, Optional
 
-from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookType, HookResult
 from claude_mpm.core.logger import get_logger
+from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookResult, HookType
 
 logger = get_logger(__name__)
 
 
 class SimpleHookRunner:
     """Simple hook runner for direct hook execution."""
-    
+
     def __init__(self):
         """Initialize the simple hook runner."""
         self._hooks: Dict[HookType, List[BaseHook]] = defaultdict(list)
         self._hook_instances: Dict[str, BaseHook] = {}
-    
+
     def register_hook(self, hook: BaseHook, hook_type: Optional[HookType] = None):
         """Register a hook instance."""
         if hook_type is None:
             hook_type = HookType.CUSTOM
-        
+
         if hook.name in self._hook_instances:
             # Remove old instance
             for hook_list in self._hooks.values():
                 if self._hook_instances[hook.name] in hook_list:
                     hook_list.remove(self._hook_instances[hook.name])
-        
+
         self._hooks[hook_type].append(hook)
         self._hook_instances[hook.name] = hook
         self._hooks[hook_type].sort()  # Sort by priority
-    
+
     async def run_hooks(self, context: HookContext) -> List[Dict[str, Any]]:
         """Run all hooks for the given context."""
         hooks = [h for h in self._hooks[context.hook_type] if h.enabled]
         results = []
-        
+
         for hook in hooks:
             try:
                 if hook.validate(context):
                     result = hook.execute(context)
-                    results.append({
-                        'hook_name': hook.name,
-                        'success': result.success,
-                        'data': result.data,
-                        'error': result.error,
-                        'modified': result.modified,
-                        'metadata': result.metadata
-                    })
-                    
+                    results.append(
+                        {
+                            "hook_name": hook.name,
+                            "success": result.success,
+                            "data": result.data,
+                            "error": result.error,
+                            "modified": result.modified,
+                            "metadata": result.metadata,
+                        }
+                    )
+
                     # Update context if modified
                     if result.modified and result.data:
                         context.data.update(result.data)
             except Exception as e:
                 logger.error(f"Hook '{hook.name}' execution failed: {e}")
-                results.append({
-                    'hook_name': hook.name,
-                    'success': False,
-                    'error': str(e)
-                })
-        
+                results.append(
+                    {"hook_name": hook.name, "success": False, "error": str(e)}
+                )
+
         return results
 
 
 class ToolCallInterceptor:
     """Intercepts and processes tool calls through the hook system."""
-    
+
     def __init__(self, hook_runner: Optional[SimpleHookRunner] = None):
         """Initialize the tool call interceptor.
-        
+
         Args:
             hook_runner: Optional hook runner instance. If not provided, creates a new one.
         """
         self.hook_runner = hook_runner or SimpleHookRunner()
-        
-    async def intercept_tool_call(self, tool_name: str, parameters: Dict[str, Any], 
-                                  metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+
+    async def intercept_tool_call(
+        self,
+        tool_name: str,
+        parameters: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
         """Intercept a tool call and run it through the hook system.
-        
+
         Args:
             tool_name: Name of the tool being called
             parameters: Parameters being passed to the tool
             metadata: Optional metadata for the tool call
-            
+
         Returns:
             Dict containing:
                 - allowed: Whether the tool call should proceed
@@ -98,45 +101,51 @@ class ToolCallInterceptor:
         context = HookContext(
             hook_type=HookType.CUSTOM,
             data={
-                'tool_name': tool_name,
-                'parameters': parameters.copy()  # Copy to avoid modifying original
+                "tool_name": tool_name,
+                "parameters": parameters.copy(),  # Copy to avoid modifying original
             },
             metadata=metadata or {},
-            timestamp=datetime.now()
+            timestamp=datetime.now(),
         )
-        
+
         # Run hooks
         results = await self.hook_runner.run_hooks(context)
-        
+
         # Process results
         allowed = True
         modified_params = parameters
         errors = []
         hook_metadata = {}
-        
+
         for result in results:
-            if not result.get('success', True):
+            if not result.get("success", True):
                 allowed = False
-                if result.get('error'):
-                    errors.append(f"[{result.get('hook_name', 'Unknown')}] {result.get('error')}")
-            
-            if result.get('modified') and result.get('data'):
+                if result.get("error"):
+                    errors.append(
+                        f"[{result.get('hook_name', 'Unknown')}] {result.get('error')}"
+                    )
+
+            if result.get("modified") and result.get("data"):
                 # Update parameters if modified
-                if 'parameters' in result.get('data', {}):
-                    modified_params = result['data']['parameters']
-            
-            if result.get('metadata'):
-                hook_metadata.update(result['metadata'])
-        
+                if "parameters" in result.get("data", {}):
+                    modified_params = result["data"]["parameters"]
+
+            if result.get("metadata"):
+                hook_metadata.update(result["metadata"])
+
         return {
-            'allowed': allowed,
-            'parameters': modified_params,
-            'error': '\n'.join(errors) if errors else None,
-            'metadata': hook_metadata
+            "allowed": allowed,
+            "parameters": modified_params,
+            "error": "\n".join(errors) if errors else None,
+            "metadata": hook_metadata,
         }
-    
-    def intercept_tool_call_sync(self, tool_name: str, parameters: Dict[str, Any], 
-                                metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+
+    def intercept_tool_call_sync(
+        self,
+        tool_name: str,
+        parameters: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
         """Synchronous version of intercept_tool_call."""
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
@@ -150,55 +159,59 @@ class ToolCallInterceptor:
 
 class ToolCallHookIntegration:
     """Integration helper for adding tool call interception to existing systems."""
-    
+
     @staticmethod
     def wrap_tool_executor(original_executor, interceptor: ToolCallInterceptor):
         """Wrap an existing tool executor with hook interception.
-        
+
         Args:
             original_executor: The original tool execution function
             interceptor: The tool call interceptor instance
-            
+
         Returns:
             Wrapped executor function
         """
-        async def wrapped_executor(tool_name: str, parameters: Dict[str, Any], **kwargs):
+
+        async def wrapped_executor(
+            tool_name: str, parameters: Dict[str, Any], **kwargs
+        ):
             # Intercept the tool call
             interception_result = await interceptor.intercept_tool_call(
-                tool_name, parameters, kwargs.get('metadata')
+                tool_name, parameters, kwargs.get("metadata")
             )
-            
+
             # Check if allowed
-            if not interception_result['allowed']:
+            if not interception_result["allowed"]:
                 raise ValueError(f"Tool call blocked: {interception_result['error']}")
-            
+
             # Execute with potentially modified parameters
             return await original_executor(
-                tool_name, 
-                interception_result['parameters'], 
-                **kwargs
+                tool_name, interception_result["parameters"], **kwargs
             )
-        
+
         return wrapped_executor
-    
+
     @staticmethod
-    def create_tool_call_validator(valid_tools: List[str], interceptor: ToolCallInterceptor):
+    def create_tool_call_validator(
+        valid_tools: List[str], interceptor: ToolCallInterceptor
+    ):
         """Create a tool call validator that uses the hook system.
-        
+
         Args:
             valid_tools: List of valid tool names
             interceptor: The tool call interceptor instance
-            
+
         Returns:
             Validator function
         """
+
         def validator(tool_name: str, parameters: Dict[str, Any]) -> bool:
             # Basic validation
             if tool_name not in valid_tools:
                 return False
-            
+
             # Hook-based validation
             result = interceptor.intercept_tool_call_sync(tool_name, parameters)
-            return result['allowed']
-        
-        return validator
+            return result["allowed"]
+
+        return validator

claude_mpm/hooks/validation_hooks.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Validation hooks for claude-mpm operations.
 
@@ -5,8 +7,8 @@ Inspired by awesome-claude-code's pre-push validation approach.
 """
 
 import logging
-from typing import Dict, Any, List, Optional, Callable
-from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
 import yaml
 
 from claude_mpm.validation import AgentValidator, ValidationResult
@@ -16,93 +18,97 @@ logger = logging.getLogger(__name__)
 
 class ValidationHooks:
     """Manages validation hooks for various operations."""
-    
+
     def __init__(self):
         """Initialize validation hooks."""
         self.pre_load_hooks: List[Callable] = []
         self.post_load_hooks: List[Callable] = []
         self.pre_execute_hooks: List[Callable] = []
         self.validator = AgentValidator()
-    
+
     def register_pre_load_hook(self, hook: Callable) -> None:
         """Register a hook to run before loading an agent."""
         self.pre_load_hooks.append(hook)
-    
+
     def register_post_load_hook(self, hook: Callable) -> None:
         """Register a hook to run after loading an agent."""
         self.post_load_hooks.append(hook)
-    
+
     def register_pre_execute_hook(self, hook: Callable) -> None:
         """Register a hook to run before executing an agent."""
         self.pre_execute_hooks.append(hook)
-    
+
     async def run_pre_load_validation(self, profile_path: Path) -> ValidationResult:
         """Run validation before loading an agent profile."""
         logger.info(f"Running pre-load validation for {profile_path}")
-        
+
         # Run basic file validation
         if not profile_path.exists():
             result = ValidationResult(is_valid=False)
             result.errors.append(f"Profile file not found: {profile_path}")
             return result
-        
+
         # Validate profile structure
         result = self.validator.validate_profile(profile_path)
-        
+
         # Run custom pre-load hooks
         for hook in self.pre_load_hooks:
             try:
                 hook_result = await hook(profile_path)
-                if hasattr(hook_result, 'errors'):
+                if hasattr(hook_result, "errors"):
                     result.errors.extend(hook_result.errors)
                     if hook_result.errors:
                         result.is_valid = False
             except Exception as e:
                 logger.error(f"Pre-load hook failed: {e}")
                 result.warnings.append(f"Pre-load hook failed: {str(e)}")
-        
+
         return result
-    
-    async def run_post_load_validation(self, agent_config: Dict[str, Any]) -> ValidationResult:
+
+    async def run_post_load_validation(
+        self, agent_config: Dict[str, Any]
+    ) -> ValidationResult:
         """Run validation after loading an agent."""
         result = ValidationResult(is_valid=True)
-        
+
         # Run custom post-load hooks
         for hook in self.post_load_hooks:
             try:
                 hook_result = await hook(agent_config)
-                if hasattr(hook_result, 'warnings'):
+                if hasattr(hook_result, "warnings"):
                     result.warnings.extend(hook_result.warnings)
             except Exception as e:
                 logger.error(f"Post-load hook failed: {e}")
                 result.warnings.append(f"Post-load hook failed: {str(e)}")
-        
+
         return result
-    
-    async def run_pre_execute_validation(self, agent_name: str, task: str) -> ValidationResult:
+
+    async def run_pre_execute_validation(
+        self, agent_name: str, task: str
+    ) -> ValidationResult:
         """Run validation before executing an agent task."""
         result = ValidationResult(is_valid=True)
-        
+
         # Validate task format
         if not task or not task.strip():
             result.errors.append("Task cannot be empty")
             result.is_valid = False
-        
+
         # Check task length
         if len(task) > 10000:
             result.warnings.append("Task is very long, consider breaking it down")
-        
+
         # Run custom pre-execute hooks
         for hook in self.pre_execute_hooks:
             try:
                 hook_result = await hook(agent_name, task)
-                if hasattr(hook_result, 'errors') and hook_result.errors:
+                if hasattr(hook_result, "errors") and hook_result.errors:
                     result.errors.extend(hook_result.errors)
                     result.is_valid = False
             except Exception as e:
                 logger.error(f"Pre-execute hook failed: {e}")
                 result.warnings.append(f"Pre-execute hook failed: {str(e)}")
-        
+
         return result
 
 
@@ -110,72 +116,74 @@ class ValidationHooks:
 async def validate_agent_dependencies(profile_path: Path) -> ValidationResult:
     """Validate that agent dependencies are available."""
     result = ValidationResult(is_valid=True)
-    
+
     try:
-        with open(profile_path, 'r') as f:
+        with open(profile_path, "r") as f:
             profile_data = yaml.safe_load(f)
-        
+
         # Check for circular dependencies
-        agents = profile_data.get('agents', [])
+        agents = profile_data.get("agents", [])
         for agent in agents:
-            dependencies = agent.get('dependencies', [])
+            dependencies = agent.get("dependencies", [])
             # Simple check - in real implementation would need graph analysis
-            if agent['name'] in dependencies:
+            if agent["name"] in dependencies:
                 result.errors.append(f"Agent '{agent['name']}' has circular dependency")
                 result.is_valid = False
-    
+
     except Exception as e:
         result.warnings.append(f"Could not check dependencies: {e}")
-    
+
     return result
 
 
 async def validate_security_constraints(agent_name: str, task: str) -> ValidationResult:
     """Validate security constraints before execution."""
     result = ValidationResult(is_valid=True)
-    
+
     # Check for potential security issues in task
     dangerous_patterns = [
-        'rm -rf /',
-        'sudo rm',
-        'format c:',
-        '__import__',
-        'eval(',
-        'exec(',
+        "rm -rf /",
+        "sudo rm",
+        "format c:",
+        "__import__",
+        "eval(",
+        "exec(",
     ]
-    
+
     task_lower = task.lower()
     for pattern in dangerous_patterns:
         if pattern in task_lower:
             result.errors.append(f"Potentially dangerous pattern detected: {pattern}")
             result.is_valid = False
-    
+
     return result
 
 
 class ValidationError(Exception):
     """Raised when validation fails."""
-    
-    def __init__(self, message: str, validation_result: Optional[ValidationResult] = None):
+
+    def __init__(
+        self, message: str, validation_result: Optional[ValidationResult] = None
+    ):
         """Initialize validation error."""
         super().__init__(message)
         self.validation_result = validation_result
-    
+
     def get_detailed_message(self) -> str:
         """Get detailed error message including validation results."""
         if not self.validation_result:
             return str(self)
-        
+
         lines = [str(self)]
-        
+
         if self.validation_result.errors:
             lines.append("\nErrors:")
             for error in self.validation_result.errors:
                 lines.append(f"  - {error}")
-        
+
         if self.validation_result.warnings:
             lines.append("\nWarnings:")
             for warning in self.validation_result.warnings:
                 lines.append(f"  - {warning}")
-        
-        return '\n'.join(lines)
+
+        return "\n".join(lines)