@fresh-editor/fresh-editor 0.1.4

package/plugins/examples/bookmarks.ts

@@ -0,0 +1,329 @@
+/// <reference path="../../types/fresh.d.ts" />
+
+/**
+ * Bookmarks Plugin for Fresh Editor (TypeScript)
+ *
+ * Demonstrates the new TypeScript plugin ops:
+ * - editor.registerCommand() - Register plugin commands
+ * - editor.openFile() - Open file at specific location
+ * - editor.getActiveSplitId() - Get current split ID
+ * - editor.openFileInSplit() - Open file in specific split
+ *
+ * Features:
+ * - Add bookmarks at current cursor position
+ * - List all bookmarks
+ * - Jump to bookmarks
+ * - Remove bookmarks
+ * - Split-aware navigation
+ */
+
+// Bookmark storage
+interface Bookmark {
+  id: number;
+  name: string;
+  path: string;
+  line: number;
+  column: number;
+  splitId: number;
+}
+
+const bookmarks: Map<number, Bookmark> = new Map();
+let nextBookmarkId = 1;
+
+// Helper: Get current location info
+function getCurrentLocation(): {
+  path: string;
+  position: number;
+  splitId: number;
+} {
+  const bufferId = editor.getActiveBufferId();
+  const path = editor.getBufferPath(bufferId);
+  const position = editor.getCursorPosition();
+  const splitId = editor.getActiveSplitId();
+
+  return { path, position, splitId };
+}
+
+// Helper: Get actual line number using the API
+function getCurrentLineCol(): { line: number; column: number } {
+  // Use the actual getCursorLine API for accurate line number
+  const lineNumber = editor.getCursorLine();
+
+  // Get cursor position within the line by reading buffer content
+  const bufferId = editor.getActiveBufferId();
+  const cursorPos = editor.getCursorPosition();
+  const bufferInfo = editor.getBufferInfo(bufferId);
+
+  // Calculate column by finding start of current line
+  let column = 1;
+  if (bufferInfo && cursorPos > 0) {
+    // Read a small chunk before cursor to find line start
+    const readStart = Math.max(0, cursorPos - 1000);
+    const textBefore = editor.getBufferText(bufferId, readStart, cursorPos);
+    const lastNewline = textBefore.lastIndexOf("\n");
+    if (lastNewline !== -1) {
+      column = cursorPos - (readStart + lastNewline);
+    } else {
+      // No newline found, column is position from readStart
+      column = cursorPos - readStart + 1;
+    }
+  }
+
+  return { line: lineNumber, column };
+}
+
+// Action: Add bookmark at current position
+globalThis.bookmark_add = function (): void {
+  const { path, position, splitId } = getCurrentLocation();
+  const { line, column } = getCurrentLineCol();
+
+  if (!path) {
+    editor.setStatus("Cannot bookmark: buffer has no file path");
+    return;
+  }
+
+  const id = nextBookmarkId++;
+  const name = `Bookmark ${id}`;
+
+  const bookmark: Bookmark = {
+    id,
+    name,
+    path,
+    line,
+    column,
+    splitId,
+  };
+
+  bookmarks.set(id, bookmark);
+
+  // Add visual indicator with bookmark namespace
+  const bufferId = editor.getActiveBufferId();
+  editor.addOverlay(
+    bufferId,
+    "bookmark",  // namespace for all bookmarks
+    position,
+    position + 1,
+    0, // Red
+    128, // Green (teal color)
+    255, // Blue
+    true // Underline
+  );
+
+  editor.setStatus(`Added ${name} at ${path}:${line}:${column}`);
+  editor.debug(`Bookmark ${id} created: ${JSON.stringify(bookmark)}`);
+};
+
+// Action: List all bookmarks
+globalThis.bookmark_list = function (): void {
+  if (bookmarks.size === 0) {
+    editor.setStatus("No bookmarks");
+    return;
+  }
+
+  const list: string[] = [];
+  bookmarks.forEach((bm, id) => {
+    list.push(`[${id}] ${bm.path}:${bm.line}:${bm.column}`);
+  });
+
+  editor.setStatus(`Bookmarks: ${list.join(" | ")}`);
+  editor.debug(`All bookmarks: ${JSON.stringify([...bookmarks.values()])}`);
+};
+
+// Action: Jump to bookmark by ID
+globalThis.bookmark_goto = function (): void {
+  if (bookmarks.size === 0) {
+    editor.setStatus("No bookmarks to jump to");
+    return;
+  }
+
+  // Jump to the first bookmark (simplified)
+  const firstBookmark = bookmarks.values().next().value;
+  if (firstBookmark) {
+    const success = editor.openFile(
+      firstBookmark.path,
+      firstBookmark.line,
+      firstBookmark.column
+    );
+
+    if (success) {
+      editor.setStatus(
+        `Jumped to ${firstBookmark.name}: ${firstBookmark.path}:${firstBookmark.line}`
+      );
+    } else {
+      editor.setStatus(`Failed to open ${firstBookmark.path}`);
+    }
+  }
+};
+
+// Action: Jump to bookmark in same split (split-aware)
+globalThis.bookmark_goto_split = function (): void {
+  if (bookmarks.size === 0) {
+    editor.setStatus("No bookmarks");
+    return;
+  }
+
+  const currentSplit = editor.getActiveSplitId();
+  const firstBookmark = bookmarks.values().next().value;
+
+  if (firstBookmark) {
+    // Open in the current split, not the bookmark's original split
+    const success = editor.openFileInSplit(
+      currentSplit,
+      firstBookmark.path,
+      firstBookmark.line,
+      firstBookmark.column
+    );
+
+    if (success) {
+      editor.setStatus(
+        `Opened ${firstBookmark.name} in split ${currentSplit}`
+      );
+    } else {
+      editor.setStatus(`Failed to open in split ${currentSplit}`);
+    }
+  }
+};
+
+// Action: Remove all bookmarks
+globalThis.bookmark_clear = function (): void {
+  const bufferId = editor.getActiveBufferId();
+
+  // Remove all bookmark overlays using namespace
+  editor.clearNamespace(bufferId, "bookmark");
+
+  const count = bookmarks.size;
+  bookmarks.clear();
+
+  editor.setStatus(`Cleared ${count} bookmark(s)`);
+};
+
+// Action: Show current split info
+globalThis.show_split_info = function (): void {
+  const splitId = editor.getActiveSplitId();
+  const bufferId = editor.getActiveBufferId();
+  const path = editor.getBufferPath(bufferId);
+
+  editor.setStatus(`Split ${splitId} | Buffer ${bufferId} | ${path || "[untitled]"}`);
+};
+
+// Interactive bookmark selection using prompt API
+let bookmarkSuggestionIds: number[] = [];
+
+globalThis.bookmark_select = function (): void {
+  if (bookmarks.size === 0) {
+    editor.setStatus("No bookmarks to select");
+    return;
+  }
+
+  // Create suggestions from bookmarks
+  const suggestions: PromptSuggestion[] = [];
+  bookmarkSuggestionIds = [];
+
+  bookmarks.forEach((bm) => {
+    const filename = bm.path.split("/").pop() || bm.path;
+    suggestions.push({
+      text: `${bm.name}: ${bm.path}:${bm.line}:${bm.column}`,
+      description: `${filename} at line ${bm.line}`,
+      value: String(bm.id),
+      disabled: false,
+    });
+    bookmarkSuggestionIds.push(bm.id);
+  });
+
+  editor.startPrompt("Select bookmark: ", "bookmark-select");
+  editor.setPromptSuggestions(suggestions);
+  editor.setStatus(`${bookmarks.size} bookmark(s) available`);
+};
+
+// Handle bookmark selection confirmation
+globalThis.onBookmarkSelectConfirmed = function (args: {
+  prompt_type: string;
+  selected_index: number | null;
+  input: string;
+}): boolean {
+  if (args.prompt_type !== "bookmark-select") {
+    return true;
+  }
+
+  if (args.selected_index !== null && bookmarkSuggestionIds[args.selected_index] !== undefined) {
+    const bookmarkId = bookmarkSuggestionIds[args.selected_index];
+    const bookmark = bookmarks.get(bookmarkId);
+
+    if (bookmark) {
+      editor.openFile(bookmark.path, bookmark.line, bookmark.column);
+      editor.setStatus(`Jumped to ${bookmark.name}: ${bookmark.path}:${bookmark.line}`);
+    }
+  } else {
+    editor.setStatus("No bookmark selected");
+  }
+
+  return true;
+};
+
+// Handle bookmark selection cancellation
+globalThis.onBookmarkSelectCancelled = function (args: { prompt_type: string }): boolean {
+  if (args.prompt_type !== "bookmark-select") {
+    return true;
+  }
+
+  editor.setStatus("Bookmark selection cancelled");
+  return true;
+};
+
+// Register bookmark event handlers
+editor.on("prompt_confirmed", "onBookmarkSelectConfirmed");
+editor.on("prompt_cancelled", "onBookmarkSelectCancelled");
+
+// Register commands on plugin load
+editor.registerCommand(
+  "Add Bookmark",
+  "Add a bookmark at the current cursor position",
+  "bookmark_add",
+  "normal"
+);
+
+editor.registerCommand(
+  "List Bookmarks",
+  "Show all bookmarks",
+  "bookmark_list",
+  "normal"
+);
+
+editor.registerCommand(
+  "Go to Bookmark",
+  "Jump to the first bookmark",
+  "bookmark_goto",
+  "normal"
+);
+
+editor.registerCommand(
+  "Go to Bookmark (Current Split)",
+  "Jump to bookmark in current split",
+  "bookmark_goto_split",
+  "normal"
+);
+
+editor.registerCommand(
+  "Clear Bookmarks",
+  "Remove all bookmarks",
+  "bookmark_clear",
+  "normal"
+);
+
+editor.registerCommand(
+  "Show Split Info",
+  "Display current split and buffer information",
+  "show_split_info",
+  "" // Available in all contexts
+);
+
+editor.registerCommand(
+  "Select Bookmark",
+  "Interactively select and jump to a bookmark",
+  "bookmark_select",
+  "normal"
+);
+
+// Plugin initialized
+editor.setStatus("Bookmarks plugin loaded - 7 commands registered");
+editor.debug("Bookmarks plugin initialized with command registration and prompt API support");

