auto-coder 0.1.348__py3-none-any.whl → 0.1.349__py3-none-any.whl

autocoder/common/printer.py

@@ -15,19 +15,18 @@ class Printer:
 
     def get_message_from_key(self, msg_key: str):
         try:
-            return get_message(msg_key)
+            v = get_message(msg_key)
+            if not v:
+                return get_chat_message(msg_key)
         except Exception as e:
             return get_chat_message(msg_key)
 
-    def get_message_from_key_with_format(self, msg_key: str, **kwargs):
-        try:
-            return format_str_jinja2(self.get_message_from_key(msg_key), **kwargs)
-        except Exception as e:
-            return format_str_jinja2(self.get_chat_message_from_key(msg_key), **kwargs)
-
+    def get_message_from_key_with_format(self, msg_key: str, **kwargs):        
+        return format_str_jinja2(self.get_message_from_key(msg_key), **kwargs)
+        
     def print_in_terminal(self, msg_key: str, style: str = None,**kwargs):     
         try:
-            if style:
+            if style:                
                 self.console.print(format_str_jinja2(self.get_message_from_key(msg_key),**kwargs), style=style)
             else:
                 self.console.print(format_str_jinja2(self.get_message_from_key(msg_key),**kwargs))

autocoder/common/run_cmd.py

@@ -0,0 +1,247 @@
+import os
+import platform
+import subprocess
+import sys
+from io import BytesIO
+
+import pexpect
+import psutil
+
+
+def run_cmd(command, verbose=False, error_print=None, cwd=None):
+    """
+    执行一条命令，根据不同系统和环境选择最合适的执行方式（交互式或非交互式）。
+
+    适用场景：
+    - 需要跨平台运行命令，自动判断是否使用pexpect（支持交互式）还是subprocess。
+    - 希望获得命令的执行状态及输出内容。
+    - 在CLI工具、自动化脚本、REPL中执行shell命令。
+
+    参数：
+    - command (str): 需要执行的命令字符串。
+    - verbose (bool): 是否打印详细调试信息，默认为False。
+    - error_print (callable|None): 自定义错误打印函数，默认为None，使用print。
+    - cwd (str|None): 指定命令的工作目录，默认为None。
+
+    返回：
+    - tuple: (exit_code, output)，其中exit_code为整型退出码，output为命令输出内容。
+
+    异常：
+    - 捕获OSError异常，返回错误信息。
+    """
+    try:
+        if sys.stdin.isatty() and hasattr(pexpect, "spawn") and platform.system() != "Windows":
+            return run_cmd_pexpect(command, verbose, cwd)
+
+        return run_cmd_subprocess(command, verbose, cwd)
+    except OSError as e:
+        error_message = f"Error occurred while running command '{command}': {str(e)}"
+        if error_print is None:
+            print(error_message)
+        else:
+            error_print(error_message)
+        return 1, error_message
+
+
+def get_windows_parent_process_name():
+    """
+    获取当前进程的父进程名（仅在Windows系统下有意义）。
+
+    适用场景：
+    - 判断命令是否由PowerShell或cmd.exe启动，以便调整命令格式。
+    - 在Windows平台上进行父进程分析。
+
+    参数：
+    - 无
+
+    返回：
+    - str|None: 父进程名（小写字符串，如"powershell.exe"或"cmd.exe"），如果无法获取则为None。
+
+    异常：
+    - 捕获所有异常，返回None。
+    """
+    try:
+        current_process = psutil.Process()
+        while True:
+            parent = current_process.parent()
+            if parent is None:
+                break
+            parent_name = parent.name().lower()
+            if parent_name in ["powershell.exe", "cmd.exe"]:
+                return parent_name
+            current_process = parent
+        return None
+    except Exception:
+        return None
+
+
+def run_cmd_subprocess(command, verbose=False, cwd=None, encoding=sys.stdout.encoding):
+    if verbose:
+        print("Using run_cmd_subprocess:", command)
+
+    try:
+        shell = os.environ.get("SHELL", "/bin/sh")
+        parent_process = None
+
+        # Determine the appropriate shell
+        if platform.system() == "Windows":
+            parent_process = get_windows_parent_process_name()
+            if parent_process == "powershell.exe":
+                command = f"powershell -Command {command}"
+
+        if verbose:
+            print("Running command:", command)
+            print("SHELL:", shell)
+            if platform.system() == "Windows":
+                print("Parent process:", parent_process)
+
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            shell=True,
+            encoding=encoding,
+            errors="replace",
+            bufsize=0,  # Set bufsize to 0 for unbuffered output
+            universal_newlines=True,
+            cwd=cwd,
+        )
+
+        output = []
+        while True:
+            chunk = process.stdout.read(1)
+            if not chunk:
+                break
+            print(chunk, end="", flush=True)  # Print the chunk in real-time
+            output.append(chunk)  # Store the chunk for later use
+
+        process.wait()
+        return process.returncode, "".join(output)
+    except Exception as e:
+        return 1, str(e)
+
+def run_cmd_subprocess_generator(command, verbose=False, cwd=None, encoding=sys.stdout.encoding):
+    """
+    使用subprocess运行命令，将命令输出逐步以生成器方式yield出来。
+
+    适用场景：
+    - 运行无需交互的命令。
+    - 希望实时逐步处理命令输出（如日志打印、进度监控）。
+    - 在Linux、macOS、Windows等多平台环境下安全运行命令。
+
+    参数：
+    - command (str): 需要执行的命令字符串。
+    - verbose (bool): 是否打印详细调试信息，默认为False。
+    - cwd (str|None): 指定命令的工作目录，默认为None。
+    - encoding (str): 输出解码使用的字符编码，默认为当前stdout编码。
+
+    返回：
+    - 生成器: 逐块yield命令的输出字符串。
+
+    异常：
+    - 捕获所有异常，yield错误信息字符串。
+    """
+    if verbose:
+        print("Using run_cmd_subprocess:", command)
+
+    try:
+        shell = os.environ.get("SHELL", "/bin/sh")
+        parent_process = None
+
+        # Windows下调整命令
+        if platform.system() == "Windows":
+            parent_process = get_windows_parent_process_name()
+            if parent_process == "powershell.exe":
+                command = f"powershell -Command {command}"
+
+        if verbose:
+            print("Running command:", command)
+            print("SHELL:", shell)
+            if platform.system() == "Windows":
+                print("Parent process:", parent_process)
+
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            shell=True,
+            encoding=encoding,
+            errors="replace",
+            bufsize=0,
+            universal_newlines=True,
+            cwd=cwd,
+        )
+
+        while True:
+            chunk = process.stdout.read(1)
+            if not chunk:
+                break            
+            # 确保始终yield字符串，避免因字节或其他类型导致异常
+            if not isinstance(chunk, str):
+                chunk = str(chunk)
+            yield chunk
+
+        process.wait()
+    except Exception as e:
+        # 出错时yield异常信息，也可以raise
+        yield f"[run_cmd_subprocess error]: {str(e)}"
+
+
+def run_cmd_pexpect(command, verbose=False, cwd=None):
+    """
+    使用pexpect以交互方式运行命令，捕获完整输出。
+
+    适用场景：
+    - 执行需要用户交互的命令（如登录、密码输入等）。
+    - 在Linux、macOS等Unix系统下模拟终端操作。
+    - 希望完整捕获交互式命令的输出。
+
+    参数：
+    - command (str): 需要执行的命令字符串。
+    - verbose (bool): 是否打印详细调试信息，默认为False。
+    - cwd (str|None): 指定命令的工作目录，默认为None。
+
+    返回：
+    - tuple: (exit_code, output)，exit_code为退出状态码，output为命令完整输出内容。
+
+    异常：
+    - 捕获pexpect相关异常，返回错误信息。
+    """
+    if verbose:
+        print("Using run_cmd_pexpect:", command)
+
+    output = BytesIO()
+
+    def output_callback(b):
+        output.write(b)
+        return b
+
+    try:
+        # Use the SHELL environment variable, falling back to /bin/sh if not set
+        shell = os.environ.get("SHELL", "/bin/sh")
+        if verbose:
+            print("With shell:", shell)
+
+        if os.path.exists(shell):
+            # Use the shell from SHELL environment variable
+            if verbose:
+                print("Running pexpect.spawn with shell:", shell)
+            child = pexpect.spawn(shell, args=["-i", "-c", command], encoding="utf-8", cwd=cwd)
+        else:
+            # Fall back to spawning the command directly
+            if verbose:
+                print("Running pexpect.spawn without shell.")
+            child = pexpect.spawn(command, encoding="utf-8", cwd=cwd)
+
+        # Transfer control to the user, capturing output
+        child.interact(output_filter=output_callback)
+
+        # Wait for the command to finish and get the exit status
+        child.close()
+        return child.exitstatus, output.getvalue().decode("utf-8", errors="replace")
+
+    except (pexpect.ExceptionPexpect, TypeError, ValueError) as e:
+        error_msg = f"Error running command {command}: {e}"
+        return 1, error_msg

