Add column filtering, highlight groups, and window controls

- Column filter utility for search/save operations with visible columns
- Highlight group CRUD: save, load, delete groups via ~/.logan/highlight-groups.json
- Frameless window with native traffic lights (macOS) and custom controls
- Window minimize/maximize/close IPC handlers
- Bookmark lineText field for storing line content
- Updated saveSelectedLines and saveToNotes to support column config

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

Author: ozgesolidkey

src/main/fileHandler.ts

@@ -3,6 +3,27 @@ import * as readline from 'readline';
 import { spawn } from 'child_process';
 import { FileInfo, LineData, SearchMatch, SearchOptions } from '../shared/types';
 
+// Shared column filter utility — filters a line to only visible columns
+export interface ColumnConfig {
+  delimiter: string;
+  columns: Array<{ index: number; visible: boolean }>;
+}
+
+export function filterLineToVisibleColumns(
+  line: string,
+  columnConfig: ColumnConfig | undefined
+): string {
+  if (!columnConfig) return line;
+  if (!columnConfig.columns.some(c => !c.visible)) return line;
+
+  const { delimiter, columns } = columnConfig;
+  const parts = delimiter === ' ' ? line.split(/\s+/) : line.split(delimiter);
+  const visibleParts = parts.filter((_, idx) =>
+    idx < columns.length ? columns[idx].visible : true
+  );
+  return visibleParts.join(delimiter === ' ' ? ' ' : delimiter);
+}
+
 // Check if ripgrep is available
 let ripgrepAvailable: boolean | null = null;
 async function checkRipgrep(): Promise<boolean> {
@@ -295,13 +316,21 @@ export class FileHandler {
     return this.searchWithStream(options, onProgress, signal);
   }
 
+  // NOTE: searchWithRipgrep does NOT support column filtering.
+  // It searches raw file text. When columns are hidden, the caller (search())
+  // must route to searchWithStream() instead, which applies column filtering.
   private async searchWithRipgrep(
     options: SearchOptions,
     onProgress?: (percent: number, matchCount: number) => void,
     signal?: { cancelled: boolean }
   ): Promise<SearchMatch[]> {
     if (!this.filePath) return [];
 
+    // Defensive: refuse to run if column filtering is active
+    if (options.columnConfig && options.columnConfig.columns.some(c => !c.visible)) {
+      return this.searchWithStream(options, onProgress, signal);
+    }
+
     const matches: SearchMatch[] = [];
     const MAX_MATCHES = 50000;
 
@@ -413,28 +442,12 @@ export class FileHandler {
     });
   }
 