package/plugins/examples/buffer_query_demo.ts

@@ -0,0 +1,110 @@
+/// <reference path="../../types/fresh.d.ts" />
+
+/**
+ * Buffer Query Demo Plugin
+ * Demonstrates the buffer query APIs in Phase 2
+ */
+
+// Show buffer info
+globalThis.show_buffer_info_demo = function(): void {
+  const bufferId = editor.getActiveBufferId();
+  const info = editor.getBufferInfo(bufferId);
+
+  if (info) {
+    const msg = `Buffer ${info.id}: ${info.path || "[No Name]"} (${
+      info.modified ? "modified" : "saved"
+    }, ${info.length} bytes)`;
+    editor.setStatus(msg);
+  } else {
+    editor.setStatus("No buffer info available");
+  }
+};
+
+editor.registerCommand(
+  "Query Demo: Show Buffer Info",
+  "Display information about the current buffer",
+  "show_buffer_info_demo",
+  "normal"
+);
+
+// Show cursor position with selection info
+globalThis.show_cursor_info_demo = function(): void {
+  const cursor = editor.getPrimaryCursor();
+
+  if (cursor) {
+    let msg: string;
+    if (cursor.selection) {
+      msg = `Cursor at ${cursor.position}, selection: ${cursor.selection.start}-${cursor.selection.end} (${
+        cursor.selection.end - cursor.selection.start
+      } chars)`;
+    } else {
+      msg = `Cursor at byte position ${cursor.position} (no selection)`;
+    }
+    editor.setStatus(msg);
+  } else {
+    editor.setStatus("No cursor info available");
+  }
+};
+
+editor.registerCommand(
+  "Query Demo: Show Cursor Position",
+  "Display cursor position and selection info",
+  "show_cursor_info_demo",
+  "normal"
+);
+
+// Count all cursors (multi-cursor support)
+globalThis.count_cursors_demo = function(): void {
+  const cursors = editor.getAllCursors();
+  editor.setStatus(`Active cursors: ${cursors.length}`);
+};
+
+editor.registerCommand(
+  "Query Demo: Count All Cursors",
+  "Display the number of active cursors",
+  "count_cursors_demo",
+  "normal"
+);
+
+// List all buffers
+globalThis.list_all_buffers_demo = function(): void {
+  const buffers = editor.listBuffers();
+  let modifiedCount = 0;
+
+  for (const buf of buffers) {
+    if (buf.modified) {
+      modifiedCount++;
+    }
+  }
+
+  editor.setStatus(`Open buffers: ${buffers.length} (${modifiedCount} modified)`);
+};
+
+editor.registerCommand(
+  "Query Demo: List All Buffers",
+  "Show count of open buffers",
+  "list_all_buffers_demo",
+  "normal"
+);
+
+// Show viewport info
+globalThis.show_viewport_demo = function(): void {
+  const vp = editor.getViewport();
+
+  if (vp) {
+    const msg = `Viewport: ${vp.width}x${vp.height}, top_byte=${vp.top_byte}, left_col=${vp.left_column}`;
+    editor.setStatus(msg);
+  } else {
+    editor.setStatus("No viewport info available");
+  }
+};
+
+editor.registerCommand(
+  "Query Demo: Show Viewport Info",
+  "Display viewport dimensions and scroll position",
+  "show_viewport_demo",
+  "normal"
+);
+
+editor.setStatus("Buffer Query Demo plugin loaded! Try the 'Query Demo' commands.");
+editor.debug("Buffer Query Demo plugin initialized (TypeScript version)");

