auto-coder 0.1.362__py3-none-any.whl → 0.1.364__py3-none-any.whl

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

@@ -4,6 +4,9 @@ from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolRe
 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:
@@ -13,7 +16,33 @@ class WriteToFileToolResolver(BaseToolResolver):
     def __init__(self, agent: Optional['AgenticEdit'], tool: WriteToFileTool, args: AutoCoderArgs):
         super().__init__(agent, tool, args)
         self.tool: WriteToFileTool = tool  # For type hinting
+        self.args = args
         self.shadow_manager = self.agent.shadow_manager if self.agent else None
+        self.shadow_linter = self.agent.shadow_linter if self.agent else None
+        
+    def _format_lint_issues(self, lint_result):
+        """
+        将 lint 结果格式化为可读的文本格式
+        
+        参数:
+            lint_result: 单个文件的 lint 结果对象
+            
+        返回:
+            str: 格式化的问题描述
+        """
+        formatted_issues = []
+        
+        for issue in lint_result.issues:
+            severity = "错误" if issue.severity.value == 3 else "警告" if issue.severity.value == 2 else "信息"
+            line_info = f"第{issue.position.line}行"
+            if issue.position.column:
+                line_info += f", 第{issue.position.column}列"
+            
+            formatted_issues.append(
+                f"  - [{severity}] {line_info}: {issue.message} (规则: {issue.code})"
+            )
+        
+        return "\n".join(formatted_issues)
 
     def resolve(self) -> ToolResult:
         file_path = self.tool.path
@@ -39,20 +68,141 @@ class WriteToFileToolResolver(BaseToolResolver):
                 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)
+                        
+            # No shadow manager fallback to original file
+            os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)            
 
-                return ToolResult(success=True, message=f"Successfully wrote to file (shadow): {file_path}", content=content)
+            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)
+
+            if self.agent and self.agent.checkpoint_manager:
+                changes = {
+                    file_path: CheckpointFileChange(
+                        file_path=file_path,
+                        content=content,
+                        is_deletion=False,
+                        is_new=True
+                    )
+                }
+                change_group_id = self.args.event_file
+                self.agent.checkpoint_manager.apply_changes(changes,change_group_id)                    
             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)
-
-                return ToolResult(success=True, message=f"Successfully wrote to file: {file_path}", 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
+                }
+            
+            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)}")

autocoder/common/v2/agent/agentic_edit_types.py

@@ -2,7 +2,6 @@ from pydantic import BaseModel
 from typing import List, Dict, Any, Callable, Optional, Type
 from pydantic import SkipValidation
 
-
 # Result class used by Tool Resolvers
 class ToolResult(BaseModel):
     success: bool
@@ -115,7 +114,7 @@ TOOL_MODEL_MAP: Dict[str, Type[BaseTool]] = {
     "attempt_completion": AttemptCompletionTool,
     "plan_mode_respond": PlanModeRespondTool,
     "use_mcp_tool": UseMcpTool,
-    "list_package_info": ListPackageInfoTool,
+    "list_package_info": ListPackageInfoTool,    
 }
 
 class FileChangeEntry(BaseModel):

autocoder/common/v2/agent/agentic_tool_display.py

@@ -93,8 +93,7 @@ TOOL_DISPLAY_MESSAGES: Dict[Type[BaseTool], Dict[str, str]] = {
             "[dim]工具：[/dim] [blue]{{ tool_name }}[/]\n"
             "[dim]参数：[/dim] {{ arguments_snippet }}{{ ellipsis }}"
         )
-    }    
-    # AttemptCompletionTool is handled separately in the display loop
+    }
 }
 
 def get_tool_display_message(tool: BaseTool) -> str:
@@ -172,7 +171,7 @@ def get_tool_display_message(tool: BaseTool) -> str:
             "tool_name": tool.tool_name,
             "arguments_snippet": snippet,
             "ellipsis": '...' if len(args_str) > 100 else ''
-        }
+        }    
     else:
         # Generic context for tools not specifically handled above
         context = tool.model_dump()

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 "未找到任何事件记录。"