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

autocoder/common/action_yml_file_manager.py

@@ -1,7 +1,6 @@
 import os
 import yaml
 import hashlib
-import git
 from typing import List, Dict, Tuple, Optional, Union, Any
 from loguru import logger
 from autocoder.common.git_utils import get_repo
@@ -9,6 +8,16 @@ from autocoder.common.printer import Printer
 import byzerllm
 from autocoder.common import git_utils
 
+# 延迟导入git模块，避免启动时的导入错误
+def _get_git_module():
+    """延迟导入git模块"""
+    try:
+        import git
+        return git, True
+    except ImportError as e:
+        logger.warning(f"Git module not available: {e}. Some git features will be disabled.")
+        return None, False
+
 class ActionYmlFileManager:
     """
     Actions 目录文件操作工具类，用于抽象和管理 actions 目录下的 YAML 文件操作。
@@ -226,12 +235,9 @@ class ActionYmlFileManager:
         
         try:
             with open(yaml_path, 'w', encoding='utf-8') as f:
-                yaml.dump(content, f, allow_unicode=True, default_flow_style=False)
-            self.printer.print_in_terminal("yaml_update_success", style="green", yaml_file=yaml_path)
+                yaml.dump(content, f, allow_unicode=True, default_flow_style=False)            
             return True
-        except Exception as e:
-            self.printer.print_in_terminal("yaml_save_error", style="red", 
-                                          yaml_file=yaml_path, error=str(e))
+        except Exception as e:            
             return False
     
     def update_yaml_field(self, file_name: str, field: str, value: Any) -> bool:
@@ -365,9 +371,14 @@ class ActionYmlFileManager:
             return [(query, urls, {})]
         
         changes = {}
+        git_module, git_available = _get_git_module()
+        if not git_available:
+            self.printer.print_in_terminal("git_not_available", style="yellow")
+            return [(query, urls, {})]
+            
         try:
-            repo = git.Repo(self.source_dir)
-            commit =repo.commit(commit_id)            
+            repo = git_module.Repo(self.source_dir)
+            commit = repo.commit(commit_id)            
             if commit.parents:
                 parent = commit.parents[0]
                 # 获取所有文件的前后内容
@@ -379,7 +390,7 @@ class ActionYmlFileManager:
                     try:
                         if diff_item.a_blob:
                             before_content = repo.git.show(f"{parent.hexsha}:{file_path}")
-                    except git.exc.GitCommandError:
+                    except git_module.exc.GitCommandError:
                         pass  # 文件可能是新增的
 
                     # 获取变更后内容
@@ -387,15 +398,16 @@ class ActionYmlFileManager:
                     try:
                         if diff_item.b_blob:
                             after_content = repo.git.show(f"{commit.hexsha}:{file_path}")
-                    except git.exc.GitCommandError:
+                    except git_module.exc.GitCommandError:
                         pass  # 文件可能被删除
 
                     changes[file_path] = (before_content, after_content)
                     break
-        except git.exc.GitCommandError as e:
-            self.printer.print_in_terminal("git_command_error", style="red", error=str(e))
         except Exception as e:
-            self.printer.print_in_terminal("get_commit_changes_error", style="red", error=str(e))
+            if git_module and hasattr(git_module.exc, 'GitCommandError') and isinstance(e, git_module.exc.GitCommandError):
+                self.printer.print_in_terminal("git_command_error", style="red", error=str(e))
+            else:
+                self.printer.print_in_terminal("get_commit_changes_error", style="red", error=str(e))
         
         return [(query, urls, changes)]
     

autocoder/common/agent_events/__init__.py

@@ -0,0 +1,52 @@
+"""
+Agent Events Module
+
+A comprehensive event handling system for auto-coder agents with support for 
+event emission, subscription, filtering, and processing.
+"""
+
+from .types import (
+    EventType,
+    EventMessage,
+    EventHandler,
+    EventListener,
+    EventMetrics,
+    EventEmitterConfig,
+    EventContext
+)
+
+from .event_factory import EventFactory
+from .agent_event_emitter import AgentEventEmitter
+from .utils import (
+    create_event_system,
+    create_pre_tool_use_event,
+    create_post_tool_use_event,
+    create_error_occurred_event,
+    create_conversation_start_event,
+    create_conversation_end_event,
+    create_custom_event
+)
+
+__all__ = [
+    # Types
+    'EventType',
+    'EventMessage', 
+    'EventHandler',
+    'EventListener',
+    'EventMetrics',
+    'EventEmitterConfig',
+    'EventContext',
+    
+    # Core classes
+    'EventFactory',
+    'AgentEventEmitter',
+    
+    # Utility functions
+    'create_event_system',
+    'create_pre_tool_use_event',
+    'create_post_tool_use_event', 
+    'create_error_occurred_event',
+    'create_conversation_start_event',
+    'create_conversation_end_event',
+    'create_custom_event'
+] 

autocoder/common/agent_events/agent_event_emitter.py

@@ -0,0 +1,193 @@
+"""
+Core event emitter for agent events with support for filtering, metrics, and error handling.
+"""
+
+import asyncio
+import time
+from collections import defaultdict
+from typing import Dict, List, Optional, Set, Callable
+from loguru import logger
+
+from autocoder.common.async_utils import AsyncSyncMixin, run_async_in_sync
+from .types import (
+    EventMessage, EventType, EventHandler, EventListener, 
+    EventMetrics, EventEmitterConfig, EventFilter
+)
+
+
+class AgentEventEmitter(AsyncSyncMixin):
+    """
+    Core event emitter for agent events.
+    
+    Provides both async and sync methods for all operations.
+    Sync methods are automatically generated with a '_sync' suffix.
+    """
+    
+    def __init__(self, config: Optional[EventEmitterConfig] = None):
+        """Initialize the event emitter."""
+        self.config = config or EventEmitterConfig()
+        self._listeners: Dict[EventType, List[EventListener]] = defaultdict(list)
+        self._metrics = EventMetrics()
+        self._lock = asyncio.Lock()
+    
+    def on(self, event_type: EventType, handler: EventHandler) -> None:
+        """Register an event handler for the specified event type."""
+        self.add_listener(event_type, handler)
+    
+    def once(self, event_type: EventType, handler: EventHandler) -> None:
+        """Register a one-time event handler."""
+        self.add_listener(event_type, handler, once=True)
+    
+    def off(self, event_type: EventType, handler: EventHandler) -> bool:
+        """Remove an event handler."""
+        listeners = self._listeners.get(event_type, [])
+        for i, listener in enumerate(listeners):
+            if listener.handler == handler:
+                del listeners[i]
+                self._metrics.total_handlers -= 1
+                return True
+        return False
+    
+    def add_listener(self, event_type: EventType, handler: EventHandler,
+                    filter: Optional[EventFilter] = None, once: bool = False) -> None:
+        """Add an event listener with advanced options."""
+        if len(self._listeners[event_type]) >= self.config.max_listeners:
+            logger.warning(f"Max listeners ({self.config.max_listeners}) reached for {event_type}")
+            return
+        
+        listener = EventListener(handler=handler, filter=filter, once=once)
+        self._listeners[event_type].append(listener)
+        self._metrics.total_handlers += 1
+        
+        if self.config.enable_logging:
+            logger.info(f"Added listener for {event_type} (once={once}, filtered={filter is not None})")
+    
+    def remove_listener(self, event_type: EventType, handler: EventHandler) -> bool:
+        """Remove a specific event listener."""
+        return self.off(event_type, handler)
+    
+    def remove_all_listeners(self, event_type: Optional[EventType] = None) -> None:
+        """Remove all listeners for a specific event type or all events."""
+        if event_type:
+            count = len(self._listeners.get(event_type, []))
+            self._listeners[event_type] = []
+            self._metrics.total_handlers -= count
+        else:
+            total_removed = sum(len(listeners) for listeners in self._listeners.values())
+            self._listeners.clear()
+            self._metrics.total_handlers -= total_removed
+        
+        if self.config.enable_logging:
+            logger.info(f"Removed all listeners for {event_type or 'all events'}")
+    
+    def listener_count(self, event_type: EventType) -> int:
+        """Get the number of listeners for an event type."""
+        return len(self._listeners.get(event_type, []))
+    
+    async def emit(self, event_message: EventMessage) -> None:
+        """Emit an event to all registered handlers."""
+        start_time = time.time()
+        event_type = event_message.event_type
+        
+        if self.config.enable_logging:
+            logger.info(f"Emitting event: {event_type} ({event_message.event_id})")
+        
+        # Get listeners for this event type (copy to avoid modification during iteration)
+        listeners = self._listeners.get(event_type, []).copy()
+        
+        # Track listeners to remove (once handlers)
+        to_remove = []
+        
+        # Process each listener
+        for listener in listeners:
+            try:
+                # Apply filter if present
+                if listener.filter and not listener.filter(event_message):
+                    continue
+                
+                # Execute handler
+                await listener.handler(event_message)
+                
+                # Mark once handlers for removal
+                if listener.once:
+                    to_remove.append((event_type, listener))
+                
+            except Exception as e:
+                self._metrics.error_count += 1
+                error_msg = f"Error in event handler for {event_type}: {e}"
+                logger.error(error_msg)
+                
+                if self.config.error_handler:
+                    try:
+                        self.config.error_handler(e, event_type)
+                    except Exception as handler_error:
+                        logger.error(f"Error in error handler: {handler_error}")
+        
+        # Remove once handlers
+        async with self._lock:
+            for event_type_remove, listener_remove in to_remove:
+                try:
+                    self._listeners[event_type_remove].remove(listener_remove)
+                    self._metrics.total_handlers -= 1
+                except ValueError:
+                    pass  # Already removed
+        
+        # Process with hook manager if available
+        if self.config.hook_manager:
+            try:
+                # Hook manager process_event is always async, so we await it
+                await self.config.hook_manager.process_event(event_message)
+            except Exception as e:
+                logger.error(f"Error in hook manager: {e}")
+        
+        # Update metrics
+        processing_time = time.time() - start_time
+        self._metrics.total_events += 1
+        self._metrics.total_processing_time += processing_time
+        
+        # Update handler count metrics
+        event_type_str = event_type.value
+        self._metrics.handler_counts[event_type_str] = self._metrics.handler_counts.get(event_type_str, 0) + len(listeners)
+        
+        if self.config.enable_logging:
+            logger.info(f"Event {event_type} processed in {processing_time:.3f}s")
+    
+    # The emit_sync method is automatically provided by AsyncSyncMixin
+    
+    async def wait_for_event(self, event_type: EventType, timeout: Optional[float] = None,
+                           filter: Optional[EventFilter] = None) -> Optional[EventMessage]:
+        """Wait for a specific event to be emitted."""
+        future = asyncio.Future()
+        
+        async def handler(event_message: EventMessage):
+            if not future.done():
+                future.set_result(event_message)
+        
+        # Add temporary listener
+        self.add_listener(event_type, handler, filter=filter, once=True)
+        
+        try:
+            if timeout:
+                return await asyncio.wait_for(future, timeout=timeout)
+            else:
+                return await future
+        except asyncio.TimeoutError:
+            # Remove the listener if timeout occurs
+            self.off(event_type, handler)
+            return None
+    
+    def get_metrics(self) -> EventMetrics:
+        """Get event processing metrics."""
+        return self._metrics
+    
+    def reset_metrics(self) -> None:
+        """Reset event processing metrics."""
+        self._metrics = EventMetrics()
+    
+    def list_event_types(self) -> List[EventType]:
+        """Get all event types that have listeners."""
+        return list(self._listeners.keys())
+    
+    def get_listeners(self, event_type: EventType) -> List[EventListener]:
+        """Get all listeners for a specific event type."""
+        return self._listeners.get(event_type, []).copy() 

autocoder/common/agent_events/event_factory.py

@@ -0,0 +1,177 @@
+"""
+Event Factory for creating typed events with proper context management.
+"""
+
+import time
+from typing import Dict, Any, Optional
+from .types import EventMessage, EventType, EventContext
+
+class EventFactory:
+    """Factory for creating typed events with context management."""
+    
+    def __init__(self, default_context: Optional[EventContext] = None):
+        """Initialize factory with optional default context."""
+        self.default_context = default_context
+    
+    @classmethod
+    def create_with_context(cls, context: EventContext) -> 'EventFactory':
+        """Create a factory with default context."""
+        return cls(default_context=context)
+    
+    def set_default_context(self, context: EventContext) -> None:
+        """Set default context for all events created by this factory."""
+        self.default_context = context
+    
+    def _create_event(self, event_type: EventType, content: Dict[str, Any], 
+                     context: Optional[EventContext] = None) -> EventMessage:
+        """Create an event with proper context inheritance."""
+        # Merge contexts - specific context overrides default
+        final_context = self.default_context
+        if context:
+            if final_context:
+                # Merge contexts
+                final_context = EventContext(
+                    agent_id=context.agent_id or final_context.agent_id,
+                    conversation_id=context.conversation_id or final_context.conversation_id,
+                    metadata={**(final_context.metadata or {}), **(context.metadata or {})}
+                )
+            else:
+                final_context = context
+        
+        return EventMessage(
+            event_type=event_type,
+            content=content,
+            context=final_context
+        )
+    
+    def create_pre_tool_use_event(self, tool_name: str, tool_input: Dict[str, Any],
+                                 context: Optional[EventContext] = None) -> EventMessage:
+        """Create a PreToolUse event."""
+        content = {
+            'tool_name': tool_name,
+            'tool_input': tool_input,
+            'timestamp': time.time()
+        }
+        return self._create_event(EventType.PRE_TOOL_USE, content, context)
+    
+    def create_post_tool_use_event(self, tool_name: str, tool_input: Dict[str, Any],
+                                  tool_output: Any, success: bool, 
+                                  execution_time_ms: Optional[float] = None,
+                                  context: Optional[EventContext] = None) -> EventMessage:
+        """Create a PostToolUse event."""
+        content = {
+            'tool_name': tool_name,
+            'tool_input': tool_input,
+            'tool_output': tool_output,
+            'success': success,
+            'timestamp': time.time()
+        }
+        if execution_time_ms is not None:
+            content['execution_time_ms'] = execution_time_ms
+        
+        return self._create_event(EventType.POST_TOOL_USE, content, context)
+    
+    def create_error_occurred_event(self, error_type: str, error_message: str,
+                                   tool_name: Optional[str] = None,
+                                   stack_trace: Optional[str] = None,
+                                   context: Optional[EventContext] = None) -> EventMessage:
+        """Create an ErrorOccurred event."""
+        content = {
+            'error_type': error_type,
+            'error_message': error_message,
+            'timestamp': time.time()
+        }
+        if tool_name:
+            content['tool_name'] = tool_name
+        if stack_trace:
+            content['stack_trace'] = stack_trace
+            
+        return self._create_event(EventType.ERROR_OCCURRED, content, context)
+    
+    def create_conversation_start_event(self, message_count: int = 0,
+                                       conversation_id: Optional[str] = None,
+                                       context: Optional[EventContext] = None) -> EventMessage:
+        """Create a ConversationStart event."""
+        content = {
+            'message_count': message_count,
+            'timestamp': time.time()
+        }
+        if conversation_id:
+            content['conversation_id'] = conversation_id
+            
+        return self._create_event(EventType.CONVERSATION_START, content, context)
+    
+    def create_conversation_end_event(self, did_complete_task: bool,
+                                     iteration_count: int = 0,
+                                     conversation_id: Optional[str] = None,
+                                     context: Optional[EventContext] = None) -> EventMessage:
+        """Create a ConversationEnd event."""
+        content = {
+            'did_complete_task': did_complete_task,
+            'iteration_count': iteration_count,
+            'timestamp': time.time()
+        }
+        if conversation_id:
+            content['conversation_id'] = conversation_id
+            
+        return self._create_event(EventType.CONVERSATION_END, content, context)
+    
+    def create_tool_execution_event(self, tool_name: str, progress: float = 0.0,
+                                   status: str = "running",
+                                   context: Optional[EventContext] = None) -> EventMessage:
+        """Create a ToolExecution event."""
+        content = {
+            'tool_name': tool_name,
+            'progress': progress,
+            'status': status,
+            'timestamp': time.time()
+        }
+        return self._create_event(EventType.TOOL_EXECUTION, content, context)
+    
+    def create_tool_request_approval_event(self, tool_name: str, 
+                                          tool_input: Dict[str, Any],
+                                          reason: str = "",
+                                          context: Optional[EventContext] = None) -> EventMessage:
+        """Create a ToolRequestApproval event."""
+        content = {
+            'tool_name': tool_name,
+            'tool_input': tool_input,
+            'reason': reason,
+            'timestamp': time.time()
+        }
+        return self._create_event(EventType.TOOL_REQUEST_APPROVAL, content, context)
+    
+    def create_mode_change_event(self, old_mode: str, new_mode: str,
+                                context: Optional[EventContext] = None) -> EventMessage:
+        """Create a ModeChange event."""
+        content = {
+            'old_mode': old_mode,
+            'new_mode': new_mode,
+            'timestamp': time.time()
+        }
+        return self._create_event(EventType.MODE_CHANGE, content, context)
+    
+    def create_token_count_info_event(self, input_tokens: int, output_tokens: int,
+                                     total_tokens: int, model: Optional[str] = None,
+                                     context: Optional[EventContext] = None) -> EventMessage:
+        """Create a TokenCountInfo event."""
+        content = {
+            'input_tokens': input_tokens,
+            'output_tokens': output_tokens,
+            'total_tokens': total_tokens,
+            'timestamp': time.time()
+        }
+        if model:
+            content['model'] = model
+            
+        return self._create_event(EventType.TOKEN_COUNT_INFO, content, context)
+    
+    def create_custom_event(self, event_name: str, data: Dict[str, Any],
+                           context: Optional[EventContext] = None) -> EventMessage:
+        """Create a custom event."""
+        content = {
+            'event_name': event_name,
+            'data': data,
+            'timestamp': time.time()
+        }
+        return self._create_event(EventType.CUSTOM_EVENT, content, context)