auto-coder 0.1.363__py3-none-any.whl → 0.1.365__py3-none-any.whl

autocoder/common/v2/agent/agentic_edit_tools/write_to_file_tool_resolver.py

@@ -1,10 +1,12 @@
 import os
 from typing import Dict, Any, Optional
-from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult
 from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
 from loguru import logger
 from autocoder.common import AutoCoderArgs
 from autocoder.common.auto_coder_lang import get_message_with_format
+from autocoder.common.file_checkpoint.models import FileChange as CheckpointFileChange
+from autocoder.common.file_checkpoint.manager import FileChangeManager as CheckpointFileChangeManager
 import typing
 
 if typing.TYPE_CHECKING:
@@ -42,145 +44,184 @@ class WriteToFileToolResolver(BaseToolResolver):
         
         return "\n".join(formatted_issues)
 
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        content = self.tool.content
-        source_dir = self.args.source_dir or "."
-        abs_project_dir = os.path.abspath(source_dir)
-        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
+    def write_file_with_shadow(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Write file using shadow manager for path translation"""
+        try:
+            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+            # Ensure shadow directory exists
+            os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
+            with open(shadow_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
 
-        # Security check: ensure the path is within the source directory
-        if not abs_file_path.startswith(abs_project_dir):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
+            # 回调AgenticEdit，记录变更
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+            
+            # 新增：执行代码质量检查
+            lint_results = None
+            lint_message = ""
+            formatted_issues = ""
+            has_lint_issues = False
+            
+            # 检查是否启用了Lint功能
+            enable_lint = self.args.enable_auto_fix_lint
+            
+            if enable_lint:
+                try:
+                    if self.shadow_linter and self.shadow_manager:
+                        # 对新创建的文件进行 lint 检查
+                        shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
+                        
+                        if lint_results and lint_results.issues:
+                            has_lint_issues = True
+                            # 格式化 lint 问题
+                            formatted_issues = self._format_lint_issues(lint_results)
+                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                        else:
+                            lint_message = "\n\n代码质量检查通过，未发现问题。"
+                except Exception as e:
+                    logger.error(f"Lint 检查失败: {str(e)}")
+                    lint_message = "\n\n尝试进行代码质量检查时出错。"
+            else:
+                logger.info("代码质量检查已禁用")
+            
+            # 构建包含 lint 结果的返回消息
+            message = f"Successfully wrote to file (shadow): {file_path}"
+            
+            # 将 lint 消息添加到结果中，如果启用了Lint
+            if enable_lint:
+                message += lint_message
+            
+            # 附加 lint 结果到返回内容
+            result_content = {
+                "content": content,
+            }
+            
+            # 只有在启用Lint时才添加Lint结果
+            if enable_lint:
+                result_content["lint_results"] = {
+                    "has_issues": has_lint_issues,
+                    "issues": formatted_issues if has_lint_issues else None
+                }
+            
+            return ToolResult(success=True, message=message, content=result_content)
+        except Exception as e:
+            logger.error(f"Error writing to shadow file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the shadow file: {str(e)}")
 
+    def write_file_normal(self, file_path: str, content: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Write file directly without using shadow manager"""
         try:
-            if self.shadow_manager:
-                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                # Ensure shadow directory exists
-                os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-                with open(shadow_path, 'w', encoding='utf-8') as f:
-                    f.write(content)
-                logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
+            os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)            
+
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
 
