auto-coder 0.1.298__py3-none-any.whl → 0.1.300__py3-none-any.whl

autocoder/common/action_yml_file_manager.py

@@ -0,0 +1,367 @@
+import os
+import yaml
+import hashlib
+import git
+from typing import List, Dict, Tuple, Optional, Union, Any
+from loguru import logger
+from autocoder.common.printer import Printer
+
+
+class ActionYmlFileManager:
+    """
+    Actions 目录文件操作工具类，用于抽象和管理 actions 目录下的 YAML 文件操作。
+    
+    主要功能包括：
+    - 获取最新的 YAML 文件
+    - 按序号排序 YAML 文件
+    - 创建新的 YAML 文件
+    - 更新 YAML 文件内容
+    - 处理 commit 消息与 YAML 文件的关联
+    """
+    
+    def __init__(self, source_dir: str):
+        """
+        初始化 ActionYmlFileManager
+        
+        Args:
+            source_dir: 项目根目录
+        """
+        self.source_dir = source_dir
+        self.actions_dir = os.path.join(source_dir, "actions")
+        self.printer = Printer()
+        
+    def ensure_actions_dir(self) -> bool:
+        """
+        确保 actions 目录存在
+        
+        Returns:
+            bool: 如果目录存在或创建成功返回 True，否则返回 False
+        """
+        if not os.path.exists(self.actions_dir):
+            try:
+                os.makedirs(self.actions_dir, exist_ok=True)
+                return True
+            except Exception as e:
+                logger.error(f"Failed to create actions directory: {e}")
+                return False
+        return True
+    
+    def get_action_files(self, filter_prefix: Optional[str] = None) -> List[str]:
+        """
+        获取所有符合条件的 YAML 文件名
+        
+        Args:
+            filter_prefix: 可选的文件名前缀过滤
+            
+        Returns:
+            List[str]: 符合条件的文件名列表
+        """
+        if not os.path.exists(self.actions_dir):
+            return []
+            
+        action_files = [
+            f for f in os.listdir(self.actions_dir) 
+            if f[:3].isdigit() and "_" in f and f.endswith('.yml')
+        ]
+        
+        if filter_prefix:
+            action_files = [f for f in action_files if f.startswith(filter_prefix)]
+            
+        return action_files
+    
+    def get_sequence_number(self, file_name: str) -> int:
+        """
+        从文件名中提取序号
+        
+        Args:
+            file_name: YAML 文件名
+            
+        Returns:
+            int: 文件序号
+        """
+        try:
+            return int(file_name.split("_")[0])
+        except (ValueError, IndexError):
+            return 0
+    
+    def get_latest_action_file(self, filter_prefix: Optional[str] = None) -> Optional[str]:
+        """
+        获取最新的 action 文件名（序号最大的）
+        
+        Args:
+            filter_prefix: 可选的文件名前缀过滤
+            
+        Returns:
+            Optional[str]: 最新文件名，如果没有则返回 None
+        """
+        action_files = self.get_action_files(filter_prefix)
+        
+        if not action_files:
+            return None
+            
+        # 按序号排序
+        sorted_files = sorted(action_files, key=self.get_sequence_number, reverse=True)
+        return sorted_files[0] if sorted_files else None
+    
+    def get_next_sequence_number(self) -> int:
+        """
+        获取下一个序号
+        
+        Returns:
+            int: 下一个序号
+        """
+        action_files = self.get_action_files()
+        
+        if not action_files:
+            return 1
+            
+        seqs = [self.get_sequence_number(f) for f in action_files]
+        return max(seqs) + 1
+    
+    def create_next_action_file(self, name: str, content: Optional[str] = None, 
+                               from_yaml: Optional[str] = None) -> Optional[str]:
+        """
+        创建下一个序号的 action 文件
+        
+        Args:
+            name: 文件基本名称（不含序号和扩展名）
+            content: 可选的文件内容
+            from_yaml: 可选的基于某个已有 YAML 文件（指定前缀）
+            
+        Returns:
+            Optional[str]: 创建的文件路径，如果创建失败返回 None
+        """
+        if not self.ensure_actions_dir():
+            return None
+            
+        next_seq = str(self.get_next_sequence_number()).zfill(12)
+        new_file_name = f"{next_seq}_{name}.yml"
+        new_file_path = os.path.join(self.actions_dir, new_file_name)
+        
+        if from_yaml:
+            from_files = [f for f in self.get_action_files() if f.startswith(from_yaml)]
+            if from_files:
+                from_file = from_files[0]  # 取第一个匹配的文件
+                try:
+                    with open(os.path.join(self.actions_dir, from_file), "r", encoding="utf-8") as f:
+                        content = f.read()
+                except Exception as e:
+                    logger.error(f"Failed to read from yaml file: {e}")
+                    return None
+            else:
+                logger.error(f"No YAML file found matching prefix: {from_yaml}")
+                return None
+        else:
+            # 如果没有指定内容和基础文件，则尝试复制最新的文件内容
+            if content is None:
+                latest_file = self.get_latest_action_file()
+                if latest_file:
+                    try:
+                        with open(os.path.join(self.actions_dir, latest_file), "r", encoding="utf-8") as f:
+                            content = f.read()
+                    except Exception as e:
+                        logger.error(f"Failed to read latest yaml file: {e}")
+                        content = ""
+                else:
+                    content = ""
+        
+        try:
+            with open(new_file_path, "w", encoding="utf-8") as f:
+                f.write(content or "")
+            return new_file_path
+        except Exception as e:
+            logger.error(f"Failed to create new action file: {e}")
+            return None
+    
+    def load_yaml_content(self, file_name: str) -> Dict:
+        """
+        加载 YAML 文件内容
+        
+        Args:
+            file_name: YAML 文件名（仅文件名，不含路径）
+            
+        Returns:
+            Dict: YAML 内容，如果加载失败返回空字典
+        """
+        yaml_path = os.path.join(self.actions_dir, file_name)
+        
+        try:
+            with open(yaml_path, 'r', encoding='utf-8') as f:
+                content = yaml.safe_load(f) or {}
+            return content
+        except Exception as e:
+            self.printer.print_in_terminal("yaml_load_error", style="red", 
+                                          yaml_file=yaml_path, error=str(e))
+            return {}
+    
+    def save_yaml_content(self, file_name: str, content: Dict) -> bool:
+        """
+        保存 YAML 文件内容
+        
+        Args:
+            file_name: YAML 文件名（仅文件名，不含路径）
+            content: 要保存的内容
+            
+        Returns:
+            bool: 保存成功返回 True，否则返回 False
+        """
+        yaml_path = os.path.join(self.actions_dir, file_name)
+        
+        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)
+            return True
+        except Exception as e:
+            self.printer.print_in_terminal("yaml_save_error", style="red", 
+                                          yaml_file=yaml_path, error=str(e))
+            return False
+    
+    def update_yaml_field(self, file_name: str, field: str, value: Any) -> bool:
+        """
+        更新 YAML 文件中的特定字段
+        
+        Args:
+            file_name: YAML 文件名（仅文件名，不含路径）
+            field: 要更新的字段名
+            value: 字段值
+            
+        Returns:
+            bool: 更新成功返回 True，否则返回 False
+        """
+        yaml_content = self.load_yaml_content(file_name)
+        yaml_content[field] = value
+        return self.save_yaml_content(file_name, yaml_content)
+    
+    def get_commit_id_from_file(self, file_name: str) -> Optional[str]:
+        """
+        从文件内容计算 commit ID
+        
+        Args:
+            file_name: YAML 文件名（仅文件名，不含路径）
+            
+        Returns:
+            Optional[str]: commit ID，如果计算失败返回 None
+        """
+        yaml_path = os.path.join(self.actions_dir, file_name)
+        
+        try:
+            with open(yaml_path, 'r', encoding='utf-8') as f:
+                yaml_content = f.read()
+            file_md5 = hashlib.md5(yaml_content.encode("utf-8")).hexdigest()
+            return f"auto_coder_{file_name}_{file_md5}"
+        except Exception as e:
+            logger.error(f"Failed to calculate commit ID: {e}")
+            return None
+    
+    def get_file_name_from_commit_id(self, commit_id: str) -> Optional[str]:
+        """
+        从 commit ID 中提取文件名
+        
+        Args:
+            commit_id: commit ID
+            
+        Returns:
+            Optional[str]: 文件名，如果提取失败返回 None
+        """
+        if not commit_id.startswith("auto_coder_"):
+            return None
+            
+        try:
+            # auto_coder_000000001926_chat_action.yml_88614d5bd4046a068786c252fbc39c13
+            parts = commit_id.split("_")
+            # 去掉第一部分 "auto_coder_" 和最后一部分 hash 值
+            if len(parts) >= 3:
+                file_name_parts = parts[1:-1]
+                return "_".join(file_name_parts)
+            return None
+        except Exception:
+            return None
+    
+    def get_commit_changes(self, file_name: Optional[str] = None) -> List[Tuple[str, List[str], Dict[str, Tuple[str, str]]]]:
+        """
+        获取与特定文件相关的 commit 变更
+        
+        Args:
+            file_name: 可选的 YAML 文件名（仅文件名，不含路径）
+            
+        Returns:
+            List[Tuple[str, List[str], Dict[str, Tuple[str, str]]]]: 变更信息列表
+        """
+        if not file_name:
+            file_name = self.get_latest_action_file()
+            if not file_name:
+                self.printer.print_in_terminal("no_latest_commit", style="red")
+                return []
+        
+        yaml_content = self.load_yaml_content(file_name)
+        query = yaml_content.get('query', '')
+        urls = yaml_content.get('urls', [])
+        
+        commit_id = self.get_commit_id_from_file(file_name)
+        if not commit_id:
+            return [(query, urls, {})]
+        
+        changes = {}
+        try:
+            repo = git.Repo(self.source_dir)
+            for commit in repo.iter_commits():
+                if commit_id in commit.message:
+                    if commit.parents:
+                        parent = commit.parents[0]
+                        # 获取所有文件的前后内容
+                        for diff_item in parent.diff(commit):
+                            file_path = diff_item.a_path if diff_item.a_path else diff_item.b_path
+                            
+                            # 获取变更前内容
+                            before_content = None
+                            try:
+                                if diff_item.a_blob:
+                                    before_content = repo.git.show(f"{parent.hexsha}:{file_path}")
+                            except git.exc.GitCommandError:
+                                pass  # 文件可能是新增的
+
+                            # 获取变更后内容
+                            after_content = None
+                            try:
+                                if diff_item.b_blob:
+                                    after_content = repo.git.show(f"{commit.hexsha}:{file_path}")
+                            except git.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))
+        
+        return [(query, urls, changes)]
+    
+    def parse_history_tasks(self, limit: int = 5) -> List[Dict]:
+        """
+        解析历史任务信息
+        
+        Args:
+            limit: 最多解析的文件数量
+            
+        Returns:
+            List[Dict]: 每个字典包含一个历史任务的信息
+        """
+        action_files = self.get_action_files()
+        
+        if not action_files:
+            return []
+            
+        # 按序号排序
+        sorted_files = sorted(action_files, key=self.get_sequence_number, reverse=True)
+        limited_files = sorted_files[:limit]
+        
+        history_tasks = []
+        for file_name in limited_files:
+            yaml_content = self.load_yaml_content(file_name)
+            if yaml_content:
+                yaml_content['file_name'] = file_name
+                history_tasks.append(yaml_content)
+        
+        return history_tasks 

