auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/agent_hooks/hook_executor.py

@@ -0,0 +1,217 @@
+"""
+Hook executor for command execution with variable substitution and process management.
+"""
+
+import asyncio
+import json
+import os
+import re
+import shlex
+import subprocess
+import time
+from typing import Dict, List, Optional, Any
+
+from loguru import logger
+from autocoder.common.async_utils import AsyncSyncMixin
+from ..agent_events.types import EventMessage
+from .types import Hook, HookExecutionResult, HookType
+
+
+class HookExecutor(AsyncSyncMixin):
+    """
+    Command execution engine with variable substitution and environment control.
+    
+    Provides both async and sync methods for all operations.
+    Sync methods are automatically generated with a '_sync' suffix.
+    """
+    
+    def __init__(self, cwd: Optional[str] = None, timeout: int = 30000, 
+                 env: Optional[Dict[str, str]] = None):
+        """
+        Initialize the hook executor.
+        
+        Args:
+            cwd: Working directory for command execution
+            timeout: Command timeout in milliseconds
+            env: Additional environment variables
+        """
+        self.cwd = cwd or os.getcwd()
+        self.timeout = timeout / 1000.0  # Convert to seconds
+        self.env = env or {}
+    
+    def set_cwd(self, cwd: str) -> None:
+        """Set working directory for command execution."""
+        self.cwd = cwd
+    
+    def set_timeout(self, timeout: int) -> None:
+        """Set command execution timeout in milliseconds."""
+        self.timeout = timeout / 1000.0
+    
+    def set_env(self, env: Dict[str, str]) -> None:
+        """Set environment variables."""
+        self.env = env
+    
+    async def execute_hooks(self, hooks: List[Hook], event_message: EventMessage) -> List[HookExecutionResult]:
+        """
+        Execute all hooks in an array.
+        
+        Args:
+            hooks: List of hooks to execute
+            event_message: Event message for variable substitution
+            
+        Returns:
+            List of execution results
+        """
+        results = []
+        for hook in hooks:
+            result = await self.execute_hook(hook, event_message)
+            results.append(result)
+        return results
+    
+    async def execute_hook(self, hook: Hook, event_message: EventMessage) -> HookExecutionResult:
+        """
+        Execute a single hook.
+        
+        Args:
+            hook: Hook to execute
+            event_message: Event message for variable substitution
+            
+        Returns:
+            Execution result
+        """
+        if hook.type != HookType.COMMAND:
+            return HookExecutionResult(
+                success=False,
+                command=hook.command,
+                error_message=f"Unsupported hook type: {hook.type}"
+            )
+        
+        # Process command variables
+        processed_command = self._substitute_variables(hook.command, event_message)
+        
+        # Execute command
+        return await self._execute_command(processed_command)
+    
+    def _substitute_variables(self, command: str, event_message: EventMessage) -> str:
+        """
+        Replace template variables in commands with runtime values.
+        
+        Supported variables:
+        - {{event_type}}: The event type
+        - {{event_id}}: The event ID
+        - {{timestamp}}: The event timestamp
+        - {{tool_name}}: The tool name from event content
+        - {{event_content}}: Full event content as JSON
+        - {{agent_id}}: Agent ID from context (if available)
+        - {{conversation_id}}: Conversation ID from context (if available)
+        - {{context_*}}: Context metadata fields
+        - {{tool_*}}: Tool input fields
+        
+        Args:
+            command: Command template with {{variable}} placeholders
+            event_message: Event message containing variable values
+            
+        Returns:
+            Command with variables substituted
+        """
+        variables = {
+            'event_type': event_message.event_type.value,
+            'event_id': event_message.event_id,
+            'timestamp': str(event_message.timestamp),
+            'tool_name': event_message.content.get('tool_name', ''),
+            'event_content': json.dumps(event_message.content),
+            'cwd': self.cwd
+        }
+        
+        # Add context variables if available
+        if event_message.context:
+            if event_message.context.agent_id:
+                variables['agent_id'] = event_message.context.agent_id
+            if event_message.context.conversation_id:
+                variables['conversation_id'] = event_message.context.conversation_id
+            if event_message.context.metadata:
+                for key, value in event_message.context.metadata.items():
+                    variables[f'context_{key}'] = str(value)
+        
+        # Add tool-specific variables
+        if 'tool_input' in event_message.content:
+            tool_input = event_message.content['tool_input']
+            if isinstance(tool_input, dict):
+                for key, value in tool_input.items():
+                    variables[f'tool_{key}'] = str(value)
+        
+        # Add additional content fields
+        for key, value in event_message.content.items():
+            if key not in ['tool_name', 'tool_input'] and isinstance(value, (str, int, float, bool)):
+                variables[key] = str(value)
+        
+        # Substitute variables using regex
+        def replace_var(match):
+            var_name = match.group(1)
+            return variables.get(var_name, match.group(0))
+        
+        # Replace {{variable}} patterns
+        result = re.sub(r'\{\{(\w+)\}\}', replace_var, command)
+        return result
+    
+    async def _execute_command(self, command: str) -> HookExecutionResult:
+        """
+        Execute shell command with timeout and error handling.
+        
+        Args:
+            command: Command to execute
+            
+        Returns:
+            Execution result with output, exit code, and timing
+        """
+        start_time = time.time()
+        result = HookExecutionResult(
+            success=False,
+            command=command,
+            start_time=start_time
+        )
+        
+        try:
+            # Prepare environment
+            exec_env = os.environ.copy()
+            exec_env.update(self.env)
+            
+            # Execute command
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=self.cwd,
+                env=exec_env
+            )
+            
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    process.communicate(),
+                    timeout=self.timeout
+                )
+                
+                # Update result
+                result.stdout = stdout.decode('utf-8', errors='replace')
+                result.stderr = stderr.decode('utf-8', errors='replace')
+                result.exit_code = process.returncode
+                result.success = process.returncode == 0
+                
+            except asyncio.TimeoutError:
+                # Kill the process if it times out
+                process.kill()
+                await process.wait()
+                result.error_message = f"Command timed out after {self.timeout}s"
+                result.exit_code = -1
+        
+        except Exception as e:
+            result.error_message = str(e)
+            result.exit_code = -1
+            logger.error(f"Error executing command '{command}': {e}")
+        
+        finally:
+            end_time = time.time()
+            result.end_time = end_time
+            result.execution_time = end_time - start_time
+        
+        return result 

