auto-coder 0.1.335__py3-none-any.whl → 0.1.336__py3-none-any.whl

autocoder/common/v2/agent/agentic_edit_tools/replace_in_file_tool_resolver.py

@@ -0,0 +1,144 @@
+import os
+import re
+from typing import Dict, Any, Optional, List, Tuple
+import typing
+from autocoder.common import AutoCoderArgs
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import ReplaceInFileTool, ToolResult  # Import ToolResult from types
+from loguru import logger
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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.shadow_manager = self.agent.shadow_manager if self.agent else None
+
+    def parse_diff(self, 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:
+                    logger.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:
+                    logger.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():
+            logger.warning(f"Could not parse any SEARCH/REPLACE blocks from diff: {diff_content}")
+        return blocks
+
+    def resolve(self) -> ToolResult:
+        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))
+
+        # Security check
+        if not abs_file_path.startswith(abs_project_dir):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to modify file outside the project directory: {file_path}")
+
+        # Determine target path: shadow file if shadow_manager exists
+        target_path = abs_file_path
+        if self.shadow_manager:
+            target_path = self.shadow_manager.to_shadow_path(abs_file_path)
+
+        # If shadow file does not exist yet, but original file exists, copy original content into shadow first? No, just treat as normal file.
+        # For now, read from shadow if exists, else fallback to original file
+        try:
+            if os.path.exists(target_path) and os.path.isfile(target_path):
+                with open(target_path, 'r', encoding='utf-8', errors='replace') as f:
+                    original_content = f.read()
+            elif self.shadow_manager and os.path.exists(abs_file_path) and os.path.isfile(abs_file_path):
+                # If shadow doesn't exist, but original exists, read original content (create shadow implicitly later)
+                with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    original_content = f.read()
+                # create parent dirs of shadow if needed
+                os.makedirs(os.path.dirname(target_path), exist_ok=True)
+                # write original content into shadow file as baseline
+                with open(target_path, 'w', encoding='utf-8') as f:
+                    f.write(original_content)
+                logger.info(f"[Shadow] Initialized shadow file from original: {target_path}")
+            else:
+                return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
+        except Exception as e:
+            logger.error(f"Error reading file for replace '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while reading the file for replacement: {str(e)}")
+
+        parsed_blocks = self.parse_diff(diff_content)
+        if not parsed_blocks:
+            return ToolResult(success=False, message="Error: No valid SEARCH/REPLACE blocks found in the provided diff.")
+
+        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
+                logger.info(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 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]))
+                logger.warning(f"Approximate context in file:\n---\n{original_content[context_start:context_end]}\n---")
+                errors.append(error_message)
+                # continue applying remaining blocks
+
+        if applied_count == 0 and errors:
+            return ToolResult(success=False, message=f"Failed to apply any changes. Errors:\n" + "\n".join(errors))
+
+        try:
+            os.makedirs(os.path.dirname(target_path), exist_ok=True)
+            with open(target_path, 'w', encoding='utf-8') as f:
+                f.write(current_content)
+            logger.info(f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to file: {file_path}")
+
+            message = f"Successfully applied {applied_count}/{len(parsed_blocks)} changes to file: {file_path}."
+            if errors:
+                message += "\nWarnings:\n" + "\n".join(errors)
+
+            # 变更跟踪，回调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)
+
+            return ToolResult(success=True, message=message, content=current_content)
+        except Exception as e:
+            logger.error(f"Error writing replaced content to file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing the modified file: {str(e)}")

autocoder/common/v2/agent/agentic_edit_tools/search_files_tool_resolver.py

@@ -0,0 +1,99 @@
+import os
+import re
+import glob
+from typing import Dict, Any, Optional
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import SearchFilesTool, ToolResult # Import ToolResult from types
+from loguru import logger
+from autocoder.common import AutoCoderArgs
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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 # For type hinting
+        self.shadow_manager = self.agent.shadow_manager if self.agent else None
+
+    def resolve(self) -> ToolResult:
+        search_path_str = self.tool.path
+        regex_pattern = self.tool.regex
+        file_pattern = self.tool.file_pattern or "*" # Default to all files
+        source_dir = self.args.source_dir or "."
+        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+
+        # Security check
+        if not absolute_search_path.startswith(os.path.abspath(source_dir)):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
+
+        # Determine search base directory: prefer shadow if exists
+        search_base_path = absolute_search_path
+        shadow_exists = False
+        if self.shadow_manager:
+            try:
+                shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_search_path)
+                if os.path.exists(shadow_dir_path) and os.path.isdir(shadow_dir_path):
+                    search_base_path = shadow_dir_path
+                    shadow_exists = True
+            except Exception as e:
+                logger.warning(f"Error checking shadow path for {absolute_search_path}: {e}")
+
+        # Validate that at least one of the directories exists
+        if not os.path.exists(absolute_search_path) and not shadow_exists:
+            return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
+        if os.path.exists(absolute_search_path) and not os.path.isdir(absolute_search_path):
+            return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
+        if shadow_exists and not os.path.isdir(search_base_path):
+            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {search_base_path}")
+
+        results = []
+        try:
+            compiled_regex = re.compile(regex_pattern)
+            search_glob_pattern = os.path.join(search_base_path, "**", file_pattern)
+
+            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{search_base_path}' (shadow: {shadow_exists})")
+
+            for filepath in glob.glob(search_glob_pattern, recursive=True):
+                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):
+                                # Provide context (e.g., line number and surrounding lines)
+                                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)])
+                                # For shadow files, convert to project-relative path
+                                if shadow_exists and self.shadow_manager:
+                                    try:
+                                        abs_project_path = self.shadow_manager.from_shadow_path(filepath)
+                                        relative_path = os.path.relpath(abs_project_path, source_dir)
+                                    except Exception:
+                                        relative_path = os.path.relpath(filepath, source_dir)
+                                else:
+                                    relative_path = os.path.relpath(filepath, source_dir)
+                                results.append({
+                                    "path": relative_path,
+                                    "line_number": i + 1,
+                                    "match_line": line.strip(),
+                                    "context": context.strip()
+                                })
+                                # Limit results per file? Or overall? For now, collect all.
+                    except Exception as e:
+                        logger.warning(f"Could not read or process file {filepath}: {e}")
+                        continue # Skip files that can't be read
+
+            message = f"Search completed. Found {len(results)} matches."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=results)
+
+        except re.error as e:
+            logger.error(f"Invalid regex pattern '{regex_pattern}': {e}")
+            return ToolResult(success=False, message=f"Invalid regex pattern: {e}")
+        except Exception as e:
+            logger.error(f"Error during file search: {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred during search: {str(e)}")

