@fresh-editor/fresh-editor 0.2.12 → 0.2.13

package/plugins/examples/bookmarks.ts

@@ -73,7 +73,7 @@ function getCurrentLineCol(): { line: number; column: number } {
 }
 
 // Action: Add bookmark at current position
-globalThis.bookmark_add = function (): void {
+function bookmark_add() : void {
   const { path, position, splitId } = getCurrentLocation();
   const { line, column } = getCurrentLineCol();
 
@@ -105,10 +105,11 @@ globalThis.bookmark_add = function (): void {
 
   editor.setStatus(`Added ${name} at ${path}:${line}:${column}`);
   editor.debug(`Bookmark ${id} created: ${JSON.stringify(bookmark)}`);
-};
+}
+registerHandler("bookmark_add", bookmark_add);
 
 // Action: List all bookmarks
-globalThis.bookmark_list = function (): void {
+function bookmark_list() : void {
   if (bookmarks.size === 0) {
     editor.setStatus("No bookmarks");
     return;
@@ -121,10 +122,11 @@ globalThis.bookmark_list = function (): void {
 
   editor.setStatus(`Bookmarks: ${list.join(" | ")}`);
   editor.debug(`All bookmarks: ${JSON.stringify([...bookmarks.values()])}`);
-};
+}
+registerHandler("bookmark_list", bookmark_list);
 
 // Action: Jump to bookmark by ID
-globalThis.bookmark_goto = function (): void {
+function bookmark_goto() : void {
   if (bookmarks.size === 0) {
     editor.setStatus("No bookmarks to jump to");
     return;
@@ -147,10 +149,11 @@ globalThis.bookmark_goto = function (): void {
       editor.setStatus(`Failed to open ${firstBookmark.path}`);
     }
   }
-};
+}
+registerHandler("bookmark_goto", bookmark_goto);
 
 // Action: Jump to bookmark in same split (split-aware)
-globalThis.bookmark_goto_split = function (): void {
+function bookmark_goto_split() : void {
   if (bookmarks.size === 0) {
     editor.setStatus("No bookmarks");
     return;
@@ -176,10 +179,11 @@ globalThis.bookmark_goto_split = function (): void {
       editor.setStatus(`Failed to open in split ${currentSplit}`);
     }
   }
-};
+}
+registerHandler("bookmark_goto_split", bookmark_goto_split);
 
 // Action: Remove all bookmarks
-globalThis.bookmark_clear = function (): void {
+function bookmark_clear() : void {
   const bufferId = editor.getActiveBufferId();
 
   // Remove all bookmark overlays using namespace
@@ -189,21 +193,23 @@ globalThis.bookmark_clear = function (): void {
   bookmarks.clear();
 
   editor.setStatus(`Cleared ${count} bookmark(s)`);
-};
+}
+registerHandler("bookmark_clear", bookmark_clear);
 
 // Action: Show current split info
-globalThis.show_split_info = function (): void {
+function show_split_info() : void {
   const splitId = editor.getActiveSplitId();
   const bufferId = editor.getActiveBufferId();
   const path = editor.getBufferPath(bufferId);
 
   editor.setStatus(`Split ${splitId} | Buffer ${bufferId} | ${path || "[untitled]"}`);
-};
+}
+registerHandler("show_split_info", show_split_info);
 
 // Interactive bookmark selection using prompt API
 let bookmarkSuggestionIds: number[] = [];
 
-globalThis.bookmark_select = function (): void {
+function bookmark_select() : void {
   if (bookmarks.size === 0) {
     editor.setStatus("No bookmarks to select");
     return;
@@ -227,10 +233,11 @@ globalThis.bookmark_select = function (): void {
   editor.startPrompt("Select bookmark: ", "bookmark-select");
   editor.setPromptSuggestions(suggestions);
   editor.setStatus(`${bookmarks.size} bookmark(s) available`);
-};
+}
+registerHandler("bookmark_select", bookmark_select);
 
 // Handle bookmark selection confirmation
-globalThis.onBookmarkSelectConfirmed = function (args: {
+function onBookmarkSelectConfirmed(args: {
   prompt_type: string;
   selected_index: number | null;
   input: string;
@@ -252,17 +259,19 @@ globalThis.onBookmarkSelectConfirmed = function (args: {
   }
 
   return true;
-};
+}
+registerHandler("onBookmarkSelectConfirmed", onBookmarkSelectConfirmed);
 
 // Handle bookmark selection cancellation
-globalThis.onBookmarkSelectCancelled = function (args: { prompt_type: string }): boolean {
+function onBookmarkSelectCancelled(args: { prompt_type: string }) : boolean {
   if (args.prompt_type !== "bookmark-select") {
     return true;
   }
 
   editor.setStatus("Bookmark selection cancelled");
   return true;
-};
+}
+registerHandler("onBookmarkSelectCancelled", onBookmarkSelectCancelled);
 
 // Register bookmark event handlers
 editor.on("prompt_confirmed", "onBookmarkSelectConfirmed");
@@ -272,50 +281,43 @@ editor.on("prompt_cancelled", "onBookmarkSelectCancelled");
 editor.registerCommand(
   "Add Bookmark",
   "Add a bookmark at the current cursor position",
-  "bookmark_add",
-  "normal"
+  "bookmark_add"
 );
 
 editor.registerCommand(
   "List Bookmarks",
   "Show all bookmarks",
-  "bookmark_list",
-  "normal"
+  "bookmark_list"
 );
 
 editor.registerCommand(
   "Go to Bookmark",
   "Jump to the first bookmark",
-  "bookmark_goto",
-  "normal"
+  "bookmark_goto"
 );
 
 editor.registerCommand(
   "Go to Bookmark (Current Split)",
   "Jump to bookmark in current split",
-  "bookmark_goto_split",
-  "normal"
+  "bookmark_goto_split"
 );
 
 editor.registerCommand(
   "Clear Bookmarks",
   "Remove all bookmarks",
-  "bookmark_clear",
-  "normal"
+  "bookmark_clear"
 );
 
 editor.registerCommand(
   "Show Split Info",
   "Display current split and buffer information",
-  "show_split_info",
-  "" // Available in all contexts
+  "show_split_info"
 );
 
 editor.registerCommand(
   "Select Bookmark",
   "Interactively select and jump to a bookmark",
-  "bookmark_select",
-  "normal"
+  "bookmark_select"
 );
 
 // Plugin initialized

package/plugins/examples/buffer_query_demo.ts

@@ -6,7 +6,7 @@
  */
 
 // Show buffer info
-globalThis.show_buffer_info_demo = function(): void {
+function show_buffer_info_demo() : void {
   const bufferId = editor.getActiveBufferId();
   const info = editor.getBufferInfo(bufferId);
 
@@ -18,17 +18,17 @@ globalThis.show_buffer_info_demo = function(): void {
   } else {
     editor.setStatus("No buffer info available");
   }
-};
+}
+registerHandler("show_buffer_info_demo", show_buffer_info_demo);
 
 editor.registerCommand(
   "Query Demo: Show Buffer Info",
   "Display information about the current buffer",
-  "show_buffer_info_demo",
-  "normal"
+  "show_buffer_info_demo"
 );
 
 // Show cursor position with selection info
-globalThis.show_cursor_info_demo = function(): void {
+function show_cursor_info_demo() : void {
   const cursor = editor.getPrimaryCursor();
 
   if (cursor) {
@@ -44,30 +44,30 @@ globalThis.show_cursor_info_demo = function(): void {
   } else {
     editor.setStatus("No cursor info available");
   }
-};
+}
+registerHandler("show_cursor_info_demo", show_cursor_info_demo);
 
 editor.registerCommand(
   "Query Demo: Show Cursor Position",
   "Display cursor position and selection info",
-  "show_cursor_info_demo",
-  "normal"
+  "show_cursor_info_demo"
 );
 
 // Count all cursors (multi-cursor support)
-globalThis.count_cursors_demo = function(): void {
+function count_cursors_demo() : void {
   const cursors = editor.getAllCursors();
   editor.setStatus(`Active cursors: ${cursors.length}`);
-};
+}
+registerHandler("count_cursors_demo", count_cursors_demo);
 
 editor.registerCommand(
   "Query Demo: Count All Cursors",
   "Display the number of active cursors",
-  "count_cursors_demo",
-  "normal"
+  "count_cursors_demo"
 );
 
 // List all buffers
-globalThis.list_all_buffers_demo = function(): void {
+function list_all_buffers_demo() : void {
   const buffers = editor.listBuffers();
   let modifiedCount = 0;
 
@@ -78,17 +78,17 @@ globalThis.list_all_buffers_demo = function(): void {
   }
 
   editor.setStatus(`Open buffers: ${buffers.length} (${modifiedCount} modified)`);
-};
+}
+registerHandler("list_all_buffers_demo", list_all_buffers_demo);
 
 editor.registerCommand(
   "Query Demo: List All Buffers",
   "Show count of open buffers",
-  "list_all_buffers_demo",
-  "normal"
+  "list_all_buffers_demo"
 );
 
 // Show viewport info
-globalThis.show_viewport_demo = function(): void {
+function show_viewport_demo() : void {
   const vp = editor.getViewport();
 
   if (vp) {
@@ -97,13 +97,13 @@ globalThis.show_viewport_demo = function(): void {
   } else {
     editor.setStatus("No viewport info available");
   }
-};
+}
+registerHandler("show_viewport_demo", show_viewport_demo);
 
 editor.registerCommand(
   "Query Demo: Show Viewport Info",
   "Display viewport dimensions and scroll position",
-  "show_viewport_demo",
-  "normal"
+  "show_viewport_demo"
 );
 
 editor.setStatus("Buffer Query Demo plugin loaded! Try the 'Query Demo' commands.");

package/plugins/examples/hello_world.ts

@@ -10,7 +10,7 @@
  */
 
 // Global action: Display buffer information
-globalThis.show_buffer_info = function (): void {
+function show_buffer_info() : void {
   const bufferId = editor.getActiveBufferId();
   const path = editor.getBufferPath(bufferId);
   const length = editor.getBufferLength(bufferId);
@@ -23,10 +23,11 @@ globalThis.show_buffer_info = function (): void {
 
   editor.setStatus(status);
   editor.debug(`Buffer info: ${status}`);
-};
+}
+registerHandler("show_buffer_info", show_buffer_info);
 
 // Global action: Insert timestamp at cursor
-globalThis.insert_timestamp = function (): void {
+function insert_timestamp() : void {
   const bufferId = editor.getActiveBufferId();
   const cursorPos = editor.getCursorPosition();
   const timestamp = new Date().toISOString();
@@ -37,10 +38,11 @@ globalThis.insert_timestamp = function (): void {
   } else {
     editor.setStatus("Failed to insert timestamp");
   }
-};
+}
+registerHandler("insert_timestamp", insert_timestamp);
 
 // Global action: Highlight current line (demo overlay)
-globalThis.highlight_region = function (): void {
+function highlight_region() : void {
   const bufferId = editor.getActiveBufferId();
   const cursorPos = editor.getCursorPosition();
 
@@ -56,20 +58,22 @@ globalThis.highlight_region = function (): void {
   if (success) {
     editor.setStatus(`Highlighted region ${start}-${end}`);
   }
-};
+}
+registerHandler("highlight_region", highlight_region);
 
 // Global action: Remove highlight
-globalThis.clear_highlight = function (): void {
+function clear_highlight() : void {
   const bufferId = editor.getActiveBufferId();
   // Clear all overlays in the "demo" namespace
   const success = editor.clearNamespace(bufferId, "demo");
   if (success) {
     editor.setStatus("Cleared highlight");
   }
-};
+}
+registerHandler("clear_highlight", clear_highlight);
 
 // Global async action: Demonstrate async/await
-globalThis.async_demo = async function (): Promise<void> {
+async function async_demo() : Promise<void> {
   editor.setStatus("Starting async operation...");
 
   // Simulate some async work
@@ -79,7 +83,39 @@ globalThis.async_demo = async function (): Promise<void> {
   const length = editor.getBufferLength(bufferId);
 
   editor.setStatus(`Async operation complete! Buffer has ${length} bytes`);
-};
+}
+registerHandler("async_demo", async_demo);
+
+// Register commands so they appear in the command palette (Ctrl+P)
+editor.registerCommand(
+  "Hello: Show Buffer Info",
+  "Display active buffer information",
+  "show_buffer_info"
+);
+
+editor.registerCommand(
+  "Hello: Insert Timestamp",
+  "Insert an ISO timestamp at the cursor",
+  "insert_timestamp"
+);
+
+editor.registerCommand(
+  "Hello: Highlight Region",
+  "Highlight 10 characters around cursor",
+  "highlight_region"
+);
+
+editor.registerCommand(
+  "Hello: Clear Highlight",
+  "Remove demo highlights",
+  "clear_highlight"
+);
+
+editor.registerCommand(
+  "Hello: Async Demo",
+  "Demonstrate async/await",
+  "async_demo"
+);
 
 // Log that plugin loaded
 editor.debug("Hello World plugin loaded!");

package/plugins/examples/virtual_buffer_demo.ts

@@ -5,8 +5,7 @@
 editor.registerCommand(
   "Virtual Buffer Demo",
   "Show a demo virtual buffer with sample diagnostics",
-  "show_virtual_buffer_demo",
-  "normal"
+  "show_virtual_buffer_demo"
 );
 
 // Define a custom mode for the demo buffer
@@ -23,7 +22,7 @@ editor.defineMode(
 );
 
 // Register actions for the mode
-globalThis.demo_goto_item = () => {
+function demo_goto_item() {
   const bufferId = editor.getActiveBufferId();
   const props = editor.getTextPropertiesAtCursor(bufferId);
 
@@ -38,22 +37,26 @@ globalThis.demo_goto_item = () => {
   } else {
     editor.setStatus("No properties at cursor position");
   }
-};
+}
+registerHandler("demo_goto_item", demo_goto_item);
 
-globalThis.demo_next_item = () => {
+function demo_next_item() {
   editor.setStatus("Next item (not implemented in demo)");
-};
+}
+registerHandler("demo_next_item", demo_next_item);
 
-globalThis.demo_prev_item = () => {
+function demo_prev_item() {
   editor.setStatus("Previous item (not implemented in demo)");
-};
+}
+registerHandler("demo_prev_item", demo_prev_item);
 
-globalThis.demo_close_buffer = () => {
+function demo_close_buffer() {
   editor.setStatus("Close buffer (not implemented in demo)");
-};
+}
+registerHandler("demo_close_buffer", demo_close_buffer);
 
 // Main action: show the virtual buffer
-globalThis.show_virtual_buffer_demo = async () => {
+async function show_virtual_buffer_demo() {
   editor.setStatus("Creating virtual buffer demo...");
 
   // Create sample diagnostic entries
@@ -110,7 +113,8 @@ globalThis.show_virtual_buffer_demo = async () => {
     const errorMessage = error instanceof Error ? error.message : String(error);
     editor.setStatus(`Failed to create virtual buffer: ${errorMessage}`);
   }
-};
+}
+registerHandler("show_virtual_buffer_demo", show_virtual_buffer_demo);
 
 // Log that the plugin loaded
 editor.debug("Virtual buffer demo plugin loaded");

package/plugins/find_references.ts

@@ -62,7 +62,7 @@ async function loadLineContent(
     } else {
       try {
         const content = await editor.readFile(ref.file);
-        lines = content.split("\n");
+        lines = content ? content.split("\n") : [];
       } catch {
         lines = [];
       }
@@ -80,7 +80,7 @@ async function loadLineContent(
 }
 
 // Handle lsp_references hook
-globalThis.on_lsp_references = async function (data: {
+async function on_lsp_references(data: {
   symbol: string;
   locations: ReferenceLocation[];
 }): Promise<void> {
@@ -104,14 +104,16 @@ globalThis.on_lsp_references = async function (data: {
       load: async () => pendingRefs,
     },
   });
-};
+}
+registerHandler("on_lsp_references", on_lsp_references);
 
 // Register the hook handler
 editor.on("lsp_references", "on_lsp_references");
 
 // Close function for command palette
-globalThis.close_references = function (): void {
+function close_references() : void {
   finder.close();
-};
+}
+registerHandler("close_references", close_references);
 
 editor.debug("Find References plugin loaded (using Finder abstraction)");

package/plugins/git_blame.ts

@@ -253,7 +253,7 @@ async function fetchFileContent(filePath: string, commit: string | null): Promis
 
   // Get current file content using editor API (cross-platform)
   try {
-    return await editor.readFile(filePath);
+    return await editor.readFile(filePath) ?? "";
   } catch {
     return "";
   }
@@ -404,7 +404,7 @@ function addBlameHeaders(): void {
 /**
  * Show git blame for the current file
  */
-globalThis.show_git_blame = async function(): Promise<void> {
+async function show_git_blame() : Promise<void> {
   if (blameState.isOpen) {
     editor.setStatus(editor.t("status.already_open"));
     return;
@@ -502,7 +502,8 @@ globalThis.show_git_blame = async function(): Promise<void> {
     resetState();
     editor.setStatus(editor.t("status.failed_open"));
   }
-};
+}
+registerHandler("show_git_blame", show_git_blame);
 
 /**
  * Reset blame state
@@ -521,7 +522,7 @@ function resetState(): void {
 /**
  * Close the git blame view
  */
-globalThis.git_blame_close = function(): void {
+function git_blame_close() : void {
   if (!blameState.isOpen) {
     return;
   }
@@ -541,7 +542,8 @@ globalThis.git_blame_close = function(): void {
   resetState();
 
   editor.setStatus(editor.t("status.closed"));
-};
+}
+registerHandler("git_blame_close", git_blame_close);
 
 /**
  * Get the commit hash at the current cursor position
@@ -564,7 +566,7 @@ function getCommitAtCursor(): string | null {
 /**
  * Navigate to blame at the parent commit of the current line's commit
  */
-globalThis.git_blame_go_back = async function(): Promise<void> {
+async function git_blame_go_back() : Promise<void> {
   if (!blameState.isOpen || !blameState.sourceFilePath) {
     return;
   }
@@ -644,12 +646,13 @@ globalThis.git_blame_go_back = async function(): Promise<void> {
 
   const depth = blameState.commitStack.length;
   editor.setStatus(editor.t("status.blame_at_parent", { hash: currentHash.slice(0, 7), depth: String(depth) }));
-};
+}
+registerHandler("git_blame_go_back", git_blame_go_back);
 
 /**
  * Copy the commit hash at cursor to clipboard
  */
-globalThis.git_blame_copy_hash = function(): void {
+function git_blame_copy_hash() : void {
   if (!blameState.isOpen) return;
 
   const hash = getCommitAtCursor();
@@ -667,7 +670,8 @@ globalThis.git_blame_copy_hash = function(): void {
   // Copy hash to clipboard
   editor.copyToClipboard(hash);
   editor.setStatus(editor.t("status.hash_copied", { short: hash.slice(0, 7), full: hash }));
-};
+}
+registerHandler("git_blame_copy_hash", git_blame_copy_hash);
 
 // =============================================================================
 // Command Registration

package/plugins/git_explorer.ts

@@ -141,17 +141,20 @@ async function refreshGitExplorerDecorations() {
   }
 }
 
-globalThis.onGitExplorerAfterFileOpen = () => {
+function onGitExplorerAfterFileOpen() {
   refreshGitExplorerDecorations();
-};
+}
+registerHandler("onGitExplorerAfterFileOpen", onGitExplorerAfterFileOpen);
 
-globalThis.onGitExplorerAfterFileSave = () => {
+function onGitExplorerAfterFileSave() {
   refreshGitExplorerDecorations();
-};
+}
+registerHandler("onGitExplorerAfterFileSave", onGitExplorerAfterFileSave);
 
-globalThis.onGitExplorerEditorInitialized = () => {
+function onGitExplorerEditorInitialized() {
   refreshGitExplorerDecorations();
-};
+}
+registerHandler("onGitExplorerEditorInitialized", onGitExplorerEditorInitialized);
 
 editor.on("after_file_open", "onGitExplorerAfterFileOpen");
 editor.on("after_file_save", "onGitExplorerAfterFileSave");

package/plugins/git_find_file.ts

@@ -39,7 +39,7 @@ async function loadGitFiles(): Promise<string[]> {
 }
 
 // Global function to start file finder
-globalThis.start_git_find_file = function (): void {
+function start_git_find_file() : void {
   finder.prompt({
     title: editor.t("prompt.find_file"),
     source: {
@@ -48,14 +48,16 @@ globalThis.start_git_find_file = function (): void {
       // Uses built-in fuzzy filter by default
     },
   });
-};
+}
+registerHandler("start_git_find_file", start_git_find_file);
 
 // Reload git files command
-globalThis.git_reload_files = async function (): Promise<void> {
+async function git_reload_files() : Promise<void> {
   // Just re-trigger the prompt which will reload
-  globalThis.start_git_find_file();
+  start_git_find_file();
   editor.setStatus(editor.t("status.reloading"));
-};
+}
+registerHandler("git_reload_files", git_reload_files);
 
 // Register commands
 editor.registerCommand(

package/plugins/git_grep.ts

@@ -54,7 +54,7 @@ async function searchWithGitGrep(query: string): Promise<GrepMatch[]> {
 }
 
 // Global function to start git grep
-globalThis.start_git_grep = function (): void {
+function start_git_grep() : void {
   finder.prompt({
     title: editor.t("prompt.grep"),
     source: {
@@ -64,7 +64,8 @@ globalThis.start_git_grep = function (): void {
       minQueryLength: 1,
     },
   });
-};
+}
+registerHandler("start_git_grep", start_git_grep);
 
 // Register command
 editor.registerCommand("%cmd.grep", "%cmd.grep_desc", "start_git_grep", null);