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

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

@@ -0,0 +1,28 @@
+# flake8: noqa
+from .base_tool_resolver import BaseToolResolver
+from .execute_command_tool_resolver import ExecuteCommandToolResolver
+from .read_file_tool_resolver import ReadFileToolResolver
+from .write_to_file_tool_resolver import WriteToFileToolResolver
+from .replace_in_file_tool_resolver import ReplaceInFileToolResolver
+from .search_files_tool_resolver import SearchFilesToolResolver
+from .list_files_tool_resolver import ListFilesToolResolver
+from .list_code_definition_names_tool_resolver import ListCodeDefinitionNamesToolResolver
+from .ask_followup_question_tool_resolver import AskFollowupQuestionToolResolver
+from .attempt_completion_tool_resolver import AttemptCompletionToolResolver
+from .plan_mode_respond_tool_resolver import PlanModeRespondToolResolver
+from .use_mcp_tool_resolver import UseMcpToolResolver
+
+__all__ = [
+    "BaseToolResolver",
+    "ExecuteCommandToolResolver",
+    "ReadFileToolResolver",
+    "WriteToFileToolResolver",
+    "ReplaceInFileToolResolver",
+    "SearchFilesToolResolver",
+    "ListFilesToolResolver",
+    "ListCodeDefinitionNamesToolResolver",
+    "AskFollowupQuestionToolResolver",
+    "AttemptCompletionToolResolver",
+    "PlanModeRespondToolResolver",
+    "UseMcpToolResolver",
+]

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

@@ -0,0 +1,70 @@
+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 AskFollowupQuestionTool, ToolResult # Import ToolResult from types
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+from autocoder.run_context import get_run_context
+from autocoder.events.event_manager_singleton import get_event_manager
+from autocoder.events import event_content as EventContentCreator
+from prompt_toolkit import PromptSession
+from prompt_toolkit.styles import Style
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+class AskFollowupQuestionToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['AgenticEdit'], tool: AskFollowupQuestionTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: AskFollowupQuestionTool = tool # For type hinting
+
+    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
+
+        if get_run_context().is_web():
+            answer = get_event_manager(
+                self.args.event_file).ask_user(prompt=question)
+            self.result_manager.append(content=answer, meta={
+                "action": "ask_user",
+                "input": {
+                    "question": question
+                }
+            })
+            return answer
+
+        console = Console()
+
+        # 创建一个醒目的问题面板
+        question_text = Text(question, style="bold cyan")
+        question_panel = Panel(
+            question_text,
+            title="[bold yellow]auto-coder.chat's Question[/bold yellow]",
+            border_style="blue",
+            expand=False
+        )
+
+        # 显示问题面板
+        console.print(question_panel)
+
+        session = PromptSession(
+            message=self.printer.get_message_from_key('tool_ask_user'))
+        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="Error: Question not answered.")
+
+        # Indicate success in preparing the question data
+        return ToolResult(success=True, message="Follow-up question prepared.", content=answer)

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

@@ -0,0 +1,35 @@
+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 AttemptCompletionTool, ToolResult # Import ToolResult from types
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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 # For type hinting
+
+    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="Error: Completion result cannot be empty.")
+
+        # 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="Task completion attempted.", content=result_content)

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

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+from autocoder.common.v2.agent.agentic_edit_types import BaseTool, ToolResult # Import ToolResult from types
+from autocoder.common import AutoCoderArgs
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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/common/v2/agent/agentic_edit_tools/execute_command_tool_resolver.py

