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

autocoder_nano/agent/agentic_edit_tools/replace_in_file_tool.py

@@ -0,0 +1,148 @@
+import os
+import typing
+from typing import Tuple
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+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 ReplaceInFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: ReplaceInFileTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ReplaceInFileTool = tool  # For type hinting
+        self.args = args
+
+    @staticmethod
+    def parse_diff(diff_content: str) -> List[Tuple[str, str]]:
+        """
+        Parses the diff content into a list of (search_block, replace_block) tuples.
+        """
+        blocks = []
+        lines = diff_content.splitlines(keepends=True)
+        i = 0
+        n = len(lines)
+
+        while i < n:
+            line = lines[i]
+            if line.strip() == "<<<<<<< SEARCH":
+                i += 1
+                search_lines = []
+                # Accumulate search block
+                while i < n and lines[i].strip() != "=======":
+                    search_lines.append(lines[i])
+                    i += 1
+                if i >= n:
+                    # warning: Unterminated SEARCH block found in diff content.
+                    break
+                i += 1  # skip '======='
+                replace_lines = []
+                # Accumulate replace block
+                while i < n and lines[i].strip() != ">>>>>>> REPLACE":
+                    replace_lines.append(lines[i])
+                    i += 1
+                if i >= n:
+                    # warning: Unterminated REPLACE block found in diff content.
+                    break
+                i += 1  # skip '>>>>>>> REPLACE'
+
+                search_block = ''.join(search_lines)
+                replace_block = ''.join(replace_lines)
+                blocks.append((search_block, replace_block))
+            else:
+                i += 1
+
+        if not blocks and diff_content.strip():
+            pass
+            # warning: Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}
+        return blocks
+
+    def replace_in_file_normal(
+            self, file_path: str, diff_content: str, source_dir: str, abs_project_dir: str, abs_file_path: str
+    ) -> ToolResult:
+        """Replace content in 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}")
+
+            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                original_content = f.read()
+
+            parsed_blocks = self.parse_diff(diff_content)
+            if not parsed_blocks:
+                return ToolResult(success=False, message="错误：在提供的diff中未找到有效的SEARCH/REPLACE代码块. ")
+
+            current_content = original_content
+            applied_count = 0
+            errors = []
+
+            # Apply blocks sequentially
+            for i, (search_block, replace_block) in enumerate(parsed_blocks):
+                start_index = current_content.find(search_block)
+
+                if start_index != -1:
+                    current_content = current_content[:start_index] + replace_block + current_content[
+                                                                                      start_index + len(search_block):]
+                    applied_count += 1
+                    # f"Applied SEARCH/REPLACE block {i + 1} in file {file_path}"
+                else:
+                    error_message = (f"SEARCH block {i+1} not found in the current file content. Content to "
+                                     f"search:\n---\n{search_block}\n---")
+                    # logger.warning(error_message)
+                    context_start = max(0, original_content.find(search_block[:20]) - 100)
+                    context_end = min(len(original_content), context_start + 200 + len(search_block[:20]))
+                    # warning: f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---"
+                    errors.append(error_message)
+
+            return_errors = "\n".join(errors)
+            if applied_count == 0 and errors:
+                return ToolResult(success=False, message=f"未能应用任何更改, 错误信息: {return_errors}")
+
+            # todo: 应该是先备份,再写入, 参考 autocoder checkpoint_manager
+
+            with open(abs_file_path, 'w', encoding='utf-8') as f:
+                f.write(current_content)
+
+            # info: f"已成功将 {applied_count}/{len(parsed_blocks)} 个更改应用到文件：{file_path}"
+
+            # todo: 写入后执行代码质量检查
+
+            # 构建包含 lint 结果的返回消息
+            if errors:
+                message = f"成功应用了 {applied_count}/{len(parsed_blocks)} 个更改到文件：{file_path}. \n警告信息: \n{return_errors}"
+            else:
+                message = f"成功应用了 {applied_count}/{len(parsed_blocks)} 个更改到文件：{file_path}"
+
+            # 变更跟踪，回调AgenticEdit
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(
+                    rel_path, "modified", diff=diff_content, content=current_content)
+
+            result_content = {"content": current_content}
+
+            return ToolResult(success=True, message=message, content=result_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 replacement in file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        diff_content = self.tool.diff
+        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))
+
+        # 安全检查
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(
+                success=False,
+                message=f"错误: 拒绝访问, 尝试修改项目目录之外的文件：{file_path}")
+
+        return self.replace_in_file_normal(file_path, diff_content, source_dir, abs_project_dir, abs_file_path)

autocoder_nano/agent/agentic_edit_tools/search_files_tool.py

@@ -0,0 +1,135 @@
+import glob
+import os
+import re
+import typing
+from typing import Optional, List, Dict, Any, Union
+
+from autocoder_nano.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder_nano.agent.agentic_edit_types import SearchFilesTool, 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 SearchFilesToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: SearchFilesTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: SearchFilesTool = 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 search_in_dir(
+            self, base_dir: str, regex_pattern: str, file_pattern: str, source_dir: str,
+            is_shadow: bool = False, compiled_regex: Optional[re.Pattern] = None
+    ) -> List[Dict[str, Any]]:
+        """Helper function to search in a directory"""
+        search_results = []
+        search_glob_pattern = os.path.join(base_dir, "**", file_pattern)
+
+        if compiled_regex is None:
+            compiled_regex = re.compile(regex_pattern)
+
+        for filepath in glob.glob(search_glob_pattern, recursive=True):
+            abs_path = os.path.abspath(filepath)
+            if self.should_exclude(abs_path):
+                continue
+            if os.path.isfile(filepath):
+                try:
+                    with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                        lines = f.readlines()
+                    for i, line in enumerate(lines):
+                        if compiled_regex.search(line):
+                            context_start = max(0, i - 2)
+                            context_end = min(len(lines), i + 3)
+                            context = "".join([f"{j + 1}: {lines[j]}" for j in range(context_start, context_end)])
+
+                            relative_path = os.path.relpath(filepath, source_dir)
+
+                            search_results.append({
+                                "path": relative_path,
+                                "line_number": i + 1,
+                                "match_line": line.strip(),
+                                "context": context.strip()
+                            })
+                except Exception as e:
+                    # logger.warning(f"Could not read or process file {filepath}: {e}")
+                    continue
+
+        return search_results
+
+    def search_files_normal(
+            self, search_path_str: str, regex_pattern: str, file_pattern: str, source_dir: str,
+            absolute_source_dir: str, absolute_search_path: str
+    ) -> Union[ToolResult, List[Dict[str, Any]]]:
+        """Search files directly without using shadow manager"""
+        # Security check
+        if not absolute_search_path.startswith(absolute_source_dir):
+            return ToolResult(success=False,
+                              message=f"错误: 拒绝访问, 尝试搜索项目目录之外的文件: {search_path_str}")
+
+        # Validate that the directory exists
+        if not os.path.exists(absolute_search_path):
+            return ToolResult(success=False, message=f"错误: 搜索路径未找到 {search_path_str}")
+        if not os.path.isdir(absolute_search_path):
+            return ToolResult(success=False, message=f"错误: 搜错路径不是目录 {search_path_str}")
+
+        try:
+            compiled_regex = re.compile(regex_pattern)
+            # Search in the directory
+            search_results = self.search_in_dir(absolute_search_path, regex_pattern, file_pattern, source_dir,
+                                                is_shadow=False, compiled_regex=compiled_regex)
+            return search_results
+        except re.error as e:
+            return ToolResult(success=False, message=f"无效的正则表达式: {e}")
+        except Exception as e:
+            return ToolResult(success=False, message=f"搜索过程中出现未知错误: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the search files tool by calling the appropriate implementation"""
+        search_path_str = self.tool.path
+        regex_pattern = self.tool.regex
+        file_pattern = self.tool.file_pattern or "*"
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+
+        result = self.search_files_normal(
+            search_path_str, regex_pattern, file_pattern, source_dir, absolute_source_dir, absolute_search_path
+        )
+
+        if isinstance(result, list):
+            total_results = len(result)
+            if total_results > 200:
+                truncated_results = result[:200]
+                message = f"搜索完成. 总计匹配 {total_results} 条结果, 当前展示前 200 条"
+                return ToolResult(success=True, message=message, content=truncated_results)
+            else:
+                message = f"搜索完成. 总计匹配 {total_results} 条结果."
+                return ToolResult(success=True, message=message, content=result)
+        else:
+            return result

