auto-coder 0.1.361__py3-none-any.whl → 0.1.363__py3-none-any.whl

autocoder/agent/base_agentic/tools/example_tool_resolver.py

@@ -0,0 +1,46 @@
+from typing import Optional
+from autocoder.common import AutoCoderArgs
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import BaseTool, ToolResult
+from pydantic import BaseModel
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+
+# 首先定义工具模型
+class ExampleTool(BaseTool):
+    """示例工具，只是一个演示"""
+    message: str
+    times: int = 1
+
+
+# 然后定义对应的解析器
+class ExampleToolResolver(BaseToolResolver):
+    """示例工具解析器"""
+    def __init__(self, agent: Optional['BaseAgent'], tool: ExampleTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: ExampleTool = tool  # 类型提示
+
+    def resolve(self) -> ToolResult:
+        """
+        执行工具逻辑
+
+        Returns:
+            工具执行结果
+        """
+        try:
+            # 简单示例：重复消息N次
+            result = self.tool.message * self.tool.times
+            return ToolResult(
+                success=True,
+                message="成功执行示例工具",
+                content=result
+            )
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                message=f"执行示例工具时出错: {str(e)}",
+                content=None
+            ) 

autocoder/agent/base_agentic/tools/execute_command_tool_resolver.py

@@ -0,0 +1,72 @@
+import os
+import subprocess
+from typing import Dict, Any, Optional
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.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
+from autocoder.events.event_manager_singleton import get_event_manager
+from autocoder.run_context import get_run_context
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+class ExecuteCommandToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], 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:            
+            # 使用封装的run_cmd方法执行命令
+            if get_run_context().is_web():
+                answer = get_event_manager(
+                    self.args.event_file).ask_user(prompt=f"Allow to execute the `{command}`?",options=["yes","no"])
+                if answer == "yes":
+                    pass
+                else:
+                    return ToolResult(success=False, message=f"Command '{command}' execution denied by user.")
+            
+            exit_code, output = run_cmd_subprocess(command, verbose=True, cwd=source_dir)
+
+            logger.info(f"Command executed: {command}")
+            logger.info(f"Return Code: {exit_code}")
+            if output:
+                logger.info(f"Output:\n{output}")
+
+            if exit_code == 0:
+                return ToolResult(success=True, message="Command executed successfully.", content=output)
+            else:
+                error_message = f"Command failed with return code {exit_code}.\nOutput:\n{output}"
+                return ToolResult(success=False, message=error_message, content={"output": output, "returncode": exit_code})
+
+        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/base_agentic/tools/list_files_tool_resolver.py

@@ -0,0 +1,110 @@
+import os
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import ListFilesTool, ToolResult  # Import ToolResult from types
+from typing import Optional, Dict, Any, List
+import fnmatch
+import re
+import json
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+
+class ListFilesToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], 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_source_dir = os.path.abspath(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?
+        is_outside_source = not absolute_list_path.startswith(absolute_source_dir)
+        if is_outside_source:
+            logger.warning(f"Listing path is outside the project source directory: {list_path_str}")
+
+        # Check if shadow directory exists for this path
+        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):
+                        # Modify dirs in-place to skip ignored dirs early
+                        dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d))]
+                        for name in files:
+                            full_path = os.path.join(root, name)
+                            if should_ignore(full_path):
+                                continue
+                            display_path = os.path.relpath(full_path, source_dir) if not is_outside_source else full_path
+                            result.add(display_path)
+                        for d in dirs:
+                            full_path = os.path.join(root, d)
+                            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)
+                        if should_ignore(full_path):
+                            continue
+                        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
+        if shadow_exists:
+            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/agent/base_agentic/tools/plan_mode_respond_tool_resolver.py

@@ -0,0 +1,35 @@
+import json
+from typing import Dict, Any, Optional
+import typing
+from autocoder.common import AutoCoderArgs
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import PlanModeRespondTool, ToolResult # Import ToolResult from types
+from loguru import logger
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+class PlanModeRespondToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], 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/agent/base_agentic/tools/read_file_tool_resolver.py

@@ -0,0 +1,54 @@
+import os
+from typing import Dict, Any, Optional
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import ReadFileTool, ToolResult  # Import ToolResult from types
+from loguru import logger
+import typing
+from autocoder.common import AutoCoderArgs
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+
+class ReadFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], 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:
+            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)
+            except Exception as e:
+                pass
+            # 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)}")

autocoder/agent/base_agentic/tools/replace_in_file_tool_resolver.py

