auto-coder 0.1.301__py3-none-any.whl → 0.1.303__py3-none-any.whl

autocoder/events/event_manager.py

@@ -0,0 +1,327 @@
+"""
+Event manager for handling events between System A and System B.
+"""
+from loguru import logger
+import os
+import time
+import threading
+from typing import Optional, List, Dict, Any, Callable, Union, TypeVar, Generic
+
+from .event_store import EventStore, JsonlEventStore
+from .event_types import Event, EventType, ResponseEvent
+
+T = TypeVar('T')
+
+
+class EventManager:
+    """
+    Manager for handling events between two systems.
+    System A writes events and can be blocked by special events.
+    System B reads events and can respond to special events.
+    """
+    
+    def __init__(self, event_store: EventStore):
+        """
+        Initialize an event manager.
+        
+        Args:
+            event_store: The event store to use
+        """
+        self.event_store = event_store        
+        self._last_read_event_id: Optional[str] = self.event_store._last_event_id
+        self._blocking_events: Dict[str, threading.Event] = {}
+        self._response_callbacks: Dict[str, Callable[[str], None]] = {}
+    
+    @classmethod
+    def create(cls, file_path: str) -> "EventManager":
+        """
+        Create an event manager with a JSONL event store.
+        
+        Args:
+            file_path: Path to the JSONL file
+            
+        Returns:
+            An initialized event manager
+        """
+        store = JsonlEventStore(file_path)
+        return cls(store)
+    
+    def write_result(self, content: Union[Dict[str, Any], Any], metadata: Dict[str, Any] = {}) -> Event:
+        """
+        Write a result event.
+        
+        Args:
+            content: The content of the result
+            metadata: The metadata of the result
+        Returns:
+            The created event
+        """
+        if not isinstance(content, dict):
+            content = content.to_dict()
+        event = Event(event_type=EventType.RESULT, content=content, metadata=metadata)
+        self.event_store.append_event(event)
+        return event
+    
+    def write_completion(self, content: Union[Dict[str, Any], Any]) -> Event:
+        """
+        Write a completion event.
+        
+        Args:
+            content: The content of the completion (CompletionContent or dict)
+            
+        Returns:
+            The created event
+        """
+        if not isinstance(content, dict):
+            content = content.to_dict()
+        event = Event(event_type=EventType.COMPLETION, content=content)
+        self.event_store.append_event(event)
+        return event
+    
+    def write_error(self, content: Union[Dict[str, Any], Any]) -> Event:
+        """
+        Write an error event.
+        
+        Args:
+            content: The content of the error (ErrorContent or dict)
+            
+        Returns:
+            The created event
+        """
+        if not isinstance(content, dict):
+            content = content.to_dict()
+        event = Event(event_type=EventType.ERROR, content=content)
+        self.event_store.append_event(event)
+        return event
+    
+    def write_stream(self, content: Union[Dict[str, Any], Any], metadata: Dict[str, Any] = {}) -> Event:
+        """
+        Write a stream event.
+        
+        Args:
+            content: The content of the stream
+            metadata: The metadata of the stream
+        Returns:
+            The created event
+        """
+        if not isinstance(content, dict):
+            content = content.to_dict()
+        event = Event(event_type=EventType.STREAM, content=content, metadata=metadata)
+        self.event_store.append_event(event)
+        return event
+    
+    def ask_user(self, 
+                prompt: str, 
+                options: Optional[List[str]] = None,
+                callback: Optional[Callable[[str], None]] = None) -> str:
+        """
+        Ask the user a question and wait for response.
+        This method blocks until a response is received.
+        
+        Args:
+            prompt: The question to ask
+            options: Optional list of valid responses
+            callback: Optional callback function that will be called with the response
+            
+        Returns:
+            The user's response
+        """
+        logger.debug(f"ask_user called with prompt: {prompt}")
+        content = {"prompt": prompt}
+        if options:
+            content["options"] = options
+        
+        event = Event(event_type=EventType.ASK_USER, content=content)
+        logger.debug(f"Created ASK_USER event with ID: {event.event_id}")
+        
+        # Register a blocking event
+        blocker = threading.Event()        
+        self.event_store.append_event(event)            
+        self._blocking_events[event.event_id] = blocker
+        logger.debug(f"self._blocking_events: {self._blocking_events}")
+        if callback:
+            self._response_callbacks[event.event_id] = callback
+            logger.debug(f"Registered callback for event: {event.event_id}")
+        
+        # Wait for response
+        logger.debug(f"Waiting for response to event: {event.event_id}")
+        
+        # 无限等待响应，不设超时
+        wait_result = blocker.wait(timeout=60.0)  # 设置一个较长的超时时间（60秒）
+        
+        if not wait_result:
+            logger.warning(f"Timeout waiting for response to event: {event.event_id}")
+            return ""
+            
+        logger.debug(f"Received signal that response is available for: {event.event_id}")
+        
+        # Get the response event
+        def is_response(e: Event) -> bool:
+            return (isinstance(e, ResponseEvent) and 
+                    e.event_type == EventType.USER_RESPONSE and 
+                    e.response_to == event.event_id)
+        
+        response_event = self.event_store.wait_for_event(is_response, timeout=1.0)
+        
+        # 获取响应内容
+        response = ""
+        if response_event and "response" in response_event.content:
+            response = response_event.content["response"]
+            logger.debug(f"Retrieved response: '{response}' from event: {response_event.event_id}")
+        else:
+            logger.warning("No valid response found in event store")
+        
+        # 清理资源（移到这里确保在获取响应后才清理）        
+        if event.event_id in self._blocking_events:
+            del self._blocking_events[event.event_id]
+            logger.debug(f"Clean up blocker for event: {event.event_id}")
+        else:
+            logger.debug(f"No blocker found for event: {event.event_id} during cleanup")
+            
+            # 注意：回调不在这里清理，而是在respond_to_user中清理
+            # 这样回调函数仍然可用
+
+        return response
+    
+    def respond_to_user(self, ask_event_id: str, response: str) -> ResponseEvent:
+        """
+        Respond to a user question.
+        
+        Args:
+            ask_event_id: ID of the ASK_USER event
+            response: The response to provide
+            
+        Returns:
+            The created response event
+        """
+        logger.debug(f"respond_to_user called for event: {ask_event_id} with response: '{response}'")
+        
+        # 创建响应事件
+        event = ResponseEvent(
+            event_type=EventType.USER_RESPONSE,
+            content={"response": response},
+            response_to=ask_event_id
+        )
+        
+        # 存储响应事件
+        self.event_store.append_event(event)
+        logger.debug(f"Response event created and stored with ID: {event.event_id}")
+                
+        # 获取回调和阻塞器
+        callback = None
+                
+        # 检查是否有回调
+        if ask_event_id in self._response_callbacks:
+            callback = self._response_callbacks[ask_event_id]
+            # 暂时不删除回调，确保不会丢失
+            logger.debug(f"Retrieved callback for event: {ask_event_id}")
+        else:
+            logger.debug(f"No callback found for event: {ask_event_id}")
+                            
+        
+        # 如果找到了回调，执行它
+        if callback:
+            try:
+                logger.debug(f"Executing callback for event: {ask_event_id}")
+                callback(response)
+                logger.debug(f"Callback execution completed for event: {ask_event_id}")
+                
+                # 回调执行后再移除它                
+                if ask_event_id in self._response_callbacks:
+                    del self._response_callbacks[ask_event_id]
+            except Exception as e:
+                logger.error(f"Error in response callback: {e}")   
+
+        # 检查是否存在对应的阻塞事件        
+        logger.debug(f"self._blocking_events: {self._blocking_events}")
+        if ask_event_id in self._blocking_events:
+            self._blocking_events[ask_event_id].set()
+            logger.debug(f"Unblocked event: {ask_event_id}")
+        else:
+            logger.warning(f"No blocking event found for event_id: {ask_event_id}")
+        
+        return event
+    
+    def read_events(self, 
+                   event_types: Optional[List[EventType]] = None,
+                   block: bool = False,
+                   timeout: Optional[float] = None) -> List[Event]:
+        """
+        Read events from the store.
+        
+        Args:
+            event_types: Only get events of these types
+            block: Whether to block until new events are available
+            timeout: Maximum time to wait if blocking
+            
+        Returns:
+            List of events
+        """        
+        events = self.event_store.get_events(
+            after_id=self._last_read_event_id,
+            event_types=event_types
+        )
+        
+        if events:
+            self._last_read_event_id = events[-1].event_id
+            return events
+        
+        # No events and not blocking
+        if not block:
+            return []
+        
+        # Wait for new events
+        def is_new_event(e: Event) -> bool:
+            if event_types and e.event_type not in event_types:
+                return False
+                        
+            return self._last_read_event_id is None or e.event_id != self._last_read_event_id
+        
+        event = self.event_store.wait_for_event(is_new_event, timeout=timeout)
+        
+        if event:            
+            events = self.event_store.get_events(
+                after_id=self._last_read_event_id,
+                event_types=event_types
+            )
+            
+            if events:
+                self._last_read_event_id = events[-1].event_id
+                return events
+        
+        return []
+        
+    
+    def close(self) -> None:
+        """
+        Close the event manager and its event store.
+        """
+        # Unblock any waiting threads        
+        for blocker in self._blocking_events.values():
+            blocker.set()
+        
+        # Close the event store
+        if isinstance(self.event_store, JsonlEventStore):
+            self.event_store.close()
+
+    def truncate(self) -> None:
+        """
+        Clear all events from the event store.
+        This truncates the underlying file and resets the last read event ID.
+        
+        Warning: This operation cannot be undone and will permanently delete all events.
+        """
+        if not hasattr(self.event_store, 'truncate'):
+            raise NotImplementedError("The current event store does not support truncation")
+        
+        # Reset the last read event ID
+        self._last_read_event_id = None
+        
+        # Clear blocking events and callbacks
+        self._blocking_events.clear()
+        self._response_callbacks.clear()
+        
+        # Truncate the store
+        self.event_store.truncate()
+        
+        logger.debug("Event store has been truncated") 