autocoder/common/agent_hooks/hook_manager.py

@@ -0,0 +1,288 @@
+"""
+Hook manager for configuration loading, caching, and event processing.
+"""
+
+import asyncio
+import json
+import os
+import re
+import time
+import yaml
+from typing import Dict, List, Optional, Tuple
+
+from loguru import logger
+from autocoder.common.async_utils import AsyncSyncMixin
+from ..agent_events.types import EventMessage
+from .types import HooksConfig, HookMatcher, HookProcessingResult
+from .hook_executor import HookExecutor
+
+
+class HookManager(AsyncSyncMixin):
+    """
+    Core hook management and event processing.
+    
+    Provides both async and sync methods for all operations.
+    Sync methods are automatically generated with a '_sync' suffix.
+    """
+    
+    def __init__(self, config_path: Optional[str] = None, cwd: Optional[str] = None, 
+                 command_timeout: int = 30000):
+        """
+        Initialize the hook manager.
+        
+        Args:
+            config_path: Path to hooks configuration file (supports .json, .yaml, .yml formats)
+            cwd: Working directory for command execution
+            command_timeout: Command timeout in milliseconds
+        """        
+        self.cwd = cwd or os.getcwd()
+        self.config_path = config_path or self._find_default_config_path()
+        self.command_timeout = command_timeout
+        
+        self._config: Optional[HooksConfig] = None
+        self._config_mtime: Optional[float] = None
+        self._executor = HookExecutor(cwd=self.cwd, timeout=command_timeout)
+        self._config_lock = asyncio.Lock()
+    
+    def _find_default_config_path(self) -> str:
+        """
+        Find the default configuration file by checking for hooks.json, hooks.yaml, hooks.yml.
+        
+        Returns:
+            Path to the first found configuration file, defaults to hooks.json if none found
+        """
+        base_dir = os.path.join(self.cwd, '.auto-coder')
+        
+        # Priority order: .json first for backward compatibility, then .yaml, then .yml
+        candidates = [
+            os.path.join(base_dir, 'hooks.json'),
+            os.path.join(base_dir, 'hooks.yaml'),
+            os.path.join(base_dir, 'hooks.yml')
+        ]
+        
+        for candidate in candidates:
+            if os.path.exists(candidate):
+                return candidate
+        
+        # Default to hooks.json for backward compatibility
+        return candidates[0]
+    
+    def _get_config_format(self, config_path: str) -> str:
+        """
+        Detect configuration file format based on file extension.
+        
+        Args:
+            config_path: Path to configuration file
+            
+        Returns:
+            File format: 'json', 'yaml', or 'unknown'
+        """
+        ext = os.path.splitext(config_path)[1].lower()
+        if ext == '.json':
+            return 'json'
+        elif ext in ['.yaml', '.yml']:
+            return 'yaml'
+        else:
+            return 'unknown'
+    
+    def config_exists(self) -> bool:
+        """Check if configuration file exists."""
+        return os.path.exists(self.config_path)
+    
+    async def load_config(self) -> Dict[str, any]:
+        """
+        Load and validate hooks configuration from file.
+        Supports both JSON and YAML formats.
+        
+        Returns:
+            Dictionary with 'config' (HooksConfig or None) and 'errors' (list of error messages)
+        """
+        async with self._config_lock:
+            errors = []
+            config = None
+            
+            try:
+                if not self.config_exists():
+                    errors.append(f"Configuration file not found: {self.config_path}")
+                    return {'config': None, 'errors': errors}
+                
+                # Check if we need to reload based on file modification time
+                current_mtime = os.path.getmtime(self.config_path)
+                if self._config is not None and self._config_mtime == current_mtime:
+                    return {'config': self._config, 'errors': []}
+                
+                # Detect file format and load accordingly
+                config_format = self._get_config_format(self.config_path)
+                
+                with open(self.config_path, 'r', encoding='utf-8') as f:
+                    if config_format == 'json':
+                        data = json.load(f)
+                    elif config_format == 'yaml':
+                        data = yaml.safe_load(f)
+                    else:
+                        errors.append(f"Unsupported configuration file format: {self.config_path}")
+                        return {'config': None, 'errors': errors}
+                
+                # Validate configuration structure
+                validation_errors = self._validate_config(data)
+                if validation_errors:
+                    errors.extend(validation_errors)
+                    return {'config': None, 'errors': errors}
+                
+                # Create config object
+                config = HooksConfig.from_dict(data)
+                
+                # Cache the configuration
+                self._config = config
+                self._config_mtime = current_mtime
+                
+                logger.info(f"Loaded hooks configuration from {self.config_path} (format: {config_format})")
+                
+            except json.JSONDecodeError as e:
+                errors.append(f"Invalid JSON in configuration file: {e}")
+            except yaml.YAMLError as e:
+                errors.append(f"Invalid YAML in configuration file: {e}")
+            except Exception as e:
+                errors.append(f"Error loading configuration: {e}")
+                logger.error(f"Failed to load hooks configuration: {e}")
+            
+            return {'config': config, 'errors': errors}
+    
+    def _validate_config(self, data: Dict) -> List[str]:
+        """Validate configuration structure."""
+        errors = []
+        
+        if not isinstance(data, dict):
+            errors.append("Configuration must be a JSON object")
+            return errors
+        
+        if 'hooks' not in data:
+            errors.append("Configuration must contain 'hooks' key")
+            return errors
+        
+        hooks = data['hooks']
+        if not isinstance(hooks, dict):
+            errors.append("'hooks' must be an object")
+            return errors
+        
+        # Validate each event type configuration
+        for event_type, matchers in hooks.items():
+            if not isinstance(matchers, list):
+                errors.append(f"Event type '{event_type}' must have a list of matchers")
+                continue
+            
+            for i, matcher in enumerate(matchers):
+                if not isinstance(matcher, dict):
+                    errors.append(f"Matcher {i} in '{event_type}' must be an object")
+                    continue
+                
+                if 'matcher' not in matcher:
+                    errors.append(f"Matcher {i} in '{event_type}' must have 'matcher' field")
+                
+                if 'hooks' not in matcher:
+                    errors.append(f"Matcher {i} in '{event_type}' must have 'hooks' field")
+                    continue
+                
+                hooks_list = matcher['hooks']
+                if not isinstance(hooks_list, list):
+                    errors.append(f"'hooks' in matcher {i} of '{event_type}' must be a list")
+                    continue
+                
+                for j, hook in enumerate(hooks_list):
+                    if not isinstance(hook, dict):
+                        errors.append(f"Hook {j} in matcher {i} of '{event_type}' must be an object")
+                        continue
+                    
+                    if 'type' not in hook:
+                        errors.append(f"Hook {j} in matcher {i} of '{event_type}' must have 'type' field")
+                    
+                    if 'command' not in hook:
+                        errors.append(f"Hook {j} in matcher {i} of '{event_type}' must have 'command' field")
+        
+        return errors
+    
+    async def process_event(self, event_message: EventMessage) -> HookProcessingResult:
+        """
+        Process an EventMessage and execute matching hooks.
+        
+        Args:
+            event_message: The event to process
+            
+        Returns:
+            HookProcessingResult containing execution results and any errors
+        """
+        start_time = time.time()
+        result = HookProcessingResult(matched=False)
+        
+        try:
+            # Load configuration
+            load_result = await self.load_config()
+            if load_result['errors']:
+                result.errors.extend(load_result['errors'])
+                return result
+            
+            config = load_result['config']
+            if not config:
+                result.errors.append("No configuration available")
+                return result
+            
+            # Extract event type and tool name
+            event_type = event_message.event_type.value
+            tool_name = event_message.content.get('tool_name', '')
+            
+            # Find matching event type configuration
+            if event_type not in config.hooks:
+                logger.debug(f"No hooks configured for event type: {event_type}")
+                return result  # No configuration for this event type
+            
+            matchers = config.hooks[event_type]
+            
+            # Process each matcher
+            for matcher in matchers:
+                try:
+                    # Check if tool name matches the pattern
+                    if re.search(matcher.matcher, tool_name):
+                        result.matched = True
+                        logger.info(f"Matched hook pattern '{matcher.matcher}' for tool '{tool_name}'")
+                        
+                        # Execute hooks for this matcher
+                        execution_results = await self._executor.execute_hooks(matcher.hooks, event_message)
+                        result.results.extend(execution_results)
+                        
+                        # Log execution summary
+                        successful = sum(1 for r in execution_results if r.success)
+                        failed = len(execution_results) - successful
+                        logger.info(f"Executed {len(execution_results)} hooks: {successful} successful, {failed} failed")
+                        
+                except re.error as e:
+                    error_msg = f"Invalid regex pattern '{matcher.matcher}': {e}"
+                    result.errors.append(error_msg)
+                    logger.error(error_msg)
+                except Exception as e:
+                    error_msg = f"Error processing matcher '{matcher.matcher}': {e}"
+                    result.errors.append(error_msg)
+                    logger.error(error_msg)
+        
+        except Exception as e:
+            error_msg = f"Error processing event: {e}"
+            result.errors.append(error_msg)
+            logger.error(error_msg)
+        
+        finally:
+            result.processing_time = time.time() - start_time
+            
+            if result.matched:
+                logger.info(f"Processed event {event_message.event_type.value} in {result.processing_time:.3f}s")
+        
+        return result
+    
+    async def reload_config(self) -> Dict[str, any]:
+        """Force reload configuration from file."""
+        async with self._config_lock:
+            self._config = None
+            self._config_mtime = None
+        return await self.load_config()
+    
+    def get_current_config(self) -> Optional[HooksConfig]:
+        """Get the currently loaded configuration."""
+        return self._config 

