feat: enhance regex handling in search functions with auto-detection and improved safety checks

Author: johnhuang316

src/code_index_mcp/search/base.py

@@ -100,22 +100,45 @@ def is_safe_regex_pattern(pattern: str) -> bool:
     Returns:
         True if the pattern looks like a safe regex, False otherwise
     """
-    # Allow basic regex operators that are commonly used and safe
-    safe_regex_chars = ['|', '(', ')', '[', ']', '^', '$']
+    # Strong indicators of regex intent
+    strong_regex_indicators = ['|', '(', ')', '[', ']', '^', '$']
 
-    # Check if pattern contains any regex metacharacters
-    has_regex_chars = any(char in pattern for char in safe_regex_chars)
+    # Weaker indicators that need context
+    weak_regex_indicators = ['.', '*', '+', '?']
 
-    # Basic safety check - avoid obviously dangerous patterns
-    dangerous_patterns = [
-        r'(.+)+',  # Nested quantifiers
-        r'(.*)*',  # Nested stars
-        r'(.{0,})+',  # Potential ReDoS patterns
-    ]
+    # Check for strong regex indicators
+    has_strong_regex = any(char in pattern for char in strong_regex_indicators)
 
-    has_dangerous_patterns = any(dangerous in pattern for dangerous in dangerous_patterns)
+    # Check for weak indicators with context
+    has_weak_regex = any(char in pattern for char in weak_regex_indicators)
 
-    return has_regex_chars and not has_dangerous_patterns
+    # If has strong indicators, likely regex
+    if has_strong_regex:
+        # Still check for dangerous patterns
+        dangerous_patterns = [
+            r'(.+)+',  # Nested quantifiers
+            r'(.*)*',  # Nested stars
+            r'(.{0,})+',  # Potential ReDoS patterns
+        ]
+        
+        has_dangerous_patterns = any(dangerous in pattern for dangerous in dangerous_patterns)
+        return not has_dangerous_patterns
+    
+    # If only weak indicators, need more context
+    if has_weak_regex:
+        # Patterns like ".*", ".+", "file.*py" look like regex
+        # But "file.txt", "test.py" look like literal filenames
+        regex_like_patterns = [
+            r'\.\*',  # .*
+            r'\.\+',  # .+
+            r'\.\w*\*',  # .something*
+            r'\*\.',  # *.
+            r'\w+\.\*\w*',  # word.*word
+        ]
+        
+        return any(re.search(regex_pattern, pattern) for regex_pattern in regex_like_patterns)
+    
+    return False
 
 
 class SearchStrategy(ABC):

src/code_index_mcp/server.py

@@ -115,7 +115,7 @@ def search_code_advanced(
     context_lines: int = 0,
     file_pattern: str = None,
     fuzzy: bool = False,
-    regex: bool = False
+    regex: bool = None
 ) -> Dict[str, Any]:
     """
     Search for a code pattern in the project using an advanced, fast tool.
@@ -141,9 +141,11 @@ def search_code_advanced(
                IMPORTANT: Only ugrep provides true fuzzy search. Other tools use word boundary
                matching which allows partial matches at word boundaries.
                For exact literal matches, set fuzzy=False (default and recommended).
-        regex: If True, enables regex pattern matching. Use this for patterns like "ERROR|WARN".
-               The pattern will be validated for safety to prevent ReDoS attacks.
-               If False (default), uses literal string search.
+        regex: Controls regex pattern matching behavior:
+               - If True, enables regex pattern matching
+               - If False, forces literal string search
+               - If None (default), automatically detects regex patterns and enables regex for patterns like "ERROR|WARN"
+               The pattern will always be validated for safety to prevent ReDoS attacks.
 
     Returns:
         A dictionary containing the search results or an error message.

src/code_index_mcp/services/search_service.py

@@ -9,6 +9,7 @@
 
 from .base_service import BaseService
 from ..utils import ValidationHelper, ResponseFormatter
+from ..search.base import is_safe_regex_pattern
 
 
 class SearchService(BaseService):
@@ -30,7 +31,7 @@ def search_code(  # pylint: disable=too-many-arguments
         context_lines: int = 0,
         file_pattern: Optional[str] = None,
         fuzzy: bool = False,
-        regex: bool = False
+        regex: Optional[bool] = None
     ) -> Dict[str, Any]:
         """
         Search for code patterns in the project.
@@ -43,7 +44,7 @@ def search_code(  # pylint: disable=too-many-arguments
             context_lines: Number of context lines to show
             file_pattern: Glob pattern to filter files
             fuzzy: Whether to enable fuzzy matching
-            regex: Whether pattern is a regex
+            regex: Regex mode - True/False to force, None for auto-detection
 
         Returns:
             Dictionary with search results or error information
@@ -53,6 +54,12 @@ def search_code(  # pylint: disable=too-many-arguments
         """
         self._require_project_setup()
 
+        # Smart regex detection if regex parameter is None
+        if regex is None:
+            regex = is_safe_regex_pattern(pattern)
+            if regex:
+                print(f"Auto-detected regex pattern: {pattern}")
+
         # Validate search pattern
         error = ValidationHelper.validate_search_pattern(pattern, regex)
         if error: