feat(search): align code search filters with index

Author: johnhuang316

src/code_index_mcp/search/ag.py

@@ -95,6 +95,26 @@ def search(
 
             cmd.extend(['-G', regex_pattern])
 
+        processed_patterns = set()
+        exclude_dirs = getattr(self, 'exclude_dirs', [])
+        exclude_file_patterns = getattr(self, 'exclude_file_patterns', [])
+
+        for directory in exclude_dirs:
+            normalized = directory.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            cmd.extend(['--ignore', normalized])
+            processed_patterns.add(normalized)
+
+        for pattern in exclude_file_patterns:
+            normalized = pattern.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            if normalized.startswith('!'):
+                normalized = normalized[1:]
+            cmd.extend(['--ignore', normalized])
+            processed_patterns.add(normalized)
+
         # Add -- to treat pattern as a literal argument, preventing injection
         cmd.append('--')
         cmd.append(search_pattern)

src/code_index_mcp/search/base.py

@@ -10,10 +10,13 @@
 import subprocess
 import sys
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
 
 from ..indexing.qualified_names import normalize_file_path
 
+if TYPE_CHECKING:  # pragma: no cover
+    from ..utils.file_filter import FileFilter
+
 def parse_search_output(
     output: str,
     base_path: str,
@@ -182,6 +185,16 @@ class SearchStrategy(ABC):
     Each strategy is responsible for searching code using a specific tool or method.
     """
 
+    def configure_excludes(self, file_filter: Optional['FileFilter']) -> None:
+        """Configure shared exclusion settings for the strategy."""
+        self.file_filter = file_filter
+        if file_filter:
+            self.exclude_dirs = sorted(set(file_filter.exclude_dirs))
+            self.exclude_file_patterns = sorted(set(file_filter.exclude_files))
+        else:
+            self.exclude_dirs = []
+            self.exclude_file_patterns = []
+
     @property
     @abstractmethod
     def name(self) -> str:

src/code_index_mcp/search/basic.py

@@ -1,9 +1,10 @@
 """
 Basic, pure-Python search strategy.
 """
+import fnmatch
 import os
 import re
-import fnmatch
+from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
 from .base import SearchStrategy, create_word_boundary_pattern, is_safe_regex_pattern
@@ -83,33 +84,38 @@ def search(
         except re.error as e:
             raise ValueError(f"Invalid regex pattern: {pattern}, error: {e}")
 
-        for root, _, files in os.walk(base_path):
+        file_filter = getattr(self, 'file_filter', None)
+        base = Path(base_path)
+
+        for root, dirs, files in os.walk(base_path):
+            if file_filter:
+                dirs[:] = [d for d in dirs if not file_filter.should_exclude_directory(d)]
+
             for file in files:
-                # Improved file pattern matching with glob support
                 if file_pattern and not self._matches_pattern(file, file_pattern):
                     continue
 
-                file_path = os.path.join(root, file)
+                file_path = Path(root) / file
+
+                if file_filter and not file_filter.should_process_path(file_path, base):
+                    continue
+
                 rel_path = os.path.relpath(file_path, base_path)
-                
+
                 try:
                     with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                         for line_num, line in enumerate(f, 1):
                             if search_regex.search(line):
                                 content = line.rstrip('\n')
-                                # Truncate content if it exceeds max_line_length
                                 if max_line_length and len(content) > max_line_length:
                                     content = content[:max_line_length] + '... (truncated)'
-                                
+
                                 if rel_path not in results:
                                     results[rel_path] = []
-                                # Strip newline for consistent output
                                 results[rel_path].append((line_num, content))
                 except (UnicodeDecodeError, PermissionError, OSError):
-                    # Ignore files that can't be opened or read due to encoding/permission issues
                     continue
                 except Exception:
-                    # Ignore any other unexpected exceptions to maintain robustness
                     continue
 
         return results

src/code_index_mcp/search/grep.py

@@ -83,6 +83,27 @@ def search(
             # Note: grep's --include uses glob patterns, not regex
             cmd.append(f'--include={file_pattern}')
 
+        exclude_dirs = getattr(self, 'exclude_dirs', [])
+        exclude_file_patterns = getattr(self, 'exclude_file_patterns', [])
+
+        processed_dirs = set()
+        for directory in exclude_dirs:
+            normalized = directory.strip()
+            if not normalized or normalized in processed_dirs:
+                continue
+            cmd.append(f'--exclude-dir={normalized}')
+            processed_dirs.add(normalized)
+
+        processed_files = set()
+        for pattern in exclude_file_patterns:
+            normalized = pattern.strip()
+            if not normalized or normalized in processed_files:
+                continue
+            if normalized.startswith('!'):
+                normalized = normalized[1:]
+            cmd.append(f'--exclude={normalized}')
+            processed_files.add(normalized)
+
         # Add -- to treat pattern as a literal argument, preventing injection
         cmd.append('--')
         cmd.append(search_pattern)

src/code_index_mcp/search/ripgrep.py

@@ -69,6 +69,31 @@ def search(
         if file_pattern:
             cmd.extend(['--glob', file_pattern])
 
+        exclude_dirs = getattr(self, 'exclude_dirs', [])
+        exclude_file_patterns = getattr(self, 'exclude_file_patterns', [])
+
+        processed_patterns = set()
+
+        for directory in exclude_dirs:
+            normalized = directory.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            cmd.extend(['--glob', f'!**/{normalized}/**'])
+            processed_patterns.add(normalized)
+
+        for pattern in exclude_file_patterns:
+            normalized = pattern.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            if normalized.startswith('!'):
+                glob_pattern = normalized
+            elif any(ch in normalized for ch in '*?[') or '/' in normalized:
+                glob_pattern = f'!{normalized}'
+            else:
+                glob_pattern = f'!**/{normalized}'
+            cmd.extend(['--glob', glob_pattern])
+            processed_patterns.add(normalized)
+
         # Add -- to treat pattern as a literal argument, preventing injection
         cmd.append('--')
         cmd.append(search_pattern)

src/code_index_mcp/search/ugrep.py

@@ -69,6 +69,30 @@ def search(
         if file_pattern:
             cmd.extend(['--include', file_pattern])
 
+        processed_patterns = set()
+        exclude_dirs = getattr(self, 'exclude_dirs', [])
+        exclude_file_patterns = getattr(self, 'exclude_file_patterns', [])
+
+        for directory in exclude_dirs:
+            normalized = directory.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            cmd.extend(['--ignore', f'**/{normalized}/**'])
+            processed_patterns.add(normalized)
+
+        for pattern in exclude_file_patterns:
+            normalized = pattern.strip()
+            if not normalized or normalized in processed_patterns:
+                continue
+            if normalized.startswith('!'):
+                ignore_pattern = normalized[1:]
+            elif any(ch in normalized for ch in '*?[') or '/' in normalized:
+                ignore_pattern = normalized
+            else:
+                ignore_pattern = f'**/{normalized}'
+            cmd.extend(['--ignore', ignore_pattern])
+            processed_patterns.add(normalized)
+
         # Add '--' to treat pattern as a literal argument, preventing injection
         cmd.append('--')
         cmd.append(pattern)