Add folder search with terminal-style results

- Add search input to folders sidebar section
- Implement ripgrep-based folder search across all opened folders
- Display results in terminal format (file:line: content)
- Highlight search matches in results
- Click result to open file at matching line
- Support search progress updates and cancellation

Author: ozgesolidkey

src/main/index.ts

@@ -355,6 +355,127 @@ ipcMain.handle(IPC.READ_FOLDER, async (_, folderPath: string) => {
   }
 });
 
+// === Folder Search ===
+let folderSearchSignal: { cancelled: boolean } = { cancelled: false };
+
+ipcMain.handle(IPC.FOLDER_SEARCH, async (_, folderPaths: string[], pattern: string, options: { isRegex: boolean; matchCase: boolean }) => {
+  folderSearchSignal = { cancelled: false };
+
+  if (!folderPaths.length || !pattern) {
+    return { success: false, error: 'No folders or pattern provided' };
+  }
+
+  const matches: Array<{ filePath: string; fileName: string; lineNumber: number; column: number; lineText: string }> = [];
+  const MAX_MATCHES = 1000;
+
+  try {
+    // Build ripgrep arguments
+    const args: string[] = [
+      '--line-number',
+      '--column',
+      '--no-heading',
+      '--with-filename',
+      '--max-count', '100', // Limit matches per file
+    ];
+
+    if (!options.matchCase) {
+      args.push('--ignore-case');
+    }
+
+    if (options.isRegex) {
+      args.push('--regexp', pattern);
+    } else {
+      args.push('--fixed-strings', pattern);
+    }
+
+    // Add file type filters for text files
+    for (const ext of TEXT_EXTENSIONS) {
+      args.push('--glob', `*${ext}`);
+    }
+    args.push('--glob', '!.*'); // Exclude hidden files
+
+    // Add folder paths
+    args.push(...folderPaths);
+
+    return new Promise((resolve) => {
+      const proc = spawn('rg', args);
+      let buffer = '';
+      let lastProgressUpdate = 0;
+
+      proc.stdout.on('data', (data: Buffer) => {
+        if (folderSearchSignal.cancelled) {
+          proc.kill();
+          return;
+        }
+
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (!line) continue;
+
+          // Parse ripgrep output: filename:line:column:text
+          const colonIndex1 = line.indexOf(':');
+          if (colonIndex1 === -1) continue;
+
+          const colonIndex2 = line.indexOf(':', colonIndex1 + 1);
+          if (colonIndex2 === -1) continue;
+
+          const colonIndex3 = line.indexOf(':', colonIndex2 + 1);
+          if (colonIndex3 === -1) continue;
+
+          const filePath = line.substring(0, colonIndex1);
+          const lineNum = parseInt(line.substring(colonIndex1 + 1, colonIndex2), 10);
+          const column = parseInt(line.substring(colonIndex2 + 1, colonIndex3), 10);
+          const lineText = line.substring(colonIndex3 + 1);
+
+          if (isNaN(lineNum) || isNaN(column)) continue;
+
+          matches.push({
+            filePath,
+            fileName: path.basename(filePath),
+            lineNumber: lineNum,
+            column: column - 1,
+            lineText: lineText.length > 500 ? lineText.substring(0, 500) + '...' : lineText,
+          });
+
+          if (matches.length >= MAX_MATCHES) {
+            proc.kill();
+            break;
+          }
+        }
+
+        // Send progress updates
+        const now = Date.now();
+        if (now - lastProgressUpdate > 100) {
+          lastProgressUpdate = now;
+          mainWindow?.webContents.send(IPC.FOLDER_SEARCH_PROGRESS, { matchCount: matches.length });
+        }
+      });
+
+      proc.on('error', () => {
+        resolve({ success: false, error: 'ripgrep not available. Install with: brew install ripgrep' });
+      });
+
+      proc.on('close', () => {
+        if (folderSearchSignal.cancelled) {
+          resolve({ success: true, matches, cancelled: true });
+        } else {
+          resolve({ success: true, matches });
+        }
+      });
+    });
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle(IPC.FOLDER_SEARCH_CANCEL, async () => {
+  folderSearchSignal.cancelled = true;
+  return { success: true };
+});
+
 // === Column Analysis ===
 
 interface ColumnInfo {

src/preload/index.ts

@@ -10,6 +10,9 @@ const IPC = {
   SEARCH_CANCEL: 'search-cancel',
   OPEN_FOLDER_DIALOG: 'open-folder-dialog',
   READ_FOLDER: 'read-folder',
+  FOLDER_SEARCH: 'folder-search',
+  FOLDER_SEARCH_PROGRESS: 'folder-search-progress',
+  FOLDER_SEARCH_CANCEL: 'folder-search-cancel',
 } as const;
 
 // API exposed to renderer
@@ -31,6 +34,19 @@ const api = {
   readFolder: (folderPath: string): Promise<{ success: boolean; files?: Array<{ name: string; path: string; isDirectory: boolean; size?: number }>; folderPath?: string; error?: string }> =>
     ipcRenderer.invoke(IPC.READ_FOLDER, folderPath),
 
+  // Folder search
+  folderSearch: (folderPaths: string[], pattern: string, options: { isRegex: boolean; matchCase: boolean }): Promise<{ success: boolean; matches?: Array<{ filePath: string; fileName: string; lineNumber: number; column: number; lineText: string }>; cancelled?: boolean; error?: string }> =>
+    ipcRenderer.invoke(IPC.FOLDER_SEARCH, folderPaths, pattern, options),
+
+  cancelFolderSearch: (): Promise<{ success: boolean }> =>
+    ipcRenderer.invoke(IPC.FOLDER_SEARCH_CANCEL),
+
+  onFolderSearchProgress: (callback: (data: { matchCount: number }) => void): (() => void) => {
+    const handler = (_: any, data: { matchCount: number }) => callback(data);
+    ipcRenderer.on(IPC.FOLDER_SEARCH_PROGRESS, handler);
+    return () => ipcRenderer.removeListener(IPC.FOLDER_SEARCH_PROGRESS, handler);
+  },
+
   getFileInfo: (): Promise<{ success: boolean; info?: any; error?: string }> =>
     ipcRenderer.invoke('get-file-info'),
 

src/renderer/index.html

@@ -61,6 +61,12 @@
             <button id="btn-add-folder" class="section-btn" title="Open folder">+</button>
           </div>
           <div class="section-content">
+            <div class="folder-search-container">
+              <input type="text" id="folder-search-input" class="folder-search-input" placeholder="Search in folders..." disabled>
+              <button id="btn-folder-search" class="folder-search-btn" title="Search" disabled>&#128269;</button>
+              <button id="btn-folder-search-cancel" class="folder-search-btn hidden" title="Cancel">&#10005;</button>
+            </div>
+            <div id="folder-search-results" class="folder-search-results hidden"></div>
             <div id="folders-list" class="folders-content">
               <p class="placeholder">No folders open</p>
             </div>

src/renderer/renderer.ts

@@ -165,6 +165,9 @@ interface AppState {
   columnConfig: ColumnConfig | null;
   // Notes file tracking
   currentNotesFile: string | null;
+  // Folder search
+  folderSearchResults: FolderSearchMatch[];
+  isFolderSearching: boolean;
 }
 
 const state: AppState = {
@@ -191,6 +194,8 @@ const state: AppState = {
   folders: [],
   columnConfig: null,
   currentNotesFile: null,
+  folderSearchResults: [],
+  isFolderSearching: false,
 };
 
 // Constants
@@ -247,6 +252,10 @@ const elements = {
   welcomeMessage: document.getElementById('welcome-message') as HTMLDivElement,
   foldersList: document.getElementById('folders-list') as HTMLDivElement,
   btnAddFolder: document.getElementById('btn-add-folder') as HTMLButtonElement,
+  folderSearchInput: document.getElementById('folder-search-input') as HTMLInputElement,
+  btnFolderSearch: document.getElementById('btn-folder-search') as HTMLButtonElement,
+  btnFolderSearchCancel: document.getElementById('btn-folder-search-cancel') as HTMLButtonElement,
+  folderSearchResults: document.getElementById('folder-search-results') as HTMLDivElement,
   fileStats: document.getElementById('file-stats') as HTMLDivElement,
   analysisResults: document.getElementById('analysis-results') as HTMLDivElement,
   analysisProgress: document.getElementById('analysis-progress') as HTMLDivElement,
@@ -1757,12 +1766,17 @@ async function openFolder(): Promise<void> {
       collapsed: false,
     });
     renderFolderTree();
+    updateFolderSearchState();
   }
 }
 
 function removeFolder(folderPath: string): void {
   state.folders = state.folders.filter((f) => f.path !== folderPath);
   renderFolderTree();
+  updateFolderSearchState();
+  if (state.folders.length === 0) {
+    closeFolderSearchResults();
+  }
 }
 
 function toggleFolder(folderPath: string): void {
@@ -1849,6 +1863,114 @@ function renderFolderTree(): void {
   });
 }
 
+// === Folder Search ===
+
+function updateFolderSearchState(): void {
+  const hasFolders = state.folders.length > 0;
+  elements.folderSearchInput.disabled = !hasFolders;
+  elements.btnFolderSearch.disabled = !hasFolders;
+}
+
+async function performFolderSearch(): Promise<void> {
+  const pattern = elements.folderSearchInput.value.trim();
+  if (!pattern || state.folders.length === 0) return;
+
+  state.isFolderSearching = true;
+  state.folderSearchResults = [];
+
+  elements.btnFolderSearch.classList.add('hidden');
+  elements.btnFolderSearchCancel.classList.remove('hidden');
+  elements.folderSearchResults.classList.remove('hidden');
+  elements.folderSearchResults.innerHTML = '<div class="folder-search-searching">Searching...</div>';
+
+  const unsubscribe = window.api.onFolderSearchProgress((data) => {
+    if (state.isFolderSearching) {
+      elements.folderSearchResults.innerHTML = `<div class="folder-search-searching">Searching... ${data.matchCount} matches found</div>`;
+    }
+  });
+
+  try {
+    const folderPaths = state.folders.map(f => f.path);
+    const result = await window.api.folderSearch(folderPaths, pattern, { isRegex: false, matchCase: false });
+
+    if (result.success && result.matches) {
+      state.folderSearchResults = result.matches;
+      renderFolderSearchResults(pattern, result.cancelled);
+    } else {
+      elements.folderSearchResults.innerHTML = `<div class="folder-search-searching">${result.error || 'Search failed'}</div>`;
+    }
+  } catch (error) {
+    elements.folderSearchResults.innerHTML = `<div class="folder-search-searching">Error: ${error}</div>`;
+  } finally {
+    unsubscribe();
+    state.isFolderSearching = false;
+    elements.btnFolderSearch.classList.remove('hidden');
+    elements.btnFolderSearchCancel.classList.add('hidden');
+  }
+}
+
+function cancelFolderSearch(): void {
+  if (state.isFolderSearching) {
+    window.api.cancelFolderSearch();
+  }
+}
+
+function closeFolderSearchResults(): void {
+  state.folderSearchResults = [];
+  elements.folderSearchResults.classList.add('hidden');
+  elements.folderSearchResults.innerHTML = '';
+}
+
+function highlightMatch(text: string, pattern: string): string {
+  const escaped = escapeHtml(text);
+  const patternEscaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`(${patternEscaped})`, 'gi');
+  return escaped.replace(regex, '<span class="folder-search-match">$1</span>');
+}
+
+function renderFolderSearchResults(pattern: string, cancelled?: boolean): void {
+  const matches = state.folderSearchResults;
+
+  if (matches.length === 0) {
+    elements.folderSearchResults.innerHTML = '<div class="folder-search-searching">No matches found</div>';
+    return;
+  }
+
+  const header = `
+    <div class="folder-search-header">
+      <span>${matches.length}${cancelled ? '+' : ''} match${matches.length !== 1 ? 'es' : ''}</span>
+      <button class="folder-search-close" title="Close">&times;</button>
+    </div>
+  `;
+
+  const items = matches.map((match, index) => {
+    const relPath = match.filePath;
+    const lineText = match.lineText.length > 200 ? match.lineText.substring(0, 200) + '...' : match.lineText;
+
+    return `
+      <div class="folder-search-item" data-index="${index}">
+        <span class="folder-search-file">${escapeHtml(match.fileName)}</span>:<span class="folder-search-line">${match.lineNumber}</span>: <span class="folder-search-text">${highlightMatch(lineText, pattern)}</span>
+      </div>
+    `;
+  }).join('');
+
+  elements.folderSearchResults.innerHTML = header + items;
+
+  // Add event listeners
+  elements.folderSearchResults.querySelector('.folder-search-close')?.addEventListener('click', closeFolderSearchResults);
+
+  elements.folderSearchResults.querySelectorAll('.folder-search-item').forEach((item) => {
+    item.addEventListener('click', async () => {
+      const index = parseInt((item as HTMLElement).dataset.index || '0', 10);
+      const match = state.folderSearchResults[index];
+      if (match) {
+        await loadFile(match.filePath);
+        goToLine(match.lineNumber - 1); // Convert to 0-based
+      }
+    });
+  });
+}
+
 async function loadFile(filePath: string, createNewTab: boolean = true): Promise<void> {
   // Check if file is already open in a tab BEFORE calling backend
   const existingTab = findTabByFilePath(filePath);
@@ -3374,6 +3496,17 @@ function init(): void {
   // Folder operations
   elements.btnAddFolder.addEventListener('click', openFolder);
 
+  // Folder search
+  elements.btnFolderSearch.addEventListener('click', performFolderSearch);
+  elements.btnFolderSearchCancel.addEventListener('click', cancelFolderSearch);
+  elements.folderSearchInput.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter') {
+      performFolderSearch();
+    } else if (e.key === 'Escape') {
+      closeFolderSearchResults();
+    }
+  });
+
   // Search
   elements.btnSearch.addEventListener('click', performSearch);
   elements.btnPrevResult.addEventListener('click', () => {