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

autocoder/auto_coder.py

@@ -5,6 +5,7 @@ from autocoder.dispacher import Dispacher
 from autocoder.common import git_utils, code_auto_execute
 from autocoder.utils.llm_client_interceptors import token_counter_interceptor
 from autocoder.db.store import Store
+from autocoder.common.action_yml_file_manager import ActionYmlFileManager
 
 from autocoder.utils.llms import get_llm_names
 from autocoder.utils.queue_communicate import (
@@ -196,59 +197,25 @@ def main(input_args: Optional[List[str]] = None):
         return
 
     if raw_args.command == "next":
-        actions_dir = os.path.join(os.getcwd(), "actions")
-        if not os.path.exists(actions_dir):
-            print("Current directory does not have an actions directory")
-            return
-
-        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 name.split("_")[0]
-
-        if not action_files:
-            max_seq = 0
-        else:
-            seqs = [int(get_old_seq(f)) for f in action_files]
-            max_seq = max(seqs)
-
-        new_seq = str(max_seq + 1).zfill(12)
-        prev_files = [f for f in action_files if int(
-            get_old_seq(f)) < int(new_seq)]
-
+        # 使用 ActionYmlFileManager 创建下一个 action 文件
+        action_manager = ActionYmlFileManager(args.source_dir)
+        
         if raw_args.from_yaml:
-            # If --from_yaml is specified, copy content from the matching YAML file
-            from_files = [
-                f for f in action_files if f.startswith(raw_args.from_yaml)]
-            if from_files:
-                from_file = from_files[0]  # Take the first match
-                with open(os.path.join(actions_dir, from_file), "r",encoding="utf-8") as f:
-                    content = f.read()
-                new_file = os.path.join(
-                    actions_dir, f"{new_seq}_{raw_args.name}.yml")
-                with open(new_file, "w",encoding="utf-8") as f:
-                    f.write(content)
-            else:
-                print(
-                    f"No YAML file found matching prefix: {raw_args.from_yaml}")
+            # 基于指定的 yaml 文件创建新文件
+            new_file = action_manager.create_next_action_file(
+                name=raw_args.name,
+                from_yaml=raw_args.from_yaml
+            )
+            if not new_file:
+                print(f"No YAML file found matching prefix: {raw_args.from_yaml}")
                 return
         else:
-            # If --from_yaml is not specified, use the previous logic
-            if not prev_files:
-                new_file = os.path.join(
-                    actions_dir, f"{new_seq}_{raw_args.name}.yml")
-                with open(new_file, "w",encoding="utf-8") as f:
-                    pass
-            else:
-                prev_file = sorted(prev_files)[-1]  # 取序号最大的文件
-                with open(os.path.join(actions_dir, prev_file), "r",encoding="utf-8") as f:
-                    content = f.read()
-                new_file = os.path.join(
-                    actions_dir, f"{new_seq}_{raw_args.name}.yml")
-                with open(new_file, "w",encoding="utf-8") as f:
-                    f.write(content)        
+            # 创建新的 action 文件
+            new_file = action_manager.create_next_action_file(name=raw_args.name)
+            if not new_file:
+                print("Failed to create new action file")
+                return
+        
         # open_yaml_file_in_editor(new_file)
         return
 
@@ -883,7 +850,6 @@ def main(input_args: Optional[List[str]] = None):
             #             os.path.join(args.source_dir, "actions")
             #         )
             #     )
-            # )
             return
         elif raw_args.agent_command == "project_reader":
                         
@@ -1062,6 +1028,15 @@ def main(input_args: Optional[List[str]] = None):
 
         elif raw_args.agent_command == "chat":
             
+            # 统一格式
+            # {"command1": {"args": ["arg1", "arg2"], "kwargs": {"key1": "value1", "key2": "value2"}}}
+            if isinstance(args.action, dict):
+                commands_info = args.action
+            else:
+                commands_info = {}
+                for command in args.action:
+                    commands_info[command] = {}
+            
             memory_dir = os.path.join(args.source_dir, ".auto-coder", "memory")
             os.makedirs(memory_dir, exist_ok=True)
             memory_file = os.path.join(memory_dir, "chat_history.json")
@@ -1167,7 +1142,7 @@ def main(input_args: Optional[List[str]] = None):
                                                file_path=source.module_name, 
                                                model_name=",".join(get_llm_names(chat_llm)))
             
