@fresh-editor/fresh-editor 0.2.18 → 0.2.20

package/plugins/diff_nav.ts

@@ -0,0 +1,196 @@
+/// <reference path="./lib/fresh.d.ts" />
+const editor = getEditor();
+
+/**
+ * Diff Navigation Plugin
+ *
+ * Provides unified next/previous change commands that merge changes from all
+ * available diff sources: git diff AND piece-tree saved-diff. This means a
+ * single keybinding pair navigates both committed and unsaved changes.
+ *
+ * When only one source is available (e.g. file not tracked by git), it still
+ * works using that source alone.
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface DiffHunk {
+  type: "added" | "modified" | "deleted";
+  startLine: number; // 1-indexed
+  lineCount: number;
+}
+
+/** A jump target with a byte position for sorting/deduplication */
+interface JumpTarget {
+  bytePos: number;
+  line: number; // 0-indexed, for scrollToLineCenter
+}
+
+// =============================================================================
+// Collecting jump targets from all sources
+// =============================================================================
+
+async function collectTargets(bid: number): Promise<JumpTarget[]> {
+  const targets: JumpTarget[] = [];
+
+  // Source 1: git gutter hunks
+  const hunks = editor.getViewState(bid, "git_gutter_hunks") as DiffHunk[] | null;
+  if (hunks && hunks.length > 0) {
+    for (const hunk of hunks) {
+      const line = Math.max(0, hunk.startLine - 1); // 0-indexed
+      const pos = await editor.getLineStartPosition(line);
+      if (pos !== null) {
+        targets.push({ bytePos: pos, line });
+      }
+    }
+  }
+
+  // Source 2: saved-diff (unsaved changes)
+  const diff = editor.getBufferSavedDiff(bid);
+  if (diff && !diff.equal) {
+    for (const [start, _end] of diff.byte_ranges) {
+      // We don't know the line yet; resolve it lazily after dedup
+      targets.push({ bytePos: start, line: -1 });
+    }
+  }
+
+  if (targets.length === 0) return targets;
+
+  // Sort by byte position
+  targets.sort((a, b) => a.bytePos - b.bytePos);
+
+  // Deduplicate: if two targets are on the same line, keep the first.
+  // Resolve line numbers for saved-diff targets that still have line = -1.
+  const deduped: JumpTarget[] = [];
+  const seenLines = new Set<number>();
+
+  for (const t of targets) {
+    // Resolve line if unknown
+    if (t.line === -1) {
+      // Jump cursor temporarily to find the line, then restore.
+      // Instead, use a simpler heuristic: find the line by checking
+      // existing targets or using getLineStartPosition in reverse.
+      // Actually, we can set cursor, read line, but that's side-effectful.
+      // Simpler: just check if any existing target has a bytePos close enough.
+      // For dedup, we check if any already-added target has same bytePos.
+      let isDup = false;
+      for (const existing of deduped) {
+        if (Math.abs(existing.bytePos - t.bytePos) < 2) {
+          isDup = true;
+          break;
+        }
+      }
+      if (isDup) continue;
+      deduped.push(t);
+    } else {
+      if (seenLines.has(t.line)) continue;
+      seenLines.add(t.line);
+      // Also check if a saved-diff target at similar byte pos was already added
+      let isDup = false;
+      for (const existing of deduped) {
+        if (existing.line === -1 && Math.abs(existing.bytePos - t.bytePos) < 2) {
+          // Replace the unresolved one with this one (which has a known line)
+          existing.line = t.line;
+          isDup = true;
+          break;
+        }
+      }
+      if (isDup) continue;
+      deduped.push(t);
+    }
+  }
+
+  return deduped;
+}
+
+// =============================================================================
+// Navigation
+// =============================================================================
+
+function goToTarget(bid: number, target: JumpTarget): void {
+  if (target.line >= 0) {
+    const splitId = editor.getActiveSplitId();
+    editor.scrollToLineCenter(splitId, bid, target.line);
+  }
+  editor.setBufferCursor(bid, target.bytePos);
+}
+
+async function diff_nav_next(): Promise<void> {
+  const bid = editor.getActiveBufferId();
+  const targets = await collectTargets(bid);
+
+  if (targets.length === 0) {
+    editor.setStatus(editor.t("status.no_changes"));
+    return;
+  }
+
+  const cursor = editor.getCursorPosition();
+  let idx = targets.findIndex((t) => t.bytePos > cursor);
+  let wrapped = false;
+  if (idx === -1) {
+    idx = 0;
+    wrapped = true;
+  }
+
+  goToTarget(bid, targets[idx]);
+
+  const msg = wrapped
+    ? editor.t("status.change_wrapped", { n: String(idx + 1), total: String(targets.length) })
+    : editor.t("status.change", { n: String(idx + 1), total: String(targets.length) });
+  editor.setStatus(msg);
+}
+registerHandler("diff_nav_next", diff_nav_next);
+
+async function diff_nav_prev(): Promise<void> {
+  const bid = editor.getActiveBufferId();
+  const targets = await collectTargets(bid);
+
+  if (targets.length === 0) {
+    editor.setStatus(editor.t("status.no_changes"));
+    return;
+  }
+
+  const cursor = editor.getCursorPosition();
+  let idx = -1;
+  for (let i = targets.length - 1; i >= 0; i--) {
+    if (targets[i].bytePos < cursor) {
+      idx = i;
+      break;
+    }
+  }
+  let wrapped = false;
+  if (idx === -1) {
+    idx = targets.length - 1;
+    wrapped = true;
+  }
+
+  goToTarget(bid, targets[idx]);
+
+  const msg = wrapped
+    ? editor.t("status.change_wrapped", { n: String(idx + 1), total: String(targets.length) })
+    : editor.t("status.change", { n: String(idx + 1), total: String(targets.length) });
+  editor.setStatus(msg);
+}
+registerHandler("diff_nav_prev", diff_nav_prev);
+
+// =============================================================================
+// Registration
+// =============================================================================
+
+editor.registerCommand(
+  "%cmd.next_change",
+  "%cmd.next_change_desc",
+  "diff_nav_next",
+  null
+);
+
+editor.registerCommand(
+  "%cmd.prev_change",
+  "%cmd.prev_change_desc",
+  "diff_nav_prev",
+  null
+);
+
+editor.debug("Diff Nav plugin loaded");

