autocoder-nano 0.1.30__py3-none-any.whl → 0.1.33__py3-none-any.whl

autocoder_nano/agent/agentic_edit_tools/__init__.py

@@ -0,0 +1,28 @@
+# flake8: noqa
+from .base_tool_resolver import BaseToolResolver
+from .execute_command_tool import ExecuteCommandToolResolver
+from .read_file_tool import ReadFileToolResolver
+from .write_to_file_tool import WriteToFileToolResolver
+from .replace_in_file_tool import ReplaceInFileToolResolver
+from .search_files_tool import SearchFilesToolResolver
+from .list_files_tool import ListFilesToolResolver
+from .list_code_definition_names_tool import ListCodeDefinitionNamesToolResolver
+from .ask_followup_question_tool import AskFollowupQuestionToolResolver
+from .attempt_completion_tool import AttemptCompletionToolResolver
+from .plan_mode_respond_tool import PlanModeRespondToolResolver
+from .list_package_info_tool import ListPackageInfoToolResolver
+
+__all__ = [
+    "BaseToolResolver",
+    "ExecuteCommandToolResolver",
+    "ReadFileToolResolver",
+    "WriteToFileToolResolver",
+    "ReplaceInFileToolResolver",
+    "SearchFilesToolResolver",
+    "ListFilesToolResolver",
+    "ListCodeDefinitionNamesToolResolver",
+    "AskFollowupQuestionToolResolver",
+    "AttemptCompletionToolResolver",
+    "PlanModeRespondToolResolver",
+    "ListPackageInfoToolResolver",
+]

autocoder_nano/agent/agentic_edit_tools/ask_followup_question_tool.py

