@fresh-editor/fresh-editor 0.1.10 → 0.1.12

package/npm-shrinkwrap.json

@@ -23,7 +23,7 @@
       "hasInstallScript": true,
       "license": "GPL-2.0",
       "name": "@fresh-editor/fresh-editor",
-      "version": "0.1.10"
+      "version": "0.1.12"
     },
     "node_modules/@isaacs/balanced-match": {
       "engines": {
@@ -896,5 +896,5 @@
     }
   },
   "requires": true,
-  "version": "0.1.10"
+  "version": "0.1.12"
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.10",
+  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.12",
   "author": "Noam Lewis",
   "bin": {
     "fresh": "run-fresh.js"
@@ -92,7 +92,7 @@
       "zipExt": ".tar.xz"
     }
   },
-  "version": "0.1.10",
+  "version": "0.1.12",
   "volta": {
     "node": "18.14.1",
     "npm": "9.5.0"

package/plugins/calculator.ts

@@ -0,0 +1,768 @@
+/// <reference path="../types/fresh.d.ts" />
+
+/**
+ * Calculator Plugin for Fresh Editor
+ *
+ * A sleek visual calculator with:
+ * - Mouse-clickable buttons (anywhere in button area)
+ * - Keyboard input support
+ * - Expression parsing with parentheses and basic arithmetic
+ * - Modern calculator styling with ANSI colors
+ * - Compact fixed-size layout centered in view
+ */
+
+// ANSI color codes
+const C = {
+  RESET: "\x1b[0m",
+  BOLD: "\x1b[1m",
+  DIM: "\x1b[2m",
+  // Colors
+  RED: "\x1b[31m",
+  GREEN: "\x1b[32m",
+  YELLOW: "\x1b[33m",
+  BLUE: "\x1b[34m",
+  MAGENTA: "\x1b[35m",
+  CYAN: "\x1b[36m",
+  WHITE: "\x1b[37m",
+  BRIGHT_RED: "\x1b[91m",
+  BRIGHT_GREEN: "\x1b[92m",
+  BRIGHT_YELLOW: "\x1b[93m",
+  BRIGHT_BLUE: "\x1b[94m",
+  BRIGHT_MAGENTA: "\x1b[95m",
+  BRIGHT_CYAN: "\x1b[96m",
+  // Backgrounds
+  BG_BLACK: "\x1b[40m",
+  BG_RED: "\x1b[41m",
+  BG_GREEN: "\x1b[42m",
+  BG_YELLOW: "\x1b[43m",
+  BG_BLUE: "\x1b[44m",
+  BG_MAGENTA: "\x1b[45m",
+  BG_CYAN: "\x1b[46m",
+  BG_WHITE: "\x1b[47m",
+  BG_BRIGHT_BLACK: "\x1b[100m",
+};
+
+// Calculator state
+interface CalculatorState {
+  expression: string;
+  result: string;
+  error: string;
+  bufferId: number;
+  splitId: number;
+  lastViewport: ViewportInfo | null;
+}
+
+const state: CalculatorState = {
+  expression: "",
+  result: "0",
+  error: "",
+  bufferId: 0,
+  splitId: 0,
+  lastViewport: null,
+};
+
+// Cache the layout so it doesn't jump around
+let cachedLayout: LayoutMetrics | null = null;
+
+// Track hovered button for visual feedback
+let hoveredButton: { row: number; col: number } | null = null;
+
+// Track if copy button is hovered
+let copyButtonHovered = false;
+
+// Button definitions
+interface Button {
+  label: string;
+  action: string;
+  type: "number" | "operator" | "function" | "clear" | "equals";
+}
+
+const BUTTON_LAYOUT: Button[][] = [
+  [
+    { label: "C", action: "clear", type: "clear" },
+    { label: "(", action: "(", type: "function" },
+    { label: ")", action: ")", type: "function" },
+    { label: "^", action: "^", type: "operator" },
+    { label: "÷", action: "/", type: "operator" },
+  ],
+  [
+    { label: "sqrt", action: "sqrt(", type: "function" },
+    { label: "ln", action: "ln(", type: "function" },
+    { label: "log", action: "log(", type: "function" },
+    { label: "π", action: "pi", type: "number" },
+    { label: "×", action: "*", type: "operator" },
+  ],
+  [
+    { label: "sin", action: "sin(", type: "function" },
+    { label: "cos", action: "cos(", type: "function" },
+    { label: "tan", action: "tan(", type: "function" },
+    { label: "e", action: "e", type: "number" },
+    { label: "-", action: "-", type: "operator" },
+  ],
+  [
+    { label: "7", action: "7", type: "number" },
+    { label: "8", action: "8", type: "number" },
+    { label: "9", action: "9", type: "number" },
+    { label: "⌫", action: "backspace", type: "clear" },
+    { label: "+", action: "+", type: "operator" },
+  ],
+  [
+    { label: "4", action: "4", type: "number" },
+    { label: "5", action: "5", type: "number" },
+    { label: "6", action: "6", type: "number" },
+    { label: "±", action: "negate", type: "function" },
+    { label: "=", action: "equals", type: "equals" },
+  ],
+  [
+    { label: "1", action: "1", type: "number" },
+    { label: "2", action: "2", type: "number" },
+    { label: "3", action: "3", type: "number" },
+    { label: "0", action: "0", type: "number" },
+    { label: ".", action: ".", type: "number" },
+  ],
+];
+
+// Fixed layout constants
+const BUTTON_WIDTH = 5;
+const NUM_COLS = 5;
+const NUM_ROWS = 6;
+const CALC_WIDTH = BUTTON_WIDTH * NUM_COLS + 1; // 26 chars
+const DISPLAY_LINES = 2;
+
+// Get color for button type (with optional hover highlight)
+function getButtonColor(type: Button["type"], isHovered: boolean): string {
+  if (isHovered) {
+    // Bright/inverted colors for hover
+    return C.BG_WHITE + "\x1b[30m"; // White background, black text
+  }
+  switch (type) {
+    case "number": return C.WHITE;
+    case "operator": return C.BRIGHT_YELLOW;
+    case "function": return C.BRIGHT_CYAN;
+    case "clear": return C.BRIGHT_RED;
+    case "equals": return C.BRIGHT_GREEN;
+    default: return C.WHITE;
+  }
+}
+
+// Layout metrics
+interface LayoutMetrics {
+  startX: number;
+  startY: number;
+}
+
+function calculateLayout(_viewport: ViewportInfo): LayoutMetrics {
+  // Position at top-left with 1 row/column gap
+  const startX = 1;
+  const startY = 1;
+
+  return { startX, startY };
+}
+
+// Render the calculator with ANSI colors
+function renderCalculator(): TextPropertyEntry[] {
+  const viewport = editor.getViewport();
+  if (!viewport) {
+    return [{ text: "No viewport\n", properties: {} }];
+  }
+
+  state.lastViewport = viewport;
+
+  // Use cached layout to prevent jumping, or calculate new one
+  if (!cachedLayout) {
+    cachedLayout = calculateLayout(viewport);
+  }
+  const layout = cachedLayout;
+  const entries: TextPropertyEntry[] = [];
+
+  const addLine = (text: string): void => {
+    entries.push({ text: text + "\n", properties: {} });
+  };
+
+  // Top margin
+  for (let i = 0; i < layout.startY; i++) {
+    addLine("");
+  }
+
+  const pad = " ".repeat(layout.startX);
+
+  // Unicode box drawing chars
+  const TL = "╭", TR = "╮", BL = "╰", BR = "╯";
+  const V = "│";
+  const LT = "├", RT = "┤", X = "┼";
+
+  // Generate border patterns dynamically
+  const cellWidth = BUTTON_WIDTH - 1; // 4 dashes per cell
+  const topBorder = TL + "─".repeat(CALC_WIDTH - 2) + TR;
+  const sepTop = LT + Array(NUM_COLS).fill("─".repeat(cellWidth)).join("┬") + RT;
+  const sepMid = LT + Array(NUM_COLS).fill("─".repeat(cellWidth)).join("┼") + RT;
+  const sepBot = BL + Array(NUM_COLS).fill("─".repeat(cellWidth)).join("┴") + BR;
+
+  // Display - top border
+  addLine(`${pad}${C.CYAN}${topBorder}${C.RESET}`);
+
+  // Expression line
+  let expr = state.expression || "";
+  const maxLen = CALC_WIDTH - 4;
+  if (expr.length > maxLen) expr = expr.slice(-maxLen);
+  addLine(`${pad}${C.CYAN}${V}${C.RESET} ${C.BRIGHT_GREEN}${expr.padStart(maxLen)}${C.RESET} ${C.CYAN}${V}${C.RESET}`);
+
+  // Result line with copy button on left - slightly different background
+  let result = state.error || state.result;
+  const copyBtnWidth = 6; // "Copy" + 2 spaces
+  const resultMaxLen = maxLen - copyBtnWidth;
+  if (result.length > resultMaxLen) result = result.slice(0, resultMaxLen);
+  const resultColor = state.error ? C.BRIGHT_RED : C.BRIGHT_GREEN;
+  const copyBtnColor = copyButtonHovered ? (C.BG_WHITE + "\x1b[30m") : (C.BG_BRIGHT_BLACK + C.BRIGHT_MAGENTA);
+  const resultBg = C.BG_BRIGHT_BLACK;
+  addLine(`${pad}${C.CYAN}${V}${C.RESET}${copyBtnColor}Copy${C.RESET}${resultBg}  ${C.BOLD}${resultColor}${result.padStart(resultMaxLen)}${C.RESET}${resultBg}  ${C.RESET}${C.CYAN}${V}${C.RESET}`);
+
+  // Separator between display and buttons
+  addLine(`${pad}${C.CYAN}${sepTop}${C.RESET}`);
+
+  // Button rows
+  for (let rowIdx = 0; rowIdx < BUTTON_LAYOUT.length; rowIdx++) {
+    const buttonRow = BUTTON_LAYOUT[rowIdx];
+    let line = `${pad}${C.CYAN}${V}${C.RESET}`;
+
+    for (let colIdx = 0; colIdx < buttonRow.length; colIdx++) {
+      const btn = buttonRow[colIdx];
+      const isHovered = hoveredButton?.row === rowIdx && hoveredButton?.col === colIdx;
+      const color = getButtonColor(btn.type, isHovered);
+      const label = btn.label;
+      const innerWidth = BUTTON_WIDTH - 1;
+      const leftSpace = Math.floor((innerWidth - label.length) / 2);
+      const rightSpace = innerWidth - label.length - leftSpace;
+      line += `${color}${C.BOLD}${" ".repeat(leftSpace)}${label}${" ".repeat(rightSpace)}${C.RESET}${C.CYAN}${V}${C.RESET}`;
+    }
+
+    addLine(line);
+
+    // Row separator (except after last row)
+    if (rowIdx < BUTTON_LAYOUT.length - 1) {
+      addLine(`${pad}${C.CYAN}${sepMid}${C.RESET}`);
+    }
+  }
+
+  // Bottom border
+  addLine(`${pad}${C.CYAN}${sepBot}${C.RESET}`);
+
+  // Help line
+  addLine("");
+  addLine(`${pad}${C.DIM}  Esc:close  =/Enter:calc  Del:clear${C.RESET}`);
+
+  return entries;
+}
+
+// Check if click is on copy button (returns true if on copy button)
+function isCopyButtonAt(contentCol: number, contentRow: number): boolean {
+  if (!cachedLayout) return false;
+
+  // Copy button is on result line (row 2 after top margin)
+  const resultLineY = cachedLayout.startY + 2; // top border + expression line
+  const copyBtnStartX = cachedLayout.startX + 1; // after left border
+  const copyBtnEndX = copyBtnStartX + 4; // "Copy" is 4 chars
+
+  return contentRow === resultLineY &&
+         contentCol >= copyBtnStartX &&
+         contentCol < copyBtnEndX;
+}
+
+// Copy result to clipboard
+function copyResultToClipboard(): void {
+  const textToCopy = state.error || state.result;
+  editor.copyToClipboard(textToCopy);
+  editor.setStatus(`Copied: ${textToCopy}`);
+}
+
+// Get button position at content-relative coordinates
+function getButtonPosition(contentCol: number, contentRow: number): { row: number; col: number } | null {
+  if (!cachedLayout) return null;
+
+  // Button area starts after: marginY + display(2 lines) + borders(2)
+  const buttonAreaStartY = cachedLayout.startY + DISPLAY_LINES + 2;
+  const buttonAreaStartX = cachedLayout.startX + 1; // +1 for left border
+
+  const relY = contentRow - buttonAreaStartY;
+  const relX = contentCol - buttonAreaStartX;
+
+  if (relX < 0 || relY < 0) return null;
+  if (relX >= BUTTON_WIDTH * NUM_COLS) return null;
+
+  // Check if on horizontal separator line (odd rows are separators)
+  if (relY % 2 === 1) return null;
+
+  // Check if on vertical border (every BUTTON_WIDTH chars, minus 1 for the separator)
+  const posInButton = relX % BUTTON_WIDTH;
+  if (posInButton === BUTTON_WIDTH - 1) return null; // On the | border
+
+  // Each button row = 2 lines (content + separator)
+  const buttonRowIdx = Math.floor(relY / 2);
+  if (buttonRowIdx < 0 || buttonRowIdx >= NUM_ROWS) return null;
+
+  // Column
+  const buttonColIdx = Math.floor(relX / BUTTON_WIDTH);
+  if (buttonColIdx < 0 || buttonColIdx >= NUM_COLS) return null;
+
+  return { row: buttonRowIdx, col: buttonColIdx };
+}
+
+// Get button at content-relative position
+function getButtonAt(contentCol: number, contentRow: number): Button | null {
+  const pos = getButtonPosition(contentCol, contentRow);
+  if (!pos) return null;
+  return BUTTON_LAYOUT[pos.row][pos.col];
+}
+
+// Expression parser
+interface Token {
+  type: "number" | "operator" | "lparen" | "rparen" | "function" | "constant";
+  value: string | number;
+}
+
+// Known functions and constants
+const FUNCTIONS = ["sqrt", "ln", "log", "sin", "cos", "tan", "asin", "acos", "atan", "abs"];
+const CONSTANTS: Record<string, number> = {
+  pi: Math.PI,
+  e: Math.E,
+};
+
+function tokenize(expr: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+
+  while (i < expr.length) {
+    const ch = expr[i];
+
+    if (/\s/.test(ch)) { i++; continue; }
+
+    // Numbers
+    if (/[0-9.]/.test(ch)) {
+      let num = "";
+      while (i < expr.length && /[0-9.]/.test(expr[i])) {
+        num += expr[i];
+        i++;
+      }
+      tokens.push({ type: "number", value: parseFloat(num) });
+      continue;
+    }
+
+    // Identifiers (functions and constants)
+    if (/[a-zA-Z]/.test(ch)) {
+      let ident = "";
+      while (i < expr.length && /[a-zA-Z0-9]/.test(expr[i])) {
+        ident += expr[i];
+        i++;
+      }
+      if (FUNCTIONS.includes(ident)) {
+        tokens.push({ type: "function", value: ident });
+      } else if (ident in CONSTANTS) {
+        tokens.push({ type: "constant", value: ident });
+      } else {
+        throw new Error(`Unknown: ${ident}`);
+      }
+      continue;
+    }
+
+    if (ch === "(") { tokens.push({ type: "lparen", value: "(" }); i++; continue; }
+    if (ch === ")") { tokens.push({ type: "rparen", value: ")" }); i++; continue; }
+    if (/[+\-*/^]/.test(ch)) { tokens.push({ type: "operator", value: ch }); i++; continue; }
+
+    i++;
+  }
+
+  return tokens;
+}
+
+// Precedence: + - < * / < ^ < unary - < functions
+function parseExpression(tokens: Token[], pos: { idx: number }): number {
+  let left = parseTerm(tokens, pos);
+
+  while (pos.idx < tokens.length) {
+    const token = tokens[pos.idx];
+    if (token.type === "operator" && (token.value === "+" || token.value === "-")) {
+      pos.idx++;
+      const right = parseTerm(tokens, pos);
+      left = token.value === "+" ? left + right : left - right;
+    } else {
+      break;
+    }
+  }
+
+  return left;
+}
+
+function parseTerm(tokens: Token[], pos: { idx: number }): number {
+  let left = parsePower(tokens, pos);
+
+  while (pos.idx < tokens.length) {
+    const token = tokens[pos.idx];
+    if (token.type === "operator" && (token.value === "*" || token.value === "/")) {
+      pos.idx++;
+      const right = parsePower(tokens, pos);
+      if (token.value === "*") {
+        left = left * right;
+      } else {
+        if (right === 0) throw new Error("Div by 0");
+        left = left / right;
+      }
+    } else {
+      break;
+    }
+  }
+
+  return left;
+}
+
+function parsePower(tokens: Token[], pos: { idx: number }): number {
+  const base = parseUnary(tokens, pos);
+
+  if (pos.idx < tokens.length && tokens[pos.idx].type === "operator" && tokens[pos.idx].value === "^") {
+    pos.idx++;
+    const exp = parsePower(tokens, pos); // Right associative
+    return Math.pow(base, exp);
+  }
+
+  return base;
+}
+
+function parseUnary(tokens: Token[], pos: { idx: number }): number {
+  if (pos.idx >= tokens.length) throw new Error("Unexpected end");
+
+  const token = tokens[pos.idx];
+
+  if (token.type === "operator" && token.value === "-") {
+    pos.idx++;
+    return -parseUnary(tokens, pos);
+  }
+
+  return parsePrimary(tokens, pos);
+}
+
+function parsePrimary(tokens: Token[], pos: { idx: number }): number {
+  if (pos.idx >= tokens.length) throw new Error("Unexpected end");
+
+  const token = tokens[pos.idx];
+
+  // Function call
+  if (token.type === "function") {
+    const fname = token.value as string;
+    pos.idx++;
+    if (pos.idx >= tokens.length || tokens[pos.idx].type !== "lparen") {
+      throw new Error(`Expected ( after ${fname}`);
+    }
+    pos.idx++; // skip (
+    const arg = parseExpression(tokens, pos);
+    if (pos.idx >= tokens.length || tokens[pos.idx].type !== "rparen") {
+      throw new Error("Missing )");
+    }
+    pos.idx++; // skip )
+
+    switch (fname) {
+      case "sqrt": return Math.sqrt(arg);
+      case "ln": return Math.log(arg);
+      case "log": return Math.log10(arg);
+      case "sin": return Math.sin(arg);
+      case "cos": return Math.cos(arg);
+      case "tan": return Math.tan(arg);
+      case "asin": return Math.asin(arg);
+      case "acos": return Math.acos(arg);
+      case "atan": return Math.atan(arg);
+      case "abs": return Math.abs(arg);
+      default: throw new Error(`Unknown function: ${fname}`);
+    }
+  }
+
+  // Constant
+  if (token.type === "constant") {
+    pos.idx++;
+    return CONSTANTS[token.value as string];
+  }
+
+  // Number
+  if (token.type === "number") {
+    pos.idx++;
+    return token.value as number;
+  }
+
+  // Parenthesized expression
+  if (token.type === "lparen") {
+    pos.idx++;
+    const result = parseExpression(tokens, pos);
+    if (pos.idx >= tokens.length || tokens[pos.idx].type !== "rparen") {
+      throw new Error("Missing )");
+    }
+    pos.idx++;
+    return result;
+  }
+
+  throw new Error("Syntax error");
+}
+
+function evaluateExpression(expr: string): string {
+  if (!expr.trim()) return "0";
+
+  const tokens = tokenize(expr);
+  if (tokens.length === 0) return "0";
+
+  const pos = { idx: 0 };
+  const result = parseExpression(tokens, pos);
+
+  if (pos.idx < tokens.length) throw new Error("Syntax error");
+
+  if (Number.isInteger(result)) {
+    return result.toString();
+  } else {
+    return parseFloat(result.toFixed(10)).toString();
+  }
+}
+
+// Handle button press
+function handleButton(button: Button): void {
+  state.error = "";
+
+  switch (button.action) {
+    case "clear":
+      state.expression = "";
+      state.result = "0";
+      break;
+    case "backspace":
+      if (state.expression.length > 0) {
+        state.expression = state.expression.slice(0, -1);
+      }
+      break;
+    case "negate":
+      // Toggle sign: if expression is empty, negate last result; otherwise toggle current number
+      if (state.expression === "") {
+        // Use negated result as new expression
+        if (state.result !== "0") {
+          const num = parseFloat(state.result);
+          state.expression = (-num).toString();
+          state.result = state.expression;
+        } else {
+          state.expression = "-";
+        }
+      } else {
+        // Try to toggle sign of last number in expression
+        const match = state.expression.match(/(-?\d+\.?\d*)$/);
+        if (match) {
+          const numStr = match[1];
+          const prefix = state.expression.slice(0, state.expression.length - numStr.length);
+          const num = parseFloat(numStr);
+          state.expression = prefix + (-num).toString();
+        } else {
+          // No number at end, just add minus
+          state.expression += "-";
+        }
+      }
+      break;
+    case "equals":
+      try {
+        state.result = evaluateExpression(state.expression);
+      } catch (e) {
+        state.error = e instanceof Error ? e.message : "Error";
+      }
+      break;
+    default:
+      state.expression += button.action;
+      break;
+  }
+
+  updateDisplay();
+}
+
+function updateDisplay(): void {
+  if (state.bufferId) {
+    const entries = renderCalculator();
+    editor.setVirtualBufferContent(state.bufferId, entries);
+  }
+}
+
+// Mouse click handler
+globalThis.onCalculatorMouseClick = function (data: {
+  column: number;
+  row: number;
+  button: string;
+  modifiers: string;
+  content_x: number;
+  content_y: number;
+}): boolean {
+  if (data.button !== "left") return true;
+
+  const activeBuffer = editor.getActiveBufferId();
+  if (activeBuffer !== state.bufferId || state.bufferId === 0) return true;
+
+  // Convert screen coordinates to content-relative coordinates
+  const relCol = data.column - data.content_x;
+  const relRow = data.row - data.content_y;
+
+  // Check for copy button click
+  if (isCopyButtonAt(relCol, relRow)) {
+    copyResultToClipboard();
+    return false;
+  }
+
+  const button = getButtonAt(relCol, relRow);
+  if (button) {
+    handleButton(button);
+    return false;
+  }
+
+  return true;
+};
+
+// Keyboard handlers
+globalThis.calc_digit_0 = function (): void { handleButton({ label: "0", action: "0", type: "number" }); };
+globalThis.calc_digit_1 = function (): void { handleButton({ label: "1", action: "1", type: "number" }); };
+globalThis.calc_digit_2 = function (): void { handleButton({ label: "2", action: "2", type: "number" }); };
+globalThis.calc_digit_3 = function (): void { handleButton({ label: "3", action: "3", type: "number" }); };
+globalThis.calc_digit_4 = function (): void { handleButton({ label: "4", action: "4", type: "number" }); };
+globalThis.calc_digit_5 = function (): void { handleButton({ label: "5", action: "5", type: "number" }); };
+globalThis.calc_digit_6 = function (): void { handleButton({ label: "6", action: "6", type: "number" }); };
+globalThis.calc_digit_7 = function (): void { handleButton({ label: "7", action: "7", type: "number" }); };
+globalThis.calc_digit_8 = function (): void { handleButton({ label: "8", action: "8", type: "number" }); };
+globalThis.calc_digit_9 = function (): void { handleButton({ label: "9", action: "9", type: "number" }); };
+
+globalThis.calc_add = function (): void { handleButton({ label: "+", action: "+", type: "operator" }); };
+globalThis.calc_subtract = function (): void { handleButton({ label: "-", action: "-", type: "operator" }); };
+globalThis.calc_multiply = function (): void { handleButton({ label: "×", action: "*", type: "operator" }); };
+globalThis.calc_divide = function (): void { handleButton({ label: "÷", action: "/", type: "operator" }); };
+globalThis.calc_lparen = function (): void { handleButton({ label: "(", action: "(", type: "function" }); };
+globalThis.calc_rparen = function (): void { handleButton({ label: ")", action: ")", type: "function" }); };
+globalThis.calc_dot = function (): void { handleButton({ label: ".", action: ".", type: "number" }); };
+globalThis.calc_equals = function (): void { handleButton({ label: "=", action: "equals", type: "equals" }); };
+globalThis.calc_clear = function (): void { handleButton({ label: "C", action: "clear", type: "clear" }); };
+globalThis.calc_backspace = function (): void { handleButton({ label: "⌫", action: "backspace", type: "clear" }); };
+globalThis.calc_power = function (): void { handleButton({ label: "^", action: "^", type: "operator" }); };
+
+// Letter handlers for typing function names
+const letterHandler = (ch: string) => () => {
+  state.error = "";
+  state.expression += ch;
+  updateDisplay();
+};
+for (const ch of "abcdefghijklmnopqrstuvwxyz") {
+  (globalThis as Record<string, unknown>)[`calc_letter_${ch}`] = letterHandler(ch);
+}
+
+globalThis.calc_close = function (): void {
+  if (state.bufferId) {
+    editor.closeBuffer(state.bufferId);
+    state.bufferId = 0;
+  }
+};
+
+// Open calculator
+globalThis.calculator_open = async function (): Promise<void> {
+  if (state.bufferId) {
+    const bufferInfo = editor.getBufferInfo(state.bufferId);
+    if (bufferInfo) {
+      editor.showBuffer(state.bufferId);
+      return;
+    }
+    state.bufferId = 0;
+  }
+
+  state.expression = "";
+  state.result = "0";
+  state.error = "";
+  cachedLayout = null; // Reset layout for fresh calculation
+  hoveredButton = null; // Reset hover state
+  copyButtonHovered = false; // Reset copy button hover state
+
+  const modeBindings: [string, string][] = [
+    ["0", "calc_digit_0"], ["1", "calc_digit_1"], ["2", "calc_digit_2"],
+    ["3", "calc_digit_3"], ["4", "calc_digit_4"], ["5", "calc_digit_5"],
+    ["6", "calc_digit_6"], ["7", "calc_digit_7"], ["8", "calc_digit_8"],
+    ["9", "calc_digit_9"],
+    ["+", "calc_add"], ["-", "calc_subtract"], ["*", "calc_multiply"],
+    ["/", "calc_divide"], ["(", "calc_lparen"], [")", "calc_rparen"],
+    [".", "calc_dot"], ["^", "calc_power"],
+    ["Return", "calc_equals"], ["=", "calc_equals"],
+    ["Delete", "calc_clear"],
+    ["Backspace", "calc_backspace"],
+    ["Escape", "calc_close"],
+  ];
+  // Add letter bindings for typing function names
+  for (const ch of "abcdefghijklmnopqrstuvwxyz") {
+    modeBindings.push([ch, `calc_letter_${ch}`]);
+  }
+  editor.defineMode("calculator", "special", modeBindings, true);
+
+  const cmds = [
+    ["calc_digit_0", "0"], ["calc_digit_1", "1"], ["calc_digit_2", "2"],
+    ["calc_digit_3", "3"], ["calc_digit_4", "4"], ["calc_digit_5", "5"],
+    ["calc_digit_6", "6"], ["calc_digit_7", "7"], ["calc_digit_8", "8"],
+    ["calc_digit_9", "9"], ["calc_add", "+"], ["calc_subtract", "-"],
+    ["calc_multiply", "*"], ["calc_divide", "/"], ["calc_lparen", "("],
+    ["calc_rparen", ")"], ["calc_dot", "."], ["calc_equals", "="],
+    ["calc_clear", "C"], ["calc_backspace", "BS"], ["calc_close", "close"],
+    ["calc_power", "^"],
+  ];
+  for (const [name, desc] of cmds) {
+    editor.registerCommand(name, `Calc: ${desc}`, name, "calculator");
+  }
+  // Register letter commands
+  for (const ch of "abcdefghijklmnopqrstuvwxyz") {
+    editor.registerCommand(`calc_letter_${ch}`, `Calc: ${ch}`, `calc_letter_${ch}`, "calculator");
+  }
+
+  const entries = renderCalculator();
+
+  state.bufferId = await editor.createVirtualBuffer({
+    name: "*Calculator*",
+    mode: "calculator",
+    read_only: true,
+    entries,
+    show_line_numbers: false,
+    show_cursors: false,
+    editing_disabled: true,
+  });
+
+  state.splitId = editor.getActiveSplitId();
+
+  editor.setStatus("Calculator opened");
+};
+
+// Mouse move handler for hover effect
+globalThis.onCalculatorMouseMove = function (data: {
+  column: number;
+  row: number;
+  content_x: number;
+  content_y: number;
+}): boolean {
+  const activeBuffer = editor.getActiveBufferId();
+  if (activeBuffer !== state.bufferId || state.bufferId === 0) return true;
+
+  // Convert screen coordinates to content-relative coordinates
+  const relCol = data.column - data.content_x;
+  const relRow = data.row - data.content_y;
+
+  const newHover = getButtonPosition(relCol, relRow);
+  const newCopyHover = isCopyButtonAt(relCol, relRow);
+
+  // Check if hover changed
+  const buttonChanged =
+    (newHover === null && hoveredButton !== null) ||
+    (newHover !== null && hoveredButton === null) ||
+    (newHover !== null && hoveredButton !== null &&
+      (newHover.row !== hoveredButton.row || newHover.col !== hoveredButton.col));
+  const copyChanged = newCopyHover !== copyButtonHovered;
+
+  if (buttonChanged || copyChanged) {
+    hoveredButton = newHover;
+    copyButtonHovered = newCopyHover;
+    updateDisplay();
+  }
+
+  return true;
+};
+
+// Register hooks
+editor.on("mouse_click", "onCalculatorMouseClick");
+editor.on("mouse_move", "onCalculatorMouseMove");
+
+// Register main command
+editor.registerCommand("Calculator", "Open calculator", "calculator_open", "normal");
+
+editor.setStatus("Calculator plugin loaded");

package/plugins/lib/fresh.d.ts

@@ -183,6 +183,12 @@ interface TextPropertyEntry {
   properties: Record<string, unknown>;
 }
 
+/** Result from createVirtualBufferInSplit */
+interface CreateVirtualBufferResult {
+  buffer_id: number;
+  split_id?: number | null;
+}
+
 /** Configuration for createVirtualBufferInSplit */
 interface CreateVirtualBufferOptions {
   /** Buffer name shown in status bar (convention: "*Name*") */
@@ -380,6 +386,14 @@ interface EditorAPI {
   setPromptSuggestions(suggestions: PromptSuggestion[]): boolean;
 
   // === Buffer Mutations ===
+  /**
+   * Copy text to the system clipboard
+   *
+   * Copies the provided text to both the internal and system clipboard.
+   * Uses OSC 52 and arboard for cross-platform compatibility.
+   * @param text - Text to copy to clipboard
+   */
+  setClipboard(text: string): void;
   /**
    * Insert text at a byte position in a buffer
    *
@@ -462,9 +476,10 @@ interface EditorAPI {
    * @param description - Human-readable description
    * @param action - JavaScript function name to call when command is triggered
    * @param contexts - Comma-separated list of contexts (e.g., "normal,prompt")
+   * @param source - Plugin source name (empty string for builtin)
    * @returns true if command was registered
    */
-  registerCommand(name: string, description: string, action: string, contexts: string): boolean;
+  registerCommand(name: string, description: string, action: string, contexts: string, source: string): boolean;
   /**
    * Unregister a custom command by name
    * @param name - The name of the command to unregister
@@ -829,7 +844,7 @@ interface EditorAPI {
    * panel_id: "search"
    * });
    */
-  createVirtualBufferInSplit(options: CreateVirtualBufferOptions): Promise<number>;
+  createVirtualBufferInSplit(options: CreateVirtualBufferOptions): Promise<CreateVirtualBufferResult>;
   /**
    * Create a virtual buffer in an existing split
    * @param options - Configuration for the virtual buffer

package/plugins/live_grep.ts

@@ -0,0 +1,342 @@
+/// <reference path="./lib/fresh.d.ts" />
+
+/**
+ * Live Grep Plugin
+ *
+ * Project-wide search with ripgrep and live preview.
+ * - Type to search across all files
+ * - Navigate results with Up/Down to see preview
+ * - Press Enter to open file at location
+ */
+
+interface GrepMatch {
+  file: string;
+  line: number;
+  column: number;
+  content: string;
+}
+
+// State management
+let grepResults: GrepMatch[] = [];
+let previewBufferId: number | null = null;
+let previewSplitId: number | null = null;
+let originalSplitId: number | null = null;
+let lastQuery: string = "";
+let searchDebounceTimer: number | null = null;
+let previewCreated: boolean = false;
+
+// Parse ripgrep output line
+// Format: file:line:column:content
+function parseRipgrepLine(line: string): GrepMatch | null {
+  const match = line.match(/^([^:]+):(\d+):(\d+):(.*)$/);
+  if (match) {
+    return {
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      content: match[4],
+    };
+  }
+  return null;
+}
+
+// Parse ripgrep output into suggestions
+function parseRipgrepOutput(stdout: string): {
+  results: GrepMatch[];
+  suggestions: PromptSuggestion[];
+} {
+  const results: GrepMatch[] = [];
+  const suggestions: PromptSuggestion[] = [];
+
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const match = parseRipgrepLine(line);
+    if (match) {
+      results.push(match);
+
+      // Truncate long content for display
+      const displayContent =
+        match.content.length > 60
+          ? match.content.substring(0, 57) + "..."
+          : match.content;
+
+      suggestions.push({
+        text: `${match.file}:${match.line}`,
+        description: displayContent.trim(),
+        value: `${results.length - 1}`, // Store index as value
+        disabled: false,
+      });
+
+      // Limit to 100 results for performance
+      if (results.length >= 100) {
+        break;
+      }
+    }
+  }
+
+  return { results, suggestions };
+}
+
+// Create or update preview buffer with file content
+async function updatePreview(match: GrepMatch): Promise<void> {
+  try {
+    // Read the file content
+    const content = await editor.readFile(match.file);
+    const lines = content.split("\n");
+
+    // Calculate context window (5 lines before and after)
+    const contextBefore = 5;
+    const contextAfter = 5;
+    const startLine = Math.max(0, match.line - 1 - contextBefore);
+    const endLine = Math.min(lines.length, match.line + contextAfter);
+
+    // Build preview entries with highlighting
+    const entries: TextPropertyEntry[] = [];
+
+    // Header
+    entries.push({
+      text: `  ${match.file}:${match.line}:${match.column}\n`,
+      properties: { type: "header" },
+    });
+    entries.push({
+      text: "─".repeat(60) + "\n",
+      properties: { type: "separator" },
+    });
+
+    // Content lines with line numbers
+    for (let i = startLine; i < endLine; i++) {
+      const lineNum = i + 1;
+      const lineContent = lines[i] || "";
+      const isMatchLine = lineNum === match.line;
+      const prefix = isMatchLine ? "▶ " : "  ";
+      const lineNumStr = String(lineNum).padStart(4, " ");
+
+      entries.push({
+        text: `${prefix}${lineNumStr} │ ${lineContent}\n`,
+        properties: {
+          type: isMatchLine ? "match" : "context",
+          line: lineNum,
+        },
+      });
+    }
+
+    // Create or update the preview buffer
+    if (previewBufferId === null) {
+      // Define mode for preview buffer
+      editor.defineMode("live-grep-preview", "special", [["q", "close_buffer"]], true);
+
+      // Create preview in a split on the right
+      const result = await editor.createVirtualBufferInSplit({
+        name: "*Preview*",
+        mode: "live-grep-preview",
+        read_only: true,
+        entries,
+        ratio: 0.5,
+        direction: "vertical",
+        panel_id: "live-grep-preview",
+        show_line_numbers: false,
+        editing_disabled: true,
+      });
+
+      // Extract buffer and split IDs from result
+      previewBufferId = result.buffer_id;
+      previewSplitId = result.split_id ?? null;
+
+      // Return focus to original split so prompt stays active
+      if (originalSplitId !== null) {
+        editor.focusSplit(originalSplitId);
+      }
+    } else {
+      // Update existing buffer content
+      editor.setVirtualBufferContent(previewBufferId, entries);
+    }
+  } catch (e) {
+    editor.debug(`Failed to update preview: ${e}`);
+  }
+}
+
+// Close preview buffer and its split
+function closePreview(): void {
+  // Close the buffer first
+  if (previewBufferId !== null) {
+    editor.closeBuffer(previewBufferId);
+    previewBufferId = null;
+  }
+  // Then close the split
+  if (previewSplitId !== null) {
+    editor.closeSplit(previewSplitId);
+    previewSplitId = null;
+  }
+}
+
+// Run ripgrep search
+async function runSearch(query: string): Promise<void> {
+  if (!query || query.trim().length < 2) {
+    editor.setPromptSuggestions([]);
+    grepResults = [];
+    return;
+  }
+
+  // Avoid duplicate searches
+  if (query === lastQuery) {
+    return;
+  }
+  lastQuery = query;
+
+  try {
+    const result = await editor.spawnProcess("rg", [
+      "--line-number",
+      "--column",
+      "--no-heading",
+      "--color=never",
+      "--smart-case",
+      "--max-count=100",
+      "-g", "!.git",
+      "-g", "!node_modules",
+      "-g", "!target",
+      "-g", "!*.lock",
+      "--",
+      query,
+    ]);
+
+    if (result.exit_code === 0) {
+      const { results, suggestions } = parseRipgrepOutput(result.stdout);
+      grepResults = results;
+      editor.setPromptSuggestions(suggestions);
+
+      if (results.length > 0) {
+        editor.setStatus(`Found ${results.length} matches`);
+        // Show preview of first result
+        await updatePreview(results[0]);
+      } else {
+        editor.setStatus("No matches found");
+      }
+    } else if (result.exit_code === 1) {
+      // No matches
+      grepResults = [];
+      editor.setPromptSuggestions([]);
+      editor.setStatus("No matches found");
+    } else {
+      editor.setStatus(`Search error: ${result.stderr}`);
+    }
+  } catch (e) {
+    editor.setStatus(`Search error: ${e}`);
+  }
+}
+
+// Start live grep
+globalThis.start_live_grep = function (): void {
+  // Clear previous state
+  grepResults = [];
+  lastQuery = "";
+  previewBufferId = null;
+
+  // Remember original split to keep focus
+  originalSplitId = editor.getActiveSplitId();
+
+  // Start the prompt
+  editor.startPrompt("Live grep: ", "live-grep");
+  editor.setStatus("Type to search (min 2 chars)...");
+};
+
+// Handle prompt input changes
+globalThis.onLiveGrepPromptChanged = function (args: {
+  prompt_type: string;
+  input: string;
+}): boolean {
+  if (args.prompt_type !== "live-grep") {
+    return true;
+  }
+
+  // Debounce search to avoid too many requests while typing
+  if (searchDebounceTimer !== null) {
+    // Can't actually cancel in this runtime, but we track it
+  }
+
+  // Run search (with small delay effect via async)
+  runSearch(args.input);
+
+  return true;
+};
+
+// Handle selection changes - update preview
+globalThis.onLiveGrepSelectionChanged = function (args: {
+  prompt_type: string;
+  selected_index: number;
+}): boolean {
+  if (args.prompt_type !== "live-grep") {
+    return true;
+  }
+
+  const match = grepResults[args.selected_index];
+  if (match) {
+    updatePreview(match);
+  }
+
+  return true;
+};
+
+// Handle prompt confirmation - open file
+globalThis.onLiveGrepPromptConfirmed = function (args: {
+  prompt_type: string;
+  selected_index: number | null;
+  input: string;
+}): boolean {
+  if (args.prompt_type !== "live-grep") {
+    return true;
+  }
+
+  // Close preview first
+  closePreview();
+
+  // Open selected file
+  if (args.selected_index !== null && grepResults[args.selected_index]) {
+    const selected = grepResults[args.selected_index];
+    editor.openFile(selected.file, selected.line, selected.column);
+    editor.setStatus(`Opened ${selected.file}:${selected.line}`);
+  } else {
+    editor.setStatus("No file selected");
+  }
+
+  // Clear state
+  grepResults = [];
+  originalSplitId = null;
+  previewSplitId = null;
+
+  return true;
+};
+
+// Handle prompt cancellation
+globalThis.onLiveGrepPromptCancelled = function (args: {
+  prompt_type: string;
+}): boolean {
+  if (args.prompt_type !== "live-grep") {
+    return true;
+  }
+
+  // Close preview and cleanup
+  closePreview();
+  grepResults = [];
+  originalSplitId = null;
+  previewSplitId = null;
+  editor.setStatus("Live grep cancelled");
+
+  return true;
+};
+
+// Register event handlers
+editor.on("prompt_changed", "onLiveGrepPromptChanged");
+editor.on("prompt_selection_changed", "onLiveGrepSelectionChanged");
+editor.on("prompt_confirmed", "onLiveGrepPromptConfirmed");
+editor.on("prompt_cancelled", "onLiveGrepPromptCancelled");
+
+// Register command
+editor.registerCommand(
+  "Live Grep (Find in Files)",
+  "Search for text across project with live preview",
+  "start_live_grep",
+  "normal"
+);
+
+editor.debug("Live Grep plugin loaded");
+editor.setStatus("Live Grep ready - use command palette or bind 'start_live_grep'");