auto-coder 3.0.2__tar.gz → 3.0.4__tar.gz

{auto_coder-3.0.2/src/auto_coder.egg-info → auto_coder-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.2
+Version: 3.0.4
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.2 → auto_coder-3.0.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.2"
+version = "3.0.4"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}

{auto_coder-3.0.2 → auto_coder-3.0.4/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-coder
-Version: 3.0.2
+Version: 3.0.4
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.2 → auto_coder-3.0.4}/src/autocoder/common/__init__.py

@@ -288,6 +288,9 @@ class AutoCoderArgs(pydantic.BaseModel):
     enable_agentic_dangerous_command_check: bool = False
     enable_display_agentic_reasoning_content: bool = True
     enable_agentic_interleaving_thinking: bool = True
+
+    enable_agentic_replace_ask_followup_question_with_attempt_completion: bool = True
+
     agentic_max_rounds: int = 10000
     agentic_mode: str = "act"  # plan|act
     agentic_connection_retries: int = 10
@@ -475,6 +478,10 @@ class AutoCoderArgs(pydantic.BaseModel):
     # Default to 30 minutes
     call_subagent_timeout: float = 30 * 60
 
+    # Timeout (in seconds) for waiting user input in ask_followup_question / ask_user.
+    # None means no timeout (block forever in terminal, default 3600s in web).
+    ask_user_timeout_seconds: Optional[float] = 3600
+
     # RAG cache build workers, 0 means use half of cpu count
     rag_cache_build_workers: int = 0
 

{auto_coder-3.0.2 → auto_coder-3.0.4}/src/autocoder/common/git_utils.py

@@ -1,4 +1,6 @@
 import os
+import locale
+import subprocess
 from loguru import logger
 from typing import List, Optional, Dict, Any
 from pydantic import BaseModel
@@ -52,6 +54,58 @@ class CommitResult(BaseModel):
     error_message: Optional[str] = None
 
 
+def _safe_decode_output(data: Any) -> str:
+    """
+    Safely decode subprocess output bytes to string.
+
+    - Prefer UTF-8 when possible (common for git output).
+    - Fallback to system preferred encoding.
+    - Never raise UnicodeDecodeError (use replacement as last resort).
+    """
+    if data is None:
+        return ""
+    if isinstance(data, str):
+        return data
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    if not isinstance(data, (bytes, bytearray)):
+        return str(data)
+
+    preferred = locale.getpreferredencoding(False) or "utf-8"
+    for enc in ("utf-8", preferred):
+        try:
+            return bytes(data).decode(enc)
+        except UnicodeDecodeError:
+            continue
+    return bytes(data).decode(preferred, errors="replace")
+
+
+def _run_git_capture(repo_path: str, args: List[str]) -> tuple[int, str, str]:
+    """
+    Run `git` with binary capture to avoid Windows locale decode crashes.
+    Returns: (exit_code, stdout_text, stderr_text)
+    """
+    try:
+        completed = subprocess.run(
+            ["git", *args],
+            cwd=repo_path,
+            capture_output=True,
+            text=False,   # critical: avoid implicit decoding (gbk/cp936) in reader threads
+            check=False,
+        )
+        return (
+            completed.returncode,
+            _safe_decode_output(completed.stdout),
+            _safe_decode_output(completed.stderr),
+        )
+    except FileNotFoundError as e:
+        # GitPython requires git executable anyway, but keep this error readable.
+        msg = str(e)
+        return 127, "", msg
+    except Exception as e:
+        return 1, "", str(e)
+
+
 def init(repo_path: str) -> bool:
     if not GIT_AVAILABLE:
         logger.warning("Git is not available. Skipping Git initialization.")
@@ -111,16 +165,45 @@ def commit_changes(repo_path: str, message: str) -> CommitResult:
             )
 
             if commit.parents:
-                changed_files = repo.git.diff(
-                    commit.parents[0].hexsha, commit.hexsha, name_only=True
-                ).split("\n")
-                result.changed_files = [file for file in changed_files if file.strip()]
+                parent_hexsha = commit.parents[0].hexsha
+
+                # Use `git` CLI in binary mode to avoid UnicodeDecodeError on Windows GBK locale.
+                # GitPython's internal decoding can crash in subprocess reader threads when output
+                # contains non-GBK bytes (e.g., UTF-8 diff content).
+                rc, stdout, stderr = _run_git_capture(
+                    repo_path,
+                    [
+                        "-c",
+                        "core.quotepath=false",
+                        "diff",
+                        "--name-only",
+                        parent_hexsha,
+                        commit.hexsha,
+                    ],
+                )
+                if rc != 0 and stderr:
+                    logger.warning(f"git diff --name-only failed: {stderr}")
+
+                changed_files = [line.strip() for line in stdout.splitlines() if line.strip()]
+                result.changed_files = changed_files
 
                 for file in result.changed_files:
-                    diff = repo.git.diff(
-                        commit.parents[0].hexsha, commit.hexsha, "--", file
+                    rc, diff_out, diff_err = _run_git_capture(
+                        repo_path,
+                        [
+                            "-c",
+                            "core.quotepath=false",
+                            "diff",
+                            "--no-color",
+                            parent_hexsha,
+                            commit.hexsha,
+                            "--",
+                            file,
+                        ],
                     )
-                    result.diffs[file] = diff
+                    if rc != 0 and diff_err:
+                        logger.warning(f"git diff for {file} failed: {diff_err}")
+                    result.diffs[file] = diff_out
             else:
                 result.error_message = (
                     "This is the initial commit, no parent to compare against."

{auto_coder-3.0.2 → auto_coder-3.0.4}/src/autocoder/common/tools_manager/utils.py

@@ -5,12 +5,39 @@ Tools Manager Utility Functions
 """
 
 import os
+import locale
 import subprocess
 from pathlib import Path
 from typing import Optional, List
 from loguru import logger
 
 
+def _safe_decode_output(data: object) -> str:
+    """
+    Safely decode subprocess output to string.
+
+    - Prefer UTF-8 when possible.
+    - Fallback to system preferred encoding.
+    - Never raise UnicodeDecodeError.
+    """
+    if data is None:
+        return ""
+    if isinstance(data, str):
+        return data
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    if not isinstance(data, (bytes, bytearray)):
+        return str(data)
+
+    preferred = locale.getpreferredencoding(False) or "utf-8"
+    for enc in ("utf-8", preferred):
+        try:
+            return bytes(data).decode(enc)
+        except UnicodeDecodeError:
+            continue
+    return bytes(data).decode(preferred, errors="replace")
+
+
 def is_tool_command_file(file_path: str) -> bool:
     """
     检查文件是否是有效的工具命令文件
@@ -93,12 +120,14 @@ def _try_command_line_help(file_path: str) -> Optional[str]:
             result = subprocess.run(
                 cmd, 
                 capture_output=True, 
-                text=True, 
+                text=False,  # Avoid Windows locale decode crashes (gbk/cp936 strict)
                 timeout=5, 
                 cwd=Path(file_path).parent
             )
-            if result.returncode == 0 and (result.stdout.strip() or result.stderr.strip()):
-                return result.stdout.strip() or result.stderr.strip()
+            stdout = _safe_decode_output(result.stdout).strip()
+            stderr = _safe_decode_output(result.stderr).strip()
+            if result.returncode == 0 and (stdout or stderr):
+                return stdout or stderr
         except Exception:
             continue
     return None

{auto_coder-3.0.2 → auto_coder-3.0.4}/src/autocoder/common/v2/agent/agentic_edit.py

@@ -664,7 +664,7 @@ class AgenticEdit:
          <list_code_definition_names>
          <path>Directory path here</path>
          </list_code_definition_names>
-
+         {% if not enable_agentic_replace_ask_followup_question_with_attempt_completion %}
          ## ask_followup_question
          Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
          Parameters:
@@ -677,7 +677,7 @@ class AgenticEdit:
          Array of options here (optional), e.g. ["Option 1", "Option 2", "Option 3"]
          </options>
          </ask_followup_question>
-
+         {% endif %}
          ## todo_read
          Description: Request to read the current todo list for the session. This tool helps you track progress, organize complex tasks, and understand the current status of ongoing work. Use this tool proactively to stay aware of task progress and demonstrate thoroughness.
          Parameters:
@@ -710,6 +710,9 @@ class AgenticEdit:
          ## attempt_completion
          Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
          IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
+         {% if enable_agentic_replace_ask_followup_question_with_attempt_completion %}
+         If you need to ask the user a question to get additional information, you should use the attempt_completion tool to ask the user a question,just put the question in the result field.
+         {% endif %}
          Parameters:
          - result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
          - command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use `open index.html` to display a created html website, or `open localhost:3000` to display a locally running development server. But DO NOT use commands like `echo` or `cat` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
@@ -2351,8 +2354,12 @@ class AgenticEdit:
          - When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
          - When you want to modify a file, use the replace_in_file or write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
          - Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+         {% if not enable_agentic_replace_ask_followup_question_with_attempt_completion %}
          - You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
-         - When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
+         {% else %}
+         - If you need to ask the user a question to get additional information, you should use the attempt_completion tool to ask the user a question.
+         {% endif %}
+         - When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the {% if not enable_agentic_replace_ask_followup_question_with_attempt_completion %}ask_followup_question{% else %}attempt_completion{% endif %} tool to request the user to copy and paste it back to you.
          - The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
          - Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
          - NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
@@ -2390,7 +2397,7 @@ class AgenticEdit:
 
          1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
          2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
-         3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+         3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the {% if not enable_agentic_replace_ask_followup_question_with_attempt_completion %}ask_followup_question{% else %}attempt_completion{% endif %} tool. DO NOT ask for more information on optional parameters if it is not provided.
          4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. `open index.html` to show the website you've built.
          5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.
          6. Work through these goals sequentially, **ALWAYS STARTING WITH COMPREHENSIVE SEARCH AND EXPLORATION** using available tools. For any code-related task, begin with check AC MODULEs exits/list_files to understand structure, then use search_files/commands(grep) to find relevant patterns, and read_file to examine context before making changes.
@@ -2439,6 +2446,7 @@ class AgenticEdit:
             or "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.",
             "sub_agents_content": sub_agents_content,
             "agentic_mode": self.args.agentic_mode,
+            "enable_agentic_replace_ask_followup_question_with_attempt_completion": self.args.enable_agentic_replace_ask_followup_question_with_attempt_completion,
         }  # type: ignore[misc]
 
     # Removed _execute_command_result and execute_auto_command methods

{auto_coder-3.0.2 → auto_coder-3.0.4}/src/autocoder/common/v2/agent/agentic_edit_tools/ask_followup_question_tool_resolver.py

@@ -8,6 +8,8 @@ from autocoder.common.v2.agent.agentic_edit_types import (
 )  # Import ToolResult from types
 from loguru import logger
 import typing
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 from autocoder.common import AutoCoderArgs
 from autocoder.run_context import get_run_context
 from autocoder.events.event_manager_singleton import get_event_manager
@@ -22,6 +24,11 @@ from autocoder.common.printer import Printer
 if typing.TYPE_CHECKING:
     from autocoder.common.v2.agent.agentic_edit import AgenticEdit
 
+# 用于 terminal 模式超时的线程池
+_timeout_executor = ThreadPoolExecutor(
+    max_workers=1, thread_name_prefix="ask_user_timeout"
+)
+
 
 class AskFollowupQuestionToolResolver(BaseToolResolver):
     def __init__(
@@ -35,10 +42,48 @@ class AskFollowupQuestionToolResolver(BaseToolResolver):
         self.result_manager = ResultManager()
         self.printer = Printer()
 
+    def _prompt_with_timeout(self, timeout_seconds: float) -> str:
+        """
+        在独立的事件循环中运行 prompt_async 并应用超时。
+        如果超时则返回空字符串。
+        """
+
+        async def _inner() -> str:
+            from prompt_toolkit import PromptSession as _RawPromptSession
+
+            session = _RawPromptSession(
+                message=self.printer.get_message_from_key("tool_ask_user")
+            )
+            return await asyncio.wait_for(
+                session.prompt_async(), timeout=timeout_seconds
+            )
+
+        # 在新线程中创建全新的事件循环来运行 prompt_async，
+        # 避免与调用方可能存在的 running loop 冲突
+        future = _timeout_executor.submit(asyncio.run, _inner())
+        try:
+            return future.result()
+        except asyncio.TimeoutError:
+            logger.warning(f"Terminal prompt timed out after {timeout_seconds}s")
+            return ""
+        except Exception as e:
+            logger.warning(
+                f"Terminal prompt with timeout failed ({e}), falling back to blocking prompt"
+            )
+            # 降级：使用普通阻塞 prompt（无超时）
+            session = PromptSession(
+                message=self.printer.get_message_from_key("tool_ask_user")
+            )
+            try:
+                return session.prompt()
+            except KeyboardInterrupt:
+                return ""
+
     def resolve(self) -> ToolResult:
         """
         Packages the question and options to be handled by the main loop/UI.
         This resolver doesn't directly ask the user but prepares the data for it.
+        Supports optional timeout via args.ask_user_timeout_seconds.
         """
         # Check if running in CLI mode, if so return immediately with a message
         # instructing the model to solve the problem on its own
@@ -53,12 +98,28 @@ class AskFollowupQuestionToolResolver(BaseToolResolver):
         options_text = "\n".join(
             [f"{i+1}. {option}" for i, option in enumerate(options)]
         )
+
+        # 统一的超时来源
+        timeout_seconds: Optional[float] = self.args.ask_user_timeout_seconds
+
         if get_run_context().is_web():
-            answer = get_event_manager(self.args.event_file).ask_user(prompt=question)
+            answer = get_event_manager(self.args.event_file).ask_user(
+                prompt=question, timeout=timeout_seconds
+            )
             self.result_manager.append(
                 content=answer + ("\n" + options_text if options_text else ""),
                 meta={"action": "ask_user", "input": {"question": question}},
             )
+            if not answer:
+                return ToolResult(
+                    success=False,
+                    message=(
+                        "I did not have time to answer your question. you can decide to how to handle this situation by yourself or ask me to answer the question later."
+                        if timeout_seconds is not None
+                        else "Error: Question not answered."
+                    ),
+                    content="",
+                )
             return ToolResult(
                 success=True, message="Follow-up question prepared.", content=answer
             )
@@ -77,18 +138,31 @@ class AskFollowupQuestionToolResolver(BaseToolResolver):
         # 显示问题面板
         console.print(question_panel)
 
-        session = PromptSession(
-            message=self.printer.get_message_from_key("tool_ask_user")
-        )
+        if timeout_seconds is not None:
+            console.print(f"[dim](timeout: {timeout_seconds}s)[/dim]")
+
         try:
-            answer = session.prompt()
+            if timeout_seconds is not None:
+                answer = self._prompt_with_timeout(timeout_seconds)
+            else:
+                session = PromptSession(
+                    message=self.printer.get_message_from_key("tool_ask_user")
+                )
+                answer = session.prompt()
         except KeyboardInterrupt:
             answer = ""
 
         # The actual asking logic resides outside the resolver, typically in the agent's main loop
         # or UI interaction layer. The resolver's job is to validate and package the request.
         if not answer:
-            return ToolResult(success=False, message="Error: Question not answered.")
+            return ToolResult(
+                success=False,
+                message=(
+                    "I did not have time to answer your question. you can decide to how to handle this situation by yourself or ask me to answer the question later."
+                    if timeout_seconds is not None
+                    else "Error: Question not answered."
+                ),
+            )
 
         # Indicate success in preparing the question data
         return ToolResult(