auto-coder 0.1.398__py3-none-any.whl → 0.1.399__py3-none-any.whl

autocoder/agent/entry_command_agent/voice2text.py

@@ -0,0 +1,71 @@
+
+
+
+import os
+import tempfile
+from rich.console import Console
+from rich.panel import Panel
+
+from autocoder.utils.request_queue import (
+    request_queue,
+    RequestValue,
+    DefaultValue,
+    RequestOption,
+)
+
+
+class Voice2TextAgent:
+    def __init__(self, args, llm, raw_args):
+        self.args = args
+        self.llm = llm
+        self.raw_args = raw_args
+        self.console = Console()
+
+    def run(self):
+        """执行 voice2text 命令的主要逻辑"""
+        from autocoder.common.audio import TranscribeAudio
+
+        transcribe_audio = TranscribeAudio()
+        temp_wav_file = os.path.join(
+            tempfile.gettempdir(), "voice_input.wav")
+
+        transcribe_audio.record_audio(temp_wav_file)
+        self.console.print(
+            Panel(
+                "Recording finished. Transcribing...",
+                title="Voice",
+                border_style="green",
+            )
+        )
+
+        if self.llm and self.llm.get_sub_client("voice2text_model"):
+            voice2text_llm = self.llm.get_sub_client("voice2text_model")
+        else:
+            voice2text_llm = self.llm
+        
+        transcription = transcribe_audio.transcribe_audio(
+            temp_wav_file, voice2text_llm
+        )
+
+        self.console.print(
+            Panel(
+                f"Transcription: <_transcription_>{transcription}</_transcription_>",
+                title="Result",
+                border_style="magenta",
+            )
+        )
+
+        with open(os.path.join(".auto-coder", "exchange.txt"), "w", encoding="utf-8") as f:
+            f.write(transcription)
+
+        request_queue.add_request(
+            self.args.request_id,
+            RequestValue(
+                value=DefaultValue(value=transcription),
+                status=RequestOption.COMPLETED,
+            ),
+        )
+
+        os.remove(temp_wav_file)
+
+

autocoder/auto_coder.py

@@ -893,566 +893,41 @@ def main(input_args: Optional[List[str]] = None):
             #     )
             return
         elif raw_args.agent_command == "project_reader":
-                        
-            target_llm = llm.get_sub_client("planner_model")
-            if not target_llm:
-                target_llm = llm
-            model_filter = ModelPathFilter.from_model_object(target_llm, args)
-            if model_filter.has_rules():
-                printer = Printer()
-                msg = printer.get_message_from_key_with_format("model_has_access_restrictions",                                            
-                                           model_name=",".join(get_llm_names(target_llm)))
-                raise ValueError(msg)
-
-            from autocoder.agent.project_reader import ProjectReader
-
-            project_reader = ProjectReader(args, llm)
-            v = project_reader.run(args.query)            
-            console = Console()
-            markdown_content = v
-
-            with Live(
-                Panel("", title="Response", border_style="green", expand=False),
-                refresh_per_second=4,
-                auto_refresh=True,
-                vertical_overflow="visible",
-                console=Console(force_terminal=True, color_system="auto", height=None)
-            ) as live:
-                live.update(
-                    Panel(
-                        Markdown(markdown_content),
-                        title="Response",
-                        border_style="green",
-                        expand=False,
-                    )
-                )
-
+            from autocoder.agent.entry_command_agent import ProjectReaderAgent
+            
+            project_reader_agent = ProjectReaderAgent(args, llm, raw_args)
+            project_reader_agent.run()
             return
         elif raw_args.agent_command == "voice2text":