-  // Helper to filter line to visible columns
+  // Helper to filter line to visible columns (delegates to shared utility)
   private filterLineToVisibleColumns(
     line: string,
     columnConfig: SearchOptions['columnConfig']
   ): string {
-    if (!columnConfig) return line;
-
-    const { delimiter, columns } = columnConfig;
-    let parts: string[];
-
-    if (delimiter === ' ') {
-      parts = line.split(/\s+/);
-    } else {
-      parts = line.split(delimiter);
-    }
-
-    // Build filtered text with only visible columns
-    const visibleParts = parts.filter((_, idx) => {
-      return idx < columns.length ? columns[idx].visible : true;
-    });
-
-    return visibleParts.join(delimiter === ' ' ? ' ' : delimiter);
+    return filterLineToVisibleColumns(line, columnConfig);
   }
 
   private async searchWithStream(

src/main/index.ts

@@ -4,8 +4,8 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { spawn } from 'child_process';
 import * as pty from 'node-pty';
-import { FileHandler } from './fileHandler';
-import { IPC, SearchOptions, Bookmark, Highlight } from '../shared/types';
+import { FileHandler, filterLineToVisibleColumns, ColumnConfig } from './fileHandler';
+import { IPC, SearchOptions, Bookmark, Highlight, HighlightGroup } from '../shared/types';
 import { analyzerRegistry, AnalyzerOptions } from './analyzers';
 
 let mainWindow: BrowserWindow | null = null;
@@ -47,6 +47,7 @@ const highlights = new Map<string, Highlight>();
 // Config folder path (~/.logan/)
 const getConfigDir = () => path.join(os.homedir(), '.logan');
 const getHighlightsPath = () => path.join(getConfigDir(), 'highlights.json');
+const getHighlightGroupsPath = () => path.join(getConfigDir(), 'highlight-groups.json');
 const getBookmarksPath = () => path.join(getConfigDir(), 'bookmarks.json');
 
 // Ensure config directory exists
@@ -235,9 +236,17 @@ function saveBookmarksForCurrentFile(): void {
 }
 
 function createWindow() {
+  const isMac = process.platform === 'darwin';
+
   mainWindow = new BrowserWindow({
     width: 1400,
     height: 900,
+    show: false,
+    frame: false,
+    ...(isMac ? {
+      titleBarStyle: 'hidden',
+      trafficLightPosition: { x: 10, y: 6 },
+    } : {}),
     webPreferences: {
       nodeIntegration: false,
       contextIsolation: true,
@@ -248,6 +257,10 @@ function createWindow() {
 
   mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'));
 
+  mainWindow.once('ready-to-show', () => {
+    mainWindow?.show();
+  });
+
   mainWindow.on('closed', () => {
     mainWindow = null;
     // Close all cached file handlers
@@ -275,6 +288,28 @@ app.on('window-all-closed', () => {
   }
 });
 
+// === Window Controls ===
+
+ipcMain.handle('window-minimize', () => {
+  mainWindow?.minimize();
+});
+
+ipcMain.handle('window-maximize', () => {
+  if (mainWindow?.isMaximized()) {
+    mainWindow.unmaximize();
+  } else {
+    mainWindow?.maximize();
+  }
+});
+
+ipcMain.handle('window-close', () => {
+  mainWindow?.close();
+});
+
+ipcMain.handle('get-platform', () => {
+  return process.platform;
+});
+
 // === File Operations ===
 
 ipcMain.handle(IPC.OPEN_FILE_DIALOG, async () => {
@@ -859,10 +894,8 @@ ipcMain.handle('export-bookmarks', async () => {
       .sort((a, b) => a.lineNumber - b.lineNumber);
 
     for (const bookmark of sortedBookmarks) {
-      // Get the line text
-      const [lineData] = handler?.getLines(bookmark.lineNumber, 1) || [];
-      const lineText = lineData?.text || '';
-      const truncatedText = lineText.length > 100 ? lineText.substring(0, 100) + '...' : lineText;
+      // Use stored lineText if available, otherwise fetch from file
+      const lineText = bookmark.lineText || (handler?.getLines(bookmark.lineNumber, 1)?.[0]?.text) || '';
 
       lines.push(`## Line ${bookmark.lineNumber + 1}`);
       lines.push(``);
@@ -874,7 +907,7 @@ ipcMain.handle('export-bookmarks', async () => {
       lines.push(`**Link:** \`${fileInfo.path}:${bookmark.lineNumber + 1}\``);
       lines.push(``);
       lines.push(`\`\`\``);
-      lines.push(truncatedText);
+      lines.push(lineText);
       lines.push(`\`\`\``);
       lines.push(``);
       lines.push(`---`);
@@ -941,6 +974,45 @@ ipcMain.handle('highlight-get-next-color', async () => {
   return { success: true, color: getNextColor() };
 });
 
+// === Highlight Groups ===
+
+function loadHighlightGroups(): HighlightGroup[] {
+  try {
+    const filePath = getHighlightGroupsPath();
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  return [];
+}
+
+function saveHighlightGroups(groups: HighlightGroup[]): void {
+  ensureConfigDir();
+  fs.writeFileSync(getHighlightGroupsPath(), JSON.stringify(groups, null, 2), 'utf-8');
+}
+
+ipcMain.handle('highlight-group-list', async () => {
+  return { success: true, groups: loadHighlightGroups() };
+});
+
+ipcMain.handle('highlight-group-save', async (_, group: HighlightGroup) => {
+  const groups = loadHighlightGroups();
+  const existingIdx = groups.findIndex(g => g.id === group.id);
+  if (existingIdx >= 0) {
+    groups[existingIdx] = group;
+  } else {
+    groups.push(group);
+  }
+  saveHighlightGroups(groups);
+  return { success: true };
+});
+
+ipcMain.handle('highlight-group-delete', async (_, groupId: string) => {
+  const groups = loadHighlightGroups().filter(g => g.id !== groupId);
+  saveHighlightGroups(groups);
+  return { success: true };
+});
+
 // === Utility ===
 
 ipcMain.handle('get-file-info', async () => {
@@ -984,7 +1056,7 @@ ipcMain.handle('open-external-url', async (_, url: string) => {
 
 // === Save Selected Lines ===
 
-ipcMain.handle('save-selected-lines', async (_, startLine: number, endLine: number) => {
+ipcMain.handle('save-selected-lines', async (_, startLine: number, endLine: number, columnConfig?: ColumnConfig) => {
   const handler = getFileHandler();
   if (!handler) return { success: false, error: 'No file open' };
 
@@ -1014,8 +1086,8 @@ ipcMain.handle('save-selected-lines', async (_, startLine: number, endLine: numb
     const filename = `${timestamp}.log`;
     const filePath = path.join(selectedDir, filename);
 
-    // Write lines to file
-    const content = lines.map(l => l.text).join('\n');
+    // Write lines to file, respecting column visibility
+    const content = lines.map(l => filterLineToVisibleColumns(l.text, columnConfig)).join('\n');
     fs.writeFileSync(filePath, content, 'utf-8');
 
     return { success: true, filePath, lineCount: lines.length };
@@ -1088,7 +1160,8 @@ ipcMain.handle('save-to-notes', async (
   startLine: number,
   endLine: number,
   note?: string,
-  targetFilePath?: string // If provided, append to this file; otherwise create new
+  targetFilePath?: string, // If provided, append to this file; otherwise create new
+  columnConfig?: ColumnConfig
 ) => {
   const handler = getFileHandler();
   if (!handler) return { success: false, error: 'No file open' };
@@ -1153,7 +1226,7 @@ ipcMain.handle('save-to-notes', async (
     content += [
       '',
       `--- [${timestamp}] Lines ${startLine + 1}-${endLine + 1}${noteDesc} ---`,
-      ...lines.map(l => l.text),
+      ...lines.map(l => filterLineToVisibleColumns(l.text, columnConfig)),
       '',
     ].join('\n');
 
@@ -1258,7 +1331,8 @@ interface FilterConfig {
   levels: string[];
   includePatterns: string[];
   excludePatterns: string[];
-  collapseDuplicates: boolean;
+  matchCase?: boolean;
+  exactMatch?: boolean;
   contextLines?: number;
   advancedFilter?: AdvancedFilterConfig;
 }
@@ -1334,6 +1408,31 @@ ipcMain.handle('apply-filter', async (_, config: FilterConfig) => {
       ? compileAdvancedFilter(config.advancedFilter!)
       : null;
 
+    // For basic filter: separate include and exclude passes
+    // Include matches get context window, exclude removes exact lines only
+    const hasBasicExclude = !useAdvancedFilter && config.excludePatterns.length > 0;
+    const excludeLines: Set<number> = new Set();
+
+    // Pattern matching helper respecting matchCase and exactMatch options
+    const caseSensitive = config.matchCase || false;
+    const exactMatch = config.exactMatch || false;
+    const matchPattern = (text: string, pattern: string): boolean => {
+      if (exactMatch) {
+        // Literal substring match
+        return caseSensitive
+          ? text.includes(pattern)
+          : text.toLowerCase().includes(pattern.toLowerCase());
+      }
+      // Regex match with fallback to substring
+      try {
+        return new RegExp(pattern, caseSensitive ? '' : 'i').test(text);
+      } catch {
+        return caseSensitive
+          ? text.includes(pattern)
+          : text.toLowerCase().includes(pattern.toLowerCase());
+      }
+    };
+
     // Process in batches for performance
     const batchSize = 10000;
     for (let start = 0; start < totalLines; start += batchSize) {
@@ -1357,24 +1456,15 @@ ipcMain.handle('apply-filter', async (_, config: FilterConfig) => {
 
           // Include patterns (OR logic)
           if (matches && config.includePatterns.length > 0) {
-            matches = config.includePatterns.some(pattern => {
-              try {
-                return new RegExp(pattern, 'i').test(line.text);
-              } catch {
-                return line.text.toLowerCase().includes(pattern.toLowerCase());
-              }
-            });
+            matches = config.includePatterns.some(pattern => matchPattern(line.text, pattern));
           }
 
-          // Exclude patterns (AND logic - all must not match)
-          if (matches && config.excludePatterns.length > 0) {
-            matches = !config.excludePatterns.some(pattern => {
-              try {
-                return new RegExp(pattern, 'i').test(line.text);
-              } catch {
-                return line.text.toLowerCase().includes(pattern.toLowerCase());
-              }
-            });
+          // Track exclude matches separately (exact lines only)
+          if (hasBasicExclude) {
+            const excluded = config.excludePatterns.some(pattern => matchPattern(line.text, pattern));
+            if (excluded) {
+              excludeLines.add(line.lineNumber);
+            }
           }
         }
 
@@ -1384,7 +1474,7 @@ ipcMain.handle('apply-filter', async (_, config: FilterConfig) => {
       }
     }
 
-    // Add context lines
+    // Add context lines around include matches (before exclude removal)
     if (contextLines > 0) {
       const matchArray = Array.from(matchingLines);
       for (const lineNum of matchArray) {
@@ -1395,6 +1485,13 @@ ipcMain.handle('apply-filter', async (_, config: FilterConfig) => {
       }
     }
 
+    // Remove exact exclude lines after context expansion
+    if (hasBasicExclude) {
+      for (const lineNum of excludeLines) {
+        matchingLines.delete(lineNum);
+      }
+    }
+
     // Sort and store
     const sortedLines = Array.from(matchingLines).sort((a, b) => a - b);
     filterState.set(currentFilePath, sortedLines);