package/plugins/examples/git_grep.ts

@@ -0,0 +1,262 @@
+/// <reference path="../../types/fresh.d.ts" />
+
+/**
+ * Git Grep TypeScript Plugin for Fresh Editor
+ *
+ * Demonstrates async process spawning with native Promises:
+ * - Uses editor.spawnProcess() for async git operations
+ * - Parses git grep output and displays results
+ * - Shows file opening with line/column positioning
+ * - Registers multiple commands on plugin load
+ *
+ * This is a significant improvement over the Lua version because:
+ * - Native async/await instead of callback-based pattern
+ * - Cleaner error handling with try/catch
+ * - Type safety from TypeScript
+ * - Better state management with closures
+ */
+
+// Store search results for navigation
+interface GrepMatch {
+  file: string;
+  line: number;
+  text: string;
+}
+
+let searchResults: GrepMatch[] = [];
+let currentResultIndex = 0;
+
+// Parse git grep output into structured results
+function parseGitGrepOutput(output: string): GrepMatch[] {
+  const matches: GrepMatch[] = [];
+  const lines = output.split("\n").filter((line) => line.trim());
+
+  for (const line of lines) {
+    // git grep output format: file:line:text
+    const match = line.match(/^([^:]+):(\d+):(.*)$/);
+    if (match) {
+      matches.push({
+        file: match[1],
+        line: parseInt(match[2], 10),
+        text: match[3].trim(),
+      });
+    }
+  }
+
+  return matches;
+}
+
+// Action: Search for pattern in repository
+globalThis.git_grep_search = async function (): Promise<void> {
+  // For now, search for a hardcoded pattern
+  // In a full implementation, this would use a prompt
+  const pattern = "TODO";
+
+  editor.setStatus(`Searching for "${pattern}"...`);
+
+  try {
+    const result = await editor.spawnProcess("git", [
+      "grep",
+      "-n", // Show line numbers
+      "-I", // Skip binary files
+      pattern,
+    ]);
+
+    if (result.exit_code === 0 && result.stdout.trim()) {
+      searchResults = parseGitGrepOutput(result.stdout);
+      currentResultIndex = 0;
+
+      if (searchResults.length > 0) {
+        editor.setStatus(
+          `Found ${searchResults.length} matches for "${pattern}"`
+        );
+        editor.debug(`Git grep results: ${JSON.stringify(searchResults)}`);
+
+        // Jump to first result
+        const first = searchResults[0];
+        editor.openFile(first.file, first.line, 1);
+        editor.setStatus(
+          `[1/${searchResults.length}] ${first.file}:${first.line}: ${first.text}`
+        );
+      }
+    } else if (result.exit_code === 1) {
+      // git grep returns 1 when no matches found
+      editor.setStatus(`No matches found for "${pattern}"`);
+      searchResults = [];
+    } else {
+      editor.setStatus(`Git grep error: ${result.stderr || "Unknown error"}`);
+      editor.debug(`Git grep failed with exit code ${result.exit_code}`);
+    }
+  } catch (error) {
+    editor.setStatus(`Git grep failed: ${error}`);
+    editor.debug(`Git grep exception: ${error}`);
+  }
+};
+
+// Action: Go to next search result
+globalThis.git_grep_next = function (): void {
+  if (searchResults.length === 0) {
+    editor.setStatus("No search results. Run git_grep_search first.");
+    return;
+  }
+
+  currentResultIndex = (currentResultIndex + 1) % searchResults.length;
+  const result = searchResults[currentResultIndex];
+
+  editor.openFile(result.file, result.line, 1);
+  editor.setStatus(
+    `[${currentResultIndex + 1}/${searchResults.length}] ${result.file}:${result.line}: ${result.text}`
+  );
+};
+
+// Action: Go to previous search result
+globalThis.git_grep_prev = function (): void {
+  if (searchResults.length === 0) {
+    editor.setStatus("No search results. Run git_grep_search first.");
+    return;
+  }
+
+  currentResultIndex =
+    (currentResultIndex - 1 + searchResults.length) % searchResults.length;
+  const result = searchResults[currentResultIndex];
+
+  editor.openFile(result.file, result.line, 1);
+  editor.setStatus(
+    `[${currentResultIndex + 1}/${searchResults.length}] ${result.file}:${result.line}: ${result.text}`
+  );
+};
+
+// Action: Show current git status
+globalThis.git_status = async function (): Promise<void> {
+  editor.setStatus("Getting git status...");
+
+  try {
+    const result = await editor.spawnProcess("git", ["status", "--short"]);
+
+    if (result.exit_code === 0) {
+      const lines = result.stdout.trim().split("\n").filter((l) => l);
+      if (lines.length === 0) {
+        editor.setStatus("Git: Clean working directory");
+      } else {
+        editor.setStatus(`Git: ${lines.length} changed file(s)`);
+        editor.debug(`Git status:\n${result.stdout}`);
+      }
+    } else {
+      editor.setStatus(`Not a git repository or git error`);
+    }
+  } catch (error) {
+    editor.setStatus(`Git status failed: ${error}`);
+  }
+};
+
+// Action: Show current branch
+globalThis.git_branch = async function (): Promise<void> {
+  try {
+    const result = await editor.spawnProcess("git", [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD",
+    ]);
+
+    if (result.exit_code === 0) {
+      const branch = result.stdout.trim();
+      editor.setStatus(`Git branch: ${branch}`);
+    } else {
+      editor.setStatus("Not a git repository");
+    }
+  } catch (error) {
+    editor.setStatus(`Git branch failed: ${error}`);
+  }
+};
+
+// Action: Show recent commits
+globalThis.git_log = async function (): Promise<void> {
+  editor.setStatus("Fetching recent commits...");
+
+  try {
+    const result = await editor.spawnProcess("git", [
+      "log",
+      "--oneline",
+      "-10", // Last 10 commits
+    ]);
+
+    if (result.exit_code === 0) {
+      const lines = result.stdout.trim().split("\n");
+      editor.setStatus(`Git: ${lines.length} recent commits`);
+      editor.debug(`Recent commits:\n${result.stdout}`);
+
+      // Show first commit in status
+      if (lines.length > 0) {
+        editor.setStatus(`Latest: ${lines[0]}`);
+      }
+    } else {
+      editor.setStatus("Git log failed");
+    }
+  } catch (error) {
+    editor.setStatus(`Git log failed: ${error}`);
+  }
+};
+
+// Register commands on plugin load
+editor.registerCommand(
+  "Git Grep: Search TODOs",
+  "Search for TODO comments in the repository",
+  "git_grep_search",
+  "normal"
+);
+
+editor.registerCommand(
+  "Git Grep: Next Result",
+  "Jump to next search result",
+  "git_grep_next",
+  "normal"
+);
+
+editor.registerCommand(
+  "Git Grep: Previous Result",
+  "Jump to previous search result",
+  "git_grep_prev",
+  "normal"
+);
+
+editor.registerCommand(
+  "Git: Show Status",
+  "Display git status summary",
+  "git_status",
+  "" // Available in all contexts
+);
+
+editor.registerCommand(
+  "Git: Show Branch",
+  "Display current git branch",
+  "git_branch",
+  ""
+);
+
+editor.registerCommand(
+  "Git: Recent Commits",
+  "Show recent commit history",
+  "git_log",
+  ""
+);
+
+// Plugin initialized
+editor.setStatus("Git Grep plugin loaded - 6 commands registered");
+editor.debug("Git Grep TypeScript plugin initialized");
+
+// Automatically show git branch on load
+(async () => {
+  try {
+    const result = await editor.spawnProcess("git", [
+      "rev-parse",
+      "--abbrev-ref",
+      "HEAD",
+    ]);
+    if (result.exit_code === 0) {
+      const branch = result.stdout.trim();
+      editor.setStatus(`Git Grep plugin ready | Branch: ${branch}`);
+    }
+  } catch {
+    // Silently fail if not in a git repo
+  }
+})();