package/plugins/git_gutter.ts

@@ -248,6 +248,8 @@ async function updateGitGutter(bufferId: number): Promise<void> {
       editor.debug("Git Gutter: file not tracked by git");
       editor.clearLineIndicators(bufferId, NAMESPACE);
       state.hunks = [];
+      // Signal to other plugins that git is not available for this buffer
+      editor.setViewState(bufferId, "git_gutter_hunks", null);
       return;
     }
 
@@ -304,6 +306,9 @@ async function updateGitGutter(bufferId: number): Promise<void> {
     }
 
     state.hunks = hunks;
+
+    // Export hunks for other plugins (e.g. diff_nav) via shared view state
+    editor.setViewState(bufferId, "git_gutter_hunks", hunks);
   } finally {
     state.updating = false;
   }

package/plugins/lib/finder.ts

@@ -115,6 +115,9 @@ export interface FinderConfig<T> {
 
   /** Panel-specific: navigate source split when cursor moves (preview without focus change) */
   navigateOnCursorMove?: boolean;
+
+  /** Called when the panel or prompt is closed (e.g. via Escape) */
+  onClose?: () => void;
 }
 
 /**
@@ -1254,18 +1257,17 @@ export class Finder<T> {
     if (this.config.onSelect) {
       this.config.onSelect(item, entry);
     } else if (entry.location) {
-      // Default: open file at location
-      if (this.panelState.sourceSplitId !== null) {
-        this.editor.focusSplit(this.panelState.sourceSplitId);
-      }
-      this.editor.openFile(
-        entry.location.file,
-        entry.location.line,
-        entry.location.column
-      );
-      this.editor.setStatus(
-        `Jumped to ${entry.location.file}:${entry.location.line}`
-      );
+      const loc = entry.location;
+
+      // Close the panel first. This is necessary because
+      // navigateOnCursorMove's focusSplit(panelSplitId) can interfere with
+      // the jump — it queues a FocusSplit that runs after OpenFileInSplit
+      // and restores the panel as the active split.
+      this.closePanel();
+
+      // Now navigate with the panel gone — only one split remains
+      this.editor.openFile(loc.file, loc.line, loc.column);
+      this.editor.setStatus(`Jumped to ${loc.file}:${loc.line}`);
     }
   }
 
@@ -1306,6 +1308,11 @@ export class Finder<T> {
     }
 
     this.editor.setStatus("Closed");
+
+    // Notify the caller that the panel was closed
+    if (this.config.onClose) {
+      this.config.onClose();
+    }
   }
 
   private revealItem(index: number): void {

package/plugins/lib/fresh.d.ts

@@ -539,7 +539,6 @@ type BackgroundProcessResult = {
 type BufferSavedDiff = {
 	equal: boolean;
 	byte_ranges: Array<[number, number]>;
-	line_ranges: Array<[number, number]> | null;
 };
 type CreateVirtualBufferInExistingSplitOptions = {
 	/**
@@ -1096,6 +1095,11 @@ interface EditorAPI {
 	*/
 	reloadGrammars(): Promise<void>;
 	/**
+	* Get the directory where this plugin's files are stored.
+	* For package plugins this is `<plugins_dir>/packages/<plugin_name>/`.
+	*/
+	getPluginDir(): string;
+	/**
 	* Get config directory path
 	*/
 	getConfigDir(): string;

package/plugins/pkg.ts

@@ -3035,34 +3035,9 @@ editor.registerCommand("%cmd.install_url", "%cmd.install_url_desc", "pkg_install
 // Note: Other commands (install_plugin, install_theme, update, remove, sync, etc.)
 // are available via the package manager UI and don't need global command palette entries.
 
-// =============================================================================
-// Startup: Load installed language packs and bundles
-// =============================================================================
-
-(async function loadInstalledPackages() {
-  // Load language packs
-  const languages = getInstalledPackages("language");
-  for (const pkg of languages) {
-    if (pkg.manifest) {
-      editor.debug(`[pkg] Loading language pack: ${pkg.name}`);
-      await loadLanguagePack(pkg.path, pkg.manifest);
-    }
-  }
-  if (languages.length > 0) {
-    editor.debug(`[pkg] Loaded ${languages.length} language pack(s)`);
-  }
-
-  // Load bundles
-  const bundles = getInstalledPackages("bundle");
-  for (const pkg of bundles) {
-    if (pkg.manifest) {
-      editor.debug(`[pkg] Loading bundle: ${pkg.name}`);
-      await loadBundle(pkg.path, pkg.manifest);
-    }
-  }
-  if (bundles.length > 0) {
-    editor.debug(`[pkg] Loaded ${bundles.length} bundle(s)`);
-  }
-})();
+// Note: Startup loading of installed language packs and bundles is now handled
+// by Rust (services::packages::scan_installed_packages) during editor init.
+// The loadLanguagePack() and loadBundle() functions above are still used for
+// runtime installs via the package manager UI.
 
 editor.debug("Package Manager plugin loaded");