-            if "no_context" not in args.action:
+            if "no_context" not in commands_info:
                 s = build_index_and_filter_files(
                     llm=llm, args=args, sources=filtered_sources).to_str()                        
                 
@@ -1304,7 +1279,7 @@ def main(input_args: Optional[List[str]] = None):
                     ),
                 )
 
-                if "save" in args.action:
+                if "save" in commands_info:
                     save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
                                         query=args.query,
                                         response=result)
@@ -1314,8 +1289,9 @@ def main(input_args: Optional[List[str]] = None):
 
             # 计算耗时            
             start_time = time.time()    
+            commit_file_name = None
                         
-            if "rag" in args.action:
+            if "rag" in commands_info:
                 from autocoder.rag.rag_entry import RAGFactory
                 args.enable_rag_search = True
                 args.enable_rag_context = False
@@ -1324,25 +1300,35 @@ def main(input_args: Optional[List[str]] = None):
                     conversations=loaded_conversations)[0]                                                
                 v = (item for item in response)
                 
-            elif "mcp" in args.action: 
+            elif "mcp" in commands_info: 
                 from autocoder.common.mcp_server import get_mcp_server, McpRequest, McpInstallRequest, McpRemoveRequest, McpListRequest, McpListRunningRequest, McpRefreshRequest                               
                 mcp_server = get_mcp_server()
+                
+                pos_args = commands_info["mcp"].get("args", [])
+                final_query = pos_args[0] if pos_args else args.query                
                 response = mcp_server.send_request(
                     McpRequest(
-                        query=args.query,
+                        query=final_query,
                         model=args.inference_model or args.model,
                         product_mode=args.product_mode
                     )
                 )
                 v = [[response.result,None]]
-            elif "review_commit" in args.action:
-                from autocoder.agent.auto_review_commit import AutoReviewCommit
+            elif "review" in commands_info:
+                from autocoder.agent.auto_review_commit import AutoReviewCommit                
                 reviewer = AutoReviewCommit(llm=chat_llm, args=args)
-                v = reviewer.review_commit(query=args.query,conversations=loaded_conversations)
-            elif "learn_from_commit" in args.action:
+                pos_args = commands_info["review"].get("args", [])
+                final_query = pos_args[0] if pos_args else args.query
+                kwargs = commands_info["review"].get("kwargs", {})
+                commit_id = kwargs.get("commit", None)
+                v = reviewer.review_commit(query=final_query, conversations=loaded_conversations, commit_id=commit_id)
+            elif "learn" in commands_info:
                 from autocoder.agent.auto_learn_from_commit import AutoLearnFromCommit
                 learner = AutoLearnFromCommit(llm=chat_llm, args=args)
-                v = learner.learn_from_commit(query=args.query,conversations=loaded_conversations)
+                pos_args = commands_info["learn"].get("args", [])
+                final_query = pos_args[0] if pos_args else args.query
+                v,tmp_file_name = learner.learn_from_commit(query=final_query,conversations=loaded_conversations)
+                commit_file_name = tmp_file_name
             else:                
                 # 预估token数量
                 dumped_conversations = json.dumps(loaded_conversations, ensure_ascii=False)                
@@ -1375,7 +1361,15 @@ def main(input_args: Optional[List[str]] = None):
                 "input": {
                     "query": args.query
                 }
-            })                                                           
+            }) 
+
+            if "learn" in commands_info:                
+                if commit_file_name:                    
+                    # 使用 ActionYmlFileManager 更新 YAML 文件                    
+                    action_manager = ActionYmlFileManager(args.source_dir)
+                    if not action_manager.update_yaml_field(commit_file_name, 'how_to_reproduce', assistant_response):
+                        printer = Printer()
+                        printer.print_in_terminal("yaml_save_error", style="red", yaml_file=commit_file_name)
             
             # 打印耗时和token统计            
             if last_meta:
@@ -1410,7 +1404,7 @@ def main(input_args: Optional[List[str]] = None):
             with open(memory_file, "w",encoding="utf-8") as f:
                 json.dump(chat_history, f, ensure_ascii=False)
 
-            if "copy" in args.action:
+            if "copy" in commands_info:
                 #copy assistant_response to clipboard
                 import pyperclip
                 try:
@@ -1418,12 +1412,17 @@ def main(input_args: Optional[List[str]] = None):
                 except:
                     print("pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard.")
 
-            if "save" in args.action:
-                save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
+            if "save" in commands_info:                
+                tmp_dir = save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
                                     query=args.query,
                                     response=assistant_response)  
                 printer = Printer()