autocoder/common/test_run_cmd.py

@@ -0,0 +1,110 @@
+
+import sys
+import platform
+from unittest import mock
+import io
+
+import pytest
+
+from autocoder.common.run_cmd import (
+    run_cmd,
+    run_cmd_subprocess,
+    run_cmd_subprocess_generator,
+    run_cmd_pexpect,
+    get_windows_parent_process_name,
+)
+
+def test_run_cmd_basic():
+    """
+    测试run_cmd函数，确保其正确执行命令并返回预期结果。
+    """
+    cmd = "echo hello"
+    exit_code, output = run_cmd(cmd)
+    assert exit_code == 0, f"命令退出码非零: {exit_code}"
+    assert "hello" in output, f"输出不包含hello: {output}"
+
+def test_run_cmd_subprocess_normal():
+    """
+    测试run_cmd_subprocess正常执行命令，逐步输出。
+    """
+    cmd = "echo hello_subprocess"
+    gen = run_cmd_subprocess_generator(cmd)
+    output = ""
+    try:
+        for chunk in gen:
+            output += chunk
+    except Exception as e:
+        pytest.fail(f"run_cmd_subprocess异常: {e}")
+    assert "hello_subprocess" in output
+
+def test_run_cmd_subprocess_error():
+    """
+    测试run_cmd_subprocess执行错误命令时能否正确返回异常信息。
+    """
+    cmd = "non_existing_command_xyz"
+    gen = run_cmd_subprocess_generator(cmd)
+    output = ""
+    for chunk in gen:
+        output += chunk
+    # 应该包含错误提示
+    assert "[run_cmd_subprocess error]" in output or "not found" in output or "无法" in output or "未找到" in output
+
+def test_run_cmd_pexpect_mock():
+    """
+    测试run_cmd_pexpect函数，mock pexpect交互行为。
+    """
+    with mock.patch("pexpect.spawn") as mock_spawn:
+        mock_child = mock.MagicMock()
+        mock_child.exitstatus = 0
+        mock_child.interact.side_effect = lambda output_filter=None: output_filter(b"mock output\n")
+        mock_child.close.return_value = None
+        mock_child.exitstatus = 0
+        mock_child.getvalue = lambda: b"mock output\n"
+        mock_spawn.return_value = mock_child
+
+        # 由于run_cmd_pexpect内部会decode BytesIO内容
+        exit_code, output = run_cmd_pexpect("echo hello", verbose=False)
+        assert exit_code == 0
+        assert "mock output" in output
+
+def test_get_windows_parent_process_name_mocked():
+    """
+    测试get_windows_parent_process_name，模拟不同父进程
+    """
+    if platform.system() != "Windows":
+        # 非Windows系统跳过
+        return
+
+    # 构造mock进程树
+    class FakeProcess:
+        def __init__(self, name, parent=None):
+            self._name = name
+            self._parent = parent
+
+        def name(self):
+            return self._name
+
+        def parent(self):
+            return self._parent
+
+    powershell_proc = FakeProcess("powershell.exe")
+    cmd_proc = FakeProcess("cmd.exe")
+    other_proc = FakeProcess("python.exe")
+
+    # 模拟powershell父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", powershell_proc)
+        assert get_windows_parent_process_name() == "powershell.exe"
+
+    # 模拟cmd父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", cmd_proc)
+        assert get_windows_parent_process_name() == "cmd.exe"
+
+    # 模拟无匹配父进程
+    with mock.patch("psutil.Process") as MockProcess:
+        MockProcess.return_value = FakeProcess("python.exe", other_proc)
+        assert get_windows_parent_process_name() is None
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__]))

autocoder/common/v2/agent/agentic_edit.py

