Add a /search command for string-matching to add files

Author: tekacs

aider/commands.py

@@ -22,7 +22,7 @@
 from aider.repo import ANY_GIT_ERROR
 from aider.run_cmd import run_cmd
 from aider.scrape import Scraper, install_playwright
-from aider.utils import is_image_file
+from aider.utils import is_image_file, is_likely_binary
 
 from .dump import dump  # noqa: F401
 
@@ -1649,6 +1649,55 @@ def completions_find(self):
 
         return sorted(symbols)
 
+    def cmd_search(self, args):
+        "Search for exact string matches in files and add matching files to chat"
+
+        if not args.strip():
+            self.io.tool_error("Please provide a text string to search for.")
+            return
+
+        search_string = args.strip()
+        found_files = set()
+
+        # Create a spinner for user feedback
+        self.io.tool_output(f"Searching for '{search_string}'...")
+        chat_files = set(self.coder.abs_fnames)
+        other_files = set(self.coder.get_all_abs_files()) - chat_files
+
+        # Search through all files
+        for fname in other_files:
+            # Skip binary files
+            if is_likely_binary(fname):
+                continue
+
+            # Read file with silent=True to suppress error messages
+            content = self.io.read_text(fname, silent=True)
+            if content and search_string in content:
+                found_files.add(fname)
+                rel_fname = self.coder.get_rel_fname(fname)
+                self.io.tool_output(f"Found '{search_string}' in {rel_fname}")
+
+        if not found_files:
+            self.io.tool_error(f"No files found containing '{search_string}'.")
+            return
+
+        # Add the files to the chat
+        for abs_file_path in found_files:
+            if abs_file_path in self.coder.abs_fnames:
+                self.io.tool_output(
+                    f"{self.coder.get_rel_fname(abs_file_path)} is already in the chat"
+                )
+                continue
+
+            content = self.io.read_text(abs_file_path)
+            if content is None:
+                self.io.tool_error(f"Unable to read {abs_file_path}")
+            else:
+                self.coder.abs_fnames.add(abs_file_path)
+                rel_fname = self.coder.get_rel_fname(abs_file_path)
+                self.io.tool_output(f"Added {rel_fname} to the chat")
+                self.coder.check_added_files()
+
     def cmd_copy_context(self, args=None):
         """Copy the current chat context as markdown, suitable to paste into a web UI"""
 

aider/utils.py

@@ -12,6 +12,22 @@
 
 IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp", ".pdf"}
 
+# Extensions for files that are likely binary
+BINARY_EXTENSIONS = {
+    # Images
+    ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".ico", ".icns", ".webp", ".tiff", ".svg",
+    # Fonts
+    ".ttf", ".otf", ".woff", ".woff2", ".eot", 
+    # Audio/Video
+    ".mp3", ".mp4", ".wav", ".ogg", ".flac", ".avi", ".mov", ".mkv",
+    # Archives
+    ".zip", ".tar", ".gz", ".rar", ".7z", ".iso", ".jar",
+    # Compiled files
+    ".exe", ".dll", ".so", ".dylib", ".class", ".pyc",
+    # Other binary formats
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".db", ".bin"
+}
+
 
 class IgnorantTemporaryDirectory:
     def __init__(self):
@@ -93,6 +109,45 @@ def is_image_file(file_name):
     return any(file_name.endswith(ext) for ext in IMAGE_EXTENSIONS)
 
 
+def is_likely_binary(file_name):
+    """
+    Check if a file is likely binary based on extension and content.
+    
+    :param file_name: The name of the file to check.
+    :return: True if the file is likely binary, False otherwise.
+    """
+    file_name = str(file_name)  # Convert file_name to string
+    
+    # Check for directory
+    if os.path.isdir(file_name):
+        return True
+    
+    # Check extension first (faster)
+    ext = os.path.splitext(file_name)[1].lower()
+    if ext in BINARY_EXTENSIONS:
+        return True
+    
+    # For files without telling extensions, check content
+    try:
+        # Read first 1024 bytes to check for binary content
+        with open(file_name, 'rb') as f:
+            chunk = f.read(1024)
+            # Check for null bytes (common in binary files)
+            if b'\x00' in chunk:
+                return True
+                
+            # Heuristic: If there are many non-ASCII bytes, it's likely binary
+            # Count bytes that are not ASCII printable or common control chars
+            non_text = sum(1 for b in chunk if b < 9 or 13 < b < 32 or b > 126)
+            if len(chunk) > 0 and non_text / len(chunk) > 0.3:  # >30% non-text chars
+                return True
+    except (IOError, OSError):
+        # If we can't read the file, assume it's not binary to be safe
+        return False
+        
+    return False
+
+
 def safe_abs_path(res):
     "Gives an abs path, which safely returns a full (not 8.3) windows path"
     res = Path(res).resolve()

tests/basic/test_commands.py

@@ -2190,3 +2190,77 @@ def mock_get_tags(fname, rel_fname):
 
             # Verify no files were added
             self.assertEqual(len(coder.abs_fnames), 0)
+            
+    def test_cmd_search(self):
+        from unittest import mock
+        
+        # Create test environment
+        with GitTemporaryDirectory() as repo_dir:
+            io = InputOutput(pretty=False, fancy_input=False, yes=True)
+            coder = Coder.create(self.GPT35, None, io)
+            
+            # Setup test files
+            file1_path = Path(repo_dir) / "file1.py"
+            file2_path = Path(repo_dir) / "file2.py" 
+            file3_path = Path(repo_dir) / "file3.py"  # File without the search string
+            file1_path.write_text("def test_function(): pass")
+            file2_path.write_text("# This file contains search_string in a comment")
+            file3_path.write_text("# This file has no reference to the search term")
+            
+            # Mock get_all_abs_files to return our test files
+            coder.get_all_abs_files = mock.MagicMock(return_value=[
+                str(file1_path),
+                str(file2_path),
+                str(file3_path)
+            ])
+            
+            # Mock read_text to return the actual file contents
+            def mock_read_text(fname, silent=False):
+                if str(file1_path) in str(fname):
+                    return "def test_function(): pass"
+                elif str(file2_path) in str(fname):
+                    return "# This file contains search_string in a comment"
+                elif str(file3_path) in str(fname):
+                    return "# This file has no reference to the search term"
+                return None
+                
+            io.read_text = mock.MagicMock(side_effect=mock_read_text)
+            
+            # Run the search command
+            commands = Commands(io, coder)
+            # Test searching for a string that exists
+            commands.cmd_search("search_string")
+            
+            # Check that the expected files were added to the chat
+            self.assertEqual(len(coder.abs_fnames), 1)
+            
+            # Convert abs_fnames to a list of rel paths for easier comparison
+            added_files = [str(Path(path).name) for path in coder.abs_fnames]
+            self.assertIn("file2.py", added_files)
+            self.assertNotIn("file1.py", added_files)
+            self.assertNotIn("file3.py", added_files)
+            
+            # Clear added files
+            coder.abs_fnames.clear()
+            
+            # Test searching for a string in a single file
+            io.read_text = mock.MagicMock(side_effect=mock_read_text)
+            commands.cmd_search("test_function")
+            
+            # Check that only the file with "test_function" was added
+            self.assertEqual(len(coder.abs_fnames), 1)
+            added_files = [str(Path(path).name) for path in coder.abs_fnames]
+            self.assertIn("file1.py", added_files)
+            self.assertNotIn("file2.py", added_files)
+            self.assertNotIn("file3.py", added_files)
+            
+            # Clear added files
+            coder.abs_fnames.clear()
+            
+            # Test searching for a non-existent string
+            with mock.patch.object(io, "tool_error") as mock_tool_error:
+                commands.cmd_search("nonexistent_string")
+                mock_tool_error.assert_called_with("No files found containing 'nonexistent_string'.")
+                
+            # Verify no files were added
+            self.assertEqual(len(coder.abs_fnames), 0)