-                printer.print_in_terminal("memory_save_success")                      
+                printer.print_in_terminal("memory_save_success", style="green", path=tmp_dir)                      
+
+                if len(commands_info["save"]["args"]) > 0:
+                    # 保存到指定文件
+                    with open(commands_info["save"]["args"][0], "w",encoding="utf-8") as f:
+                        f.write(assistant_response)
             return
 
         else:

autocoder/auto_coder_runner.py

@@ -51,6 +51,7 @@ from autocoder.common.printer import Printer
 from autocoder.utils.thread_utils import run_in_raw_thread
 from autocoder.common.command_completer import CommandCompleter,FileSystemModel as CCFileSystemModel,MemoryConfig as CCMemoryModel
 from autocoder.common.conf_validator import ConfigValidator
+from autocoder import command_parser as CommandParser
 
 class SymbolItem(BaseModel):
     symbol_name: str
@@ -1598,48 +1599,30 @@ def chat(query: str):
     if "emb_model" in conf:
         yaml_config["emb_model"] = conf["emb_model"]
 
-    is_new = "/new" in query
-    if is_new:
-        query = query.replace("/new", "", 1).strip()
-
-    yaml_config["action"] = []    
-
-    if "/mcp " in query:
-        yaml_config["action"].append("mcp")
-        query = query.replace("/mcp ", "", 1).strip()
-
-    if "/rag " in query:
-        yaml_config["action"].append("rag")
-        query = query.replace("/rag ", "", 1).strip()
-
-    if "/copy" in query:
-        yaml_config["action"].append("copy")
-        query = query.replace("/copy", "", 1).strip()   
-
-    if "/save" in query:
-        yaml_config["action"].append("save")
-        query = query.replace("/save", "", 1).strip()        
-
-    if "/review" in query and "/commit" in query:
-        yaml_config["action"].append("review_commit")
-        query = query.replace("/review", "", 1).replace("/commit", "", 1).strip()
-    elif "/learn" in query:
-        yaml_config["action"].append("learn_from_commit")
-        query = query.replace("/learn", "", 1).strip()
-    else:    
-        is_review = query.strip().startswith("/review")
-        if is_review:
-            query = query.replace("/review", "", 1).strip()
-            if "prompt_review" in conf:
-                query = format_str_jinja2(conf["prompt_review"], query=query)
-            else:
-                query = code_review.prompt(query)
+    # 解析命令        
+    commands_infos = CommandParser.parse_query(query)    
+    if len(commands_infos) > 0:
+        if "query" in commands_infos:
+            query = commands_infos["query"]["args"][-1]
+        else:
+            # 获取第一个command 的最后一个位置参数作为默认query 
+            temp_query = ""
+            for (command,command_info) in commands_infos.items():
+                if command_info["args"]:
+                    temp_query = command_info["args"][-1]
+                    break            
+            query = temp_query
+
+    is_new = "new" in commands_infos
 
-    is_no_context = "/no_context" in query.strip()
-    if is_no_context:
-        query = query.replace("/no_context", "", 1).strip()
-        yaml_config["action"].append("no_context")
+    if "learn" in commands_infos:
+        commands_infos["no_context"] = {}
 
+    if "review" in commands_infos:
+        commands_infos["no_context"] = {}
+
+    yaml_config["action"] = commands_infos            
+    
     for key, value in conf.items():
         converted_value = convert_config_value(key, value)
         if converted_value is not None:

autocoder/command_parser.py