autocoder/common/auto_coder_lang.py

@@ -47,7 +47,7 @@ MESSAGES = {
         "model_not_found": "Model {{model_name}} not found",
         "generating_shell_script": "Generating Shell Script",
         "new_session_started": "New session started. Previous chat history has been archived.",
-        "memory_save_success": "✅ Saved to your memory",
+        "memory_save_success": "✅ Saved to your memory(path: {{path}})",
         "file_decode_error": "Failed to decode file: {{file_path}}. Tried encodings: {{encodings}}",
         "file_write_error": "Failed to write file: {{file_path}}. Error: {{error}}",
         "yaml_load_error": "Error loading yaml file {{yaml_file}}: {{error}}",
@@ -194,6 +194,9 @@ MESSAGES = {
         "super_big_filter_title": "{{ model_name }} is analyzing how to filter extremely large context...",
         "mcp_server_info_error": "Error getting MCP server info: {{ error }}",
         "mcp_server_info_title": "Connected MCP Server Info",
+        "no_commit_file_name": "Cannot get the file name of the commit_id in the actions directory: {{commit_id}}",
+        "yaml_update_success": "✅ Successfully updated YAML file: {{yaml_file}} with how_to_reproduce field",
+        "yaml_save_error": "❌ Error saving YAML file {{yaml_file}}: {{error}}",
     },
     "zh": {
         "file_sliding_window_processing": "文件 {{ file_path }} 过大 ({{ tokens }} tokens)，正在使用滑动窗口处理...",
@@ -257,7 +260,7 @@ MESSAGES = {
         "model_not_found": "未找到模型: {{model_name}}",
         "generating_shell_script": "正在生成 Shell 脚本",
         "new_session_started": "新会话已开始。之前的聊天历史已存档。",
-        "memory_save_success": "✅ 已保存到您的记忆中",
+        "memory_save_success": "✅ 已保存到您的记忆中(路径: {{path}})",
         "file_decode_error": "无法解码文件: {{file_path}}。尝试的编码: {{encodings}}",
         "file_write_error": "无法写入文件: {{file_path}}. 错误: {{error}}",
         "yaml_load_error": "加载YAML文件出错 {{yaml_file}}: {{error}}",
@@ -385,6 +388,9 @@ MESSAGES = {
         "super_big_filter_title": "{{ model_name }} 正在分析如何过滤极大规模上下文...",
         "mcp_server_info_error": "获取MCP服务器信息时出错: {{ error }}",
         "mcp_server_info_title": "已连接的MCP服务器信息",
+        "no_commit_file_name": "无法获取commit_id关联的actions 目录下的文件名: {{commit_id}}",
+        "yaml_update_success": "✅ 成功更新YAML文件: {{yaml_file}}，添加了how_to_reproduce字段",
+        "yaml_save_error": "❌ 保存YAML文件出错 {{yaml_file}}: {{error}}",
     }}
 
 

autocoder/common/auto_configure.py

@@ -157,6 +157,12 @@ def config_readme() -> str:
     3. 代码文件后缀名列表（比如.java,.py,.go,.js,.ts），多个按逗号分割    
 
     推荐使用 3 选项，因为项目类型通常为多种后缀名混合。
+
+    ## include_project_structure: 是否包含项目结构
+    是否包含项目结构。推荐设置为 true。默认为true,但是项目结构也可能很大，如果项目结构很大，那么可以设置为 false。
+
+    ## conversation_prune_safe_zone_tokens: 对话剪枝安全区token数量
+    在对话剪枝时，会根据对话的token数量，如果token数量超过该值，那么会剪枝掉一部分对话。
     """
 
 class ConfigAutoTuner:

autocoder/common/command_completer.py

@@ -16,7 +16,14 @@ COMMANDS = {
         "/sd": {},
     },
     "/coding": {"/apply": {}, "/next": {}},
-    "/chat": {"/new": {}, "/save": {}, "/copy":{}, "/mcp": {}, "/rag": {}, "/review": {}, "/no_context": {}},
+    "/chat": {"/new": {}, 
+              "/save": {}, 
+              "/copy":{}, 
+              "/mcp": {}, 
+              "/rag": {}, 
+              "/review": {}, 
+              "/learn": {},
+              "/no_context": {}},
     "/mcp": {
         "/add": "",         
         "/remove": "",

autocoder/common/memory_manager.py

@@ -40,7 +40,11 @@ def save_to_memory_file(ask_conversation,query:str,response:str):
     
     # Save memory
     with open(memory_file, 'w') as f:
-        json.dump(memory_data, f, ensure_ascii=False, indent=2)   
+        json.dump(memory_data, f, ensure_ascii=False, indent=2) 
+
+    get_global_memory_file_paths()          
+    tmp_dir = os.path.join(memory_dir, ".tmp")
+    return tmp_dir
 
 def load_from_memory_file() -> List[MemoryEntry]:
     """Load memory data from file and return as list of MemoryEntry objects"""

autocoder/index/entry.py

@@ -25,10 +25,13 @@ from autocoder.index.index import IndexManager
 from loguru import logger
 from autocoder.common import SourceCodeList
 from autocoder.common.context_pruner import PruneContext
+from autocoder.common.action_yml_file_manager import ActionYmlFileManager
 
 def build_index_and_filter_files(
     llm, args: AutoCoderArgs, sources: List[SourceCode]
 ) -> SourceCodeList:
+    
+    action_yml_file_manager = ActionYmlFileManager(args.source_dir)
     # Initialize timing and statistics
     total_start_time = time.monotonic()
     stats = {
@@ -369,5 +372,19 @@ def build_index_and_filter_files(
                 })
             )
         )
+    
+    if args.file:
+        action_file_name = os.path.basename(args.file)
+        dynamic_urls = []
+        
+        for file in source_code_list.sources:
+            dynamic_urls.append(file.module_name)
+        
+        args.dynamic_urls = dynamic_urls
 
+        update_yaml_success = action_yml_file_manager.update_yaml_field(action_file_name, "dynamic_urls", args.dynamic_urls)    
+        if not update_yaml_success:        
+            printer = Printer()
+            printer.print_in_terminal("yaml_save_error", style="red", yaml_file=action_file_name)  
+    
     return source_code_list

autocoder/rag/cache/local_duckdb_storage_cache.py

@@ -652,40 +652,68 @@ class LocalDuckDBStorageCache(BaseCacheManager):
 
         return all_files
 
-    def get_cache(self, options: Optional[Dict[str, Any]] = None) -> Dict[str, Dict]:
-        """Search cached documents using query"""
-        self.trigger_update()  # 检查更新
-
-        if options is None or "queries" not in options:
-            return {file_path: self.cache[file_path].model_dump() for file_path in self.cache}
-
-        queries = options.get("queries", "")
-        query = queries[0]
+    def _get_single_cache(self, query: str, options: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        使用单个查询检索缓存文档
+        
+        参数:
+            query: 查询字符串
+            options: 包含查询选项的字典
+            
+        返回:
+            包含文档信息的字典列表，每个字典包含_id、file_path、mtime和score字段
+        """
         logger.info(f"正在使用向量搜索检索数据, 你的问题: {query}")
-        total_tokens = 0
         results = []
 
         # Add vector search if enabled
         if options.get("enable_vector_search", True):
             # 返回值包含  [(_id, file_path, mtime, score,),]
-            # results = self.storage.vector_search(query, similarity_value=0.7, similarity_top_k=200)
             search_results = self.storage.vector_search(
                 query,
                 similarity_value=self.extra_params.rag_duckdb_query_similarity,
                 similarity_top_k=self.extra_params.rag_duckdb_query_top_k,
                 query_dim=self.extra_params.rag_duckdb_vector_dim
             )
-            results.extend(search_results)
-
+            
+            # Convert tuples to dictionaries for the merger
+            for _id, file_path, mtime, score in search_results:
+                results.append({
+                    "_id": _id,
+                    "file_path": file_path,
+                    "mtime": mtime,
+                    "score": score
+                })
+        
+        logger.info(f"查询 '{query}' 返回 {len(results)} 条记录")
+        return results
+        
+    def _process_search_results(self, results: List[Dict[str, Any]]) -> Dict[str, Dict]:
+        """
+        处理搜索结果，提取文件路径并构建结果字典
+        
+        参数:
+            results: 搜索结果列表，每项包含文档信息的字典
+            
+        返回:
+            匹配文档的字典，键为文件路径，值为文件内容
+            
+        说明:
+            该方法会根据查询结果从缓存中提取文件内容，并记录累计token数，
+            当累计token数超过max_output_tokens时，将停止处理并返回已处理的结果。
+        """
+        # 记录被处理的总tokens数
+        total_tokens = 0
+        
         # Group results by file_path and reconstruct documents while preserving order
         # 这里还可以有排序优化，综合考虑一篇内容出现的次数以及排序位置
         file_paths = []
         seen = set()
         for result in results:
-            _id, _file_path, _mtime, _score = result
-            if _file_path not in seen:
-                seen.add(_file_path)
-                file_paths.append(_file_path)
+            file_path = result["file_path"]
+            if file_path not in seen:
+                seen.add(file_path)
+                file_paths.append(file_path)
 
         # 从缓存中获取文件内容
         result = {}
@@ -706,3 +734,69 @@ class LocalDuckDBStorageCache(BaseCacheManager):
             f"累计tokens: {total_tokens}, "
             f"经过向量搜索共检索出 {len(result.keys())} 个文档, 共 {len(self.cache.keys())} 个文档")
         return result
+
+    def get_cache(self, options: Optional[Dict[str, Any]] = None) -> Dict[str, Dict]:
+        """
+        获取缓存中的文档信息
+        
+        参数:
+            options: 包含查询参数的字典，可以包含以下键：
+                - queries: 查询列表，可以是单个查询或多个查询
+                - enable_vector_search: 是否启用向量搜索，默认为True
+                - merge_strategy: 多查询时的合并策略，默认为WEIGHTED_RANK
+                - max_results: 最大结果数，默认为None表示不限制
+                
+        返回:
+            匹配文档的字典，键为文件路径，值为文件内容
+        """
+        self.trigger_update()  # 检查更新
+
+        if options is None or "queries" not in options:
+            return {file_path: self.cache[file_path].model_dump() for file_path in self.cache}
+
+        queries = options.get("queries", [])
+        
+        # 如果没有查询或只有一个查询，使用原来的方法
+        if not queries:
+            return {file_path: self.cache[file_path].model_dump() for file_path in self.cache}
+        elif len(queries) == 1:
+            results = self._get_single_cache(queries[0], options)
+            return self._process_search_results(results)
+        
+        # 导入合并策略
+        from autocoder.rag.cache.cache_result_merge import CacheResultMerger, MergeStrategy
+        
+        # 获取合并策略
+        merge_strategy_name = options.get("merge_strategy", MergeStrategy.WEIGHTED_RANK.value)
+        try:
+            merge_strategy = MergeStrategy(merge_strategy_name)
+        except ValueError:
+            logger.warning(f"未知的合并策略: {merge_strategy_name}, 使用默认策略 WEIGHTED_RANK")
+            merge_strategy = MergeStrategy.WEIGHTED_RANK
+        
+        # 限制最大结果数
+        max_results = options.get("max_results", None)
+        merger = CacheResultMerger(max_results=max_results)
+        
+        # 并发处理多个查询
+        logger.info(f"处理多查询请求，查询数量: {len(queries)}, 合并策略: {merge_strategy}")
+        query_results = []
+        with ThreadPoolExecutor(max_workers=min(len(queries), 10)) as executor:
+            future_to_query = {executor.submit(self._get_single_cache, query, options): query for query in queries}
+            for future in as_completed(future_to_query):
+                query = future_to_query[future]
+                try:
+                    query_result = future.result()
+                    logger.info(f"查询 '{query}' 返回 {len(query_result)} 条记录")
+                    query_results.append((query, query_result))
+                except Exception as e:
+                    logger.error(f"处理查询 '{query}' 时出错: {str(e)}")
+        
+        logger.info(f"所有查询共返回 {sum(len(r) for _, r in query_results)} 条记录")
+        
+        # 使用策略合并结果
+        merged_results = merger.merge(query_results, strategy=merge_strategy)
+        logger.info(f"合并后的结果共 {len(merged_results)} 条记录")
+        
+        # 处理合并后的结果
+        return self._process_search_results(merged_results)

autocoder/utils/__init__.py

@@ -3,17 +3,21 @@ from typing import Optional
 import subprocess
 import shutil
 from loguru import logger
+from autocoder.common.action_yml_file_manager import ActionYmlFileManager
 
 def get_last_yaml_file(actions_dir:str)->Optional[str]:
-    action_files = [
-            f for f in os.listdir(actions_dir) if f[:3].isdigit() and "_" in f and f.endswith(".yml")
-        ]
-
-    def get_old_seq(name):
-        return int(name.split("_")[0])
-
-    sorted_action_files = sorted(action_files, key=get_old_seq)
-    return sorted_action_files[-1] if sorted_action_files else None
+    """
+    获取最新的 YAML 文件
+    
+    Args:
+        actions_dir: actions 目录路径
+        
+    Returns:
+        Optional[str]: 最新的 YAML 文件名，如果没有则返回 None
+    """
+    # 兼容已有代码，创建临时 ActionYmlFileManager
+    action_manager = ActionYmlFileManager(os.path.dirname(actions_dir))
+    return action_manager.get_latest_action_file()
 
 def open_yaml_file_in_editor(new_file:str):
     try:

autocoder/version.py

@@ -1 +1 @@
-__version__ = "0.1.298"
+__version__ = "0.1.300"