@@ -0,0 +1,51 @@
+import typing
+from typing import Optional
+
+from prompt_toolkit import PromptSession
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ToolResult, AskFollowupQuestionTool
+from autocoder_nano.llm_types import AutoCoderArgs
+from autocoder_nano.utils.printer_utils import Printer
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+printer = Printer()
+
+
+class AskFollowupQuestionToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: AskFollowupQuestionTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: AskFollowupQuestionTool = tool
+
+    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.
+        """
+        question = self.tool.question
+        options = self.tool.options or []
+        options_text = "\n".join([f"{i + 1}. {option}" for i, option in enumerate(options)])
+
+        # 创建一个醒目的问题面板
+        printer.print_panel(
+            content=question,
+            title="[bold yellow]AutoCoder Nano 的提问[/bold yellow]",
+            border_style="blue",
+            center=True
+        )
+
+        session = PromptSession(message="> 您的回复是: ")
+        try:
+            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="错误: 问题未得到回答.")
+
+        # Indicate success in preparing the question data
+        return ToolResult(success=True, message="已生成后续追问问题.", content=answer)

autocoder_nano/agent/agentic_edit_tools/attempt_completion_tool.py

@@ -0,0 +1,36 @@
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ToolResult, AttemptCompletionTool
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class AttemptCompletionToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: AttemptCompletionTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: AttemptCompletionTool = tool
+
+    def resolve(self) -> ToolResult:
+        """
+        Packages the completion result and optional command to signal task completion.
+        """
+        result_text = self.tool.result
+        command = self.tool.command
+
+        # logger.info(f"Resolving AttemptCompletionTool: Result='{result_text[:100]}...', Command='{command}'")
+
+        if not result_text:
+            return ToolResult(success=False, message="错误：生成结果不能为空.")
+
+        # The actual presentation of the result happens outside the resolver.
+        result_content = {
+            "result": result_text,
+            "command": command
+        }
+
+        # Indicate success in preparing the completion data
+        return ToolResult(success=True, message="尝试完成任务.", content=result_content)

autocoder_nano/agent/agentic_edit_tools/base_tool_resolver.py

@@ -0,0 +1,31 @@
+import typing
+from abc import ABC, abstractmethod
+
+from autocoder_nano.agent.agentic_edit_types import *
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class BaseToolResolver(ABC):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: BaseTool, args: AutoCoderArgs):
+        """
+        Initializes the resolver.
+        Args:
+            agent: The AutoCoder agent instance.
+            tool: The Pydantic model instance representing the tool call.
+            args: Additional arguments needed for execution (e.g., source_dir).
+        """
+        self.agent = agent
+        self.tool = tool
+        self.args = args
+
+    @abstractmethod
+    def resolve(self) -> ToolResult:
+        """
+        Executes the tool's logic.
+        Returns:
+            A ToolResult object indicating success or failure and a message.
+        """
+        pass

autocoder_nano/agent/agentic_edit_tools/execute_command_tool.py

@@ -0,0 +1,65 @@
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ExecuteCommandTool, ToolResult
+from autocoder_nano.llm_types import AutoCoderArgs
+from autocoder_nano.utils.printer_utils import Printer
+from autocoder_nano.utils.shell_utils import run_cmd_subprocess
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+printer = Printer()
+
+
+class ExecuteCommandToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ExecuteCommandTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ExecuteCommandTool = tool  # For type hinting
+
+    @staticmethod
+    def _prune_file_content(content: str, file_path: str) -> str:
+        """
+        该函数主要目的是对命令行执行后的结果内容进行剪枝处理
+        因为执行的命令可能包含
+        - 读取大量文件
+        等操作
+        todo: 该函数目前暂时未实现，直接返回全部结果
+        """
+        return content
+
+    def resolve(self) -> ToolResult:
+        command = self.tool.command
+        requires_approval = self.tool.requires_approval
+        source_dir = self.args.source_dir or "."
+
+        try:
+            exit_code, output = run_cmd_subprocess(command, verbose=False, cwd=source_dir)
+
+            printer.print_key_value(
+                items={"执行命令": f"{command}", "返回 Code": f"{exit_code}", "输出大小": f"{len(output)} chars"},
+                title="使用 run_cmd_subprocess 执行命令工具"
+            )
+
+            final_output = self._prune_file_content(output, "command_output")
+
+            if exit_code == 0:
+                return ToolResult(success=True, message="Command executed successfully.", content=final_output)
+            else:
+                # For the human-readable error message, we might prefer the original full output.
+                # For the agent-consumable content, we provide the (potentially pruned) final_output.
+                error_message_for_human = f"Command failed with return code {exit_code}.\nOutput:\n{output}"
+                return ToolResult(success=False, message=error_message_for_human,
+                                  content={"output": final_output, "returncode": exit_code})
+
+        except FileNotFoundError:
+            return ToolResult(success=False,
+                              message=f"Error: The command '{command.split()[0]}' was not found. Please ensure it is "
+                                      f"installed and in the system's PATH.")
+        except PermissionError:
+            return ToolResult(success=False, message=f"Error: Permission denied when trying to execute '{command}'.")
+        except Exception as e:
+            return ToolResult(success=False,
+                              message=f"An unexpected error occurred while executing the command: {str(e)}")

autocoder_nano/agent/agentic_edit_tools/list_code_definition_names_tool.py

@@ -0,0 +1,78 @@
+import os
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ToolResult, ListCodeDefinitionNamesTool
+from autocoder_nano.index.index_manager import IndexManager
+from autocoder_nano.index.symbols_utils import extract_symbols
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class ListCodeDefinitionNamesToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ListCodeDefinitionNamesTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ListCodeDefinitionNamesTool = tool
+        self.llm = self.agent.llm
+
+    def _get_index(self):
+        index_manager = IndexManager(
+            args=self.args,
+            source_codes=[],
+            llm=self.llm)
+        return index_manager
+
+    def resolve(self) -> ToolResult:
+        index_items = self._get_index().read_index()  # 仅读取索引
+        index_data = {item.module_name: item for item in index_items}
+
+        target_path_str = self.tool.path
+        source_dir = self.args.source_dir or "."
+        absolute_target_path = os.path.abspath(os.path.join(source_dir, target_path_str))
+
+        # Security check
+        if not absolute_target_path.startswith(os.path.abspath(source_dir)):
+            return ToolResult(success=False,
+                              message=f"错误: 拒绝访问, 尝试分析项目目录之外的代码 {target_path_str}")
+
+        if not os.path.exists(absolute_target_path):
+            return ToolResult(success=False, message=f"错误: 路径不存在 {target_path_str}")
+
+        try:
+            # Use RepoParser or a similar mechanism to extract definitions
+            # RepoParser might need adjustments or a specific method for this tool's purpose.
+            # This is a placeholder implementation. A real implementation needs robust code parsing.
+            # logger.info(f"Analyzing definitions in: {absolute_target_path}")
+            all_symbols = []
+
+            if os.path.isfile(absolute_target_path):
+                file_paths = [absolute_target_path]
+            else:
+                return ToolResult(success=False,
+                                  message=f"错误：路径既不是文件也不是目录 {target_path_str}")
+
+            for file_path in file_paths:
+                try:
+                    item = index_data[file_path]
+                    symbols_str = item.symbols
+                    symbols = extract_symbols(symbols_str)
+                    if symbols:
+                        all_symbols.append({
+                            "path": file_path,
+                            "definitions": [{"name": s, "type": "function"} for s in symbols.functions] + [
+                                {"name": s, "type": "variable"} for s in symbols.variables] + [
+                                {"name": s, "type": "class"} for s in symbols.classes]
+                        })
+                except Exception as e:
+                    # logger.warning(f"Could not parse symbols from {file_path}: {e}")
+                    pass
+            total_symbols = sum(len(s['definitions']) for s in all_symbols)
+            message = f"成功从目标路径 '{target_path_str}' 的 {len(all_symbols)} 个文件中提取了 {total_symbols} 个定义."
+            return ToolResult(success=True, message=message, content=all_symbols)
+
+        except Exception as e:
+            return ToolResult(success=False,
+                              message=f"提取 Code Definitions 时发生错误: {str(e)}")

autocoder_nano/agent/agentic_edit_tools/list_files_tool.py

@@ -0,0 +1,123 @@
+import os
+import re
+import typing
+from typing import Optional, List, Union, Set
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ListFilesTool, ToolResult
+from autocoder_nano.llm_types import AutoCoderArgs
+from autocoder_nano.sys_utils import default_exclude_dirs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class ListFilesToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ListFilesTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ListFilesTool = tool
+        self.exclude_files = args.exclude_files + default_exclude_dirs
+        self.exclude_patterns = self.parse_exclude_files(self.exclude_files)
+
+    @staticmethod
+    def parse_exclude_files(exclude_files):
+        if not exclude_files:
+            return []
+
+        if isinstance(exclude_files, str):
+            exclude_files = [exclude_files]
+
+        exclude_patterns = []
+        for pattern in exclude_files:
+            if pattern.startswith("regex://"):
+                pattern = pattern[8:]
+                exclude_patterns.append(re.compile(pattern))
+            else:
+                exclude_patterns.append(re.compile(pattern))
+        return exclude_patterns
+
+    def should_exclude(self, file_path):
+        for pattern in self.exclude_patterns:
+            if pattern.search(file_path):
+                return True
+        return False
+
+    def list_files_in_dir(self, base_dir: str, recursive: bool, source_dir: str, is_outside_source: bool) -> Set[str]:
+        """Helper function to list files in a directory"""
+        result = set()
+        try:
+            if recursive:
+                for root, dirs, files in os.walk(base_dir):
+                    # Modify dirs in-place to skip ignored dirs early
+                    dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+                    for name in files:
+                        full_path = os.path.join(root, name)
+                        if self.should_exclude(full_path):
+                            continue
+                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                        result.add(display_path)
+                    for d in dirs:
+                        full_path = os.path.join(root, d)
+                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                        result.add(display_path + "/")
+            else:
+                for item in os.listdir(base_dir):
+                    full_path = os.path.join(base_dir, item)
+                    if self.should_exclude(full_path):
+                        continue
+                    display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                    if os.path.isdir(full_path):
+                        result.add(display_path + "/")
+                    else:
+                        result.add(display_path)
+        except Exception as e:
+            pass
+            # logger.warning(f"Error listing files in {base_dir}: {e}")
+        return result
+
+    def list_files_normal(
+            self, list_path_str: str, recursive: bool, source_dir: str, absolute_source_dir: str,
+            absolute_list_path: str) -> Union[ToolResult, List[str]]:
+        """List files directly without using shadow manager"""
+        # Security check: Allow listing outside source_dir IF the original path is outside?
+        is_outside_source = not absolute_list_path.startswith(absolute_source_dir)
+        if is_outside_source:
+            return ToolResult(success=False,
+                              message=f"错误: 拒绝访问, 尝试列出项目目录之外的文件: {list_path_str}")
+
+        if not os.path.exists(absolute_list_path):
+            return ToolResult(success=False, message=f"错误: 路径未找到 {list_path_str}")
+        if not os.path.isdir(absolute_list_path):
+            return ToolResult(success=False, message=f"错误: 路径不是目录 {list_path_str}")
+
+        # Collect files from the directory
+        files_set = self.list_files_in_dir(absolute_list_path, recursive, source_dir, is_outside_source)
+
+        try:
+            # Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(files_set)} items.
+            return sorted(files_set)
+        except Exception as e:
+            return ToolResult(success=False, message=f"列出文件时发生意外错误: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the list files tool by calling the appropriate implementation"""
+        list_path_str = self.tool.path
+        recursive = self.tool.recursive or False
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_list_path = os.path.abspath(os.path.join(source_dir, list_path_str))
+
+        result = self.list_files_normal(list_path_str, recursive, source_dir, absolute_source_dir, absolute_list_path)
+
+        if isinstance(result, list):
+            total_items = len(result)
+            # Limit results to 200 if needed
+            if total_items > 200:
+                truncated_result = result[:200]
+                message = f"成功获取目录内容: {list_path_str} (递归:{recursive}), 总计 {total_items} 项, 当前截取前 200 条."
+                return ToolResult(success=True, message=message, content=truncated_result)
+            else:
+                message = f"成功获取目录内容: {list_path_str} (递归:{recursive}), 总计 {total_items} 项."
+                return ToolResult(success=True, message=message, content=result)
+        else:
+            return result