-            from autocoder.common.audio import TranscribeAudio
-            import tempfile
-
-            transcribe_audio = TranscribeAudio()
-            temp_wav_file = os.path.join(
-                tempfile.gettempdir(), "voice_input.wav")
-
-            console = Console()
-
-            transcribe_audio.record_audio(temp_wav_file)
-            console.print(
-                Panel(
-                    "Recording finished. Transcribing...",
-                    title="Voice",
-                    border_style="green",
-                )
-            )
-
-            if llm and llm.get_sub_client("voice2text_model"):
-                voice2text_llm = llm.get_sub_client("voice2text_model")
-            else:
-                voice2text_llm = llm
-            transcription = transcribe_audio.transcribe_audio(
-                temp_wav_file, voice2text_llm
-            )
-
-            console.print(
-                Panel(
-                    f"Transcription: <_transcription_>{transcription}</_transcription_>",
-                    title="Result",
-                    border_style="magenta",
-                )
-            )
-
-            with open(os.path.join(".auto-coder", "exchange.txt"), "w",encoding="utf-8") as f:
-                f.write(transcription)
-
-            request_queue.add_request(
-                args.request_id,
-                RequestValue(
-                    value=DefaultValue(value=transcription),
-                    status=RequestOption.COMPLETED,
-                ),
-            )
-
-            os.remove(temp_wav_file)
+            from autocoder.agent.entry_command_agent import Voice2TextAgent
+            
+            voice2text_agent = Voice2TextAgent(args, llm, raw_args)
+            voice2text_agent.run()
             return
         elif raw_args.agent_command == "generate_command":
-            from autocoder.common.command_generator import generate_shell_script
-
-            console = Console()            
-
-            shell_script = generate_shell_script(args, llm)
-
-            console.print(
-                Panel(
-                    shell_script,
-                    title="Shell Script",
-                    border_style="magenta",
-                )
-            )
-
-            with open(os.path.join(".auto-coder", "exchange.txt"), "w",encoding="utf-8") as f:
-                f.write(shell_script)
-
-            request_queue.add_request(
-                args.request_id,
-                RequestValue(
-                    value=DefaultValue(value=shell_script),
-                    status=RequestOption.COMPLETED,
-                ),
-            )
-
+            from autocoder.agent.entry_command_agent import GenerateCommandAgent
+            
+            generate_command_agent = GenerateCommandAgent(args, llm, raw_args)
+            generate_command_agent.run()
             return
         elif raw_args.agent_command == "auto_tool":
-            from autocoder.agent.auto_tool import AutoTool
-
-            auto_tool = AutoTool(args, llm)
-            v = auto_tool.run(args.query)
-            if args.request_id:
-                request_queue.add_request(
-                    args.request_id,
-                    RequestValue(
-                        value=DefaultValue(value=v), status=RequestOption.COMPLETED
-                    ),
-                )
-            console = Console()
-            markdown_content = v
-
-            with Live(
-                Panel("", title="Response", border_style="green", expand=False),
-                refresh_per_second=4,
-                auto_refresh=True,
-                vertical_overflow="visible",
-                console=Console(force_terminal=True, color_system="auto", height=None)
-            ) as live:
-                live.update(
-                    Panel(
-                        Markdown(markdown_content),
-                        title="Response",
-                        border_style="green",
-                        expand=False,
-                    )
-                )
-
+            from autocoder.agent.entry_command_agent import AutoToolAgent
+            
+            auto_tool_agent = AutoToolAgent(args, llm, raw_args)
+            auto_tool_agent.run()
             return
         elif raw_args.agent_command == "designer":
-            from autocoder.agent.designer import SVGDesigner, SDDesigner, LogoDesigner
-
-            if args.agent_designer_mode == "svg":
-                designer = SVGDesigner(args, llm)
-                designer.run(args.query)
-                print("Successfully generated image in output.png")
-            elif args.agent_designer_mode == "sd":
-                designer = SDDesigner(args, llm)
-                designer.run(args.query)
-                print("Successfully generated image in output.jpg")
-            elif args.agent_designer_mode.startswith("logo"):
-                designer = LogoDesigner(args, llm)
-                designer.run(args.query)
-                print("Successfully generated image in output.png")
-            if args.request_id:
-                request_queue.add_request(
-                    args.request_id,
-                    RequestValue(
-                        value=DefaultValue(
-                            value="Successfully generated image"),
-                        status=RequestOption.COMPLETED,
-                    ),
-                )
+            from autocoder.agent.entry_command_agent import DesignerAgent
+            
+            designer_agent = DesignerAgent(args, llm, raw_args)
+            designer_agent.run()
             return
 
         elif raw_args.agent_command == "chat":