autocoder/common/v2/agent/agentic_edit_tools/use_mcp_tool_resolver.py

@@ -0,0 +1,46 @@
+from typing import Dict, Any, Optional
+import typing
+from autocoder.common import AutoCoderArgs
+from autocoder.common.mcp_server_types import McpRequest
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from autocoder.common.v2.agent.agentic_edit_types import UseMcpTool, ToolResult # Import ToolResult from types
+from autocoder.common.mcp_server import get_mcp_server
+from loguru import logger
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+
+class UseMcpToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: UseMcpTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: UseMcpTool = tool # For type hinting
+
+    def resolve(self) -> ToolResult:
+        """
+        Executes a tool via the Model Context Protocol (MCP) server.
+        """
+        final_query = ""
+        server_name = self.tool.server_name
+        tool_name = self.tool.tool_name
+
+        if server_name:
+            final_query += f"{server_name}\n"
+        
+        if tool_name:
+            final_query += f"{tool_name} is recommended for the following query:\n"
+        
+        final_query += f"{self.tool.query}"
+
+        logger.info(f"Resolving UseMcpTool: Server='{server_name}', Tool='{tool_name}', Query='{final_query}'")
+
+        mcp_server = get_mcp_server()
+        response = mcp_server.send_request(
+            McpRequest(
+                query=final_query,
+                model=self.args.inference_model or self.args.model,
+                product_mode=self.args.product_mode
+            )
+        )
+        return ToolResult(success=True, message=response.result)
+