autocoder/common/agent_hooks/types.py

@@ -0,0 +1,133 @@
+"""
+Type definitions for the Agent Hooks system.
+"""
+
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+import time
+
+class HookType(str, Enum):
+    """Types of hooks supported by the system."""
+    COMMAND = "command"
+
+@dataclass
+class Hook:
+    """Individual hook definition with type and command."""
+    type: HookType
+    command: str
+    description: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert hook to dictionary."""
+        result = {
+            'type': self.type.value,
+            'command': self.command
+        }
+        if self.description:
+            result['description'] = self.description
+        return result
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Hook':
+        """Create hook from dictionary."""
+        return cls(
+            type=HookType(data.get('type', HookType.COMMAND.value)),
+            command=data.get('command', ''),
+            description=data.get('description')
+        )
+
+@dataclass 
+class HookMatcher:
+    """Pattern matching and hook configuration."""
+    matcher: str  # Regular expression pattern
+    hooks: List[Hook] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert hook matcher to dictionary."""
+        return {
+            'matcher': self.matcher,
+            'hooks': [hook.to_dict() for hook in self.hooks]
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'HookMatcher':
+        """Create hook matcher from dictionary."""
+        hooks = []
+        for hook_data in data.get('hooks', []):
+            hooks.append(Hook.from_dict(hook_data))
+        
+        return cls(
+            matcher=data.get('matcher', ''),
+            hooks=hooks
+        )
+
+@dataclass
+class HooksConfig:
+    """Complete configuration structure with event type mapping."""
+    hooks: Dict[str, List[HookMatcher]] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert hooks config to dictionary."""
+        result = {}
+        for event_type, matchers in self.hooks.items():
+            result[event_type] = [matcher.to_dict() for matcher in matchers]
+        return {'hooks': result}
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'HooksConfig':
+        """Create hooks config from dictionary."""
+        hooks = {}
+        hooks_data = data.get('hooks', {})
+        
+        for event_type, matchers_data in hooks_data.items():
+            matchers = []
+            for matcher_data in matchers_data:
+                matchers.append(HookMatcher.from_dict(matcher_data))
+            hooks[event_type] = matchers
+        
+        return cls(hooks=hooks)
+
+@dataclass
+class HookExecutionResult:
+    """Command execution results and metrics."""
+    success: bool
+    command: str
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+    execution_time: float = 0.0
+    start_time: float = field(default_factory=time.time)
+    end_time: Optional[float] = None
+    error_message: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert execution result to dictionary."""
+        return {
+            'success': self.success,
+            'command': self.command,
+            'stdout': self.stdout,
+            'stderr': self.stderr,
+            'exit_code': self.exit_code,
+            'execution_time': self.execution_time,
+            'start_time': self.start_time,
+            'end_time': self.end_time,
+            'error_message': self.error_message
+        }
+
+@dataclass
+class HookProcessingResult:
+    """Overall event processing results."""
+    matched: bool
+    results: List[HookExecutionResult] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    processing_time: float = 0.0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert processing result to dictionary."""
+        return {
+            'matched': self.matched,
+            'results': [result.to_dict() for result in self.results],
+            'errors': self.errors,
+            'processing_time': self.processing_time
+        }