+            from autocoder.agent.entry_command_agent import ChatAgent
             
-            # 统一格式
-            # {"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")
-            console = Console()
-            result_manager = ResultManager()
-            if args.new_session:
-                if os.path.exists(memory_file):
-                    with open(memory_file, "r",encoding="utf-8") 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",encoding="utf-8") as f:
-                    json.dump(chat_history, f, ensure_ascii=False)
-                
-                result_manager.add_result(content=get_message("new_session_started"), meta={
-                    "action": "chat",
-                    "input": {
-                        "query": args.query
-                    }
-                })    
-                console.print(
-                    Panel(
-                        get_message("new_session_started"),
-                        title="Session Status",
-                        expand=False,
-                        border_style="green",
-                    )
-                )
-                if not args.query or (args.query_prefix and args.query == args.query_prefix) or (args.query_suffix and args.query == args.query_suffix):
-                    return
-
-            if os.path.exists(memory_file):
-                with open(memory_file, "r",encoding="utf-8") as f:
-                    chat_history = json.load(f)
-                if "conversation_history" not in chat_history:
-                    chat_history["conversation_history"] = []
-            else:
-                chat_history = {"ask_conversation": [],
-                                "conversation_history": []}
-
-            chat_history["ask_conversation"].append(
-                {"role": "user", "content": args.query}
-            )
-
-            if llm.get_sub_client("chat_model"):
-                chat_llm = llm.get_sub_client("chat_model")                
-            else:
-                chat_llm = llm
-
-            source_count = 0
-            pre_conversations = []            
-            context_content = args.context if args.context else ""
-            if args.context:                
-                try:
-                    context = json.loads(args.context)
-                    if "file_content" in context:
-                        context_content = context["file_content"]
-                except:
-                    pass                     
-
-                pre_conversations.append(
-                    {
-                        "role": "user",
-                        "content": f"请阅读下面的代码和文档：\n\n <files>\n{context_content}\n</files>",
-                    },
-                )
-                pre_conversations.append(
-                    {"role": "assistant", "content": "read"})
-                source_count += 1
-
-            from autocoder.index.index import IndexManager
-            from autocoder.index.entry import build_index_and_filter_files
-            from autocoder.pyproject import PyProject
-            from autocoder.tsproject import TSProject
-            from autocoder.suffixproject import SuffixProject
-
-            if args.project_type == "ts":
-                pp = TSProject(args=args, llm=llm)
-            elif args.project_type == "py":
-                pp = PyProject(args=args, llm=llm)
-            else:
-                pp = SuffixProject(args=args, llm=llm, file_filter=None)
-            pp.run()
-            sources = pp.sources
-            
-            # Apply model filter for chat_llm            
-            model_filter = ModelPathFilter.from_model_object(chat_llm, args)
-            filtered_sources = []
-            printer = Printer()            
-            for source in sources:
-                if model_filter.is_accessible(source.module_name):
-                    filtered_sources.append(source)
-                else:                    
-                    printer.print_in_terminal("index_file_filtered", 
-                                               style="yellow",
-                                               file_path=source.module_name, 
-                                               model_name=",".join(get_llm_names(chat_llm)))
-            
-            if "no_context" not in commands_info:
-                s = build_index_and_filter_files(
-                    llm=llm, args=args, sources=filtered_sources).to_str()                        
-                
-                if s:
-                    pre_conversations.append(
-                        {
-                            "role": "user",
-                            "content": f"请阅读下面的代码和文档：\n\n <files>\n{s}\n</files>",
-                        }
-                    )
-                    pre_conversations.append(
-                        {"role": "assistant", "content": "read"})
-                    source_count += 1
-
-            loaded_conversations = pre_conversations + \
-                chat_history["ask_conversation"]              
-
-            if get_run_context().mode != RunMode.WEB and args.human_as_model:
-                console = Console()
-
-                @byzerllm.prompt()
-                def chat_with_human_as_model(
-                    source_codes, pre_conversations, last_conversation
-                ):
-                    """                    
-                    {% if source_codes %}                    
-                    {{ source_codes }}
-                    {% endif %}                    
-
-                    {% if pre_conversations %}
-                    下面是我们之间的历史对话，假设我是A，你是B。
-                    <conversations>
-                    {% for conv in pre_conversations %}
-                    {{ "A" if conv.role == "user" else "B" }}: {{ conv.content }}
-                    {% endfor %}
-                    </conversations>
-                    {% endif %}
-
-
-                    参考上面的文件以及历史对话，回答用户的问题。
-                    用户的问题: {{ last_conversation.content }}
-                    """
-
-                source_codes_conversations = loaded_conversations[0: source_count * 2]
-                source_codes = ""
-                for conv in source_codes_conversations:
-                    if conv["role"] == "user":
-                        source_codes += conv["content"]
-
-                chat_content = chat_with_human_as_model.prompt(
-                    source_codes=source_codes,
-                    pre_conversations=loaded_conversations[source_count * 2: -1],
-                    last_conversation=loaded_conversations[-1],
-                )  
-                
-                with open(args.target_file, "w",encoding="utf-8") as f:
-                    f.write(chat_content)
-                
-                try:
-                    import pyperclip
-
-                    pyperclip.copy(chat_content)
-                    console.print(
-                        Panel(
-                            get_message("chat_human_as_model_instructions"),
-                            title="Instructions",
-                            border_style="blue",
-                            expand=False,
-                        )
-                    )
-                except Exception:
-                    logger.warning(get_message("clipboard_not_supported"))
-                    console.print(
-                        Panel(
-                            get_message(
-                                "human_as_model_instructions_no_clipboard"),
-                            title="Instructions",
-                            border_style="blue",
-                            expand=False,
-                        )
-                    )    
-
-                lines = []
-                while True:
-                    line = prompt(FormattedText(
-                        [("#00FF00", "> ")]), multiline=False)
-                    line_lower = line.strip().lower()
-                    if line_lower in ["eof", "/eof"]:
-                        break
-                    elif line_lower in ["/clear"]:
-                        lines = []
-                        print("\033[2J\033[H")  # Clear terminal screen
-                        continue
-                    elif line_lower in ["/break"]:
-                        raise Exception(
-                            "User requested to break the operation.")
-                    lines.append(line)
-
-                result = "\n".join(lines)
-                
-
-                result_manager = ResultManager()
-                result_manager.append(content=result, 
-                                      meta={"action": "chat","input":{
-                                            "query":args.query
-                                      }})
-
-                # Update chat history with user's response
-                chat_history["ask_conversation"].append(
-                    {"role": "assistant", "content": result}
-                )
-
-                with open(memory_file, "w",encoding="utf-8") as f:
-                    json.dump(chat_history, f, ensure_ascii=False)                
-
-                if "save" in commands_info:
-                    save_to_memory_file(ask_conversation=chat_history["ask_conversation"],
-                                        query=args.query,
-                                        response=result)
-                    printer = Printer()
-                    printer.print_in_terminal("memory_save_success")
-                return {}
-
-            # 计算耗时            
-            start_time = time.time()    
-            commit_file_name = None
-                        
-            if "rag" in commands_info:
-                from autocoder.rag.rag_entry import RAGFactory
-                args.enable_rag_search = True
-                args.enable_rag_context = False
-                rag = RAGFactory.get_rag(llm=chat_llm, args=args, path="")
-                response = rag.stream_chat_oai(
-                    conversations=loaded_conversations)[0]                                                
-                v = (item for item in response)
-                
-            elif "mcp" in commands_info: 
-                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=final_query,
-                        model=args.inference_model or args.model,
-                        product_mode=args.product_mode
-                    )
-                )
-                v = [[response.result,None]]
-            elif "review" in commands_info:
-                from autocoder.agent.auto_review_commit import AutoReviewCommit                
-                reviewer = AutoReviewCommit(llm=chat_llm, args=args)
-                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)
-                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)                
-                estimated_input_tokens = count_tokens(dumped_conversations)
-                printer = Printer()
-                printer.print_in_terminal("estimated_chat_input_tokens", style="yellow",
-                                  estimated_input_tokens=estimated_input_tokens
-                                  )
-                
-                # with open("/tmp/output.txt", "w",encoding="utf-8") as f:
-                #     f.write(json.dumps(loaded_conversations, ensure_ascii=False, indent=4))
-
-                v = stream_chat_with_continue(
-                    llm=chat_llm,
-                    conversations=loaded_conversations,
-                    llm_config={},
-                    args=args
-                )              
-
-
-            model_name = ",".join(get_llm_names(chat_llm))
-            
-            assistant_response, last_meta = stream_out(
-                    v, 
-                    request_id=args.request_id,                    
-                    console=console,
-                    model_name=model_name,
-                    args=args
-                )
-
-            result_manager = ResultManager()
-            result_manager.append(content=assistant_response, meta={
-                "action": "chat",
-                "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:
-                elapsed_time = time.time() - start_time
-                printer = Printer()
-                speed = last_meta.generated_tokens_count / elapsed_time
-                
-                # Get model info for pricing
-                from autocoder.utils import llms as llm_utils
-                model_info = llm_utils.get_model_info(model_name, args.product_mode) or {}
-                input_price = model_info.get("input_price", 0.0) if model_info else 0.0
-                output_price = model_info.get("output_price", 0.0) if model_info else 0.0
-                
-                # Calculate costs
-                input_cost = (last_meta.input_tokens_count * input_price) / 1000000  # Convert to millions
-                output_cost = (last_meta.generated_tokens_count * output_price) / 1000000  # Convert to millions
-                
-                printer.print_in_terminal("stream_out_stats", 
-                                    model_name=model_name,
-                                    elapsed_time=elapsed_time,
-                                    first_token_time=last_meta.first_token_time,
-                                    input_tokens=last_meta.input_tokens_count,
-                                    output_tokens=last_meta.generated_tokens_count,
-                                    input_cost=round(input_cost, 4),
-                                    output_cost=round(output_cost, 4),
-                                    speed=round(speed, 2))
-                get_event_manager(args.event_file).write_result(
-                    EventContentCreator.create_result(content=EventContentCreator.ResultTokenStatContent(
-                        model_name=model_name,
-                        elapsed_time=elapsed_time,
-                        input_tokens=last_meta.input_tokens_count,
-                        output_tokens=last_meta.generated_tokens_count,
-                        input_cost=round(input_cost, 4),
-                        output_cost=round(output_cost, 4),
-                        speed=round(speed, 2)
-                    )).to_dict(), metadata=EventMetadata(
-                        action_file=args.file
-                    ).to_dict())                
-                
-            
-            chat_history["ask_conversation"].append(
-                {"role": "assistant", "content": assistant_response}
-            )
-
-            with open(memory_file, "w",encoding="utf-8") as f:
-                json.dump(chat_history, f, ensure_ascii=False)
-
-            if "copy" in commands_info:
-                #copy assistant_response to clipboard
-                import pyperclip
-                try:
-                    pyperclip.copy(assistant_response)    
-                except:
-                    print("pyperclip not installed or clipboard is not supported, instruction will not be copied to clipboard.")
-
-            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", 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)
+            chat_agent = ChatAgent(args, llm, raw_args)
+            chat_agent.run()
             return
 
         else: