auto-coder 0.1.263__py3-none-any.whl → 0.1.265__py3-none-any.whl

autocoder/common/code_auto_merge_strict_diff.py

@@ -10,6 +10,7 @@ import hashlib
 from pathlib import Path
 from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
 from autocoder.common.code_modification_ranker import CodeModificationRanker
+from autocoder.common import files as  FileUtils
 
 class PathAndCode(pydantic.BaseModel):
     path: str
@@ -138,15 +139,35 @@ class CodeAutoMergeStrictDiff:
     def choose_best_choice(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
         if len(generate_result.contents) == 1:
             return generate_result
+        
+        merge_results = []
+        for content,conversations in zip(generate_result.contents,generate_result.conversations):
+            merge_result = self._merge_code_without_effect(content)
+            merge_results.append(merge_result)
+
+        # If all merge results are None, return first one
+        if all(len(result.failed_blocks) != 0 for result in merge_results):
+            self.printer.print_in_terminal("all_merge_results_failed")
+            return CodeGenerateResult(contents=[generate_result.contents[0]], conversations=[generate_result.conversations[0]])
+        
+        # If only one merge result is not None, return that one
+        not_none_indices = [i for i, result in enumerate(merge_results) if len(result.failed_blocks) == 0]
+        if len(not_none_indices) == 1:
+            idx = not_none_indices[0]
+            self.printer.print_in_terminal("only_one_merge_result_success")
+            return CodeGenerateResult(contents=[generate_result.contents[idx]], conversations=[generate_result.conversations[idx]])        
 
+        # 最后，如果有多个，那么根据质量排序再返回
         ranker = CodeModificationRanker(self.llm, self.args)
-        ranked_result = ranker.rank_modifications(generate_result)
-        # Filter out contents with failed blocks
+        ranked_result = ranker.rank_modifications(generate_result,merge_results)        
+         
+        ## 得到的结果，再做一次合并，第一个通过的返回 , 返回做合并有点重复低效，未来修改。
         for content,conversations in zip(ranked_result.contents,ranked_result.conversations):
             merge_result = self._merge_code_without_effect(content)
             if not merge_result.failed_blocks:
                 return CodeGenerateResult(contents=[content], conversations=[conversations])
-        # If all have failed blocks, return the first one
+
+        # 最后保底，但实际不会出现
         return CodeGenerateResult(contents=[ranked_result.contents[0]], conversations=[ranked_result.conversations[0]])
     
 
@@ -175,8 +196,7 @@ class CodeAutoMergeStrictDiff:
                 continue
                 
             if full_path not in file_content_mapping:
-                with open(full_path, "r") as f:
-                    file_content_mapping[full_path] = f.read()
+                file_content_mapping[full_path] = FileUtils.read_file(full_path)
             
             try:
                 import patch
@@ -204,7 +224,7 @@ class CodeAutoMergeStrictDiff:
     def _merge_code(self, content: str, force_skip_git: bool = False):        
         total = 0
         
-        file_content = open(self.args.file).read()
+        file_content = FileUtils.read_file(self.args.file)
         md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()
         # get the file name 
         file_name = os.path.basename(self.args.file)

autocoder/common/code_modification_ranker.py

@@ -9,6 +9,8 @@ import traceback
 from autocoder.common.utils_code_auto_generate import chat_with_continue
 from byzerllm.utils.str2model import to_model
 from autocoder.utils.llms import get_llm_names, get_model_info
+from autocoder.common.types import CodeGenerateResult, MergeCodeWithoutEffect
+import os
 
 class RankResult(BaseModel):
     rank_result: List[int]
@@ -51,12 +53,67 @@ class CodeModificationRanker:
         }
         ```
 
-        注意：   
+        注意：                   
         1. id 为 edit_block 的 id,按质量从高到低排序，并且 id 必须是数字        
         2. 只输出前面要求的 Json 格式就好，不要输出其他内容，Json 需要使用 ```json ```包裹                
         '''
 
-    def rank_modifications(self, generate_result: CodeGenerateResult) -> CodeGenerateResult:
+    @byzerllm.prompt()
+    def _rank_modifications_with_merge_result(self, s: CodeGenerateResult,merge_results: List[MergeCodeWithoutEffect]) -> str:
+        '''
+        对一组代码修改进行质量评估并排序。
+
+        下面是修改需求：
+
+        <edit_requirement>
+        {{ s.conversations[0][-2]["content"] }}
+        </edit_requirement>
+
+        下面是相应的代码修改，如果Before 为空，那么表示是新增文件，如果After 为空，那么表示是删除文件，如果Before 和 After 都不为空，那么表示是修改文件：        
+        {% for change in changes %}
+        <edit_file id="{{ loop.index0 }}">
+        {{change}}
+        </edit_file>
+        {% endfor %}
+        
+        请输出如下格式的评估结果,只包含 JSON 数据:
+
+        ```json
+        {
+            "rank_result": [id1, id2, id3] 
+        }
+        ```
+
+        注意：     
+        1. 像python的缩进，前端诸如 reacjs,vue 的标签闭合匹配，这些很重要，需要在排序中作为重点考虑对象之一。   
+        1. id 为 edit_file 的 id,按质量从高到低排序，并且 id 必须是数字        
+        2. 只输出前面要求的 Json 格式就好，不要输出其他内容，Json 需要使用 ```json ```包裹                
+        '''
+        changes = []
+        for merge_result in merge_results:
+            s = ""
+            for block in merge_result.success_blocks:
+                file_path,content = block
+                s += f"##File: {file_path}\n\n"
+                if not os.path.exists(file_path):                    
+                    s += f"##Before: \n\n"
+                    s += f"##File: {file_path}\n\n"
+                    s += f"##After: \n\n"
+                    s += content
+                else:
+                    with open(file_path, "r",encoding="utf-8") as f:
+                        original_content = f.read()
+                    s += f"##Before: \n\n"
+                    s += original_content
+                    s += f"##File: {file_path}\n\n"
+                    s += f"##After: \n\n"
+                    s += content 
+            changes.append(s)                       
+        return {
+            "changes": changes
+        }    
+
+    def rank_modifications(self, generate_result: CodeGenerateResult, merge_result: List[MergeCodeWithoutEffect]) -> CodeGenerateResult:
         import time
         from collections import defaultdict
 
@@ -69,8 +126,13 @@ class CodeModificationRanker:
         
         rank_times = self.args.rank_times_same_model
         total_tasks = len(self.llms) * rank_times
+        if self.args.rank_strategy == "block":
+            query = self._rank_modifications.prompt(generate_result)
+        elif self.args.rank_strategy == "file":
+            query = self._rank_modifications_with_merge_result.prompt(generate_result, merge_result)            
+        else:
+            raise Exception(f"Invalid rank strategy: {self.args.rank_strategy}")
 
-        query = self._rank_modifications.prompt(generate_result)
         input_tokens_count = 0
         generated_tokens_count = 0
         try:

autocoder/common/command_completer.py

@@ -43,6 +43,9 @@ COMMANDS = {
         "/output_price": "",       
     },
     "/auto": {     
+    },
+    "/shell": {
+        "/chat": "",
     }
 }
 

autocoder/common/command_generator.py

@@ -4,6 +4,7 @@ from autocoder.utils.auto_coder_utils.chat_stream_out import stream_out
 from autocoder.common import detect_env
 from autocoder.common import shells
 from autocoder.common.printer import Printer
+from typing import Dict,Union
 
 @byzerllm.prompt()
 def _generate_shell_script(user_input: str) -> str:
@@ -14,6 +15,11 @@ def _generate_shell_script(user_input: str) -> str:
     Python版本: {{ env_info.python_version }}
     终端类型: {{ env_info.shell_type }}
     终端编码: {{ env_info.shell_encoding }}
+    
+    {%- if shell_type %}
+    脚本类型：{{ shell_type }}
+    {%- endif %}
+
     {%- if env_info.conda_env %}
     Conda环境: {{ env_info.conda_env }}
     {%- endif %}
@@ -21,29 +27,39 @@ def _generate_shell_script(user_input: str) -> str:
     虚拟环境: {{ env_info.virtualenv }}
     {%- endif %}    
 
-    根据用户的输入以及当前的操作系统和Shell类型生成合适的 shell 脚本，注意只能生成一个shell脚本，不要生成多个。
+    根据用户的输入以及当前的操作系统和终端类型以及脚本类型生成脚本，
+    注意只能生成一个shell脚本，不要生成多个。    
 
     用户输入: {{ user_input }}
 
-    请生成一个适当的 shell 脚本来执行用户的请求。确保脚本是安全的,并且可以在当前Shell环境中运行。
+    请生成一个适当的脚本来执行用户的请求。确保脚本是安全的,并且可以在当前Shell环境中运行。
     脚本应该包含必要的注释来解释每个步骤。
     脚本内容请用如下方式返回:
 
-    ```shell    
-    # 你的 shell 脚本内容
+    ```script    
+    # 你的 script 脚本内容
     ```
     """
-    env_info = detect_env()    
+    env_info = detect_env() 
+    shell_type = "bash"
+    if shells.is_running_in_cmd():
+        shell_type = "cmd"
+    elif shells.is_running_in_powershell():
+        shell_type = "powershell"
     return {
         "env_info": env_info,
-        "shell_type": shells.get_terminal_name(),
+        "shell_type": shell_type,
         "shell_encoding": shells.get_terminal_encoding()
     }
 
 
-def generate_shell_script(user_input: str, llm: byzerllm.ByzerLLM) -> str:
+def generate_shell_script(user_input: str, llm: Union[byzerllm.ByzerLLM,byzerllm.SimpleByzerLLM]) -> str:
     # 获取 prompt 内容
     prompt = _generate_shell_script.prompt(user_input=user_input)
+    if llm.get_sub_client("chat_model"):
+        shell_llm = llm.get_sub_client("chat_model")                
+    else:
+        shell_llm = llm
     
     # 构造对话上下文
     conversations = [{"role": "user", "content": prompt}]
@@ -52,7 +68,7 @@ def generate_shell_script(user_input: str, llm: byzerllm.ByzerLLM) -> str:
     printer = Printer()
     title = printer.get_message_from_key("generating_shell_script")
     result, _ = stream_out(
-        llm.stream_chat_oai(conversations=conversations, delta_mode=True),
+        shell_llm.stream_chat_oai(conversations=conversations, delta_mode=True),
         model_name=llm.default_model_name,
         title=title        
     )

autocoder/common/command_templates.py

@@ -139,7 +139,7 @@ def create_actions(source_dir:str,params:Dict[str,str]):
         "000_example": base_000_example.prompt(),
     }
     init_file_path = os.path.join(source_dir, "actions", "101_current_work.yml")
-    with open(init_file_path, "w") as f:
+    with open(init_file_path, "w", encoding="utf-8") as f:
         f.write(init_command_template.prompt(source_dir=source_dir))
 
     for k,v in mapping.items():
@@ -152,7 +152,7 @@ def create_actions(source_dir:str,params:Dict[str,str]):
         if k == "000_example":
             file_path = os.path.join(source_dir, "actions", f"{k}.yml")
 
-        with open(file_path, "w") as f:
+        with open(file_path, "w", encoding="utf-8") as f:
             f.write(v)    
 
 @byzerllm.prompt()

autocoder/common/conf_import_export.py

@@ -0,0 +1,105 @@
+import os
+import json
+import shutil
+from loguru import logger
+from autocoder.common.printer import Printer
+from autocoder.common.result_manager import ResultManager
+
+result_manager = ResultManager()
+
+def export_conf(project_root: str, export_path: str) -> bool:
+    printer = Printer()
+    """
+    Export conf from memory.json to a specified directory
+
+    Args:
+        project_root: Project root directory
+        export_path: Path to export the conf file
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    project_root = os.path.abspath(project_root) or os.getcwd()
+    try:
+        memory_path = os.path.join(project_root, ".auto-coder", "plugins", "chat-auto-coder", "memory.json")
+        if not os.path.exists(memory_path):
+            printer.print_in_terminal("conf_not_found", path=memory_path)
+            return False
+
+        # Read and extract conf
+        with open(memory_path, "r",encoding="utf-8") as f:
+            memory_data = json.load(f)
+
+        conf_data = memory_data.get("conf", {})
+
+        # Write to export location
+        export_file = os.path.join(export_path, "conf.json")
+        os.makedirs(export_path, exist_ok=True)
+        with open(export_file, "w",encoding="utf-8") as f:
+            json.dump(conf_data, f, indent=2)
+        printer.print_in_terminal("conf_export_success", path=export_file)
+        result_manager.add_result(content=printer.get_message_from_key_with_format("conf_export_success", path=export_file), meta={"action": "conf_export", "input": {
+            "path": export_file
+        }})
+        return True
+
+    except Exception as e:
+        result_manager.add_result(content=printer.get_message_from_key_with_format("conf_export_error", error=str(e)), meta={"action": "conf_export", "input": {
+            "path": export_file
+        }})
+        printer.print_in_terminal("conf_export_error", error=str(e))
+        return False
+
+
+def import_conf(project_root: str, import_path: str) -> bool:
+    project_root = os.path.abspath(project_root) or os.getcwd()
+    printer = Printer()
+    """
+    Import conf from a specified directory into memory.json
+
+    Args:
+        project_root: Project root directory
+        import_path: Path containing the conf file to import
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        import_file = os.path.join(import_path, "conf.json")
+        if not os.path.exists(import_file):
+            printer.print_in_terminal("conf_not_found", path=import_file)
+            return False
+
+        # Read conf file
+        with open(import_file, "r",encoding="utf-8") as f:
+            conf_data = json.load(f)
+
+        # Backup existing memory
+        memory_path = os.path.join(project_root, ".auto-coder", "plugins", "chat-auto-coder", "memory.json")
+        if os.path.exists(memory_path):
+            backup_path = memory_path + ".bak"
+            shutil.copy2(memory_path, backup_path)
+            printer.print_in_terminal("conf_backup_success", path=backup_path)
+
+        # Update conf in memory
+        with open(memory_path, "r",encoding="utf-8") as f:
+            memory_data = json.load(f)
+
+        memory_data["conf"] = conf_data
+
+        # Write updated memory
+        with open(memory_path, "w",encoding="utf-8") as f:
+            json.dump(memory_data, f, indent=2)
+        
+        printer.print_in_terminal("conf_import_success", path=memory_path)
+        result_manager.add_result(content=printer.get_message_from_key_with_format("conf_import_success", path=memory_path), meta={"action": "conf_import", "input": {
+            "path": memory_path
+        }})
+        return True
+
+    except Exception as e:
+        result_manager.add_result(content=printer.get_message_from_key_with_format("conf_import_error", error=str(e)), meta={"action": "conf_import", "input": {
+            "path": memory_path
+        }})
+        printer.print_in_terminal("conf_import_error", error=str(e))
+        return False

autocoder/common/conf_validator.py

@@ -132,11 +132,17 @@ class ConfigValidator:
             "type": str,
             "default": "v3_chat",
             "description": "提交信息生成模型名称"
+        },
+        "rank_strategy": {
+            "type": str,
+            "allowed": ["block", "file"],
+            "default": "block",
+            "description": "排序策略(block/file)"
         }
     }
 
     @classmethod
-    def validate(cls, key: str, value: Any, product_mode: str) -> Any:
+    def validate(cls, key: str, value: Any, product_mode: str) -> Any:        
         # 获取配置规范
         spec = cls.CONFIG_SPEC.get(key)
         if not spec: