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

autocoder/common/v2/agent/agentic_edit_conversation.py

@@ -0,0 +1,179 @@
+# src/autocoder/common/v2/agent/agentic_edit_conversation.py
+import os
+import json
+import uuid
+from typing import List, Dict, Any, Optional
+from autocoder.common import AutoCoderArgs
+
+# Define a type alias for a message dictionary
+MessageType = Dict[str, Any]
+
+class AgenticConversation:
+    """
+    Manages the conversation history for an agentic editing process.
+
+    Handles adding messages (user, assistant, tool calls, tool results)
+    and retrieving the history.
+    """
+
+    def __init__(self, args: AutoCoderArgs, initial_history: Optional[List[MessageType]] = None, conversation_name: Optional[str] = None):
+        """
+        Initializes the conversation history.
+
+        Args:
+            initial_history: An optional list of messages to start with.
+            conversation_name: Optional conversation identifier. If provided, history is saved/loaded from a file named after it.
+        """
+        self.project_path = args.source_dir
+        self._history: List[MessageType] = initial_history if initial_history is not None else []
+
+        # Determine the memory directory
+        memory_dir = os.path.join(self.project_path, ".auto-coder", "memory", "agentic_edit_memory")
+        os.makedirs(memory_dir, exist_ok=True)
+
+        # Determine conversation file path
+        if conversation_name:
+            filename = f"{conversation_name}.json"
+        else:
+            conversation_name = str(uuid.uuid4())
+            filename = f"{conversation_name}.json"
+
+        self.conversation_name = conversation_name
+        self.memory_file_path = os.path.join(memory_dir, filename)
+
+        # Load existing history if file exists
+        self._load_memory()
+
+    def add_message(self, role: str, content: Any, **kwargs):
+        """
+        Adds a message to the conversation history.
+
+        Args:
+            role: The role of the message sender (e.g., "user", "assistant", "tool").
+            content: The content of the message. Can be None for messages like tool calls.
+            **kwargs: Additional key-value pairs to include in the message dictionary (e.g., tool_calls, tool_call_id).
+        """
+        message: MessageType = {"role": role}
+        if content is not None:
+            message["content"] = content
+        message.update(kwargs)
+        self._history.append(message)
+        self._save_memory()
+
+    def add_user_message(self, content: str):
+        """Adds a user message."""
+        self.add_message(role="user", content=content)
+
+    def add_assistant_message(self, content: str):
+        """Adds an assistant message (potentially containing text response)."""
+        self.add_message(role="assistant", content=content)
+
+    def add_assistant_tool_call_message(self, tool_calls: List[Dict[str, Any]], content: Optional[str] = None):
+         """
+         Adds a message representing one or more tool calls from the assistant.
+         Optionally includes assistant's textual reasoning/content alongside the calls.
+         """
+         self.add_message(role="assistant", content=content, tool_calls=tool_calls)
+
+
+    def add_tool_result_message(self, tool_call_id: str, content: Any):
+         """Adds a message representing the result of a specific tool call."""
+         # The content here is typically the output/result from the tool execution.
+         self.add_message(role="tool", content=content, tool_call_id=tool_call_id)
+
+
+    def get_history(self) -> List[MessageType]:
+        """
+        Returns the latest 20 pairs of (user, assistant) conversation history.
+        Merges adjacent same-role messages into one, concatenated by newline.
+        Ensures that each user message is paired with the subsequent assistant response,
+        skips other roles, and that the last message is always assistant (drops trailing user if unpaired).
+        
+        Returns:
+            A list of message dictionaries, ordered chronologically.
+        """
+        paired_history = []
+        pair_count = 0
+        pending_assistant = None
+        pending_user = None
+
+        # Traverse history in reverse to collect latest pairs with merging
+        for msg in reversed(self._history):
+            role = msg.get("role")
+            if role == "assistant":
+                if pending_assistant is None:
+                    pending_assistant = dict(msg)
+                else:
+                    # Merge with previous assistant
+                    prev_content = pending_assistant.get("content", "")
+                    curr_content = msg.get("content", "")
+                    merged_content = (curr_content.strip() + "\n" + prev_content.strip()).strip()
+                    pending_assistant["content"] = merged_content
+            elif role == "user":
+                if pending_user is None:
+                    pending_user = dict(msg)
+                else:
+                    # Merge with previous user
+                    prev_content = pending_user.get("content", "")
+                    curr_content = msg.get("content", "")
+                    merged_content = (curr_content.strip() + "\n" + prev_content.strip()).strip()
+                    pending_user["content"] = merged_content
+
+                if pending_assistant is not None:
+                    # Have a full pair, insert in order
+                    paired_history.insert(0, pending_user)
+                    paired_history.insert(1, pending_assistant)
+                    pair_count += 1
+                    pending_assistant = None
+                    pending_user = None
+                    if pair_count >= 20:
+                        break
+                else:
+                    # User without assistant yet, continue accumulating
+                    continue
+            else:
+                # Ignore other roles
+                continue
+
+        # Ensure last message is assistant, drop trailing user if unpaired
+        if paired_history and paired_history[-1].get("role") == "user":
+            paired_history.pop()
+
+        return paired_history
+
+    def clear_history(self):
+        """Clears the conversation history."""
+        self._history = []
+        self._save_memory()
+
+    def __len__(self) -> int:
+        """Returns the number of messages in the history."""
+        return len(self._history)
+
+    def __str__(self) -> str:
+        """Returns a string representation of the conversation history."""
+        # Consider a more readable format if needed for debugging
+        return str(self._history)
+
+    # Potential future enhancements:
+    # - Method to limit history size (by tokens or message count)
+    # - Method to format history specifically for different LLM APIs
+    # - Serialization/deserialization methods
+
+    def _save_memory(self):
+        try:
+            os.makedirs(os.path.dirname(self.memory_file_path), exist_ok=True)
+            with open(self.memory_file_path, "w", encoding="utf-8") as f:
+                json.dump(self._history, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            # Optionally log or ignore
+            pass
+
+    def _load_memory(self):
+        try:
+            if os.path.exists(self.memory_file_path):
+                with open(self.memory_file_path, "r", encoding="utf-8") as f:
+                    self._history = json.load(f)
+        except Exception as e:
+            # Ignore loading errors, start fresh
+            pass

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)