@@ -0,0 +1,88 @@
+import subprocess
+import os
+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 ExecuteCommandTool, ToolResult # Import ToolResult from types
+from autocoder.common import shells
+from autocoder.common.printer import Printer
+from loguru import logger
+import typing   
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.agent.agentic_edit import AgenticEdit
+
+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
+
+    def resolve(self) -> ToolResult:
+        printer = Printer()
+        command = self.tool.command
+        requires_approval = self.tool.requires_approval
+        source_dir = self.args.source_dir or "."
+
+        # Basic security check (can be expanded)
+        if ";" in command or "&&" in command or "|" in command or "`" in command:
+             # Allow && for cd chaining, but be cautious
+             if not command.strip().startswith("cd ") and " && " in command:
+                 pass # Allow cd chaining like 'cd subdir && command'
+             else:
+                return ToolResult(success=False, message=f"Command '{command}' contains potentially unsafe characters.")
+
+        # Approval mechanism (simplified)
+        if requires_approval:
+             # In a real scenario, this would involve user interaction
+             printer.print_str_in_terminal(f"Command requires approval: {command}")
+             # For now, let's assume approval is granted in non-interactive mode or handled elsewhere
+             pass
+
+        printer.print_str_in_terminal(f"Executing command: {command} in {os.path.abspath(source_dir)}")
+        try:
+            # Determine shell based on OS
+            shell = True
+            executable = None
+            if shells.is_windows():
+                # Decide between cmd and powershell if needed, default is cmd
+                pass # shell=True uses default shell
+            else:
+                # Use bash or zsh? Default is usually fine.
+                pass # shell=True uses default shell
+
+            # Execute the command
+            process = subprocess.Popen(
+                command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=source_dir,
+                text=True,
+                encoding=shells.get_terminal_encoding(),
+                errors='replace' # Handle potential decoding errors
+            )
+
+            stdout, stderr = process.communicate()
+            returncode = process.returncode
+
+            logger.info(f"Command executed: {command}")
+            logger.info(f"Return Code: {returncode}")
+            if stdout:
+                logger.info(f"stdout:\n{stdout}")
+            if stderr:
+                logger.info(f"stderr:\n{stderr}")
+
+
+            if returncode == 0:
+                return ToolResult(success=True, message="Command executed successfully.", content=stdout)
+            else:
+                error_message = f"Command failed with return code {returncode}.\nStderr:\n{stderr}\nStdout:\n{stdout}"
+                return ToolResult(success=False, message=error_message, content={"stdout": stdout, "stderr": stderr, "returncode": returncode})
+
+        except FileNotFoundError:
+            return ToolResult(success=False, message=f"Error: The command '{command.split()[0]}' was not found. Please ensure it is 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:
+            logger.error(f"Error executing command '{command}': {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred while executing the command: {str(e)}")

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

@@ -0,0 +1,80 @@
+import os
+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 ListCodeDefinitionNamesTool, ToolResult # Import ToolResult from types
+import json
+from autocoder.index.index import IndexManager
+from loguru import logger
+import traceback
+from autocoder.index.symbols_utils import (
+    extract_symbols,
+    SymbolType,
+    symbols_info_to_str,
+)
+import typing
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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 # For type hinting
+        self.llm = self.agent.llm
+
+    def _get_index(self):        
+        index_manager = IndexManager(
+            llm=self.llm, sources=[], args=self.args)
+        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"Error: Access denied. Attempted to analyze code outside the project directory: {target_path_str}")
+
+        if not os.path.exists(absolute_target_path):
+            return ToolResult(success=False, message=f"Error: Path not found: {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"Error: Path is neither a file nor a directory: {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}")
+
+
+            message = f"Successfully extracted {sum(len(s['definitions']) for s in all_symbols)} definitions from {len(all_symbols)} files in '{target_path_str}'."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=all_symbols)
+
+        except Exception as e:
+            logger.error(f"Error extracting code definitions from '{target_path_str}': {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred while extracting code definitions: {str(e)}")

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

