auto-coder 0.1.207__py3-none-any.whl → 0.1.209__py3-none-any.whl

autocoder/auto_coder.py

@@ -207,7 +207,8 @@ def main(input_args: Optional[List[str]] = None):
             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)]
+        prev_files = [f for f in action_files if int(
+            get_old_seq(f)) < int(new_seq)]
 
         if raw_args.from_yaml:
             # If --from_yaml is specified, copy content from the matching YAML file
@@ -278,9 +279,30 @@ def main(input_args: Optional[List[str]] = None):
         llm = byzerllm.ByzerLLM(verbose=args.print_request)
 
         if args.code_model:
-            code_model = byzerllm.ByzerLLM()
-            code_model.setup_default_model_name(args.code_model)
-            llm.setup_sub_client("code_model", code_model)
+            if "," in args.code_model:
+                # Multiple code models specified
+                model_names = args.code_model.split(",")
+                models = []
+                for _, model_name in enumerate(model_names):
+                    code_model = byzerllm.ByzerLLM()
+                    code_model.setup_default_model_name(model_name.strip())
+                    models.append(code_model)
+                llm.setup_sub_client("code_model", models)
+            else:
+                # Single code model
+                code_model = byzerllm.ByzerLLM()
+                code_model.setup_default_model_name(args.code_model)
+                llm.setup_sub_client("code_model", code_model)
+
+        if args.generate_rerank_model:
+            generate_rerank_model = byzerllm.ByzerLLM()
+            generate_rerank_model.setup_default_model_name(args.generate_rerank_model)
+            llm.setup_sub_client("generate_rerank_model", generate_rerank_model)
+
+        if args.inference_model:
+            inference_model = byzerllm.ByzerLLM()
+            inference_model.setup_default_model_name(args.inference_model)
+            llm.setup_sub_client("inference_model", inference_model)
 
         if args.human_as_model:
 
@@ -386,18 +408,25 @@ def main(input_args: Optional[List[str]] = None):
 
             llm.add_event_callback(
                 EventName.BEFORE_CALL_MODEL, intercept_callback)
-            code_model = llm.get_sub_client("code_model")
-            if code_model:
-                code_model.add_event_callback(
-                    EventName.BEFORE_CALL_MODEL, intercept_callback
-                )
+            
+            code_models = llm.get_sub_client("code_model")
+            if code_models:
+                if not isinstance(code_models, list):
+                    code_models = [code_models]
+                for model in code_models:
+                    model.add_event_callback(
+                        EventName.BEFORE_CALL_MODEL, intercept_callback
+                    )
         # llm.add_event_callback(EventName.AFTER_CALL_MODEL, token_counter_interceptor)
 
-        code_model = llm.get_sub_client("code_model")
-        if code_model:
-            code_model.add_event_callback(
-                EventName.AFTER_CALL_MODEL, token_counter_interceptor
-            )
+        code_models = llm.get_sub_client("code_model")
+        if code_models:
+            if not isinstance(code_models, list):
+                code_models = [code_models]
+            for model in code_models:
+                model.add_event_callback(
+                    EventName.AFTER_CALL_MODEL, token_counter_interceptor
+                )
 
         llm.setup_template(model=args.model, template="auto")
         llm.setup_default_model_name(args.model)
@@ -493,7 +522,7 @@ def main(input_args: Optional[List[str]] = None):
         from autocoder.index.for_command import index_query_command
 
         index_query_command(args, llm)
-        return   
+        return
 
     if raw_args.command == "agent":
         if raw_args.agent_command == "planner":
@@ -694,24 +723,39 @@ def main(input_args: Optional[List[str]] = None):
             memory_file = os.path.join(memory_dir, "chat_history.json")
             console = Console()
             if args.new_session:
-                chat_history = {"ask_conversation": []}
+                if os.path.exists(memory_file):
+                    with open(memory_file, "r") as f:
+                        old_chat_history = json.load(f)
+                    if "conversation_history" not in old_chat_history:
+                        old_chat_history["conversation_history"] = []
+                    old_chat_history["conversation_history"].append(
+                        old_chat_history.get("ask_conversation", []))
+                    chat_history = {"ask_conversation": [
+                    ], "conversation_history": old_chat_history["conversation_history"]}
+                else:
+                    chat_history = {"ask_conversation": [],
+                                    "conversation_history": []}
                 with open(memory_file, "w") as f:
                     json.dump(chat_history, f, ensure_ascii=False)
                 console.print(
                     Panel(
-                        "New session started. Previous chat history has been cleared.",
+                        "New session started. Previous chat history has been archived.",
                         title="Session Status",
                         expand=False,
                         border_style="green",
                     )
                 )