-                # 回调AgenticEdit，记录变更
-                if self.agent:
-                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-                
-                # 新增：执行代码质量检查
-                lint_results = None
-                lint_message = ""
-                formatted_issues = ""
-                has_lint_issues = False
-                
-                # 检查是否启用了Lint功能
-                enable_lint = self.args.enable_auto_fix_lint
-                
-                if enable_lint:
-                    try:
-                        if self.shadow_linter and self.shadow_manager:
-                            # 对新创建的文件进行 lint 检查
-                            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                            lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                            
-                            if lint_results and lint_results.issues:
-                                has_lint_issues = True
-                                # 格式化 lint 问题
-                                formatted_issues = self._format_lint_issues(lint_results)
-                                lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                            else:
-                                lint_message = "\n\n代码质量检查通过，未发现问题。"
-                    except Exception as e:
-                        logger.error(f"Lint 检查失败: {str(e)}")
-                        lint_message = "\n\n尝试进行代码质量检查时出错。"
-                else:
-                    logger.info("代码质量检查已禁用")
-                
-                # 构建包含 lint 结果的返回消息
-                message = f"Successfully wrote to file (shadow): {file_path}"
-                
-                # 将 lint 消息添加到结果中，如果启用了Lint
-                if enable_lint:
-                    message += lint_message
-                
-                # 附加 lint 结果到返回内容
-                result_content = {
-                    "content": content,
+            if self.agent and self.agent.checkpoint_manager:
+                changes = {
+                    file_path: CheckpointFileChange(
+                        file_path=file_path,
+                        content=content,
+                        is_deletion=False,
+                        is_new=True
+                    )
                 }
-                
-                # 只有在启用Lint时才添加Lint结果
-                if enable_lint:
-                    result_content["lint_results"] = {
-                        "has_issues": has_lint_issues,
-                        "issues": formatted_issues if has_lint_issues else None
-                    }
-                
-                return ToolResult(success=True, message=message, content=result_content)
+                change_group_id = self.args.event_file
+                                                              
+                self.agent.checkpoint_manager.apply_changes_with_conversation(
+                            changes=changes,
+                            conversations=self.agent.current_conversations,
+                            change_group_id=change_group_id,
+                            metadata={"event_file": self.args.event_file}
+                        )                    
             else:
-                # No shadow manager fallback to original file
-                os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)
                 with open(abs_file_path, 'w', encoding='utf-8') as f:
                     f.write(content)