@@ -0,0 +1,156 @@
+import os
+import re
+import difflib
+import traceback
+from typing import Dict, Any, Optional, List, Tuple
+import typing
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import ReplaceInFileTool, ToolResult  # Import ToolResult from types
+from autocoder.common.printer import Printer
+from autocoder.common import AutoCoderArgs
+from loguru import logger
+from autocoder.common.auto_coder_lang import get_message_with_format
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+class ReplaceInFileToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], 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=get_message_with_format("replace_in_file.access_denied", file_path=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=get_message_with_format("replace_in_file.file_not_found", file_path=file_path))
+        except Exception as e:
+            logger.error(f"Error reading file for replace '{file_path}': {str(e)}")
+            return ToolResult(success=False, message=get_message_with_format("replace_in_file.read_error", error=str(e)))
+
+        parsed_blocks = self.parse_diff(diff_content)
+        if not parsed_blocks:
+            return ToolResult(success=False, message=get_message_with_format("replace_in_file.no_valid_blocks"))
+
+        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=get_message_with_format("replace_in_file.apply_failed", errors="\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}")
+
+            if errors:
+                message = get_message_with_format("replace_in_file.apply_success_with_warnings", 
+                                                  applied=applied_count, 
+                                                  total=len(parsed_blocks), 
+                                                  file_path=file_path,
+                                                  errors="\n".join(errors))
+            else:
+                message = get_message_with_format("replace_in_file.apply_success", 
+                                                  applied=applied_count, 
+                                                  total=len(parsed_blocks), 
+                                                  file_path=file_path)
+
+            # 变更跟踪，回调AgenticEdit
+            if self.agent:
+                rel_path = os.path.relpath(abs_file_path, abs_project_dir)
+                self.agent.record_file_change(rel_path, "modified", diff=diff_content, content=current_content)
+
+            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=get_message_with_format("replace_in_file.write_error", error=str(e)))

autocoder/agent/base_agentic/tools/search_files_tool_resolver.py

@@ -0,0 +1,134 @@
+import os
+import re
+import glob
+from typing import Dict, Any, Optional, List
+from autocoder.agent.base_agentic.tools.base_tool_resolver import BaseToolResolver
+from autocoder.agent.base_agentic.types import SearchFilesTool, ToolResult  # Import ToolResult from types
+from loguru import logger
+from autocoder.common import AutoCoderArgs
+import typing
+
+from autocoder.common.ignorefiles.ignore_file_utils import should_ignore
+
+if typing.TYPE_CHECKING:
+    from ..base_agent import BaseAgent
+
+
+class SearchFilesToolResolver(BaseToolResolver):
+    def __init__(self, agent: Optional['BaseAgent'], tool: SearchFilesTool, args: AutoCoderArgs):
+        super().__init__(agent, tool, args)
+        self.tool: SearchFilesTool = tool
+        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 "*"
+        source_dir = self.args.source_dir or "."
+        absolute_source_dir = os.path.abspath(source_dir)
+        absolute_search_path = os.path.abspath(os.path.join(source_dir, search_path_str))
+
+        # Security check
+        if not absolute_search_path.startswith(absolute_source_dir):
+            return ToolResult(success=False, message=f"Error: Access denied. Attempted to search outside the project directory: {search_path_str}")
+
+        # Check if shadow directory exists
+        shadow_exists = False
+        shadow_dir_path = None
+        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):
+                    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(shadow_dir_path):
+            return ToolResult(success=False, message=f"Error: Shadow search path is not a directory: {shadow_dir_path}")
+
+        try:
+            compiled_regex = re.compile(regex_pattern)
+            
+            # Helper function to search in a directory
+            def search_in_dir(base_dir, is_shadow=False):
+                search_results = []
+                search_glob_pattern = os.path.join(base_dir, "**", file_pattern)
+                
+                logger.info(f"Searching for regex '{regex_pattern}' in files matching '{file_pattern}' under '{base_dir}' (shadow: {is_shadow}) with ignore rules applied.")
+                
+                for filepath in glob.glob(search_glob_pattern, recursive=True):
+                    abs_path = os.path.abspath(filepath)
+                    if should_ignore(abs_path):
+                        continue
+
+                    if os.path.isfile(filepath):
+                        try:
+                            with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                                lines = f.readlines()
+                            for i, line in enumerate(lines):
+                                if compiled_regex.search(line):
+                                    context_start = max(0, i - 2)
+                                    context_end = min(len(lines), i + 3)
+                                    context = "".join([f"{j+1}: {lines[j]}" for j in range(context_start, context_end)])
+                                    
+                                    if is_shadow 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)
+                                    
+                                    search_results.append({
+                                        "path": relative_path,
+                                        "line_number": i + 1,
+                                        "match_line": line.strip(),
+                                        "context": context.strip()
+                                    })
+                        except Exception as e:
+                            logger.warning(f"Could not read or process file {filepath}: {e}")
+                            continue
+                
+                return search_results
+            
+            # Search in both directories and merge results
+            shadow_results = []
+            source_results = []
+            
+            if shadow_exists:
+                shadow_results = search_in_dir(shadow_dir_path, is_shadow=True)
+            
+            if os.path.exists(absolute_search_path) and os.path.isdir(absolute_search_path):
+                source_results = search_in_dir(absolute_search_path, is_shadow=False)
+            
+            # Merge results, prioritizing shadow results
+            # Create a dictionary for quick lookup
+            results_dict = {}
+            for result in source_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Override with shadow results
+            for result in shadow_results:
+                key = (result["path"], result["line_number"])
+                results_dict[key] = result
+            
+            # Convert back to list
+            merged_results = list(results_dict.values())
+
+            message = f"Search completed. Found {len(merged_results)} matches."
+            logger.info(message)
+            return ToolResult(success=True, message=message, content=merged_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)}")