-                return
+                if not args.query:
+                    return
 
             if os.path.exists(memory_file):
                 with open(memory_file, "r") as f:
                     chat_history = json.load(f)
+                if "conversation_history" not in chat_history:
+                    chat_history["conversation_history"] = []
             else:
-                chat_history = {"ask_conversation": []}
+                chat_history = {"ask_conversation": [],
+                                "conversation_history": []}
 
             chat_history["ask_conversation"].append(
                 {"role": "user", "content": args.query}
@@ -937,6 +981,7 @@ def main(input_args: Optional[List[str]] = None):
 
             with open(memory_file, "w") as f:
                 json.dump(chat_history, f, ensure_ascii=False)
+
             return
 
         else:

autocoder/auto_coder_rag.py

@@ -314,6 +314,12 @@ def main(input_args: Optional[List[str]] = None):
         action="store_true",
         help="Whether to return responses without contexts. only works when pro plugin is installed",
     )
+    serve_parser.add_argument(
+        "--data_cells_max_num",
+        type=int,
+        default=2000,
+        help="Maximum number of data cells to process",
+    )
 
     serve_parser.add_argument(
         "--recall_model",

autocoder/chat_auto_coder.py

@@ -59,6 +59,7 @@ import byzerllm
 from byzerllm.utils import format_str_jinja2
 from autocoder.chat_auto_coder_lang import get_message
 from autocoder.utils import operate_config_api
+from autocoder.agent.auto_guess_query import AutoGuessQuery
 
 
 class SymbolItem(BaseModel):
@@ -930,6 +931,14 @@ class CommandCompleter(Completer):
                             yield Completion(
                                 lib_name, start_position=-len(current_word)
                             )
+            elif words[0] == "/coding":
+                new_text = text[len("/coding"):]
+                parser = CommandTextParser(new_text, words[0])
+                parser.lib()
+                current_word = parser.current_word()
+                for command in parser.get_sub_commands():
+                    if command.startswith(current_word):
+                        yield Completion(command, start_position=-len(current_word))
 
             elif words[0] == "/conf":
                 new_words = text[len("/conf"):].strip().split()
@@ -1427,6 +1436,88 @@ def convert_yaml_to_config(yaml_file: str):
                 setattr(args, key, value)
     return args
 
+
+def code_next(query: str):
+    conf = memory.get("conf", {})
+    yaml_config = {
+        "include_file": ["./base/base.yml"],
+        "auto_merge": conf.get("auto_merge", "editblock"),
+        "human_as_model": conf.get("human_as_model", "false") == "true",
+        "skip_build_index": conf.get("skip_build_index", "true") == "true",
+        "skip_confirm": conf.get("skip_confirm", "true") == "true",
+        "silence": conf.get("silence", "true") == "true",
+        "include_project_structure": conf.get("include_project_structure", "true")
+        == "true",
+    }
+    for key, value in conf.items():
+        converted_value = convert_config_value(key, value)
+        if converted_value is not None:
+            yaml_config[key] = converted_value
+
+    temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
+    try:
+        with open(temp_yaml, "w") as f:
+            f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
+        args = convert_yaml_to_config(temp_yaml)
+    finally:
+        if os.path.exists(temp_yaml):
+            os.remove(temp_yaml)
+
+    llm = byzerllm.ByzerLLM.from_default_model(
+        args.inference_model or args.model)
+
+    auto_guesser = AutoGuessQuery(
+        llm=llm,
+        project_dir=os.getcwd(),
+        skip_diff=True
+    )
+
+    predicted_tasks = auto_guesser.predict_next_tasks(
+        5, is_human_as_model=args.human_as_model)
+
+    if not predicted_tasks:
+        console = Console()
+        console.print(Panel("No task predictions available", style="yellow"))
+        return
+
+    console = Console()
+
+    # Create main panel for all predicted tasks
+    table = Table(show_header=True,
+                  header_style="bold magenta", show_lines=True)
+    table.add_column("Priority", style="cyan", width=8)
+    table.add_column("Task Description", style="green",
+                     width=40, overflow="fold")
+    table.add_column("Files", style="yellow", width=30, overflow="fold")
+    table.add_column("Reason", style="blue", width=30, overflow="fold")
+    table.add_column("Dependencies", style="magenta",
+                     width=30, overflow="fold")
+
+    for task in predicted_tasks:
+        # Format file paths to be more readable
+        file_list = "\n".join([os.path.relpath(f, os.getcwd())
+                              for f in task.urls])
+
+        # Format dependencies to be more readable
+        dependencies = "\n".join(
+            task.dependency_queries) if task.dependency_queries else "None"
+
+        table.add_row(
+            str(task.priority),
+            task.query,
+            file_list,
+            task.reason,
+            dependencies
+        )
+
+    console.print(Panel(
+        table,
+        title="[bold]Predicted Next Tasks[/bold]",
+        border_style="blue",
+        padding=(1, 2)  # Add more horizontal padding
+    ))
+
+
 def commit(query: str):
     def prepare_commit_yaml():
         auto_coder_main(["next", "chat_action"])
@@ -1435,15 +1526,15 @@ def commit(query: str):
 
     # no_diff = query.strip().startswith("/no_diff")
     # if no_diff:
-    #     query = query.replace("/no_diff", "", 1).strip()            
+    #     query = query.replace("/no_diff", "", 1).strip()
 
     latest_yaml_file = get_last_yaml_file("actions")
-    
+
     conf = memory.get("conf", {})
     current_files = memory["current_files"]["files"]
     execute_file = None
-    
-    if latest_yaml_file:        
+
+    if latest_yaml_file:
         try:
             execute_file = os.path.join("actions", latest_yaml_file)
             yaml_config = {
@@ -1469,26 +1560,30 @@ def commit(query: str):
             temp_yaml = os.path.join("actions", f"{uuid.uuid4()}.yml")
             try:
                 with open(temp_yaml, "w") as f:
-                    f.write(convert_yaml_config_to_str(yaml_config=yaml_config))
+                    f.write(convert_yaml_config_to_str(
+                        yaml_config=yaml_config))
                 args = convert_yaml_to_config(temp_yaml)
             finally:
                 if os.path.exists(temp_yaml):
                     os.remove(temp_yaml)
-            
-            llm = byzerllm.ByzerLLM.from_default_model(args.code_model or args.model)
-            uncommitted_changes = git_utils.get_uncommitted_changes(".")                       
+
+            llm = byzerllm.ByzerLLM.from_default_model(
+                args.code_model or args.model)
+            uncommitted_changes = git_utils.get_uncommitted_changes(".")
             commit_message = git_utils.generate_commit_message.with_llm(
                 llm).run(uncommitted_changes)
-            memory["conversation"].append({"role": "user", "content": commit_message})
+            memory["conversation"].append(
+                {"role": "user", "content": commit_message})
             yaml_config["query"] = commit_message
-            yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)            
+            yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
             with open(os.path.join(execute_file), "w") as f:
-                f.write(yaml_content) 
-                        
+                f.write(yaml_content)
+
             file_content = open(execute_file).read()
-            md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()            
-            file_name = os.path.basename(execute_file)             
-            commit_result = git_utils.commit_changes(".", f"auto_coder_{file_name}_{md5}")            
+            md5 = hashlib.md5(file_content.encode('utf-8')).hexdigest()
+            file_name = os.path.basename(execute_file)
+            commit_result = git_utils.commit_changes(
+                ".", f"auto_coder_{file_name}_{md5}")
             git_utils.print_commit_info(commit_result=commit_result)
         except Exception as e:
             print(f"Failed to commit: {e}")
@@ -1502,6 +1597,14 @@ def coding(query: str):
     if is_apply:
         query = query.replace("/apply", "", 1).strip()
 
+    is_next = query.strip().startswith("/next")
+    if is_next:
+        query = query.replace("/next", "", 1).strip()
+
+    if is_next:
+        code_next(query)
+        return
+
     memory["conversation"].append({"role": "user", "content": query})
     conf = memory.get("conf", {})
 
@@ -2198,7 +2301,7 @@ def main():
         mode = memory["mode"]
         human_as_model = memory["conf"].get("human_as_model", "false")
         return (
-            f" Mode: {MODES[mode]} (ctl+k) | Human as Model: {human_as_model} (ctl+n)"
+            f" Mode: {MODES[mode]} (ctl+k) | Human as Model: {human_as_model} (ctl+n or /conf human_as_model:true/false)"
         )
 
     session = PromptSession(

autocoder/command_args.py

@@ -102,7 +102,11 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         "--print_request", action="store_true", help=desc["print_request"]
     )
     parser.add_argument("--code_model", default="", help=desc["code_model"])
-    parser.add_argument("--system_prompt", default="", help=desc["system_prompt"])
+    parser.add_argument("--generate_rerank_model", default="", help=desc["generate_rerank_model"])
+    parser.add_argument("--inference_model", default="",
+                        help="The name of the inference model to use. Default is empty")
+    parser.add_argument("--system_prompt", default="",
+                        help=desc["system_prompt"])
     parser.add_argument("--planner_model", default="",
                         help=desc["planner_model"])
     parser.add_argument(
@@ -111,6 +115,9 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
     parser.add_argument(
         "--human_as_model", action="store_true", help=desc["human_as_model"]
     )
+    parser.add_argument(
+        "--human_model_num", type=int, default=1, help=desc["human_model_num"]
+    )
     parser.add_argument("--urls", default="", help=desc["urls"])
     parser.add_argument(
         "--urls_use_model", action="store_true", help=desc["urls_use_model"]
@@ -129,6 +136,13 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         "--search_engine_token", default="", help=desc["search_engine_token"]
     )
 
+    parser.add_argument(
+        "--generate_times_same_model",
+        type=int,
+        default=1,
+        help=desc["generate_times_same_model"],
+    )
+
     parser.add_argument(
         "--enable_rag_search",
         nargs="?",
@@ -196,7 +210,6 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
         help="是否静默执行,不打印任何信息。默认为False",
     )
 
-
     revert_parser = subparsers.add_parser("revert", help=desc["revert_desc"])
     revert_parser.add_argument("--file", help=desc["revert_desc"])
     revert_parser.add_argument(
@@ -554,7 +567,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     read_project_parser.add_argument("--rag_token", default="", help="")
     read_project_parser.add_argument("--rag_url", default="", help="")
-    read_project_parser.add_argument("--rag_params_max_tokens", default=4096, help="")
+    read_project_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     read_project_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )
@@ -644,7 +658,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     auto_tool_parser.add_argument("--rag_token", default="", help="")
     auto_tool_parser.add_argument("--rag_url", default="", help="")
-    auto_tool_parser.add_argument("--rag_params_max_tokens", default=4096, help="")
+    auto_tool_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     auto_tool_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )
@@ -710,7 +725,8 @@ def parse_args(input_args: Optional[List[str]] = None) -> AutoCoderArgs:
 
     planner_parser.add_argument("--rag_token", default="", help="")
     planner_parser.add_argument("--rag_url", default="", help="")
-    planner_parser.add_argument("--rag_params_max_tokens", default=4096, help="")   
+    planner_parser.add_argument(
+        "--rag_params_max_tokens", default=4096, help="")
     planner_parser.add_argument(
         "--rag_type", default="storage", help="RAG type, default is storage"
     )

autocoder/common/__init__.py

@@ -248,9 +248,12 @@ class AutoCoderArgs(pydantic.BaseModel):
     sd_model: Optional[str] = ""
     emb_model: Optional[str] = ""
     code_model: Optional[str] = ""
+    generate_rerank_model: Optional[str] = ""
+    inference_model: Optional[str] = ""
     system_prompt: Optional[str] = ""
-    text2voice_model: Optional[str] = ""
+    planner_model: Optional[str] = ""
     voice2text_model: Optional[str] = ""
+    text2voice_model: Optional[str] = ""
     
     skip_build_index: Optional[bool] = False
     skip_filter_index: Optional[bool] = False
@@ -291,6 +294,7 @@ class AutoCoderArgs(pydantic.BaseModel):
 
     auto_merge: Optional[Union[bool, str]] = False
     human_as_model: Optional[bool] = False
+    human_model_num: Optional[int] = 1
 
     image_file: Optional[str] = ""
     image_mode: Optional[str] = "direct"
@@ -341,6 +345,8 @@ class AutoCoderArgs(pydantic.BaseModel):
     inference_compute_precision: int = 64
     without_contexts: Optional[bool] = False
     skip_events: Optional[bool] = False
+    data_cells_max_num: Optional[int] = 2000
+    generate_times_same_model: Optional[int] = 1
 
     class Config:
         protected_namespaces = ()

autocoder/common/code_auto_generate.py

@@ -4,6 +4,8 @@ from autocoder.common import AutoCoderArgs
 import byzerllm
 from autocoder.utils.queue_communicate import queue_communicate, CommunicateEvent, CommunicateEventType
 from autocoder.common import sys_prompt
+from concurrent.futures import ThreadPoolExecutor
+from autocoder.common.types import CodeGenerateResult
 
 
 class CodeAutoGenerate:
@@ -12,13 +14,15 @@ class CodeAutoGenerate:
     ) -> None:
         self.llm = llm
         self.args = args