autocoder_nano/agent/agentic_edit_tools/list_package_info_tool.py

@@ -0,0 +1,42 @@
+import os
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ToolResult, ListPackageInfoTool
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class ListPackageInfoToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ListPackageInfoTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ListPackageInfoTool = tool
+
+    def resolve(self) -> ToolResult:
+        source_dir = self.args.source_dir or "."
+        abs_source_dir = os.path.abspath(source_dir)
+
+        input_path = self.tool.path.strip()
+        abs_input_path = os.path.abspath(os.path.join(source_dir, input_path)) if not os.path.isabs(
+            input_path) else input_path
+
+        # 校验输入目录是否在项目目录内
+        if not abs_input_path.startswith(abs_source_dir):
+            return ToolResult(success=False, message=f"错误: 访问被拒, 路径超出项目范围 {self.tool.path}")
+
+        rel_package_path = os.path.relpath(abs_input_path, abs_source_dir)
+        active_md_path = os.path.join(abs_source_dir, ".auto-coder", "active-context", rel_package_path, "active.md")
+
+        if not os.path.exists(active_md_path):
+            return ToolResult(success=True, message="该路径下未找到包信息.", content="没有相关包信息.")
+
+        try:
+            with open(active_md_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+            return ToolResult(success=True, message="成功获取包信息.", content=content)
+        except Exception as e:
+
+            return ToolResult(success=False, message=f"读取包信息文件失败: {e}")

autocoder_nano/agent/agentic_edit_tools/plan_mode_respond_tool.py

@@ -0,0 +1,35 @@
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ToolResult, AttemptCompletionTool, PlanModeRespondTool
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class PlanModeRespondToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: PlanModeRespondTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: PlanModeRespondTool = tool  # For type hinting
+
+    def resolve(self) -> ToolResult:
+        """
+        Packages the response and options for Plan Mode interaction.
+        """
+        response_text = self.tool.response
+        options = self.tool.options
+        # logger.info(f"Resolving PlanModeRespondTool: Response='{response_text[:100]}...', Options={options}")
+
+        if not response_text:
+            return ToolResult(success=False, message="错误：规划模式返回结果不可为空.")
+
+        # The actual presentation happens outside the resolver.
+        result_content = {
+            "response": response_text,
+            "options": options
+        }
+
+        # Indicate success in preparing the plan mode response data
+        return ToolResult(success=True, message="规划模式响应已就绪.", content=result_content)

autocoder_nano/agent/agentic_edit_tools/read_file_tool.py

@@ -0,0 +1,73 @@
+import os
+import typing
+from typing import Optional
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import ReadFileTool, ToolResult
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class ReadFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ReadFileTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ReadFileTool = tool  # For type hinting
+        self.shadow_manager = self.agent.shadow_manager if self.agent else None
+
+    @staticmethod
+    def _prune_file_content(content: str, file_path: str) -> str:
+        """
+        该函数主要目的是对命令行执行后的结果内容进行剪枝处理
+        因为执行的命令可能包含
+        - 读取大量文件
+        等操作
+        todo: 该函数目前暂时未实现，直接返回全部结果
+        """
+        return content
+
+    def _read_file_content(self, file_path_to_read: str) -> str:
+        content = ""
+        ext = os.path.splitext(file_path_to_read)[1].lower()
+
+        if ext == '.pdf':
+            # content = extract_text_from_pdf(file_path_to_read)
+            # todo: 解析pdf文件
+            pass
+        elif ext == '.docx':
+            # content = extract_text_from_docx(file_path_to_read)
+            # todo: 解析doc文件
+            pass
+        elif ext in ('.pptx', '.ppt'):
+            pass  # todo: 解析ppt文件
+        else:
+            with open(file_path_to_read, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+
+        # 对内容进行剪枝处理
+        return self._prune_file_content(content, file_path_to_read)
+
+    def read_file_normal(self, file_path: str, source_dir: str, abs_project_dir: str, abs_file_path: str) -> ToolResult:
+        """Read file directly without using shadow manager"""
+        try:
+            if not os.path.exists(abs_file_path):
+                return ToolResult(success=False, message=f"错误：未找到文件路径：{file_path}")
+            if not os.path.isfile(abs_file_path):
+                return ToolResult(success=False, message=f"错误：该路径不是文件：{file_path}")
+
+            content = self._read_file_content(abs_file_path)
+            return ToolResult(success=True, message=f"{file_path}", content=content)
+
+        except Exception as e:
+            return ToolResult(success=False,
+                              message=f"An error occurred while processing the file '{file_path}': {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the read file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        source_dir = self.args.source_dir or "."
+        abs_project_dir = os.path.abspath(source_dir)
+        abs_file_path = os.path.abspath(os.path.join(source_dir, file_path))
+
+        return self.read_file_normal(file_path, source_dir, abs_project_dir, abs_file_path)