Add wildcard search mode and fix regex match length in ripgrep search

Adds a Wildcard checkbox (mutually exclusive with Regex) where * matches
any characters and ? matches any single character, with all other special
chars treated as literals. Also fixes a bug where ripgrep search used
pattern length instead of actual match length for regex matches.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ozgesolidkey

src/main/fileHandler.ts

@@ -3,6 +3,13 @@ import * as readline from 'readline';
 import { spawn } from 'child_process';
 import { FileInfo, LineData, SearchMatch, SearchOptions } from '../shared/types';
 
+// Convert wildcard pattern to regex string: * = .*, ? = ., rest escaped
+function wildcardToRegex(pattern: string): string {
+  return pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+}
+
 // Shared column filter utility — filters a line to only visible columns
 export interface ColumnConfig {
   delimiter: string;
@@ -334,6 +341,25 @@ export class FileHandler {
     const matches: SearchMatch[] = [];
     const MAX_MATCHES = 50000;
 
+    // Determine the effective regex pattern and whether ripgrep should use regex mode
+    const useRegexMode = options.isRegex || options.isWildcard;
+    let rgPattern = options.pattern;
+    if (options.isWildcard) {
+      rgPattern = wildcardToRegex(options.pattern);
+    }
+
+    // Pre-compile regex for determining actual match length (ripgrep doesn't report it)
+    let searchRegex: RegExp | null = null;
+    if (useRegexMode) {
+      try {
+        const flags = options.matchCase ? '' : 'i';
+        searchRegex = new RegExp(rgPattern, flags);
+      } catch {
+        // Invalid regex - ripgrep will also fail, return empty
+        return [];
+      }
+    }
+
     // Build ripgrep arguments
     const args: string[] = [
       '--line-number',
@@ -350,15 +376,15 @@ export class FileHandler {
       args.push('--word-regexp');
     }
 
-    if (!options.isRegex) {
+    if (!useRegexMode) {
       args.push('--fixed-strings');
     }
 
     // Limit matches
     args.push('--max-count', String(MAX_MATCHES));
 
     // Add pattern and file
-    args.push('--', options.pattern, this.filePath);
+    args.push('--', rgPattern, this.filePath);
 
     return new Promise((resolve) => {
       const proc = spawn('rg', args);
@@ -396,10 +422,20 @@ export class FileHandler {
           const adjustedLineNum = lineNum - 1 - this.headerLineCount;
           if (adjustedLineNum < 0) continue;
 
+          // For regex patterns, determine actual match length from the line text
+          let matchLength = options.pattern.length;
+          if (searchRegex) {
+            const textFromMatch = lineText.substring(column - 1);
+            const reMatch = searchRegex.exec(textFromMatch);
+            if (reMatch && reMatch.index === 0) {
+              matchLength = reMatch[0].length;
+            }
+          }
+
           matches.push({
             lineNumber: adjustedLineNum,
             column: column - 1, // ripgrep uses 1-based columns
-            length: options.pattern.length,
+            length: matchLength,
             lineText,
           });
 
@@ -464,6 +500,12 @@ export class FileHandler {
       const flags = options.matchCase ? 'g' : 'gi';
       if (options.isRegex) {
         regex = new RegExp(options.pattern, flags);
+      } else if (options.isWildcard) {
+        let converted = wildcardToRegex(options.pattern);
+        if (options.wholeWord) {
+          converted = `\\b${converted}\\b`;
+        }
+        regex = new RegExp(converted, flags);
       } else {
         let escaped = options.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         if (options.wholeWord) {

src/preload/index.ts

@@ -60,7 +60,7 @@ const api = {
     ipcRenderer.invoke('check-search-engine'),
 
   // Search
-  search: (options: { pattern: string; isRegex: boolean; matchCase: boolean; wholeWord: boolean; columnConfig?: { delimiter: string; columns: Array<{ index: number; visible: boolean }> } }): Promise<{ success: boolean; matches?: any[]; error?: string }> =>
+  search: (options: { pattern: string; isRegex: boolean; isWildcard: boolean; matchCase: boolean; wholeWord: boolean; columnConfig?: { delimiter: string; columns: Array<{ index: number; visible: boolean }> } }): Promise<{ success: boolean; matches?: any[]; error?: string }> =>
     ipcRenderer.invoke(IPC.SEARCH, options),
 
   cancelSearch: (): Promise<{ success: boolean }> =>

src/renderer/index.html

@@ -36,6 +36,9 @@
           <label class="checkbox-label">
             <input type="checkbox" id="search-regex"> Regex
           </label>
+          <label class="checkbox-label">
+            <input type="checkbox" id="search-wildcard"> Wildcard
+          </label>
           <label class="checkbox-label">
             <input type="checkbox" id="search-case"> Match Case
           </label>

src/renderer/renderer.ts

@@ -606,6 +606,7 @@ const elements = {
   btnToggleSidebar: document.getElementById('btn-toggle-sidebar') as HTMLButtonElement,
   searchInput: document.getElementById('search-input') as HTMLInputElement,
   searchRegex: document.getElementById('search-regex') as HTMLInputElement,
+  searchWildcard: document.getElementById('search-wildcard') as HTMLInputElement,
   searchCase: document.getElementById('search-case') as HTMLInputElement,
   searchWholeWord: document.getElementById('search-whole-word') as HTMLInputElement,
   searchResultCount: document.getElementById('search-result-count') as HTMLSpanElement,
@@ -1580,6 +1581,7 @@ function applySearchHighlightsRaw(text: string, lineNumber: number): { searchRan
   // Get the search pattern
   const pattern = elements.searchInput.value;
   const isRegex = elements.searchRegex.checked;
+  const isWildcard = elements.searchWildcard.checked;
   const matchCase = elements.searchCase.checked;
 
   const searchRanges: SearchRange[] = [];
@@ -1588,6 +1590,12 @@ function applySearchHighlightsRaw(text: string, lineNumber: number): { searchRan
     let searchRegex: RegExp;
     if (isRegex) {
       searchRegex = new RegExp(pattern, matchCase ? 'g' : 'gi');
+    } else if (isWildcard) {
+      // Wildcard mode: * = any chars, ? = any single char, rest literal
+      const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+      searchRegex = new RegExp(escaped, matchCase ? 'g' : 'gi');
     } else {
       // Escape special regex chars for literal search
       const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -3472,6 +3480,7 @@ async function performSearch(): Promise<void> {
     const searchOptions: SearchOptions = {
       pattern,
       isRegex: elements.searchRegex.checked,
+      isWildcard: elements.searchWildcard.checked,
       matchCase: elements.searchCase.checked,
       wholeWord: elements.searchWholeWord.checked,
     };
@@ -4664,6 +4673,7 @@ async function navigateHighlight(highlightId: string, direction: 'prev' | 'next'
     const result = await window.api.search({
       pattern: highlight.pattern,
       isRegex: highlight.isRegex,
+      isWildcard: false,
       matchCase: highlight.matchCase,
       wholeWord: highlight.wholeWord,
     });
@@ -5816,6 +5826,18 @@ function init(): void {
   elements.btnPrevResult.addEventListener('click', () => navigateSearchPrev());
   elements.btnNextResult.addEventListener('click', () => navigateSearchNext());
 
+  // Regex and Wildcard are mutually exclusive
+  elements.searchRegex.addEventListener('change', () => {
+    if (elements.searchRegex.checked) {
+      elements.searchWildcard.checked = false;
+    }
+  });
+  elements.searchWildcard.addEventListener('change', () => {
+    if (elements.searchWildcard.checked) {
+      elements.searchRegex.checked = false;
+    }
+  });
+
   // Search options popup
   elements.btnSearchOptions.addEventListener('click', (e) => {
     e.stopPropagation();

src/renderer/types.d.ts

@@ -36,6 +36,7 @@ interface SearchColumnConfig {
 interface SearchOptions {
   pattern: string;
   isRegex: boolean;
+  isWildcard: boolean;
   matchCase: boolean;
   wholeWord: boolean;
   columnConfig?: SearchColumnConfig;

src/shared/types.ts

@@ -27,6 +27,7 @@ export interface SearchColumnConfig {
 export interface SearchOptions {
   pattern: string;
   isRegex: boolean;
+  isWildcard: boolean;
   matchCase: boolean;
   wholeWord: boolean;
   columnConfig?: SearchColumnConfig;

src/tests/benchmark.test.ts

@@ -264,6 +264,7 @@ describe('Logan Benchmark', () => {
         const matches = await handler.search({
           pattern: 'Timeout waiting',
           isRegex: false,
+          isWildcard: false,
           matchCase: false,
           wholeWord: false,
         });
@@ -297,6 +298,7 @@ describe('Logan Benchmark', () => {
         const matches = await handler.search({
           pattern: 'user_\\d{1,3}\\s+authenticated',
           isRegex: true,
+          isWildcard: false,
           matchCase: false,
           wholeWord: false,
         });