-        self.action = action
+        self.action = action        
+        self.generate_times_same_model = args.generate_times_same_model
         if not self.llm:
             raise ValueError(
                 "Please provide a valid model instance to use for code generation."
             )
-        if self.llm.get_sub_client("code_model"):
-            self.llm = self.llm.get_sub_client("code_model")
+        self.llms = self.llm.get_sub_client("code_model") or [self.llm]
+        if not isinstance(self.llms, list):
+            self.llms = [self.llms]
 
     @byzerllm.prompt(llm=lambda self: self.llm)
     def auto_implement_function(self, instruction: str, content: str) -> str:
@@ -145,7 +149,7 @@ class CodeAutoGenerate:
 
     def single_round_run(
         self, query: str, source_content: str
-    ) -> Tuple[str, Dict[str, str]]:
+    ) -> Tuple[List[str], Dict[str, str]]:
         llm_config = {"human_as_model": self.args.human_as_model}
 
         if self.args.request_id and not self.args.skip_events:
@@ -178,9 +182,27 @@ class CodeAutoGenerate:
         
         conversations.append({"role": "user", "content": init_prompt})
 
-
-        t = self.llm.chat_oai(conversations=conversations, llm_config=llm_config)
-        conversations.append({"role": "assistant", "content": t[0].output})
+        conversations_list = []
+        results = []
+        if not self.args.human_as_model:
+            with ThreadPoolExecutor(max_workers=len(self.llms) * self.generate_times_same_model) as executor:
+                futures = []
+                for llm in self.llms:
+                    for _ in range(self.generate_times_same_model):
+                        futures.append(executor.submit(
+                            llm.chat_oai, conversations=conversations, llm_config=llm_config))
+                results = [future.result()[0].output for future in futures]
+            for result in results:
+                conversations_list.append(
+                    conversations + [{"role": "assistant", "content": result}])
+        else:
+            results = []
+            conversations_list = []
+            for _ in range(self.args.human_model_num):
+                v = self.llms[0].chat_oai(
+                    conversations=conversations, llm_config=llm_config)
+                results.append(v[0].output)
+                conversations_list.append(conversations + [{"role": "assistant", "content": v[0].output}])
 
         if self.args.request_id and not self.args.skip_events:
             queue_communicate.send_event_no_wait(
@@ -191,7 +213,7 @@ class CodeAutoGenerate:
                 ),
             )
 
-        return [t[0].output], conversations
+        return CodeGenerateResult(contents=results, conversations=conversations_list)
 
     def multi_round_run(
         self, query: str, source_content: str, max_steps: int = 10
@@ -246,6 +268,6 @@ class CodeAutoGenerate:
                 or "/done" in t[0].output
                 or "__EOF__" in t[0].output
             ):
-                return result, conversations
+                return CodeGenerateResult(contents=["\n\n".join(result)], conversations=[conversations])
 
-        return result, conversations
+        return CodeGenerateResult(contents=["\n\n".join(result)], conversations=[conversations])