-                logger.info(f"Successfully wrote to file: {file_path}")
-
-                if self.agent:
-                    rel_path = os.path.relpath(abs_file_path, abs_project_dir)
-                    self.agent.record_file_change(rel_path, "added", diff=None, content=content)
-                
-                # 新增：执行代码质量检查
-                lint_results = None
-                lint_message = ""
-                formatted_issues = ""
-                has_lint_issues = False
-                
-                # 检查是否启用了Lint功能
-                enable_lint = self.args.enable_auto_fix_lint
-                
-                if enable_lint:
-                    try:
-                        if self.shadow_linter and self.shadow_manager:
-                            # 对新创建的文件进行 lint 检查
-                            # 由于没有shadow系统，需要先创建shadow文件
-                            shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
-                            os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
-                            with open(shadow_path, 'w', encoding='utf-8') as f:
-                                f.write(content)
-                            
-                            lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
-                            
-                            if lint_results and lint_results.issues:
-                                has_lint_issues = True
-                                # 格式化 lint 问题
-                                formatted_issues = self._format_lint_issues(lint_results)
-                                lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
-                            else:
-                                lint_message = "\n\n代码质量检查通过，未发现问题。"
-                    except Exception as e:
-                        logger.error(f"Lint 检查失败: {str(e)}")
-                        lint_message = "\n\n尝试进行代码质量检查时出错。"
-                else:
-                    logger.info("代码质量检查已禁用")
-                
-                # 构建包含 lint 结果的返回消息
-                message = f"Successfully wrote to file: {file_path}"
-                
-                # 将 lint 消息添加到结果中，如果启用了Lint
-                if enable_lint:
-                    message += lint_message
-                
-                # 附加 lint 结果到返回内容
-                result_content = {
-                    "content": content,
+            logger.info(f"Successfully wrote to file: {file_path}")    
+            
+            # 新增：执行代码质量检查
+            lint_results = None
+            lint_message = ""
+            formatted_issues = ""
+            has_lint_issues = False
+            
+            # 检查是否启用了Lint功能
+            enable_lint = self.args.enable_auto_fix_lint
+            
+            if enable_lint:
+                try:
+                    if self.shadow_linter and self.shadow_manager:
+                        # 对新创建的文件进行 lint 检查
+                        # 由于没有shadow系统，需要先创建shadow文件
+                        shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                        os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
+                        with open(shadow_path, 'w', encoding='utf-8') as f:
+                            f.write(content)
+                        
+                        lint_results = self.shadow_linter.lint_shadow_file(shadow_path)
+                        
+                        if lint_results and lint_results.issues:
+                            has_lint_issues = True
+                            # 格式化 lint 问题
+                            formatted_issues = self._format_lint_issues(lint_results)
+                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                        else:
+                            lint_message = "\n\n代码质量检查通过，未发现问题。"
+                    if self.agent.linter:
+                        lint_results = self.agent.linter.lint_file(file_path)
+                        if lint_results and lint_results.issues:
+                            has_lint_issues = True
+                            # 格式化 lint 问题
+                            formatted_issues = self._format_lint_issues(lint_results)
+                            lint_message = f"\n\n代码质量检查发现 {len(lint_results.issues)} 个问题:\n{formatted_issues}"
+                except Exception as e:
+                    logger.error(f"Lint 检查失败: {str(e)}")
+                    lint_message = "\n\n尝试进行代码质量检查时出错。"
+            else:
+                logger.info("代码质量检查已禁用")
+            
+            # 构建包含 lint 结果的返回消息
+            message = f"{file_path}"
+            
+            # 将 lint 消息添加到结果中，如果启用了Lint
+            if enable_lint:
+                message += lint_message
+            
+            # 附加 lint 结果到返回内容
+            result_content = {
+                "content": content,
+            }
+            
+            # 只有在启用Lint时才添加Lint结果
+            if enable_lint:
+                result_content["lint_results"] = {
+                    "has_issues": has_lint_issues,
+                    "issues": formatted_issues if has_lint_issues else None
                 }
-                
-                # 只有在启用Lint时才添加Lint结果
-                if enable_lint:
-                    result_content["lint_results"] = {
-                        "has_issues": has_lint_issues,
-                        "issues": formatted_issues if has_lint_issues else None
-                    }
-                
-                return ToolResult(success=True, message=message, content=result_content)
+            
+            return ToolResult(success=True, message=message, content=result_content)
         except Exception as e:
             logger.error(f"Error writing to file '{file_path}': {str(e)}")
-            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the write file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        content = self.tool.content
+        source_dir = self.args.source_dir or "."
+        abs_project_dir = os.path.abspath(source_dir)
+        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
+
+        # Security check: ensure the path is within the source directory
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
+
+        # Choose the appropriate implementation based on whether shadow_manager is available
+        if self.shadow_manager:
+            return self.write_file_with_shadow(file_path, content, source_dir, abs_project_dir, abs_file_path)
+        else:
+            return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)

autocoder/common/v2/agent/agentic_edit_types.py

@@ -96,6 +96,10 @@ class ErrorEvent(BaseModel):
     """Represents an error during the process."""
     message: str
 
+class WindowLengthChangeEvent(BaseModel):
+    """Represents the token usage in the conversation window."""
+    tokens_used: int
+
 # Deprecated: Will be replaced by specific Event types
 # class PlainTextOutput(BaseModel):
 #     text: str

autocoder/compilers/normal_compiler.py

