@involvex/fresh-editor 0.1.76 → 0.1.78

package/bin/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
+  }
+})();

package/bin/plugins/examples/hello_world.ts

@@ -0,0 +1,93 @@
+/// <reference path="../../types/fresh.d.ts" />
+
+/**
+ * Hello World TypeScript Plugin for Fresh Editor
+ *
+ * This is a simple example plugin that demonstrates:
+ * - Querying editor state (buffer info, cursor position)
+ * - Sending commands (status messages, text insertion)
+ * - Using async/await for plugin actions
+ */
+
+// Global action: Display buffer information
+globalThis.show_buffer_info = function (): void {
+  const bufferId = editor.getActiveBufferId();
+  const path = editor.getBufferPath(bufferId);
+  const length = editor.getBufferLength(bufferId);
+  const modified = editor.isBufferModified(bufferId);
+  const cursorPos = editor.getCursorPosition();
+
+  const status = `Buffer ${bufferId}: ${path || "[untitled]"} | ${length} bytes | ${
+    modified ? "modified" : "saved"
+  } | cursor@${cursorPos}`;
+
+  editor.setStatus(status);
+  editor.debug(`Buffer info: ${status}`);
+};
+
+// Global action: Insert timestamp at cursor
+globalThis.insert_timestamp = function (): void {
+  const bufferId = editor.getActiveBufferId();
+  const cursorPos = editor.getCursorPosition();
+  const timestamp = new Date().toISOString();
+
+  const success = editor.insertText(bufferId, cursorPos, timestamp);
+  if (success) {
+    editor.setStatus(`Inserted timestamp: ${timestamp}`);
+  } else {
+    editor.setStatus("Failed to insert timestamp");
+  }
+};
+
+// Global action: Highlight current line (demo overlay)
+globalThis.highlight_region = function (): void {
+  const bufferId = editor.getActiveBufferId();
+  const cursorPos = editor.getCursorPosition();
+
+  // Highlight 10 characters around cursor
+  const start = Math.max(0, cursorPos - 5);
+  const end = cursorPos + 5;
+
+  // Use namespace "demo" for batch operations
+  const success = editor.addOverlay(
+    bufferId,
+    "demo",  // namespace
+    start,
+    end,
+    255, // Red
+    255, // Green
+    0, // Blue (yellow highlight)
+    false // No underline
+  );
+
+  if (success) {
+    editor.setStatus(`Highlighted region ${start}-${end}`);
+  }
+};
+
+// Global action: Remove highlight
+globalThis.clear_highlight = function (): void {
+  const bufferId = editor.getActiveBufferId();
+  // Clear all overlays in the "demo" namespace
+  const success = editor.clearNamespace(bufferId, "demo");
+  if (success) {
+    editor.setStatus("Cleared highlight");
+  }
+};
+
+// Global async action: Demonstrate async/await
+globalThis.async_demo = async function (): Promise<void> {
+  editor.setStatus("Starting async operation...");
+
+  // Simulate some async work
+  await Promise.resolve();
+
+  const bufferId = editor.getActiveBufferId();
+  const length = editor.getBufferLength(bufferId);
+
+  editor.setStatus(`Async operation complete! Buffer has ${length} bytes`);
+};
+
+// Log that plugin loaded
+editor.debug("Hello World plugin loaded!");
+editor.setStatus("Hello World plugin ready");

package/bin/plugins/examples/virtual_buffer_demo.ts

@@ -0,0 +1,116 @@
+// Virtual Buffer Demo Plugin
+// Demonstrates the virtual buffer API for creating diagnostic panels, search results, etc.
+
+// Register a command to show a demo virtual buffer
+editor.registerCommand(
+  "Virtual Buffer Demo",
+  "Show a demo virtual buffer with sample diagnostics",
+  "show_virtual_buffer_demo",
+  "normal"
+);
+
+// Define a custom mode for the demo buffer
+editor.defineMode(
+  "demo-list", // mode name
+  null,         // no parent mode
+  [
+    ["Return", "demo_goto_item"],
+    ["n", "demo_next_item"],
+    ["p", "demo_prev_item"],
+    ["q", "demo_close_buffer"],
+  ],
+  true // read-only
+);
+
+// Register actions for the mode
+globalThis.demo_goto_item = () => {
+  const bufferId = editor.getActiveBufferId();
+  const props = editor.getTextPropertiesAtCursor(bufferId);
+
+  if (props.length > 0) {
+    const location = props[0].location as { file: string; line: number; column: number } | undefined;
+    if (location) {
+      editor.openFile(location.file, location.line, location.column || 0);
+      editor.setStatus(`Jumped to ${location.file}:${location.line}`);
+    } else {
+      editor.setStatus("No location info for this item");
+    }
+  } else {
+    editor.setStatus("No properties at cursor position");
+  }
+};
+
+globalThis.demo_next_item = () => {
+  editor.setStatus("Next item (not implemented in demo)");
+};
+
+globalThis.demo_prev_item = () => {
+  editor.setStatus("Previous item (not implemented in demo)");
+};
+
+globalThis.demo_close_buffer = () => {
+  editor.setStatus("Close buffer (not implemented in demo)");
+};
+
+// Main action: show the virtual buffer
+globalThis.show_virtual_buffer_demo = async () => {
+  editor.setStatus("Creating virtual buffer demo...");
+
+  // Create sample diagnostic entries
+  const entries = [
+    {
+      text: "[ERROR] src/main.rs:42:10 - undefined variable 'foo'\n",
+      properties: {
+        severity: "error",
+        location: { file: "src/main.rs", line: 42, column: 10 },
+        message: "undefined variable 'foo'",
+      },
+    },
+    {
+      text: "[WARNING] src/lib.rs:100:5 - unused variable 'bar'\n",
+      properties: {
+        severity: "warning",
+        location: { file: "src/lib.rs", line: 100, column: 5 },
+        message: "unused variable 'bar'",
+      },
+    },
+    {
+      text: "[INFO] src/utils.rs:25:1 - consider using 'if let' instead of 'match'\n",
+      properties: {
+        severity: "info",
+        location: { file: "src/utils.rs", line: 25, column: 1 },
+        message: "consider using 'if let' instead of 'match'",
+      },
+    },
+    {
+      text: "[HINT] src/config.rs:8:20 - type annotation unnecessary\n",
+      properties: {
+        severity: "hint",
+        location: { file: "src/config.rs", line: 8, column: 20 },
+        message: "type annotation unnecessary",
+      },
+    },
+  ];
+
+  // Create the virtual buffer in a horizontal split
+  try {
+    const bufferId = await editor.createVirtualBufferInSplit({
+      name: "*Demo Diagnostics*",
+      mode: "demo-list",
+      read_only: true,
+      entries: entries,
+      ratio: 0.7, // Original pane takes 70%, demo buffer takes 30%
+      panel_id: "demo-diagnostics",
+      show_line_numbers: false,
+      show_cursors: true,
+    });
+
+    editor.setStatus(`Created demo virtual buffer (ID: ${bufferId}) with ${entries.length} items - Press RET to jump to location`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    editor.setStatus(`Failed to create virtual buffer: ${errorMessage}`);
+  }
+};
+
+// Log that the plugin loaded
+editor.debug("Virtual buffer demo plugin loaded");