auto-coder 0.1.374__py3-none-any.whl → 0.1.376__py3-none-any.whl

autocoder/agent/agentic_edit_tools/__init__.py

@@ -1,28 +0,0 @@
-# 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/agent/agentic_edit_tools/ask_followup_question_tool_resolver.py

@@ -1,32 +0,0 @@
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import AskFollowupQuestionTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-class AskFollowupQuestionToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: AskFollowupQuestionTool, args: Dict[str, Any]):
-        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
-
-        logger.info(f"Resolving AskFollowupQuestionTool: Question='{question}', Options={options}")
-
-        # 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 question:
-            return ToolResult(success=False, message="Error: Question cannot be empty.")
-
-        result_content = {
-            "question": question,
-            "options": options
-        }
-
-        # Indicate success in preparing the question data
-        return ToolResult(success=True, message="Follow-up question prepared.", content=result_content)

autocoder/agent/agentic_edit_tools/attempt_completion_tool_resolver.py

@@ -1,29 +0,0 @@
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import AttemptCompletionTool, ToolResult # Import ToolResult from types
-from loguru import logger
-class AttemptCompletionToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: AttemptCompletionTool, args: Dict[str, Any]):
-        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/agent/agentic_edit_tools/base_tool_resolver.py

@@ -1,29 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional
-from autocoder.agent.agentic_edit_types import BaseTool, ToolResult # Import ToolResult from types
-from autocoder.common import AutoCoderArgs
-
-
-class BaseToolResolver(ABC):
-    def __init__(self, agent: Optional[Any], 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/agent/agentic_edit_tools/execute_command_tool_resolver.py

@@ -1,84 +0,0 @@
-import subprocess
-import os
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.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
-
-
-class ExecuteCommandToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: ExecuteCommandTool, args: Dict[str, Any]):
-        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.get("source_dir", ".")
-
-        # 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_warning(f"Command requires approval: {command}")
-             # For now, let's assume approval is granted in non-interactive mode or handled elsewhere
-             pass
-
-        printer.print_message(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/agent/agentic_edit_tools/list_code_definition_names_tool_resolver.py

@@ -1,75 +0,0 @@
-import os
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.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,
-)
-
-
-class ListCodeDefinitionNamesToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: ListCodeDefinitionNamesTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: ListCodeDefinitionNamesTool = tool # For type hinting
-
-    def _get_index(self):
-        sources = self._get_sources()
-        index_manager = IndexManager(
-            llm=self.llm, sources=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.get("source_dir", ".")
-        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/agent/agentic_edit_tools/list_files_tool_resolver.py

@@ -1,62 +0,0 @@
-import os
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import ListFilesTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-
-class ListFilesToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: ListFilesTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: ListFilesTool = tool # For type hinting
-
-    def resolve(self) -> ToolResult:
-        list_path_str = self.tool.path
-        recursive = self.tool.recursive or False
-        source_dir = self.args.get("source_dir", ".")
-        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
-
-        if not os.path.exists(absolute_list_path):
-            return ToolResult(success=False, message=f"Error: Path not found: {list_path_str}")
-        if not os.path.isdir(absolute_list_path):
-             return ToolResult(success=False, message=f"Error: Path is not a directory: {list_path_str}")
-
-        file_list = []
-        try:
-            if recursive:
-                for root, dirs, files in os.walk(absolute_list_path):
-                    for name in files:
-                        full_path = os.path.join(root, name)
-                        # Return relative path if inside source_dir, else absolute
-                        display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
-                        file_list.append(display_path)
-                    for name in dirs:
-                         # Optionally list directories too? The description implies files and 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
-                         file_list.append(display_path + "/") # Indicate directory
-            else:
-                for item in os.listdir(absolute_list_path):
-                    full_path = os.path.join(absolute_list_path, item)
-                    display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
-                    if os.path.isdir(full_path):
-                        file_list.append(display_path + "/")
-                    else:
-                        file_list.append(display_path)
-
-            message = f"Successfully listed contents of '{list_path_str}' (Recursive: {recursive}). Found {len(file_list)} items."
-            logger.info(message)
-            return ToolResult(success=True, message=message, content=sorted(file_list))
-
-        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/agent/agentic_edit_tools/plan_mode_respond_tool_resolver.py

@@ -1,30 +0,0 @@
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import PlanModeRespondTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-class PlanModeRespondToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: PlanModeRespondTool, args: Dict[str, Any]):
-        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/agent/agentic_edit_tools/read_file_tool_resolver.py

@@ -1,36 +0,0 @@
-import os
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import ReadFileTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-
-class ReadFileToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: ReadFileTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: ReadFileTool = tool # For type hinting
-
-    def resolve(self) -> ToolResult:
-        file_path = self.tool.path
-        source_dir = self.args.get("source_dir", ".")
-        absolute_path = os.path.abspath(os.path.join(source_dir, file_path))
-
-        # Security check: ensure the path is within the source directory
-        if not absolute_path.startswith(os.path.abspath(source_dir)):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to read file outside the project directory: {file_path}")
-
-        try:
-            if not os.path.exists(absolute_path):
-                return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
-            if not os.path.isfile(absolute_path):
-                 return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
-
-            # Handle different file types if necessary (e.g., PDF, DOCX)
-            # For now, assume text files
-            with open(absolute_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)}")

autocoder/agent/agentic_edit_tools/replace_in_file_tool_resolver.py