@@ -771,12 +771,16 @@ class AgenticEdit:
         Analyzes the user request, interacts with the LLM, parses responses,
         executes tools, and yields structured events for visualization until completion or error.
         """
+        logger.info(f"Starting analyze method with user input: {request.user_input[:50]}...")
         system_prompt = self._analyze.prompt(request)
+        logger.info(f"Generated system prompt with length: {len(system_prompt)}")
+        
         # print(system_prompt)
         conversations = [
             {"role": "system", "content": system_prompt},
         ] 
         
+        logger.info("Adding initial files context to conversation")
         conversations.append({
             "role":"user","content":f'''
 Below are some files the user is focused on, and the content is up to date. These entries show the file paths along with their full text content, which can help you better understand the user's needs. If the information is insufficient, you can use tools such as read_file to retrieve more details.
@@ -788,23 +792,36 @@ Below are some files the user is focused on, and the content is up to date. Thes
         conversations.append({
             "role":"assistant","content":"Ok"
         })
+        
+        logger.info("Adding conversation history")
         conversations.extend(self.conversation_manager.get_history())        
         conversations.append({
             "role": "user", "content": request.user_input
         })
         self.conversation_manager.add_user_message(request.user_input)
         
-        logger.debug(
+        logger.info(
             f"Initial conversation history size: {len(conversations)}")
 
+        iteration_count = 0
         tool_executed = False
         while True:
+            iteration_count += 1            
+            logger.info(f"Starting LLM interaction cycle #{iteration_count}")
             global_cancel.check_and_raise()
+            last_message = conversations[-1]
+            if last_message["role"] == "assistant":
+                logger.info(f"Last message is assistant, skipping LLM interaction cycle")
+                yield CompletionEvent(completion=AttemptCompletionTool(
+                    result=last_message["content"],
+                    command=""
+                ), completion_xml="")
+                break
             logger.info(
                 f"Starting LLM interaction cycle. History size: {len(conversations)}")
 
             assistant_buffer = ""
-
+            logger.info("Initializing stream chat with LLM")
             llm_response_gen = stream_chat_with_continue(
                 llm=self.llm,
                 conversations=conversations,
@@ -813,21 +830,29 @@ Below are some files the user is focused on, and the content is up to date. Thes
             )
 
             meta_holder = byzerllm.MetaHolder()
+            logger.info("Starting to parse LLM response stream")
             parsed_events = self.stream_and_parse_llm_response(
                 llm_response_gen, meta_holder)
 
+            event_count = 0
             for event in parsed_events:
+                event_count += 1
+                logger.info(f"Processing event #{event_count}: {type(event).__name__}")
                 global_cancel.check_and_raise()
                 if isinstance(event, (LLMOutputEvent, LLMThinkingEvent)):
                     assistant_buffer += event.text
-                    yield event  # Yield text/thinking immediately for display
+                    logger.debug(f"Accumulated {len(assistant_buffer)} chars in assistant buffer")
+                    yield event  # Yield text/thinking immediately for display                    
 
                 elif isinstance(event, ToolCallEvent):
                     tool_executed = True
                     tool_obj = event.tool
+                    tool_name = type(tool_obj).__name__
+                    logger.info(f"Tool call detected: {tool_name}")
                     tool_xml = event.tool_xml  # Already reconstructed by parser
 
                     # Append assistant's thoughts and the tool call to history
+                    logger.info(f"Adding assistant message with tool call to conversation history")
                     conversations.append({
                         "role": "assistant",
                         "content": assistant_buffer + tool_xml
@@ -837,11 +862,13 @@ Below are some files the user is focused on, and the content is up to date. Thes
                     assistant_buffer = ""  # Reset buffer after tool call
 
                     yield event  # Yield the ToolCallEvent for display
+                    logger.info("Yielded ToolCallEvent")
 
                     # Handle AttemptCompletion separately as it ends the loop
                     if isinstance(tool_obj, AttemptCompletionTool):
                         logger.info(
                             "AttemptCompletionTool received. Finalizing session.")
+                        logger.info(f"Completion result: {tool_obj.result[:50]}...")
                         yield CompletionEvent(completion=tool_obj, completion_xml=tool_xml)
                         logger.info(
                             "AgenticEdit analyze loop finished due to AttemptCompletion.")
@@ -850,6 +877,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                     if isinstance(tool_obj, PlanModeRespondTool):
                         logger.info(
                             "PlanModeRespondTool received. Finalizing session.")
+                        logger.info(f"Plan mode response: {tool_obj.response[:50]}...")
                         yield PlanModeRespondEvent(completion=tool_obj, completion_xml=tool_xml)
                         logger.info(
                             "AgenticEdit analyze loop finished due to PlanModeRespond.")
@@ -867,6 +895,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                         error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>Error: Tool resolver not implemented.</message><content></content></tool_result>"
                     else:
                         try:
+                            logger.info(f"Creating resolver for tool: {tool_name}")
                             resolver = resolver_cls(
                                 agent=self, tool=tool_obj, args=self.args)
                             logger.info(
@@ -878,6 +907,7 @@ Below are some files the user is focused on, and the content is up to date. Thes
                                 tool_obj).__name__, result=tool_result)
 
                             # Prepare XML for conversation history
+                            logger.info("Preparing XML for conversation history")
                             escaped_message = xml.sax.saxutils.escape(
                                 tool_result.message)
                             content_str = str(
@@ -902,40 +932,55 @@ Below are some files the user is focused on, and the content is up to date. Thes
                                 error_message)
                             error_xml = f"<tool_result tool_name='{type(tool_obj).__name__}' success='false'><message>{escaped_error}</message><content></content></tool_result>"
 
-                    yield result_event  # Yield the ToolResultEvent for display
+                    yield result_event  # Yield the ToolResultEvent for display    
+                    logger.info("Yielded ToolResultEvent")
 
                     # Append the tool result (as user message) to history
+                    logger.info("Adding tool result to conversation history")
                     conversations.append({
                         "role": "user",  # Simulating the user providing the tool result
                         "content": error_xml
                     })
                     self.conversation_manager.add_user_message(error_xml)
-                    logger.debug(
+                    logger.info(
                         f"Added tool result to conversations for tool {type(tool_obj).__name__}")
+                    logger.info(f"Breaking LLM cycle after executing tool: {tool_name}")
                     break  # After tool execution and result, break to start a new LLM cycle
 
                 elif isinstance(event, ErrorEvent):
+                    logger.error(f"Error event occurred: {event.message}")
                     yield event  # Pass through errors
                     # Optionally stop the process on parsing errors
                     # logger.error("Stopping analyze loop due to parsing error.")
                     # return
 
+            logger.info("Yielding token usage event")
             yield TokenUsageEvent(usage=meta_holder.meta)
+            
             if not tool_executed:
                 # No tool executed in this LLM response cycle
-                logger.info("LLM response finished without executing a tool.")
+                logger.info("LLM response finished without executing a tool.")                
                 # Append any remaining assistant buffer to history if it wasn't followed by a tool
                 if assistant_buffer:
-                    conversations.append(
-                        {"role": "assistant", "content": assistant_buffer})
-                    self.conversation_manager.add_assistant_message(
-                        assistant_buffer)
+                    logger.info(f"Appending assistant buffer to history: {len(assistant_buffer)} chars")
+                    last_message = conversations[-1]
+                    if last_message["role"] != "assistant":
+                        logger.info("Adding new assistant message")
+                        conversations.append(
+                            {"role": "assistant", "content": assistant_buffer})
+                        self.conversation_manager.add_assistant_message(
+                            assistant_buffer)
+                    elif last_message["role"] == "assistant":
+                        logger.info("Appending to existing assistant message")
+                        last_message["content"] += assistant_buffer
+                        self.conversation_manager.append_to_last_message(assistant_buffer)                        
                 # If the loop ends without AttemptCompletion, it means the LLM finished talking
                 # without signaling completion. We might just stop or yield a final message.
                 # Let's assume it stops here.
+                logger.info("No tool executed and LLM finished. Breaking out of main loop.")
                 break
 
-        logger.info("AgenticEdit analyze loop finished.")
+        logger.info(f"AgenticEdit analyze loop finished after {iteration_count} iterations.")
 
     def stream_and_parse_llm_response(
         self, generator: Generator[Tuple[str, Any], None, None], meta_holder: byzerllm.MetaHolder
@@ -1323,6 +1368,11 @@ Below are some files the user is focused on, and the content is up to date. Thes
         Apply all tracked file changes to the original project directory.
         """
         for (file_path, change) in self.get_all_file_changes().items():
+            # Ensure the directory exists before writing the file
+            dir_path = os.path.dirname(file_path)
+            if dir_path: # Ensure dir_path is not empty (for files in root)
+                 os.makedirs(dir_path, exist_ok=True)
+
             with open(file_path, 'w', encoding='utf-8') as f:
                 f.write(change.content)
 

autocoder/common/v2/agent/agentic_edit_conversation.py

@@ -68,6 +68,15 @@ class AgenticConversation:
         """Adds an assistant message (potentially containing text response)."""
         self.add_message(role="assistant", content=content)
 
+    def append_to_last_message(self, content: str, role: str = "assistant"):
+        """Appends content to the last message."""
+        if self._history:
+            last_message = self._history[-1]  
+            if role and last_message["role"] == role:
+                last_message["content"] += content   
+            elif not role:
+                last_message["content"] += content
+
     def add_assistant_tool_call_message(self, tool_calls: List[Dict[str, Any]], content: Optional[str] = None):
          """
          Adds a message representing one or more tool calls from the assistant.