autocoder/common/v2/agent/agentic_edit_tools/write_to_file_tool_resolver.py

@@ -0,0 +1,58 @@
+import os
+from typing import Dict, Any, Optional
+from autocoder.common.v2.agent.agentic_edit_types import WriteToFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.v2.agent.agentic_edit_tools.base_tool_resolver import BaseToolResolver
+from loguru import logger
+from autocoder.common import AutoCoderArgs
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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.shadow_manager = self.agent.shadow_manager if self.agent else None
+
+    def resolve(self) -> ToolResult:
+        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"Error: Access denied. Attempted to write file outside the project directory: {file_path}")
+
+        try:
+            if self.shadow_manager:
+                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                # Ensure shadow directory exists
+                os.makedirs(os.path.dirname(shadow_path), exist_ok=True)
+                with open(shadow_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                logger.info(f"[Shadow] Successfully wrote shadow file: {shadow_path}")
+
+                # 回调AgenticEdit，记录变更
+                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)
+
+                return ToolResult(success=True, message=f"Successfully wrote to file (shadow): {file_path}", content=content)
+            else:
+                # No shadow manager fallback to original file
+                os.makedirs(os.path.dirname(abs_file_path), exist_ok=True)
+                with open(abs_file_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                logger.info(f"Successfully wrote to file: {file_path}")
+
+                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)
+
+                return ToolResult(success=True, message=f"Successfully wrote to file: {file_path}", content=content)
+        except Exception as e:
+            logger.error(f"Error writing to file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while writing to the file: {str(e)}")

autocoder/common/v2/agent/agentic_edit_types.py

@@ -0,0 +1,162 @@
+from pydantic import BaseModel
+from typing import List, Dict, Any, Callable, Optional, Type
+from pydantic import SkipValidation
+
+
+# Result class used by Tool Resolvers
+class ToolResult(BaseModel):
+    success: bool
+    message: str
+    content: Any = None # Can store file content, command output, etc.
+
+# Pydantic Models for Tools
+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 UseMcpTool(BaseTool):
+    server_name: str
+    tool_name: str
+    query:str
+
+# Event Types for Rich Output Streaming
+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
+
+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 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
+
+# Deprecated: Will be replaced by specific Event types
+# class PlainTextOutput(BaseModel):
+#     text: str
+
+
+# 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_mcp_tool": UseMcpTool,
+}
+
+class FileChangeEntry(BaseModel):
+    type: str  # 'added' or 'modified'
+    diffs: List[str] = []
+    content: Optional[str] = None
+
+
+class AgenticEditRequest(BaseModel):
+    user_input: str
+
+
+class FileOperation(BaseModel):
+    path: str
+    operation: str  # e.g., "MODIFY", "REFERENCE", "ADD", "REMOVE"
+class MemoryConfig(BaseModel):
+    """
+    A model to encapsulate memory configuration and operations.
+    """
+
+    memory: Dict[str, Any]
+    save_memory_func: SkipValidation[Callable]
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class CommandConfig(BaseModel):
+    coding: SkipValidation[Callable]
+    chat: SkipValidation[Callable]
+    add_files: SkipValidation[Callable]
+    remove_files: SkipValidation[Callable]
+    index_build: SkipValidation[Callable]
+    index_query: SkipValidation[Callable]
+    list_files: SkipValidation[Callable]
+    ask: SkipValidation[Callable]
+    revert: SkipValidation[Callable]
+    commit: SkipValidation[Callable]
+    help: SkipValidation[Callable]
+    exclude_dirs: SkipValidation[Callable]
+    summon: SkipValidation[Callable]
+    design: SkipValidation[Callable]
+    mcp: SkipValidation[Callable]
+    models: SkipValidation[Callable]
+    lib: SkipValidation[Callable]
+    execute_shell_command: SkipValidation[Callable]
+    generate_shell_command: SkipValidation[Callable]
+    conf_export: SkipValidation[Callable]
+    conf_import: SkipValidation[Callable]
+    index_export: SkipValidation[Callable]
+    index_import: SkipValidation[Callable]
+    exclude_files: SkipValidation[Callable]
+