@@ -0,0 +1,64 @@
+"""
+用于对文件进行编译的模块。
+"""
+
+import os
+from typing import Optional
+from autocoder.compilers.compiler_factory import CompilerFactory
+from autocoder.compilers.models import ProjectCompilationResult, FileCompilationResult
+
+class NormalCompiler:
+    """
+    用于对文件进行编译的类。
+    """
+    
+    def __init__(self, project_dir: str, verbose: bool = False):
+        """
+        初始化编译器。
+        
+        参数:
+            project_dir (str): 项目根目录路径
+            verbose (bool): 是否启用详细输出
+        """
+        self.project_dir = project_dir
+        self.compiler = CompilerFactory.create_compiler(
+            language="provided",
+            config_path=os.path.join(self.project_dir, ".auto-coder", "projects", "compiler.yml")
+        )
+
+    def compile_file(self, file_path: str) -> FileCompilationResult:
+        """
+        编译单个文件。
+        
+        参数:
+            file_path (str): 文件路径
+            
+        返回:
+            FileCompilationResult: 编译结果
+        """
+        return FileCompilationResult(
+            file_path=file_path,
+            success=True,
+            language="provided",
+            errors=[],
+            error_message=None,
+            warning_count=0,
+            error_count=0,
+            info_count=0,
+            execution_time_ms=0,
+            output_file=None
+        )  
+
+    def compile_all_files(self, target_compiler_name: Optional[str] = None) -> ProjectCompilationResult:
+        """
+        编译项目中的所有文件。
+        
+        参数:
+            target_compiler_name (Optional[str]): 目标编译器名称
+            
+        返回:
+            ProjectCompilationResult: 项目编译结果
+        """
+        result = self.compiler.compile_project(self.project_dir, target_compiler_name)
+        result.project_path = self.project_dir
+        return result

autocoder/events/event_manager_singleton.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import glob
 import json
 import re
+import time
 from pathlib import Path
 import byzerllm
 
@@ -22,6 +23,10 @@ class EventManagerSingleton:
     _default_instance: Optional[EventManager] = None
     _instances: Dict[str, EventManager] = {}
     _lock = threading.RLock()  # 用于线程安全操作的锁
+    _cleanup_thread: Optional[threading.Thread] = None
+    _stop_cleanup = threading.Event()
+    _max_event_files = 100  # 最大保留的事件文件数量
+    _cleanup_interval = 60  # 清理线程执行间隔，单位秒
     
     @classmethod
     def get_instance(cls, event_file: Optional[str] = None) -> EventManager:
@@ -34,15 +39,26 @@ class EventManagerSingleton:
         Returns:
             EventManager: The appropriate EventManager instance
         """
+        # 确保清理线程已启动
+        cls._ensure_cleanup_thread_started()
+        
         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")))
+                logger.info("Creating new default EventManager instance.")
+                event_store_path = os.path.join(".auto-coder", "events", "events.jsonl")
+                logger.debug(f"Default EventManager using event store: {event_store_path}")
+                cls._default_instance = EventManager(JsonlEventStore(event_store_path))
+            else:
+                logger.debug("Returning existing default EventManager instance.")
             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:
+            logger.info(f"Creating new EventManager instance for event file: {event_file}")
             cls._instances[event_file] = EventManager(JsonlEventStore(event_file))  
+        else:
+            logger.debug(f"Returning existing EventManager instance for event file: {event_file}")
         
         return cls._instances[event_file]
     
@@ -52,7 +68,11 @@ class EventManagerSingleton:
         重置单例实例。主要用于测试或需要更改事件文件时。
         """
         with cls._lock:
-            cls._default_instance = None
+            if cls._default_instance is not None:
+                logger.info("Resetting default EventManager instance.")
+                cls._default_instance = None
+            else:
+                logger.debug("Default EventManager instance was already None. No reset needed.")
     
     @classmethod
     def set_default_event_file(cls, event_file: str) -> None:
@@ -68,6 +88,110 @@ class EventManagerSingleton:
                 cls._default_event_file = event_file
         else:
             logger.warning("尝试更改默认事件文件，但实例已存在。请先调用reset_instance()。")