@@ -0,0 +1,105 @@
+import os
+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 ListFilesTool, ToolResult # Import ToolResult from types
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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 # For type hinting
+        self.shadow_manager = self.agent.shadow_manager
+
+    def resolve(self) -> ToolResult:
+        list_path_str = self.tool.path
+        recursive = self.tool.recursive or False
+        source_dir = self.args.source_dir or "."
+        absolute_list_path = os.path.abspath(os.path.join(source_dir, list_path_str))
+
+        # Security check: Allow listing outside source_dir IF the original path is outside?
+        # For now, let's restrict to source_dir for safety, unless path explicitly starts absolute
+        # This needs careful consideration based on security requirements.
+        # Let's allow listing anywhere for now, but log a warning if outside source_dir.
+        is_outside_source = not absolute_list_path.startswith(os.path.abspath(source_dir))
+        if is_outside_source:
+             logger.warning(f"Listing path is outside the project source directory: {list_path_str}")
+             # Add more checks if needed, e.g., prevent listing sensitive system dirs
+
+        # Check if shadow directory exists for this path
+        shadow_paths = []
+        shadow_exists = False
+        shadow_dir_path = None
+        if self.shadow_manager:
+            try:
+                shadow_dir_path = self.shadow_manager.to_shadow_path(absolute_list_path)
+                if os.path.exists(shadow_dir_path) and os.path.isdir(shadow_dir_path):
+                    shadow_exists = True
+            except Exception as e:
+                logger.warning(f"Error checking shadow path for {absolute_list_path}: {e}")
+
+        # Validate that at least one of the directories exists
+        if not os.path.exists(absolute_list_path) and not shadow_exists:
+            return ToolResult(success=False, message=f"Error: Path not found: {list_path_str}")
+        if os.path.exists(absolute_list_path) and not os.path.isdir(absolute_list_path):
+            return ToolResult(success=False, message=f"Error: Path is not a directory: {list_path_str}")
+        if shadow_exists and not os.path.isdir(shadow_dir_path):
+            return ToolResult(success=False, message=f"Error: Shadow path is not a directory: {shadow_dir_path}")
+
+        # Helper function to list files in a directory
+        def list_files_in_dir(base_dir: str) -> set:
+            result = set()
+            try:
+                if recursive:
+                    for root, dirs, files in os.walk(base_dir):
+                        for name in files:
+                            full_path = os.path.join(root, name)
+                            display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                            result.add(display_path)
+                        for name in dirs:
+                            full_path = os.path.join(root, name)
+                            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)
+                        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:
+                logger.warning(f"Error listing files in {base_dir}: {e}")
+            return result
+
+        # Collect files from shadow and/or source directory
+        shadow_files_set = set()
+        if shadow_exists:
+            shadow_files_set = list_files_in_dir(shadow_dir_path)
+
+        source_files_set = set()
+        if os.path.exists(absolute_list_path) and os.path.isdir(absolute_list_path):
+            source_files_set = list_files_in_dir(absolute_list_path)
+
+        # Merge results, prioritizing shadow files if exist
+        merged_files = set()
+        if shadow_exists:
+            # Use shadow files + source files that are NOT shadowed
+            merged_files = shadow_files_set.union(
+                {f for f in source_files_set if f not in shadow_files_set}
+            )
+        else:
+            merged_files = source_files_set
+
+        try:
+            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(merged_files)} items."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=sorted(merged_files))
+        except Exception as e:
+            logger.error(f"Error listing files in '{list_path_str}': {str(e)}")
+            return ToolResult(success=False, message=f"An unexpected error occurred while listing files: {str(e)}")

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

@@ -0,0 +1,35 @@
+from typing import Dict, Any, Optional
+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 PlanModeRespondTool, ToolResult # Import ToolResult from types
+from loguru import logger
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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="Error: Plan mode response cannot be empty.")
+
+        # 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="Plan mode response prepared.", content=result_content)

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

@@ -0,0 +1,51 @@
+import os
+from typing import Dict, Any, Optional
+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 ReadFileTool, ToolResult  # Import ToolResult from types
+from loguru import logger
+import typing
+
+if typing.TYPE_CHECKING:
+    from autocoder.common.v2.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
+
+    def resolve(self) -> ToolResult:
+        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))
+
+        # 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 read file outside the project directory: {file_path}")
+
+        try:
+            if self.shadow_manager:
+                shadow_path = self.shadow_manager.to_shadow_path(abs_file_path)
+                # If shadow file exists, read from it
+                if os.path.exists(shadow_path) and os.path.isfile(shadow_path):
+                    with open(shadow_path, 'r', encoding='utf-8', errors='replace') as f:
+                        content = f.read()
+                    logger.info(f"[Shadow] Successfully read shadow file: {shadow_path}")
+                    return ToolResult(success=True, message=f"Successfully read file (shadow): {file_path}", content=content)
+                # else fallback to original file
+            # Fallback to original file
+            if not os.path.exists(abs_file_path):
+                return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
+            if not os.path.isfile(abs_file_path):
+                return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
+
+            with open(abs_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+            logger.info(f"Successfully read file: {file_path}")
+            return ToolResult(success=True, message=f"Successfully read file: {file_path}", content=content)
+        except Exception as e:
+            logger.error(f"Error reading file '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=f"An error occurred while reading the file: {str(e)}")