autocoder/events/event_manager_singleton.py

@@ -0,0 +1,245 @@
+import os
+import threading
+from typing import Optional, Dict, Any, List
+import uuid
+from datetime import datetime
+import glob
+import json
+import re
+from pathlib import Path
+import byzerllm
+
+from .event_manager import EventManager
+from .event_store import EventStore, JsonlEventStore
+from .event_types import Event, EventType
+from loguru import logger
+
+
+class EventManagerSingleton:
+    """
+    EventManager的单例包装器。确保整个应用程序中只有一个EventManager实例    
+    """
+    _default_instance: Optional[EventManager] = None
+    _instances: Dict[str, EventManager] = {}
+    _lock = threading.RLock()  # 用于线程安全操作的锁
+    
+    @classmethod
+    def get_instance(cls, event_file: Optional[str] = None) -> EventManager:
+        """
+        Get an EventManager instance for the specified event file.
+        
+        Args:
+            event_file: Event file path to use as key. If None, returns the default instance.
+            
+        Returns:
+            EventManager: The appropriate EventManager instance
+        """
+        if event_file is None:
+            # Use default instance logic
+            if cls._default_instance is None:
+                cls._default_instance = EventManager(JsonlEventStore(os.path.join(".auto-coder", "events", "events.jsonl")))
+            return cls._default_instance
+        
+        # If event_file is provided, use it as a key to store/retrieve EventManager instances
+        if event_file not in cls._instances:
+            cls._instances[event_file] = EventManager(JsonlEventStore(event_file))  
+        
+        return cls._instances[event_file]
+    
+    @classmethod
+    def reset_instance(cls) -> None:
+        """
+        重置单例实例。主要用于测试或需要更改事件文件时。
+        """
+        with cls._lock:
+            cls._default_instance = None
+    
+    @classmethod
+    def set_default_event_file(cls, event_file: str) -> None:
+        """
+        设置默认事件文件路径。
+        仅在实例尚未创建时有效。
+        
+        Args:
+            event_file: 新的默认事件文件路径
+        """
+        if cls._default_instance is None:
+            with cls._lock:
+                cls._default_event_file = event_file
+        else:
+            logger.warning("尝试更改默认事件文件，但实例已存在。请先调用reset_instance()。")
+
+def get_event_file_path(file_id:str,project_path: Optional[str] = None) -> str:
+    if project_path is None:
+        return os.path.join(".auto-coder", "events", f"{file_id}.jsonl")
+    else:
+        return os.path.join(project_path, ".auto-coder", "events", f"{file_id}.jsonl")
+
+def gengerate_event_file_path(project_path: Optional[str] = None) -> (str,str):
+    """
+    生成一个格式为 uuid_timestamp.jsonl 的事件文件名。
+    timestamp 格式为 YYYYMMDD-HHMMSS。
+    
+    Returns:
+        生成的事件文件路径
+    """
+    # 生成 UUID
+    unique_id = str(uuid.uuid4())
+    
+    # 生成当前时间戳，格式为 YYYYMMDD-HHMMSS
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    
+    file_id = f"{unique_id}_{timestamp}"
+    # 组合文件名
+    file_name = f"{file_id}.jsonl"
+    
+    if project_path is None:
+        return os.path.join(".auto-coder", "events", file_name),file_id
+    else:   
+        return os.path.join(project_path, ".auto-coder", "events", file_name),file_id
+
+@byzerllm.prompt()
+def _format_events_prompt(event_files: List[Dict]) -> str:
+    """       
+    <recent_events>                
+    最近的事件记录，从最新到最旧排序：
+    
+    {% for event_file in event_files %}
+    ## 事件文件 {{ loop.index }}: {{ event_file.file_name }}
+    
+    {% if event_file.timestamp %}
+    **时间**: {{ event_file.timestamp }}
+    {% endif %}
+    
+    {% if event_file.events %}
+    **事件内容**:
+    {% for event in event_file.events %}
+    - 类型: {{ event.event_type }}
+      {% if event.content %}
+      内容: 
+      ```
+      {{ event.content }}
+      ```
+      {% endif %}
+      {% if event.metadata %}
+      元数据: {{ event.metadata }}
+      {% endif %}
+    {% endfor %}
+    {% endif %}
+    
+    {% if not loop.last %}
+    ---
+    {% endif %}
+    {% endfor %}
+    </recent_events>
+    请注意上述最近的事件记录，以便更好地理解当前系统状态和交互历史。
+    """
+
+def to_events_prompt(limit: int = 5, project_path: Optional[str] = None) -> str:
+    """
+    获取最近的N条事件文件并读取其中的事件内容，返回格式化后的提示文本。
+    排除类型为 STREAM 的事件，以减少输出内容的冗余。
+    
+    Args:
+        limit: 最多返回的事件文件数量，默认为5
+        project_path: 可选的项目路径，如果提供则在该路径下查找事件文件
+        
+    Returns:
+        格式化后的事件提示文本
+    """
+    # 确定事件文件所在目录
+    if project_path is None:
+        events_dir = os.path.join(".auto-coder", "events")
+    else:
+        events_dir = os.path.join(project_path, ".auto-coder", "events")
+    
+    # 确保目录存在
+    if not os.path.exists(events_dir):
+        logger.warning(f"事件目录不存在: {events_dir}")
+        return "未找到任何事件记录。"
+    
+    # 获取所有事件文件
+    event_file_pattern = os.path.join(events_dir, "*.jsonl")
+    event_files = glob.glob(event_file_pattern)
+    
+    if not event_files:
+        logger.warning(f"未找到任何事件文件: {event_file_pattern}")
+        return "未找到任何事件记录。"
+    
+    # 解析文件名中的时间戳，格式为 uuid_YYYYMMDD-HHMMSS.jsonl
+    def extract_timestamp(file_path):
+        file_name = os.path.basename(file_path)
+        match = re.search(r'_(\d{8}-\d{6})\.jsonl$', file_name)
+        if match:
+            timestamp_str = match.group(1)
+            try:
+                return datetime.strptime(timestamp_str, "%Y%m%d-%H%M%S")
+            except ValueError:
+                return datetime.fromtimestamp(0)  # 默认最早时间
+        return datetime.fromtimestamp(0)  # 默认最早时间
+    
+    # 按时间戳从新到旧排序
+    sorted_files = sorted(event_files, key=extract_timestamp, reverse=True)
+    limited_files = sorted_files[:limit]
+    
+    # 读取和解析事件文件
+    event_data = []
+    for file_path in limited_files:
+        file_name = os.path.basename(file_path)
+        timestamp = extract_timestamp(file_path).strftime("%Y-%m-%d %H:%M:%S")
+        
+        try:
+            events = []
+            with open(file_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        try:
+                            event_json = json.loads(line)
+                            event = Event.from_dict(event_json)
+                            
+                            # 排除 STREAM 类型的事件
+                            if event.event_type == EventType.STREAM:
+                                continue
+                                
+                            events.append({
+                                "event_type": event.event_type.name,
+                                "content": json.dumps(event.content, ensure_ascii=False, indent=2) if event.content else "",
+                                "metadata": json.dumps(event.metadata, ensure_ascii=False, indent=2) if event.metadata else ""
+                            })
+                        except json.JSONDecodeError:
+                            logger.warning(f"无法解析事件行: {line}")
+                        except Exception as e:
+                            logger.warning(f"处理事件时出错: {e}")
+            
+            event_data.append({
+                "file_name": file_name,
+                "timestamp": timestamp,
+                "events": events
+            })
+        except Exception as e:
+            logger.error(f"读取事件文件出错 {file_path}: {e}")
+            event_data.append({
+                "file_name": file_name,
+                "timestamp": timestamp,
+                "error": str(e)
+            })
+    
+    # 使用模板格式化事件数据
+    return _format_events_prompt(event_data)
+
+# 便捷函数，可以直接导入使用
+def get_event_manager(event_file: Optional[str] = None) -> EventManager:
+    """
+    获取EventManager的单例实例。
+    
+    如果没有提供event_file，将返回默认的EventManager实例。
+    如果提供了event_file，将返回或创建与该文件关联的EventManager实例。
+    
+    Args:
+        event_file: 事件文件路径，如果为None则使用默认路径
+        
+    Returns:
+        EventManager实例
+    """
+    return EventManagerSingleton.get_instance(event_file)