+    
+    @classmethod
+    def _ensure_cleanup_thread_started(cls) -> None:
+        """
+        确保清理线程已启动。如果尚未启动，则启动线程。
+        """
+        with cls._lock:
+            if cls._cleanup_thread is None or not cls._cleanup_thread.is_alive():
+                logger.info("启动事件文件清理线程")
+                cls._stop_cleanup.clear()
+                cls._cleanup_thread = threading.Thread(
+                    target=cls._cleanup_event_files_thread,
+                    daemon=True,
+                    name="EventFilesCleanupThread"
+                )
+                cls._cleanup_thread.start()
+    
+    @classmethod
+    def _cleanup_event_files_thread(cls) -> None:
+        """
+        定时清理线程的主函数。定期执行清理操作，确保事件目录只保留最新的指定数量文件。
+        """
+        logger.info(f"事件文件清理线程已启动，将保留最新的{cls._max_event_files}个文件")
+        while not cls._stop_cleanup.is_set():
+            try:
+                cls._cleanup_event_files()
+                # 等待指定时间或直到停止信号
+                cls._stop_cleanup.wait(cls._cleanup_interval)
+            except Exception as e:
+                logger.error(f"事件文件清理过程中发生错误: {e}")
+                # 出错后等待一段时间再重试
+                time.sleep(60)
+    
+    @classmethod
+    def _cleanup_event_files(cls) -> None:
+        """
+        清理事件文件，只保留最新的指定数量文件。
+        """
+        logger.info("开始清理事件文件...")
+        
+        # 确定事件文件所在目录
+        events_dir = os.path.join(os.getcwd(),".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.info(f"未找到任何事件文件: {event_file_pattern}")
+            return
+        
+        # 排除默认的events.jsonl文件
+        event_files = [f for f in event_files if os.path.basename(f) != "events.jsonl"]
+        
+        if len(event_files) <= cls._max_event_files:
+            logger.info(f"事件文件数量({len(event_files)})未超过最大保留数量({cls._max_event_files})，无需清理")
+            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)
+        
+        # 保留最新的文件，删除其余文件
+        files_to_keep = sorted_files[:cls._max_event_files]
+        files_to_delete = sorted_files[cls._max_event_files:]
+        
+        for file_path in files_to_delete:
+            try:
+                os.remove(file_path)
+                logger.info(f"已删除旧事件文件: {file_path}")
+            except Exception as e:
+                logger.error(f"删除事件文件失败 {file_path}: {e}")
+        
+        logger.info(f"事件文件清理完成，删除了{len(files_to_delete)}个旧文件，保留了{len(files_to_keep)}个最新文件")
+    
+    @classmethod
+    def stop_cleanup_thread(cls) -> None:
+        """
+        停止清理线程，通常在应用程序退出时调用。
+        """
+        logger.info("正在停止事件文件清理线程...")
+        cls._stop_cleanup.set()
+        if cls._cleanup_thread and cls._cleanup_thread.is_alive():
+            cls._cleanup_thread.join(timeout=5)
+            if cls._cleanup_thread.is_alive():
+                logger.warning("清理线程未在指定时间内停止")
+            else:
+                logger.info("清理线程已成功停止")
 
 def get_event_file_path(file_id:str,project_path: Optional[str] = None) -> str:
     if project_path is None:
@@ -95,9 +219,12 @@ def gengerate_event_file_path(project_path: Optional[str] = None) -> Tuple[str,s
     
     # 要使用绝对路径，否则会被认为产生两个event_manager
     if project_path is None:
-        return os.path.join(os.getcwd(),".auto-coder", "events", file_name),file_id
+        full_path = os.path.join(os.getcwd(),".auto-coder", "events", file_name)
     else:   
-        return os.path.join(project_path, ".auto-coder", "events", file_name),file_id
+        full_path = os.path.join(project_path, ".auto-coder", "events", file_name)
+    
+    logger.info(f"Generated event file path: {full_path}, file_id: {file_id}")
+    return full_path, file_id
 
 @byzerllm.prompt()
 def _format_events_prompt(event_files: List[Dict]) -> str:
@@ -148,6 +275,7 @@ def to_events_prompt(limit: int = 5, project_path: Optional[str] = None) -> str:
     Returns:
         格式化后的事件提示文本
     """
+    logger.info(f"Generating events prompt with limit={limit}, project_path={project_path}")
     # 确定事件文件所在目录
     if project_path is None:
         events_dir = os.path.join(".auto-coder", "events")
@@ -164,6 +292,7 @@ def to_events_prompt(limit: int = 5, project_path: Optional[str] = None) -> str:
     event_files = glob.glob(event_file_pattern)
     
     if not event_files:
+        logger.info(f"No event files found in pattern: {event_file_pattern}")
         logger.warning(f"未找到任何事件文件: {event_file_pattern}")
         return "未找到任何事件记录。"