@@ -0,0 +1,280 @@
+from typing import Dict, List, Tuple, Any, Optional
+import re
+
+
+class CommandParser:
+    """
+    命令解析器，用于解析命令行格式的查询字符串。
+    支持以下格式：
+    1. /command arg1 arg2
+    2. /command key1=value1 key2=value2
+    3. /command arg1 key1=value1
+    4. /command1 arg1 /command2 arg2
+    5. /command1 /command2 arg2
+    6. /command1 /command2 key=value
+    7. /command key="value with spaces"
+    8. /command key='value with spaces'
+    
+    注意：路径参数（如/path/to/file）不会被识别为命令。
+    """
+
+    def __init__(self):
+        # 匹配命令的正则表达式 - 必须是以/开头，后跟单词字符，且不能后跟/或.
+        # (?<!\S) 确保命令前是字符串开头或空白字符
+        self.command_pattern = r'(?<!\S)/(\w+)(?!/|\.)'
+        # 匹配键值对参数的正则表达式，支持带引号的值
+        self.key_value_pattern = r'(\w+)=(?:"([^"]*?)"|\'([^\']*?)\'|([^\s"\']+))(?:\s|$)'
+        # 匹配路径模式的正则表达式
+        self.path_pattern = r'/\w+(?:/[^/\s]+)+'
+
+    def parse(self, query: str) -> Dict[str, Any]:
+        """
+        解析命令行格式的查询字符串，返回命令和参数的字典。
+        
+        参数:
+            query: 命令行格式的查询字符串
+            
+        返回:
+            Dict[str, Any]: 命令和参数的字典，格式为：
+                {
+                    'command1': {
+                        'args': ['arg1', 'arg2'],
+                        'kwargs': {'key1': 'value1', 'key2': 'value with spaces'}
+                    },
+                    'command2': {
+                        'args': [],
+                        'kwargs': {'key': 'value'}
+                    }
+                }
+        """
+        if not query or not query.strip():
+            return {}
+
+        # 预处理：标记路径参数，避免被识别为命令
+        processed_query = query
+        path_matches = re.finditer(self.path_pattern, query)
+        placeholders = {}
+        
+        for i, match in enumerate(path_matches):
+            path = match.group(0)
+            placeholder = f"__PATH_PLACEHOLDER_{i}__"
+            placeholders[placeholder] = path
+            processed_query = processed_query.replace(path, placeholder, 1)
+
+        # 找出所有命令
+        commands = re.findall(self.command_pattern, processed_query)
+        if not commands:
+            return {}
+
+        # 将查询字符串按命令分割
+        parts = re.split(self.command_pattern, processed_query)
+        # 第一个元素是空字符串或之前的非命令内容，保留它
+        first_part = parts[0]
+        parts = parts[1:]
+
+        result = {}
+        
+        # 处理每个命令和它的参数
+        for i in range(0, len(parts), 2):
+            command = parts[i]
+            
+            # 获取此命令的参数部分
+            params_str = parts[i+1].strip() if i+1 < len(parts) else ""
+            
+            # 恢复路径参数的原始值
+            for placeholder, path in placeholders.items():
+                params_str = params_str.replace(placeholder, path)
+            
+            # 解析参数
+            args, kwargs = self._parse_params(params_str)
+            
+            result[command] = {
+                'args': args,
+                'kwargs': kwargs
+            }
+            
+        return result
+
+    def _parse_params(self, params_str: str) -> Tuple[List[str], Dict[str, str]]:
+        """
+        解析参数字符串，区分位置参数和键值对参数。
+        支持带引号(双引号或单引号)的值，引号内可以包含空格。
+        
+        参数:
+            params_str: 参数字符串
+            
+        返回:
+            Tuple[List[str], Dict[str, str]]: 位置参数列表和键值对参数字典
+        """
+        args = []
+        kwargs = {}
+        
+        if not params_str:
+            return args, kwargs
+        
+        # 找出所有键值对
+        key_value_pairs = re.findall(self.key_value_pattern, params_str)
+        
+        # 如果有键值对，处理它们
+        if key_value_pairs:
+            for match in key_value_pairs:
+                key = match[0]
+                # 值可能在三个捕获组中的一个，取非空的那个
+                value = match[1] or match[2] or match[3]
+                kwargs[key] = value.strip()
+                
+            # 替换带引号的键值对
+            processed_params_str = params_str
+            for match in re.finditer(self.key_value_pattern, params_str):
+                full_match = match.group(0)
+                processed_params_str = processed_params_str.replace(full_match, "", 1).strip()
+            
+            # 现在 processed_params_str 中应该只剩下位置参数
+            
+            # 处理带引号的位置参数
+            quote_pattern = r'(?:"([^"]*?)"|\'([^\']*?)\')'
+            quoted_args = re.findall(quote_pattern, processed_params_str)
+            for quoted_arg in quoted_args:
+                # 取非空的那个捕获组
+                arg = quoted_arg[0] or quoted_arg[1]
+                args.append(arg)
+                # 从参数字符串中移除这个带引号的参数
+                quoted_pattern = f'"{arg}"' if quoted_arg[0] else f"'{arg}'"
+                processed_params_str = processed_params_str.replace(quoted_pattern, "", 1).strip()
+            
+            # 分割剩余的位置参数（不带引号的）
+            remaining_args = [arg.strip() for arg in processed_params_str.split() if arg.strip()]
+            args.extend(remaining_args)
+        else:
+            # 如果没有键值对，处理所有参数作为位置参数
+            
+            # 处理带引号的位置参数
+            quote_pattern = r'(?:"([^"]*?)"|\'([^\']*?)\')'
+            quoted_args = re.findall(quote_pattern, params_str)
+            processed_params_str = params_str
+            
+            for quoted_arg in quoted_args:
+                # 取非空的那个捕获组
+                arg = quoted_arg[0] or quoted_arg[1]
+                args.append(arg)
+                # 从参数字符串中移除这个带引号的参数
+                quoted_pattern = f'"{arg}"' if quoted_arg[0] else f"'{arg}'"
+                processed_params_str = processed_params_str.replace(quoted_pattern, "", 1).strip()
+            
+            # 分割剩余的位置参数（不带引号的）
+            remaining_args = [arg.strip() for arg in processed_params_str.split() if arg.strip()]
+            args.extend(remaining_args)
+        
+        return args, kwargs
+    
+    def parse_command(self, query: str, command: str) -> Optional[Dict[str, Any]]:
+        """
+        解析特定命令的参数。
+        
+        参数:
+            query: 命令行格式的查询字符串
+            command: 要解析的命令名
+            
+        返回:
+            Optional[Dict[str, Any]]: 如果找到命令，返回其参数；否则返回None
+        """
+        commands = self.parse(query)
+        return commands.get(command)
+
+
+def parse_query(query: str) -> Dict[str, Any]:
+    """
+    解析命令行格式的查询字符串的便捷函数。
+    
+    参数:
+        query: 命令行格式的查询字符串
+        
+    返回:
+        Dict[str, Any]: 命令和参数的字典
+    """
+    parser = CommandParser()
+    return parser.parse(query)
+
+
+def has_command(query: str, command: str) -> bool:
+    """
+    检查查询字符串中是否包含特定命令。
+    
+    参数:
+        query: 命令行格式的查询字符串
+        command: 要检查的命令名
+        
+    返回:
+        bool: 如果包含命令返回True，否则返回False
+    """
+    parser = CommandParser()
+    commands = parser.parse(query)
+    return command in commands
+
+
+def get_command_args(query: str, command: str) -> List[str]:
+    """
+    获取特定命令的位置参数。
+    
+    参数:
+        query: 命令行格式的查询字符串
+        command: 要获取参数的命令名
+        
+    返回:
+        List[str]: 命令的位置参数列表，如果命令不存在返回空列表
+    """
+    parser = CommandParser()
+    command_info = parser.parse_command(query, command)
+    if command_info:
+        return command_info['args']
+    return []
+
+
+def get_command_kwargs(query: str, command: str) -> Dict[str, str]:
+    """
+    获取特定命令的键值对参数。
+    
+    参数:
+        query: 命令行格式的查询字符串
+        command: 要获取参数的命令名
+        
+    返回:
+        Dict[str, str]: 命令的键值对参数字典，如果命令不存在返回空字典
+    """
+    parser = CommandParser()
+    command_info = parser.parse_command(query, command)
+    if command_info:
+        return command_info['kwargs']
+    return {}
+
+
+# 示例用法
+if __name__ == "__main__":
+    # 测试各种格式的查询
+    test_queries = [
+        "/learn hello world /commit 123456",
+        "/learn /commit 123456",
+        "/learn /commit commit_id=123456",
+        "/learn msg=hello /commit commit_id=123456",
+        "/learn hello key=value /commit",
+        # 带引号的值
+        '/learn msg="hello world" /commit message="Fix bug #123"',
+        "/learn 'quoted arg' key='value with spaces' /commit",
+        # 路径参数测试
+        "/learn /path/to/file.txt",
+        "/commit message='Added /path/to/file.txt'",
+        "Check /path/to/file.txt and also /another/path/file.md",
+        "/clone /path/to/repo /checkout branch",
+        "Use the file at /usr/local/bin/python with /learn"
+    ]
+    
+    for query in test_queries:
+        print(f"\nQuery: {query}")
+        result = parse_query(query)
+        print(f"Parsed: {result}")
+        
+        if has_command(query, "commit"):
+            args = get_command_args(query, "commit")
+            kwargs = get_command_kwargs(query, "commit")
+            print(f"Commit args: {args}")
+            print(f"Commit kwargs: {kwargs}")