autocoder_nano/agent/agentic_edit_tools/write_to_file_tool.py

@@ -0,0 +1,57 @@
+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 WriteToFileTool, ToolResult
+from autocoder_nano.llm_types import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder_nano.agent.agentic_edit import AgenticEdit
+
+
+class WriteToFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: WriteToFileTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: WriteToFileTool = tool  # For type hinting
+        self.args = args
+
+    def write_file_normal(self, file_path: str, content: str, source_dir: str, abs_project_dir: str,
+                          abs_file_path: str) -> ToolResult:
+        """Write file directly without using shadow manager"""
+        try:
+            os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)
+
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "added", diff=None, content=content)
+
+            # todo: 应该是先备份,再写入, 参考 autocoder checkpoint_manager
+
+            with open(abs_file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+            # todo: 写入后执行代码质量检查
+
+            message = f"{file_path}"
+            result_content = {"content": content}
+
+            return ToolResult(success=True, message=message, content=result_content)
+        except Exception as e:
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")
+
+    def resolve(self) -> ToolResult:
+        """Resolve the write file tool by calling the appropriate implementation"""
+        file_path = self.tool.path
+        content = self.tool.content
+        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))
+
+        # Security check: ensure the path is within the source directory
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(
+                success=False,
+                message=f"错误: 拒绝访问, 尝试修改项目目录之外的文件：{file_path}")
+
+        return self.write_file_normal(file_path, content, source_dir, abs_project_dir, abs_file_path)

