@fresh-editor/fresh-editor 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Release Notes
 
+## 0.3.5
+
+### Improvements
+
+* **Live Grep overlay polish**: Surrounding editor is now visibly dimmed; shortcut hints and the active provider moved into a toolbar row with plainer labels; match cap raised from 100 to 1000 (with a `1000+ matches` indicator); provider errors render as a disabled result entry instead of a silent "0 matches"; `ripgrep` provider renamed to `rg`.
+
+### Bug Fixes
+
+* **Live Grep on Windows returned no results**: `git grep` outputs `\r\n`; splitting on `\n` left a trailing `\r` that broke the result regex. Split on `\r?\n` instead.
+
+* **Plain `grep` provider was broken**: `--column` is a ripgrep-only flag and was being passed unconditionally. Removed.
+
+### Under the Hood
+
+* **Plugin API: `setPromptTitle` takes styled segments** (`{ text, style? }[]`) instead of a single string, so plugins control hint colouring directly instead of the renderer guessing structure from punctuation.
+
 ## 0.3.4
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fresh-editor/fresh-editor",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "A modern terminal-based text editor with plugin support",
   "repository": {
     "type": "git",

package/plugins/git_grep.ts

@@ -48,8 +48,10 @@ async function searchWithGitGrep(query: string): Promise<GrepMatch[]> {
   );
 
   if (result.exit_code === 0) {
-    return parseGrepOutput(result.stdout, 100) as GrepMatch[];
+    return parseGrepOutput(result.stdout, 100, (msg) => editor.debug(msg)) as GrepMatch[];
   }
+  editor.error(`[git_grep] process exited with code ${result.exit_code}: ${result.stderr}`);
+  editor.setStatus(`git grep failed (exit ${result.exit_code})`);
   return [];
 }
 

package/plugins/lib/finder.ts