@@ -1,95 +0,0 @@
-import os
-import re
-from typing import Dict, Any, Optional, List, Tuple
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import ReplaceInFileTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-
-class ReplaceInFileToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: ReplaceInFileTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: ReplaceInFileTool = tool # For type hinting
-
-    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 = []
-        # Regex to find SEARCH/REPLACE blocks, handling potential variations in line endings
-        pattern = re.compile(r"<<<<<<< SEARCH\r?\n(.*?)\r?\n=======\r?\n(.*?)\r?\n>>>>>>> REPLACE", re.DOTALL)
-        matches = pattern.findall(diff_content)
-        for search_block, replace_block in matches:
-            # Normalize line endings within blocks if needed, though exact match is preferred
-            blocks.append((search_block, replace_block))
-        if not matches 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.get("source_dir", ".")
-        absolute_path = os.path.abspath(os.path.join(source_dir, file_path))
-
-        # Security check
-        if not absolute_path.startswith(os.path.abspath(source_dir)):
-            return ToolResult(success=False, message=f"Error: Access denied. Attempted to modify file outside the project directory: {file_path}")
-
-        if not os.path.exists(absolute_path):
-            return ToolResult(success=False, message=f"Error: File not found at path: {file_path}")
-        if not os.path.isfile(absolute_path):
-             return ToolResult(success=False, message=f"Error: Path is not a file: {file_path}")
-
-        try:
-            with open(absolute_path, 'r', encoding='utf-8', errors='replace') as f:
-                original_content = f.read()
-        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):
-            # Use find() for exact, first match semantics
-            start_index = current_content.find(search_block)
-
-            if start_index != -1:
-                # Replace the first occurrence
-                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)
-                # Log surrounding context for debugging
-                context_start = max(0, original_content.find(search_block[:20]) - 100) # Approximate location
-                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)
-                # Stop applying further changes if one fails? Or continue? Let's continue for now.
-
-        if applied_count == 0 and errors:
-            return ToolResult(success=False, message=f"Failed to apply any changes. Errors:\n" + "\n".join(errors))
-
-        try:
-            with open(absolute_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)
-
-            # Return the final content (might be changed by auto-formatting later)
-            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/agent/agentic_edit_tools/search_files_tool_resolver.py

@@ -1,70 +0,0 @@
-import os
-import re
-import glob
-from typing import Dict, Any, Optional
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import SearchFilesTool, ToolResult # Import ToolResult from types
-from loguru import logger
-
-
-class SearchFilesToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], tool: SearchFilesTool, args: Dict[str, Any]):
-        super().__init__(agent, tool, args)
-        self.tool: SearchFilesTool = tool # For type hinting
-
-    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.get("source_dir", ".")
-        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}")
-
-        if not os.path.exists(absolute_search_path):
-            return ToolResult(success=False, message=f"Error: Search path not found: {search_path_str}")
-        if not os.path.isdir(absolute_search_path):
-             return ToolResult(success=False, message=f"Error: Search path is not a directory: {search_path_str}")
-
-        results = []
-        try:
-            compiled_regex = re.compile(regex_pattern)
-            search_glob_pattern = os.path.join(absolute_search_path, "**", file_pattern)
-
-            logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{absolute_search_path}'")
-
-            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)])
-                                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/agent/agentic_edit_tools/use_mcp_tool_resolver.py

@@ -1,55 +0,0 @@
-from typing import Dict, Any, Optional
-from autocoder.common import AutoCoderArgs
-from .base_tool_resolver import BaseToolResolver
-from autocoder.agent.agentic_edit_types import UseMcpTool, ToolResult # Import ToolResult from types
-from autocoder.common.mcp_server import get_mcp_server
-from loguru import logger
-
-
-class UseMcpToolResolver(BaseToolResolver):
-    def __init__(self, agent: Optional[Any], 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.
-        """
-        server_name = self.tool.server_name
-        tool_name = self.tool.tool_name
-        arguments = self.tool.arguments        
-        model = self.args.model 
-        product_mode = self.args.product_mode
-
-
-        logger.info(f"Resolving UseMcpTool: Server='{server_name}', Tool='{tool_name}', Args={arguments}")
-
-        # if not server_name or not tool_name:
-        return ToolResult(success=False, message="Error: MCP server name and tool name are required.")
-
-        # try:
-        #     mcp_server = get_mcp_server()
-        #     if not mcp_server:
-        #          return ToolResult(success=False, message="Error: MCP server is not available or configured.")
-
-        #     request = McpExecuteToolRequest(
-        #         server_name=server_name,
-        #         tool_name=tool_name,
-        #         arguments=arguments,
-        #         model=model, # Pass model info if required by MCP server
-        #         product_mode=product_mode
-        #     )
-
-        #     logger.debug(f"Sending MCP request: {request.dict()}")
-        #     response: McpExecuteToolResponse = mcp_server.send_request(request)
-        #     logger.debug(f"Received MCP response: Success={response.success}, Message={response.message}")
-
-
-        #     if response.success:
-        #         return ToolResult(success=True, message=f"MCP tool '{tool_name}' executed successfully. {response.message}", content=response.result)
-        #     else:
-        #         return ToolResult(success=False, message=f"MCP tool '{tool_name}' failed: {response.message}", content=response.result)
-
-        # except Exception as e:
-        #     logger.error(f"Error executing MCP tool '{tool_name}' on server '{server_name}': {str(e)}")
-        #     return ToolResult(success=False, message=f"An unexpected error occurred while executing the MCP tool: {str(e)}")