@fresh-editor/fresh-editor 0.1.58 → 0.1.63

package/plugins/git_grep.ts

@@ -89,7 +89,8 @@ globalThis.onGitGrepPromptChanged = function(args: {
   }
 
   // Spawn git grep asynchronously
-  editor.spawnProcess("git", ["grep", "-n", "--column", "-I", "--", query])
+  const cwd = editor.getCwd();
+  editor.spawnProcess("git", ["grep", "-n", "--column", "-I", "--", query], cwd)
     .then((result) => {
       if (result.exit_code === 0) {
         // Parse results and update suggestions

package/plugins/lib/fresh.d.ts

@@ -81,6 +81,16 @@ interface LayoutHints {
   column_guides?: number[] | null;
 }
 
+/** Handle for a cancellable process spawned with spawnProcess */
+interface ProcessHandle extends PromiseLike<SpawnResult> {
+  /** Promise that resolves to the process ID */
+  readonly processId: Promise<number>;
+  /** Promise that resolves to the result when the process completes */
+  readonly result: Promise<SpawnResult>;
+  /** Kill the process. Returns true if killed, false if already completed */
+  kill(): Promise<boolean>;
+}
+
 /** Result from spawnProcess */
 interface SpawnResult {
   /** Complete stdout as string. Newlines preserved; trailing newline included. */
@@ -626,15 +636,31 @@ interface EditorAPI {
    */
   spawnBackgroundProcess(command: string, args: string[], cwd?: string | null): Promise<BackgroundProcessResult>;
   /**
-   * Kill a background process by ID
+   * Kill a background or cancellable process by ID
    *
    * Sends SIGTERM to gracefully terminate the process.
    * Returns true if the process was found and killed, false if not found.
    *
-   * @param process_id - ID returned from spawnBackgroundProcess
+   * @param process_id - ID returned from spawnBackgroundProcess or spawnProcessStart
    * @returns true if process was killed, false if not found
    */
   killProcess(#[bigint] process_id: number): Promise<boolean>;
+  /**
+   * Wait for a cancellable process to complete and get its result
+   *
+   * @param process_id - ID returned from spawnProcessStart
+   * @returns SpawnResult with stdout, stderr, and exit_code
+   */
+  spawnProcessWait(#[bigint] process_id: number): Promise<SpawnResult>;
+  /**
+   * Delay execution for a specified number of milliseconds
+   *
+   * Useful for debouncing user input or adding delays between operations.
+   * @param ms - Number of milliseconds to delay
+   * @example
+   * await editor.delay(100);  // Wait 100ms
+   */
+  delay(#[bigint] ms: number): Promise<[]>;
   /**
    * Start a prompt with pre-filled initial value
    * @param label - Label to display (e.g., "Git grep: ")
@@ -672,24 +698,24 @@ interface EditorAPI {
    */
   setBufferCursor(buffer_id: number, position: number): boolean;
 
-  // === Async Operations ===
   /**
-   * Run an external command and capture its output
+   * Spawn an external process and return a cancellable handle
    *
-   * Waits for process to complete before returning. For long-running processes,
-   * consider if this will block your plugin. Output is captured completely;
-   * very large outputs may use significant memory.
+   * Returns a ProcessHandle that can be awaited for the result or killed early.
+   * The handle is also a PromiseLike, so `await spawnProcess(...)` works directly.
    * @param command - Program name (searched in PATH) or absolute path
    * @param args - Command arguments (each array element is one argument)
    * @param cwd - Working directory; null uses editor's cwd
    * @example
-   * const result = await editor.spawnProcess("git", ["log", "--oneline", "-5"]);
-   * if (result.exit_code !== 0) {
-   * editor.setStatus(`git failed: ${result.stderr}`);
-   * }
+   * // Simple usage (backward compatible)
+   * const result = await editor.spawnProcess("git", ["status"]);
+   *
+   * // Cancellable usage
+   * const search = editor.spawnProcess("rg", ["pattern"]);
+   * // ... later, if user types new query:
+   * search.kill();  // Cancel the search
    */
-  spawnProcess(command: string, args: string[], cwd?: string | null): Promise<SpawnResult>;
-
+  spawnProcess(command: string, args?: string[], cwd?: string | null): ProcessHandle;
   // === Overlay Operations ===
   /**
    * Add a colored highlight overlay to text without modifying content

package/plugins/live_grep.ts

@@ -22,8 +22,12 @@ let previewBufferId: number | null = null;
 let previewSplitId: number | null = null;
 let originalSplitId: number | null = null;
 let lastQuery: string = "";
-let searchDebounceTimer: number | null = null;
 let previewCreated: boolean = false;
+let currentSearch: ProcessHandle | null = null;
+let pendingKill: Promise<boolean> | null = null;  // Track pending kill globally
+let searchVersion = 0;  // Incremented on each input change for debouncing
+
+const DEBOUNCE_MS = 150;  // Wait 150ms after last keystroke before searching
 
 // Parse ripgrep output line
 // Format: file:line:column:content
@@ -169,22 +173,62 @@ function closePreview(): void {
   }
 }
 
-// Run ripgrep search
+// Run ripgrep search with debouncing
 async function runSearch(query: string): Promise<void> {
+  // Increment version to invalidate any pending debounced search
+  const thisVersion = ++searchVersion;
+  editor.debug(`[live_grep] runSearch called: query="${query}", version=${thisVersion}`);
+
+  // Kill any existing search immediately (don't wait) to stop wasting CPU
+  // Store the kill promise globally so ALL pending searches wait for it
+  if (currentSearch) {
+    editor.debug(`[live_grep] killing existing search immediately`);
+    pendingKill = currentSearch.kill();
+    currentSearch = null;
+  }
+
   if (!query || query.trim().length < 2) {
+    // Wait for any pending kill to complete before returning
+    if (pendingKill) {
+      await pendingKill;
+      pendingKill = null;
+    }
+    editor.debug(`[live_grep] query too short, clearing`);
     editor.setPromptSuggestions([]);
     grepResults = [];
     return;
   }
 
+  // Debounce: wait a bit to see if user is still typing
+  editor.debug(`[live_grep] debouncing for ${DEBOUNCE_MS}ms...`);
+  await editor.delay(DEBOUNCE_MS);
+
+  // Always await any pending kill before continuing - ensures old process is dead
+  if (pendingKill) {
+    editor.debug(`[live_grep] waiting for previous search to terminate`);
+    await pendingKill;
+    pendingKill = null;
+    editor.debug(`[live_grep] previous search terminated`);
+  }
+
+  // If version changed during delay, a newer search was triggered - abort this one
+  if (searchVersion !== thisVersion) {
+    editor.debug(`[live_grep] version mismatch after debounce (${thisVersion} vs ${searchVersion}), aborting`);
+    return;
+  }
+
   // Avoid duplicate searches
   if (query === lastQuery) {
+    editor.debug(`[live_grep] duplicate query, skipping`);
     return;
   }
   lastQuery = query;
 
   try {
-    const result = await editor.spawnProcess("rg", [
+    const cwd = editor.getCwd();
+    editor.debug(`[live_grep] spawning rg for query="${query}" in cwd="${cwd}"`);
+    const searchStartTime = Date.now();
+    const search = editor.spawnProcess("rg", [
       "--line-number",
       "--column",
       "--no-heading",
@@ -197,10 +241,25 @@ async function runSearch(query: string): Promise<void> {
       "-g", "!*.lock",
       "--",
       query,
-    ]);
+    ], cwd);
+
+    currentSearch = search;
+    editor.debug(`[live_grep] awaiting search result...`);
+    const result = await search;
+    const searchDuration = Date.now() - searchStartTime;
+    editor.debug(`[live_grep] rg completed in ${searchDuration}ms, exit_code=${result.exit_code}, stdout_len=${result.stdout.length}`);
+
+    // Check if this search was cancelled (a new search started)
+    if (currentSearch !== search) {
+      editor.debug(`[live_grep] search was superseded, discarding results`);
+      return; // Discard stale results
+    }
+    currentSearch = null;
 
     if (result.exit_code === 0) {
+      const parseStart = Date.now();
       const { results, suggestions } = parseRipgrepOutput(result.stdout);
+      editor.debug(`[live_grep] parsed ${results.length} results in ${Date.now() - parseStart}ms`);
       grepResults = results;
       editor.setPromptSuggestions(suggestions);
 
@@ -213,14 +272,24 @@ async function runSearch(query: string): Promise<void> {
       }
     } else if (result.exit_code === 1) {
       // No matches
+      editor.debug(`[live_grep] no matches (exit_code=1)`);
       grepResults = [];
       editor.setPromptSuggestions([]);
       editor.setStatus("No matches found");
+    } else if (result.exit_code === -1) {
+      // Process was killed, ignore
+      editor.debug(`[live_grep] process was killed`);
     } else {
+      editor.debug(`[live_grep] search error: ${result.stderr}`);
       editor.setStatus(`Search error: ${result.stderr}`);
     }
   } catch (e) {
-    editor.setStatus(`Search error: ${e}`);
+    // Ignore errors from killed processes
+    const errorMsg = String(e);
+    editor.debug(`[live_grep] caught error: ${errorMsg}`);
+    if (!errorMsg.includes("killed") && !errorMsg.includes("not found")) {
+      editor.setStatus(`Search error: ${e}`);
+    }
   }
 }
 
@@ -248,12 +317,9 @@ globalThis.onLiveGrepPromptChanged = function (args: {
     return true;
   }
 
-  // Debounce search to avoid too many requests while typing
-  if (searchDebounceTimer !== null) {
-    // Can't actually cancel in this runtime, but we track it
-  }
+  editor.debug(`[live_grep] onPromptChanged: input="${args.input}"`);
 
-  // Run search (with small delay effect via async)
+  // runSearch handles debouncing internally
   runSearch(args.input);
 
   return true;
@@ -286,6 +352,12 @@ globalThis.onLiveGrepPromptConfirmed = function (args: {
     return true;
   }
 
+  // Kill any running search
+  if (currentSearch) {
+    currentSearch.kill();
+    currentSearch = null;
+  }
+
   // Close preview first
   closePreview();
 
@@ -314,6 +386,12 @@ globalThis.onLiveGrepPromptCancelled = function (args: {
     return true;
   }
 
+  // Kill any running search
+  if (currentSearch) {
+    currentSearch.kill();
+    currentSearch = null;
+  }
+
   // Close preview and cleanup
   closePreview();
   grepResults = [];

package/plugins/search_replace.ts

@@ -185,7 +185,8 @@ async function performSearch(pattern: string, replace: string, isRegex: boolean)
   args.push("--", pattern);
 
   try {
-    const result = await editor.spawnProcess("git", args);
+    const cwd = editor.getCwd();
+    const result = await editor.spawnProcess("git", args, cwd);
 
     searchResults = [];
 

package/themes/dracula.json

@@ -0,0 +1,62 @@
+{
+  "name": "dracula",
+  "editor": {
+    "bg": [40, 42, 54],
+    "fg": [248, 248, 242],
+    "cursor": [255, 121, 198],
+    "selection_bg": [68, 71, 90],
+    "current_line_bg": [68, 71, 90],
+    "line_number_fg": [98, 114, 164],
+    "line_number_bg": [40, 42, 54]
+  },
+  "ui": {
+    "tab_active_fg": [248, 248, 242],
+    "tab_active_bg": [189, 147, 249],
+    "tab_inactive_fg": [248, 248, 242],
+    "tab_inactive_bg": [68, 71, 90],
+    "tab_separator_bg": [40, 42, 54],
+    "status_bar_fg": [40, 42, 54],
+    "status_bar_bg": [189, 147, 249],
+    "prompt_fg": [40, 42, 54],
+    "prompt_bg": [80, 250, 123],
+    "prompt_selection_fg": [248, 248, 242],
+    "prompt_selection_bg": [189, 147, 249],
+    "popup_border_fg": [98, 114, 164],
+    "popup_bg": [68, 71, 90],
+    "popup_selection_bg": [189, 147, 249],
+    "popup_text_fg": [248, 248, 242],
+    "suggestion_bg": [68, 71, 90],
+    "suggestion_selected_bg": [189, 147, 249],
+    "help_bg": [40, 42, 54],
+    "help_fg": [248, 248, 242],
+    "help_key_fg": [139, 233, 253],
+    "help_separator_fg": [98, 114, 164],
+    "help_indicator_fg": [255, 85, 85],
+    "help_indicator_bg": [40, 42, 54],
+    "split_separator_fg": [98, 114, 164]
+  },
+  "search": {
+    "match_bg": [241, 250, 140],
+    "match_fg": [40, 42, 54]
+  },
+  "diagnostic": {
+    "error_fg": [255, 85, 85],
+    "error_bg": [64, 42, 54],
+    "warning_fg": [241, 250, 140],
+    "warning_bg": [64, 60, 42],
+    "info_fg": [139, 233, 253],
+    "info_bg": [40, 56, 70],
+    "hint_fg": [98, 114, 164],
+    "hint_bg": [40, 42, 54]
+  },
+  "syntax": {
+    "keyword": [255, 121, 198],
+    "string": [241, 250, 140],
+    "comment": [98, 114, 164],
+    "function": [80, 250, 123],
+    "type": [139, 233, 253],
+    "variable": [248, 248, 242],
+    "constant": [189, 147, 249],
+    "operator": [255, 121, 198]
+  }
+}

package/themes/nord.json

@@ -0,0 +1,62 @@
+{
+  "name": "nord",
+  "editor": {
+    "bg": [46, 52, 64],
+    "fg": [216, 222, 233],
+    "cursor": [136, 192, 208],
+    "selection_bg": [67, 76, 94],
+    "current_line_bg": [59, 66, 82],
+    "line_number_fg": [76, 86, 106],
+    "line_number_bg": [46, 52, 64]
+  },
+  "ui": {
+    "tab_active_fg": [236, 239, 244],
+    "tab_active_bg": [67, 76, 94],
+    "tab_inactive_fg": [216, 222, 233],
+    "tab_inactive_bg": [59, 66, 82],
+    "tab_separator_bg": [46, 52, 64],
+    "status_bar_fg": [46, 52, 64],
+    "status_bar_bg": [136, 192, 208],
+    "prompt_fg": [46, 52, 64],
+    "prompt_bg": [163, 190, 140],
+    "prompt_selection_fg": [236, 239, 244],
+    "prompt_selection_bg": [94, 129, 172],
+    "popup_border_fg": [76, 86, 106],
+    "popup_bg": [59, 66, 82],
+    "popup_selection_bg": [94, 129, 172],
+    "popup_text_fg": [216, 222, 233],
+    "suggestion_bg": [59, 66, 82],
+    "suggestion_selected_bg": [94, 129, 172],
+    "help_bg": [46, 52, 64],
+    "help_fg": [216, 222, 233],
+    "help_key_fg": [136, 192, 208],
+    "help_separator_fg": [76, 86, 106],
+    "help_indicator_fg": [191, 97, 106],
+    "help_indicator_bg": [46, 52, 64],
+    "split_separator_fg": [76, 86, 106]
+  },
+  "search": {
+    "match_bg": [235, 203, 139],
+    "match_fg": [46, 52, 64]
+  },
+  "diagnostic": {
+    "error_fg": [191, 97, 106],
+    "error_bg": [59, 46, 50],
+    "warning_fg": [235, 203, 139],
+    "warning_bg": [59, 56, 46],
+    "info_fg": [129, 161, 193],
+    "info_bg": [46, 52, 64],
+    "hint_fg": [76, 86, 106],
+    "hint_bg": [46, 52, 64]
+  },
+  "syntax": {
+    "keyword": [129, 161, 193],
+    "string": [163, 190, 140],
+    "comment": [76, 86, 106],
+    "function": [136, 192, 208],
+    "type": [143, 188, 187],
+    "variable": [216, 222, 233],
+    "constant": [180, 142, 173],
+    "operator": [129, 161, 193]
+  }
+}

package/themes/solarized-dark.json

@@ -0,0 +1,62 @@
+{
+  "name": "solarized-dark",
+  "editor": {
+    "bg": [0, 43, 54],
+    "fg": [131, 148, 150],
+    "cursor": [38, 139, 210],
+    "selection_bg": [7, 54, 66],
+    "current_line_bg": [7, 54, 66],
+    "line_number_fg": [88, 110, 117],
+    "line_number_bg": [0, 43, 54]
+  },
+  "ui": {
+    "tab_active_fg": [253, 246, 227],
+    "tab_active_bg": [38, 139, 210],
+    "tab_inactive_fg": [131, 148, 150],
+    "tab_inactive_bg": [7, 54, 66],
+    "tab_separator_bg": [0, 43, 54],
+    "status_bar_fg": [0, 43, 54],
+    "status_bar_bg": [147, 161, 161],
+    "prompt_fg": [0, 43, 54],
+    "prompt_bg": [181, 137, 0],
+    "prompt_selection_fg": [253, 246, 227],
+    "prompt_selection_bg": [38, 139, 210],
+    "popup_border_fg": [88, 110, 117],
+    "popup_bg": [7, 54, 66],
+    "popup_selection_bg": [38, 139, 210],
+    "popup_text_fg": [131, 148, 150],
+    "suggestion_bg": [7, 54, 66],
+    "suggestion_selected_bg": [38, 139, 210],
+    "help_bg": [0, 43, 54],
+    "help_fg": [131, 148, 150],
+    "help_key_fg": [42, 161, 152],
+    "help_separator_fg": [88, 110, 117],
+    "help_indicator_fg": [220, 50, 47],
+    "help_indicator_bg": [0, 43, 54],
+    "split_separator_fg": [88, 110, 117]
+  },
+  "search": {
+    "match_bg": [181, 137, 0],
+    "match_fg": [253, 246, 227]
+  },
+  "diagnostic": {
+    "error_fg": [220, 50, 47],
+    "error_bg": [42, 43, 54],
+    "warning_fg": [181, 137, 0],
+    "warning_bg": [30, 54, 54],
+    "info_fg": [38, 139, 210],
+    "info_bg": [0, 50, 66],
+    "hint_fg": [88, 110, 117],
+    "hint_bg": [0, 43, 54]
+  },
+  "syntax": {
+    "keyword": [133, 153, 0],
+    "string": [42, 161, 152],
+    "comment": [88, 110, 117],
+    "function": [38, 139, 210],
+    "type": [181, 137, 0],
+    "variable": [131, 148, 150],
+    "constant": [203, 75, 22],
+    "operator": [131, 148, 150]
+  }
+}