autocoder_nano/agent/agentic_edit_types.py

@@ -0,0 +1,151 @@
+from typing import List, Optional, Dict, Type, Any
+
+from pydantic import BaseModel, SkipValidation
+
+
+class FileChangeEntry(BaseModel):
+    """ 文件变更条目，用于记录文件的变更信息 """
+    type: str  # 'added' 或 'modified'
+    diffs: List[str] = []  # 使用 replace_in_file 时，记录 diff 内容
+    content: Optional[str] = None  # 使用 write_to_file 时，记录文件内容
+
+
+class AgenticEditRequest(BaseModel):
+    user_input: str
+
+
+# 工具的基本Pydantic模型
+class BaseTool(BaseModel):
+    """ 代理工具的基类，所有工具类都应继承此类 """
+    pass
+
+
+class ExecuteCommandTool(BaseTool):
+    command: str
+    requires_approval: bool
+
+
+class ReadFileTool(BaseTool):
+    path: str
+
+
+class WriteToFileTool(BaseTool):
+    path: str
+    content: str
+
+
+class ReplaceInFileTool(BaseTool):
+    path: str
+    diff: str
+
+
+class SearchFilesTool(BaseTool):
+    path: str
+    regex: str
+    file_pattern: Optional[str] = None
+
+
+class ListFilesTool(BaseTool):
+    path: str
+    recursive: Optional[bool] = False
+
+
+class ListCodeDefinitionNamesTool(BaseTool):
+    path: str
+
+
+class AskFollowupQuestionTool(BaseTool):
+    question: str
+    options: Optional[List[str]] = None
+
+
+class AttemptCompletionTool(BaseTool):
+    result: str
+    command: Optional[str] = None
+
+
+class PlanModeRespondTool(BaseTool):
+    response: str
+    options: Optional[List[str]] = None
+
+
+class UseRAGTool(BaseTool):
+    server_name: str
+    query: str
+
+
+class ListPackageInfoTool(BaseTool):
+    path: str  # 源码包目录，相对路径或绝对路径
+
+
+class LLMOutputEvent(BaseModel):
+    """Represents plain text output from the LLM."""
+    text: str
+
+
+class LLMThinkingEvent(BaseModel):
+    """Represents text within <thinking> tags from the LLM."""
+    text: str
+
+
+class ToolCallEvent(BaseModel):
+    """Represents the LLM deciding to call a tool."""
+    tool: SkipValidation[BaseTool]  # Use SkipValidation as BaseTool itself is complex
+    tool_xml: str
+
+
+# Result class used by Tool Resolvers
+class ToolResult(BaseModel):
+    success: bool
+    message: str
+    content: Any = None  # Can store file content, command output, etc.
+
+
+class ToolResultEvent(BaseModel):
+    """Represents the result of executing a tool."""
+    tool_name: str
+    result: ToolResult
+
+
+class TokenUsageEvent(BaseModel):
+    """Represents the result of executing a tool."""
+    usage: Any
+
+
+class PlanModeRespondEvent(BaseModel):
+    """Represents the LLM attempting to complete the task."""
+    completion: SkipValidation[PlanModeRespondTool]  # Skip validation
+    completion_xml: str
+
+
+class CompletionEvent(BaseModel):
+    """Represents the LLM attempting to complete the task."""
+    completion: SkipValidation[AttemptCompletionTool]  # Skip validation
+    completion_xml: str
+
+
+class ErrorEvent(BaseModel):
+    """Represents an error during the process."""
+    message: str
+
+
+class WindowLengthChangeEvent(BaseModel):
+    """Represents the token usage in the conversation window."""
+    tokens_used: int
+
+
+# Mapping from tool tag names to Pydantic models
+TOOL_MODEL_MAP: Dict[str, Type[BaseTool]] = {
+    "execute_command": ExecuteCommandTool,
+    "read_file": ReadFileTool,
+    "write_to_file": WriteToFileTool,
+    "replace_in_file": ReplaceInFileTool,
+    "search_files": SearchFilesTool,
+    "list_files": ListFilesTool,
+    "list_code_definition_names": ListCodeDefinitionNamesTool,
+    "ask_followup_question": AskFollowupQuestionTool,
+    "attempt_completion": AttemptCompletionTool,
+    "plan_mode_respond": PlanModeRespondTool,
+    "use_rag_tool": UseRAGTool,
+    "list_package_info": ListPackageInfoTool,
+}