@fresh-editor/fresh-editor 0.1.75 → 0.1.76

package/plugins/lib/search-utils.ts

@@ -0,0 +1,343 @@
+/// <reference path="./fresh.d.ts" />
+
+/**
+ * Shared utilities for search plugins (Live Grep, Git Grep, etc.)
+ *
+ * Provides:
+ * - Debounced search execution
+ * - Preview panel management
+ * - Common search result types
+ *
+ * NOTE: These utilities receive the editor instance as a parameter
+ * to avoid calling getEditor() at module scope (which causes errors).
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface SearchMatch {
+  file: string;
+  line: number;
+  column: number;
+  content: string;
+}
+
+export interface PreviewState {
+  bufferId: number | null;
+  splitId: number | null;
+  originalSplitId: number | null;
+}
+
+export interface DebouncedSearchOptions {
+  debounceMs?: number;
+  minQueryLength?: number;
+}
+
+// Editor interface (subset of what we need)
+interface EditorApi {
+  readFile(path: string): Promise<string>;
+  defineMode(name: string, parent: string, bindings: [string, string][], readOnly: boolean): void;
+  createVirtualBufferInSplit(options: {
+    name: string;
+    mode: string;
+    read_only: boolean;
+    entries: TextPropertyEntry[];
+    ratio: number;
+    direction: string;
+    panel_id: string;
+    show_line_numbers: boolean;
+    editing_disabled: boolean;
+  }): Promise<{ buffer_id: number; split_id?: number }>;
+  setVirtualBufferContent(bufferId: number, entries: TextPropertyEntry[]): void;
+  closeBuffer(bufferId: number): void;
+  closeSplit(splitId: number): void;
+  focusSplit(splitId: number): void;
+  delay(ms: number): Promise<void>;
+  debug(msg: string): void;
+}
+
+// ============================================================================
+// Preview Panel
+// ============================================================================
+
+/**
+ * Creates and manages a preview panel for search results.
+ * Shows file content with context around the match.
+ */
+export class SearchPreview {
+  private bufferId: number | null = null;
+  private splitId: number | null = null;
+  private originalSplitId: number | null = null;
+  private panelId: string;
+  private modeName: string;
+  private editor: EditorApi;
+
+  constructor(editor: EditorApi, panelId: string) {
+    this.editor = editor;
+    this.panelId = panelId;
+    this.modeName = `${panelId}-preview`;
+  }
+
+  /**
+   * Remember the original split before creating preview
+   */
+  setOriginalSplit(splitId: number): void {
+    this.originalSplitId = splitId;
+  }
+
+  /**
+   * Update the preview to show a match with surrounding context
+   */
+  async update(match: SearchMatch): Promise<void> {
+    try {
+      const content = await this.editor.readFile(match.file);
+      const lines = content.split("\n");
+
+      // Calculate context window (5 lines before and after)
+      const contextBefore = 5;
+      const contextAfter = 5;
+      const startLine = Math.max(0, match.line - 1 - contextBefore);
+      const endLine = Math.min(lines.length, match.line + contextAfter);
+
+      const entries: TextPropertyEntry[] = [];
+
+      // Header
+      entries.push({
+        text: `  ${match.file}:${match.line}:${match.column}\n`,
+        properties: { type: "header" },
+      });
+      entries.push({
+        text: "─".repeat(60) + "\n",
+        properties: { type: "separator" },
+      });
+
+      // Content lines with line numbers
+      for (let i = startLine; i < endLine; i++) {
+        const lineNum = i + 1;
+        const lineContent = lines[i] || "";
+        const isMatchLine = lineNum === match.line;
+        const prefix = isMatchLine ? "> " : "  ";
+        const lineNumStr = String(lineNum).padStart(4, " ");
+
+        entries.push({
+          text: `${prefix}${lineNumStr} │ ${lineContent}\n`,
+          properties: {
+            type: isMatchLine ? "match" : "context",
+            line: lineNum,
+          },
+        });
+      }
+
+      if (this.bufferId === null) {
+        // Create preview mode if not exists
+        this.editor.defineMode(this.modeName, "special", [["q", "close_buffer"]], true);
+
+        // Create preview in a split on the right
+        const result = await this.editor.createVirtualBufferInSplit({
+          name: "*Preview*",
+          mode: this.modeName,
+          read_only: true,
+          entries,
+          ratio: 0.5,
+          direction: "vertical",
+          panel_id: this.panelId,
+          show_line_numbers: false,
+          editing_disabled: true,
+        });
+
+        this.bufferId = result.buffer_id;
+        this.splitId = result.split_id ?? null;
+
+        // Return focus to original split so prompt stays active
+        if (this.originalSplitId !== null) {
+          this.editor.focusSplit(this.originalSplitId);
+        }
+      } else {
+        // Update existing buffer content
+        this.editor.setVirtualBufferContent(this.bufferId, entries);
+      }
+    } catch (e) {
+      this.editor.debug(`[SearchPreview] Failed to update: ${e}`);
+    }
+  }
+
+  /**
+   * Close the preview panel and clean up
+   */
+  close(): void {
+    if (this.bufferId !== null) {
+      this.editor.closeBuffer(this.bufferId);
+      this.bufferId = null;
+    }
+    if (this.splitId !== null) {
+      this.editor.closeSplit(this.splitId);
+      this.splitId = null;
+    }
+    this.originalSplitId = null;
+  }
+
+  /**
+   * Check if preview is currently open
+   */
+  isOpen(): boolean {
+    return this.bufferId !== null;
+  }
+}
+
+// ============================================================================
+// Debounced Search
+// ============================================================================
+
+/**
+ * Creates a debounced search executor that:
+ * - Waits for user to stop typing before searching
+ * - Cancels previous searches when new input arrives
+ * - Tracks search version to discard stale results
+ */
+export class DebouncedSearch {
+  private currentSearch: ProcessHandle | null = null;
+  private pendingKill: Promise<boolean> | null = null;
+  private searchVersion = 0;
+  private lastQuery = "";
+  private debounceMs: number;
+  private minQueryLength: number;
+  private editor: EditorApi;
+
+  constructor(editor: EditorApi, options: DebouncedSearchOptions = {}) {
+    this.editor = editor;
+    this.debounceMs = options.debounceMs ?? 150;
+    this.minQueryLength = options.minQueryLength ?? 2;
+  }
+
+  /**
+   * Execute a search with debouncing.
+   * Returns results via callback to allow async processing.
+   */
+  async search(
+    query: string,
+    executor: () => ProcessHandle,
+    onResults: (result: SpawnResult) => void
+  ): Promise<void> {
+    const thisVersion = ++this.searchVersion;
+
+    // Kill any existing search immediately
+    if (this.currentSearch) {
+      this.pendingKill = this.currentSearch.kill();
+      this.currentSearch = null;
+    }
+
+    // Check minimum query length
+    if (!query || query.trim().length < this.minQueryLength) {
+      if (this.pendingKill) {
+        await this.pendingKill;
+        this.pendingKill = null;
+      }
+      return;
+    }
+
+    // Debounce
+    await this.editor.delay(this.debounceMs);
+
+    // Wait for pending kill
+    if (this.pendingKill) {
+      await this.pendingKill;
+      this.pendingKill = null;
+    }
+
+    // Check if superseded
+    if (this.searchVersion !== thisVersion) {
+      return;
+    }
+
+    // Skip duplicate queries
+    if (query === this.lastQuery) {
+      return;
+    }
+    this.lastQuery = query;
+
+    try {
+      this.currentSearch = executor();
+      const result = await this.currentSearch;
+
+      // Check if this search was cancelled
+      if (this.searchVersion !== thisVersion) {
+        return;
+      }
+
+      this.currentSearch = null;
+      onResults(result);
+    } catch (e) {
+      const errorMsg = String(e);
+      if (!errorMsg.includes("killed") && !errorMsg.includes("not found")) {
+        this.editor.debug(`[DebouncedSearch] Error: ${e}`);
+      }
+    }
+  }
+
+  /**
+   * Cancel any running search
+   */
+  cancel(): void {
+    if (this.currentSearch) {
+      this.currentSearch.kill();
+      this.currentSearch = null;
+    }
+  }
+
+  /**
+   * Reset state for new search session
+   */
+  reset(): void {
+    this.cancel();
+    this.lastQuery = "";
+    this.searchVersion = 0;
+  }
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * Parse a grep-style output line (file:line:column:content)
+ */
+export function parseGrepLine(line: string): SearchMatch | null {
+  const match = line.match(/^([^:]+):(\d+):(\d+):(.*)$/);
+  if (match) {
+    return {
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      content: match[4],
+    };
+  }
+  return null;
+}
+
+/**
+ * Convert search matches to prompt suggestions
+ */
+export function matchesToSuggestions(
+  matches: SearchMatch[],
+  maxResults: number = 100
+): PromptSuggestion[] {
+  const suggestions: PromptSuggestion[] = [];
+
+  for (let i = 0; i < Math.min(matches.length, maxResults); i++) {
+    const match = matches[i];
+    const displayContent =
+      match.content.length > 60
+        ? match.content.substring(0, 57) + "..."
+        : match.content;
+
+    suggestions.push({
+      text: `${match.file}:${match.line}`,
+      description: displayContent.trim(),
+      value: `${i}`,
+      disabled: false,
+    });
+  }
+
+  return suggestions;
+}

package/plugins/lib/virtual-buffer-factory.ts

@@ -1,4 +1,4 @@
-/// <reference path="../../types/fresh.d.ts" />
+/// <reference path="./fresh.d.ts" />
 
 /**
  * Options for creating a virtual buffer
@@ -108,7 +108,7 @@ export function createVirtualBufferFactory(editor: EditorAPI) {
         readOnly = true,
       } = options;
 
-      return await editor.createVirtualBufferInSplit({
+      const result = await editor.createVirtualBufferInSplit({
         name,
         mode,
         read_only: readOnly,
@@ -118,6 +118,7 @@ export function createVirtualBufferFactory(editor: EditorAPI) {
         show_line_numbers: showLineNumbers,
         editing_disabled: editingDisabled,
       });
+      return result.buffer_id;
     },
 
     /**