@@ -346,7 +346,8 @@ export function parseGrepLine(line: string): {
  */
 export function parseGrepOutput(
   stdout: string,
-  maxResults: number = 100
+  maxResults: number = 100,
+  debug?: (msg: string) => void
 ): Array<{ file: string; line: number; column: number; content: string }> {
   const results: Array<{
     file: string;
@@ -355,14 +356,16 @@ export function parseGrepOutput(
     content: string;
   }> = [];
 
-  for (const line of stdout.split("\n")) {
-    if (!line.trim()) continue;
+  for (const line of stdout.split(/\r?\n/)) {
+    if (!line) continue;
     const match = parseGrepLine(line);
     if (match) {
       results.push(match);
       if (results.length >= maxResults) {
         break;
       }
+    } else if (debug) {
+      debug(`[parseGrepOutput] failed to parse line: ${line}`);
     }
   }
 
@@ -784,7 +787,8 @@ export class Finder<T> {
           // Parse as grep output by default
           const parsed = parseGrepOutput(
             result.stdout,
-            this.config.maxResults
+            this.config.maxResults,
+            (msg) => this.editor.debug(msg)
           ) as unknown as T[];
           this.updatePromptResults(parsed);
 
@@ -827,9 +831,26 @@ export class Finder<T> {
       }
     } catch (e) {
       const errorMsg = String(e);
-      if (!errorMsg.includes("killed") && !errorMsg.includes("not found")) {
-        this.editor.setStatus(`Search error: ${e}`);
+      // "killed" / "not found" come from the cancellation path (a
+      // newer search aborted this one). Suppress those entirely —
+      // the user didn't ask for them.
+      if (errorMsg.includes("killed") || errorMsg.includes("not found")) {
+        return;
       }
+      // Render the error inside the overlay's result list itself.
+      // The status bar is shared and clobbered by other code paths,
+      // so it's not a reliable place to surface a feature-scoped
+      // error — the overlay is where the user is looking.
+      this.promptState.results = [];
+      this.promptState.entries = [];
+      const display = errorMsg.replace(/^Error:\s*/, "");
+      this.editor.setPromptSuggestions([
+        {
+          text: `⚠ ${display}`,
+          value: "",
+          disabled: true,
+        },
+      ]);
     }
   }
 

package/plugins/lib/fresh.d.ts

@@ -989,6 +989,10 @@ type SpawnResult = {
 	*/
 	exit_code: number;
 };
+type StyledText = {
+	text: string;
+	style?: Partial<OverlayOptions>;
+};
 type TextPropertiesAtCursor = Array<Record<string, unknown>>;
 type TsHighlightSpan = {
 	start: number;
@@ -1735,11 +1739,16 @@ interface EditorAPI {
 	setPromptInputSync(sync: boolean): boolean;
 	/**
 	* Set the title shown in the floating-overlay prompt's frame
-	* header (issue #1796). Pass `null` or omit the argument to
-	* clear the title and fall back to the default. Has no
-	* visible effect on non-overlay prompts.
-	*/
-	setPromptTitle(title?: string | null): boolean;
+	* header (issue #1796) as styled segments. Each segment
+	* carries optional `Partial<OverlayOptions>`, the same
+	* styling primitive used by virtual text — plugins mark
+	* keybinding hints with `{ fg: "ui.help_key_fg" }`,
+	* separators with `{ fg: "ui.popup_border_fg" }`, etc. Pass
+	* an empty array to clear the title and fall back to the
+	* prompt-type default. Has no visible effect on non-overlay
+	* prompts.
+	*/
+	setPromptTitle(title: StyledText[]): boolean;
 	/**
 	* Define a buffer mode (takes bindings as array of [key, command] pairs)
 	*/

package/plugins/live_grep.ts

@@ -98,10 +98,20 @@ declare global {
   }
 }
 
+// Cap on the number of matches a single search returns. Higher than
+// the previous 100 to actually fit a typical refactor's worth of
+// hits in one snapshot, but bounded so a runaway query doesn't
+// stream the entire codebase into the overlay.
+const MAX_RESULTS = 1000;
+
 // ── Registry ──────────────────────────────────────────────────────
 
 const providers: LiveGrepProvider[] = [];
 let cachedSelected: LiveGrepProvider | null | undefined = undefined;
+// Set by `search` after each query so the toolbar can show
+// "1000+ matches" when a result set was clipped at MAX_RESULTS.
+// Reset to false on every new query (before the provider call).
+let lastSearchTruncated = false;
 
 function sortByPriority(): void {
   providers.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
@@ -145,31 +155,57 @@ function unregisterProvider(name: string): boolean {
 }
 
 function updateOverlayTitle(provider: LiveGrepProvider | null): void {
-  // Reflect the active provider in the floating overlay's frame
-  // header so the user always knows which backend is producing
-  // the results, even after the search-result status overwrites
-  // any one-shot "switched to" message. Append the actual bound
-  // shortcuts (whatever the user remapped to) as hints — pulled
-  // from the editor's keybinding registry, not hardcoded, so they
-  // always match the user's actual config.
-  const hints: string[] = [];
-  const cycleKey = editor.getKeybindingLabel(
-    "cycle_live_grep_provider",
-    "prompt"
+  // The input row's prefix already says "Live grep: …", so the
+  // frame title doesn't repeat the feature name — it's reserved
+  // for the active provider plus shortcut hints. Shortcuts come
+  // from the keybinding registry (not hardcoded) so labels match
+  // the user's actual binds. Each segment carries its own theme
+  // key (`ui.help_key_fg` for keys, `ui.popup_border_fg` for
+  // separators) so the renderer doesn't have to parse the title.
+  // `resume_live_grep` is intentionally NOT shown here — it only
+  // matters once the prompt is closed; it's surfaced in the
+  // status bar at that point instead.
+  const sepStyle = { fg: "ui.popup_border_fg" };
+  const hintStyle = { fg: "ui.help_key_fg" };
+  const segments: StyledText[] = [];
+  const pushSegment = (parts: StyledText[]) => {
+    if (segments.length > 0) {
+      segments.push({ text: " · ", style: sepStyle });
+    }
+    segments.push(...parts);
+  };
+  if (provider) {
+    pushSegment([
+      { text: "Provider: " },
+      { text: provider.name, style: { bold: true } },
+    ]);
+  }
+  // Match-count indicator goes BEFORE the keybinding hints so a
+  // narrow terminal that truncates the toolbar still shows it —
+  // the trailing hints are easier to lose than the result-set
+  // status.
+  if (lastSearchTruncated) {
+    pushSegment([{ text: `${MAX_RESULTS}+ matches` }]);
+  }
+  const pushHint = (key: string | null, label: string) => {
+    if (!key) return;
+    pushSegment([
+      { text: key, style: hintStyle },
+      { text: ` ${label}` },
+    ]);
+  };
+  pushHint(
+    editor.getKeybindingLabel("cycle_live_grep_provider", "prompt"),
+    "switch grep provider"
   );
-  if (cycleKey) hints.push(`${cycleKey} cycle`);
-  const exportKey = editor.getKeybindingLabel(
-    "live_grep_export_quickfix",
-    "prompt"
+  pushHint(
+    editor.getKeybindingLabel("live_grep_export_quickfix", "prompt"),
+    "save matches"
   );
-  if (exportKey) hints.push(`${exportKey} → Quickfix`);
-  const resumeKey = editor.getKeybindingLabel("resume_live_grep", "normal");
-  if (resumeKey) hints.push(`${resumeKey} resume`);
-  const hintSuffix = hints.length > 0 ? ` · ${hints.join(" · ")}` : "";
-  const label = provider
-    ? `Live Grep · ${provider.name}${hintSuffix}`
-    : `Live Grep${hintSuffix}`;
-  editor.setPromptTitle(label);
+  if (segments.length > 0) {
+    segments.push({ text: " " });
+  }
+  editor.setPromptTitle(segments);
 }
 
 async function selectProvider(): Promise<LiveGrepProvider | null> {
@@ -198,7 +234,7 @@ async function selectProvider(): Promise<LiveGrepProvider | null> {
 // ── Built-in providers ──────────────────────────────────────────
 
 registerProvider({
-  name: "ripgrep",
+  name: "rg",
   priority: -1,
   isAvailable: async () => {
     try {
@@ -228,9 +264,9 @@ registerProvider({
       cwd
     );
     if (r.exit_code === 0) {
-      return parseGrepOutput(r.stdout, maxResults) as GrepMatch[];
+      return parseGrepOutput(r.stdout, maxResults, (msg) => editor.debug(msg)) as GrepMatch[];
     }
-    return [];
+    throw new Error(`rg exited with code ${r.exit_code}: ${r.stderr}`);
   },
 });
 
@@ -264,9 +300,9 @@ registerProvider({
       cwd
     );
     if (r.exit_code === 0 || r.exit_code === 1) {
-      return parseGrepOutput(r.stdout, maxResults) as GrepMatch[];
+      return parseGrepOutput(r.stdout, maxResults, (msg) => editor.debug(msg)) as GrepMatch[];
     }
-    return [];
+    throw new Error(`ag exited with code ${r.exit_code}: ${r.stderr}`);
   },
 });
 
@@ -301,9 +337,9 @@ registerProvider({
     );
     // git grep exits 1 when no matches — treat as empty, not error.
     if (r.exit_code === 0 || r.exit_code === 1) {
-      return parseGrepOutput(r.stdout, maxResults) as GrepMatch[];
+      return parseGrepOutput(r.stdout, maxResults, (msg) => editor.debug(msg)) as GrepMatch[];
     }
-    return [];
+    throw new Error(`git grep exited with code ${r.exit_code}: ${r.stderr}`);
   },
 });
 
@@ -334,9 +370,9 @@ registerProvider({
       cwd
     );
     if (r.exit_code === 0 || r.exit_code === 1) {
-      return parseGrepOutput(r.stdout, maxResults) as GrepMatch[];
+      return parseGrepOutput(r.stdout, maxResults, (msg) => editor.debug(msg)) as GrepMatch[];
     }
-    return [];
+    throw new Error(`ack exited with code ${r.exit_code}: ${r.stderr}`);
   },
 });
 
@@ -366,7 +402,6 @@ registerProvider({
       "grep",
       [
         "-rn",
-        "--column",
         "-I",
         "--exclude-dir=.git",
         "--exclude-dir=node_modules",
@@ -378,13 +413,11 @@ registerProvider({
       cwd
     );
     if (r.exit_code === 0 || r.exit_code === 1) {
-      // POSIX grep doesn't emit `path:line:col:content` natively
-      // even with `--column`; on most BSD/GNU greps the format is
-      // still `path:line:content`. parseGrepOutput tolerates the
-      // missing column.
-      return parseGrepOutput(r.stdout, maxResults) as GrepMatch[];
+      // grep emits `path:line:content` (no column). parseGrepOutput's
+      // 3-field fallback handles the missing column (defaults to 1).
+      return parseGrepOutput(r.stdout, maxResults, (msg) => editor.debug(msg)) as GrepMatch[];
     }
-    return [];
+    throw new Error(`grep exited with code ${r.exit_code}: ${r.stderr}`);
   },
 });
 
@@ -404,8 +437,26 @@ const finder = new Finder<GrepMatch>(editor, {
       column: match.column,
     },
   }),
+  // Override the Finder's default "open file + status: Opened X"
+  // so we can surface the resume shortcut here. The shortcut is
+  // hidden inside the overlay (it can't apply while the overlay
+  // is open), but it's exactly what the user needs to know once
+  // they've jumped to a result and want to keep browsing.
+  onSelect: (_item, entry) => {
+    if (entry.location) {
+      editor.openFile(
+        entry.location.file,
+        entry.location.line,
+        entry.location.column
+      );
+    }
+    const resumeKey = editor.getKeybindingLabel("resume_live_grep", "normal");
+    if (resumeKey) {
+      editor.setStatus(`${resumeKey} to resume search`);
+    }
+  },
   preview: false,
-  maxResults: 100,
+  maxResults: MAX_RESULTS,
 });
 
 /**
@@ -483,19 +534,34 @@ editor.registerCommand(
 async function search(query: string): Promise<GrepMatch[]> {
   const provider = await selectProvider();
   if (!provider) {
-    editor.setStatus(
-      "Live Grep: no search backend available — install ripgrep, or register a provider via init.ts (`editor.getPluginApi(\"live-grep\")?.registerProvider(...)`)."
+    // Throw rather than return [] — the Finder catches and shows
+    // the message inside the overlay. Returning [] would be
+    // indistinguishable from a real "no matches" result.
+    throw new Error(
+      "no search backend available — install ripgrep, or register a provider via init.ts (`editor.getPluginApi(\"live-grep\")?.registerProvider(...)`)."
     );
-    return [];
   }
+  const wasTruncated = lastSearchTruncated;
   try {
-    return await provider.search(query, {
+    const results = await provider.search(query, {
       cwd: editor.getCwd(),
-      maxResults: 100,
+      maxResults: MAX_RESULTS,
     });
+    lastSearchTruncated = results.length >= MAX_RESULTS;
+    // Refresh the toolbar whenever the truncation indicator
+    // changes so it appears (or disappears) alongside the new
+    // results in the same render.
+    if (lastSearchTruncated !== wasTruncated) {
+      updateOverlayTitle(provider);
+    }
+    return results;
   } catch (e) {
-    editor.setStatus(`Live Grep (${provider.name}) failed: ${e}`);
-    return [];
+    // Log to tracing for diagnostics, then re-throw so the Finder
+    // surfaces the failure in the overlay itself.
+    editor.error(`[live_grep:${provider.name}] ${e}`);
+    throw new Error(
+      `${provider.name}: ${e instanceof Error ? e.message : String(e)}`
+    );
   }
 }
 
@@ -512,7 +578,7 @@ function start_live_grep(): void {
   });
   // Pre-populate the overlay's frame title with the cached
   // provider name (if any) before the user types — avoids the
-  // brief "Live Grep" → "Live Grep · ripgrep" flash when the
+  // brief "Live Grep" → "Live Grep · rg" flash when the
   // first search resolves selectProvider().
   if (cachedSelected) {
     updateOverlayTitle(cachedSelected);