Add search history with up/down arrow navigation

- Last 50 searches stored in localStorage
- Up/Down arrows in search input navigate through history
- Deduplication: repeated patterns move to top instead of duplicating
- Current input is stashed and restored when navigating back

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ozgesolidkey

src/main/index.ts

@@ -4695,8 +4695,27 @@ function streamFormatJson(inputPath: string, outputPath: string, onProgress?: (p
       }
     };
 
+    // Shallow JSON formatter: expands only top-level keys to one line each,
+    // keeping nested values compact. Limits line explosion for large JSONL files.
+    const shallowFormat = (obj: any): string => {
+      if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+        return JSON.stringify(obj);
+      }
+      const keys = Object.keys(obj);
+      if (keys.length === 0) return '{}';
+      const lines = ['{'];
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const val = JSON.stringify(obj[k]);
+        const comma = i < keys.length - 1 ? ',' : '';
+        lines.push(`  ${JSON.stringify(k)}: ${val}${comma}`);
+      }
+      lines.push('}');
+      return lines.join('\n');
+    };
+
     if (isJsonl) {
-      // JSONL: format each line independently
+      // JSONL: format each line with shallow expansion (top-level keys only)
       let lineBuffer = '';
 
       readStream.on('data', (rawChunk: string | Buffer) => {
@@ -4705,28 +4724,26 @@ function streamFormatJson(inputPath: string, outputPath: string, onProgress?: (p
 
         lineBuffer += chunk;
         const lines = lineBuffer.split('\n');
-        lineBuffer = lines.pop() || ''; // Keep incomplete last line
+        lineBuffer = lines.pop() || '';
 
         for (const line of lines) {
           const trimmed = line.trim();
           if (!trimmed) { write('\n'); continue; }
           try {
             const obj = JSON.parse(trimmed);
-            write(JSON.stringify(obj, null, 2) + '\n');
+            write(shallowFormat(obj) + '\n');
           } catch {
-            // Not valid JSON — write as-is
             write(trimmed + '\n');
           }
         }
       });
 
       readStream.on('end', () => {
-        // Process remaining buffer
         const trimmed = lineBuffer.trim();
         if (trimmed) {
           try {
             const obj = JSON.parse(trimmed);
-            write(JSON.stringify(obj, null, 2) + '\n');
+            write(shallowFormat(obj) + '\n');
           } catch {
             write(trimmed + '\n');
           }
@@ -4846,7 +4863,6 @@ ipcMain.handle('format-json-file', async (_, filePath: string) => {
     });
 
     const writtenStats = fs.statSync(formattedPath);
-    console.log(`[JSON Format] Done. Output: ${writtenStats.size} bytes`);
 
     if (writtenStats.size > MAX_FORMATTED_SIZE) {
       // Clean up - file too large to index efficiently

src/renderer/renderer.ts

@@ -8942,9 +8942,57 @@ function applyColumnFilter(text: string): string {
 }
 
 // Search
+// ─── Search History ──────────────────────────────────────────────
+const SEARCH_HISTORY_KEY = 'logan-search-history';
+const SEARCH_HISTORY_MAX = 50;
+let searchHistory: string[] = (() => {
+  try { return JSON.parse(localStorage.getItem(SEARCH_HISTORY_KEY) || '[]'); }
+  catch { return []; }
+})();
+let searchHistoryIndex = -1; // -1 means "not navigating, showing current input"
+let searchHistoryStash = ''; // What user typed before starting to navigate history
+
+function addToSearchHistory(pattern: string): void {
+  if (!pattern.trim()) return;
+  // Remove existing duplicate, then add to top
+  searchHistory = searchHistory.filter(p => p !== pattern);
+  searchHistory.unshift(pattern);
+  if (searchHistory.length > SEARCH_HISTORY_MAX) {
+    searchHistory = searchHistory.slice(0, SEARCH_HISTORY_MAX);
+  }
+  try { localStorage.setItem(SEARCH_HISTORY_KEY, JSON.stringify(searchHistory)); } catch {}
+  searchHistoryIndex = -1;
+}
+
+function navigateSearchHistory(direction: 'up' | 'down'): void {
+  if (searchHistory.length === 0) return;
+  if (direction === 'up') {
+    if (searchHistoryIndex === -1) {
+      searchHistoryStash = elements.searchInput.value;
+      searchHistoryIndex = 0;
+    } else if (searchHistoryIndex < searchHistory.length - 1) {
+      searchHistoryIndex++;
+    }
+    elements.searchInput.value = searchHistory[searchHistoryIndex];
+  } else {
+    if (searchHistoryIndex === -1) return;
+    if (searchHistoryIndex === 0) {
+      searchHistoryIndex = -1;
+      elements.searchInput.value = searchHistoryStash;
+    } else {
+      searchHistoryIndex--;
+      elements.searchInput.value = searchHistory[searchHistoryIndex];
+    }
+  }
+  // Move cursor to end
+  const len = elements.searchInput.value.length;
+  elements.searchInput.setSelectionRange(len, len);
+}
+
 async function performSearch(): Promise<void> {
   const pattern = elements.searchInput.value;
   if (!pattern || !state.filePath) return;
+  addToSearchHistory(pattern);
 
   showProgress('Searching...');
 
@@ -11891,6 +11939,12 @@ function setupKeyboardShortcuts(): void {
       performSearch();
     }
 
+    // Up/Down arrows in search input: navigate history
+    if (document.activeElement === elements.searchInput && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
+      e.preventDefault();
+      navigateSearchHistory(e.key === 'ArrowUp' ? 'up' : 'down');
+    }
+
     // F3 or Ctrl/Cmd + G: Next search result (respects direction)
     if (e.key === 'F3' || ((e.ctrlKey || e.metaKey) && e.key === 'g')) {
       e.preventDefault();