@fresh-editor/fresh-editor 0.1.4

package/package.json

@@ -0,0 +1,100 @@
+{
+  "artifactDownloadUrl": "https://github.com/sinelaw/fresh/releases/download/v0.1.4",
+  "author": "Noam Lewis",
+  "bin": {
+    "fresh": "run-fresh.js"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "axios-proxy-builder": "^0.1.2",
+    "console.table": "^0.10.0",
+    "detect-libc": "^2.1.2",
+    "rimraf": "^6.0.1"
+  },
+  "description": "A lightweight, fast terminal-based text editor with LSP support and TypeScript plugins",
+  "devDependencies": {
+    "prettier": "^3.6.2"
+  },
+  "engines": {
+    "node": ">=14",
+    "npm": ">=6"
+  },
+  "glibcMinimum": {
+    "major": 2,
+    "series": 35
+  },
+  "keywords": [
+    "command-line-utilities",
+    "text-editors",
+    "editor",
+    "terminal",
+    "tui",
+    "text-editor",
+    "lsp"
+  ],
+  "license": "GPL-2.0",
+  "name": "@fresh-editor/fresh-editor",
+  "preferUnplugged": true,
+  "repository": "https://github.com/sinelaw/fresh",
+  "scripts": {
+    "fmt": "prettier --write **/*.js",
+    "fmt:check": "prettier --check **/*.js",
+    "postinstall": "node ./install.js"
+  },
+  "supportedPlatforms": {
+    "aarch64-apple-darwin": {
+      "artifactName": "fresh-editor-aarch64-apple-darwin.tar.xz",
+      "bins": {
+        "fresh": "fresh"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "aarch64-pc-windows-msvc": {
+      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
+      "bins": {
+        "fresh": "fresh.exe"
+      },
+      "zipExt": ".zip"
+    },
+    "aarch64-unknown-linux-gnu": {
+      "artifactName": "fresh-editor-aarch64-unknown-linux-gnu.tar.xz",
+      "bins": {
+        "fresh": "fresh"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "x86_64-apple-darwin": {
+      "artifactName": "fresh-editor-x86_64-apple-darwin.tar.xz",
+      "bins": {
+        "fresh": "fresh"
+      },
+      "zipExt": ".tar.xz"
+    },
+    "x86_64-pc-windows-gnu": {
+      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
+      "bins": {
+        "fresh": "fresh.exe"
+      },
+      "zipExt": ".zip"
+    },
+    "x86_64-pc-windows-msvc": {
+      "artifactName": "fresh-editor-x86_64-pc-windows-msvc.zip",
+      "bins": {
+        "fresh": "fresh.exe"
+      },
+      "zipExt": ".zip"
+    },
+    "x86_64-unknown-linux-gnu": {
+      "artifactName": "fresh-editor-x86_64-unknown-linux-gnu.tar.xz",
+      "bins": {
+        "fresh": "fresh"
+      },
+      "zipExt": ".tar.xz"
+    }
+  },
+  "version": "0.1.4",
+  "volta": {
+    "node": "18.14.1",
+    "npm": "9.5.0"
+  }
+}

package/plugins/README.md

@@ -0,0 +1,121 @@
+# Plugins
+
+This directory contains production-ready plugins for the editor. Plugins are automatically loaded when the editor starts.
+
+## Available Plugins
+
+### TODO Highlighter (`todo_highlighter.lua`)
+
+**A complete, useful plugin demonstrating Phase 2 API capabilities.**
+
+Highlights TODO/FIXME/HACK/NOTE/XXX/BUG keywords in comments with color-coded overlays.
+
+**Features:**
+- Multi-language comment support (C/C++, Python, Lua, JavaScript, HTML, etc.)
+- Color-coded highlighting:
+  - 🟠 **TODO** - Orange (tasks to do)
+  - 🔴 **FIXME** - Red (things to fix)
+  - 🟡 **HACK** - Yellow (temporary workarounds)
+  - 🟢 **NOTE** - Green (important notes)
+  - 🟣 **XXX** - Magenta (items needing review)
+  - 🔺 **BUG** - Dark Red (known bugs)
+- Smart comment detection (only highlights keywords in comments, not in regular text)
+
+**Commands:**
+- `TODO Highlighter: Toggle` - Enable/disable highlighting
+- `TODO Highlighter: Enable` - Turn on highlighting
+- `TODO Highlighter: Disable` - Turn off and clear highlights
+- `TODO Highlighter: Refresh` - Re-scan current buffer
+- `TODO Highlighter: Show Keywords` - Display tracked keywords
+
+**Usage:**
+1. Open any file with TODO comments
+2. Press `Ctrl+P` to open command palette
+3. Type "TODO" and select `TODO Highlighter: Toggle`
+4. Keywords in comments will be highlighted!
+
+**APIs Used:**
+- Buffer Query API: `get_active_buffer_id()`, `get_buffer_content()`
+- Overlay API: `add_overlay()`, `remove_overlay()`
+- Command Registration: `register_command()`
+
+---
+
+### Git Grep (`git-grep.lua`)
+
+**Full-featured git grep with hook-based prompt API (Phase 2 - Jan 2025)**
+
+Interactive search through all git-tracked files with real-time results.
+
+**Features:**
+- Search as you type with async git grep
+- Shows file:line:column context for each match
+- Opens files at exact match location
+- Graceful handling of empty results and errors
+- ~150 lines of Lua demonstrating prompt API
+
+**Usage:**
+```lua
+start_git_grep()  -- From Lua or keybinding
+```
+Or use command palette: "Git Grep"
+
+**APIs Used:**
+- Hook-based Prompt API: `start_prompt()`, `set_prompt_suggestions()`
+- Prompt Hooks: `prompt-changed`, `prompt-confirmed`, `prompt-cancelled`
+- Async Process: `editor.spawn()`
+- File Navigation: `editor.open_file({path, line, column})`
+
+---
+
+### Git Find File (`git-find-file.lua`)
+
+**Fast fuzzy file finder for git repos (Phase 2 - Jan 2025)**
+
+Find and open git-tracked files with fuzzy matching, similar to Ctrl+P in VSCode.
+
+**Features:**
+- Fuzzy file name filtering (all chars match in order)
+- Caches git ls-files for instant filtering
+- Shows up to 100 matches in real-time
+- Opens selected file or manual path
+- ~150 lines of pure Lua implementation
+
+**Usage:**
+```lua
+start_git_find_file()  -- From Lua or keybinding
+```
+Or use command palette: "Git Find File"
+
+**APIs Used:**
+- Same hook-based prompt API as git grep
+- Demonstrates reusability of prompt system
+- Pure Lua fuzzy matching algorithm
+
+---
+
+### Welcome (`welcome.lua`)
+
+Simple welcome message plugin that demonstrates basic plugin loading and status messages.
+
+**Commands:**
+- Various demo commands showing basic plugin capabilities
+
+---
+
+## Example Plugins
+
+See `examples/` directory for educational examples demonstrating specific API features:
+- `hello.lua` - Minimal plugin example
+- `highlight_demo.lua` - Overlay API demonstrations
+- `buffer_query_demo.lua` - Buffer state querying (Phase 2)
+- `async_demo.lua` - Async process spawning (Phase 2)
+
+---
+
+## Plugin Development
+
+For plugin development guides, see:
+- **Quick Start:** `../PLUGINS_QUICKSTART.md`
+- **API Reference:** `examples/README.md`
+- **Implementation:** `../docs/PLUGIN_SYSTEM_IMPLEMENTATION.md`

package/plugins/clangd_support.md

@@ -0,0 +1,20 @@
+# Clangd Helper Plugin
+
+Fresh bundles `plugins/clangd_support.ts` so clangd users get a small helper plugin out of the box.
+
+## Commands
+
+* `Clangd: Switch Source/Header` calls `textDocument/switchSourceHeader` for the active cpp-style buffer and opens the returned URI if there is a match.
+* `Clangd: Open Project Config` searches the current directory tree for a `.clangd` file and opens it in the editor.
+
+Those commands are registered in the command palette after the plugin loads; TypeScript plugins can register their own commands by calling `editor.registerCommand`.
+
+## Notifications
+
+The plugin listens for `lsp/custom_notification` events emitted by the core and filters for clangd-specific methods (`textDocument/clangd.fileStatus`, `$/memoryUsage`, etc.). When clangd sends `textDocument/clangd.fileStatus`, the plugin surfaces it as a status message (`Clangd file status: …`). The editor renders this plugin-provided status slot alongside the usual diagnostics/cursor info, so the notification stays visible without overwriting core messages.
+
+Use `editor.setStatus` to set a plugin status message and `editor.setStatus("")` to clear it; the core `Editor::set_status_message` call clears the plugin slot so core actions regain priority.
+
+## Project setup heuristic
+
+`Clangd: Project Setup` opens a readonly panel that inspects the current workspace root and reports whether the files clangd needs are present (`compile_commands.json`, `.clangd`, etc.). The panel also guesses the build system (CMake, Bazel, Make) by looking for markers like `CMakeLists.txt` or `WORKSPACE` and prints quick tips for generating the missing artifacts (e.g., `cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON build`, `bear -- make`). This panel gives you a quick readiness check before enabling heavier clangd features on projects such as Lustre or other Makefile-heavy trees.

package/plugins/clangd_support.ts

@@ -0,0 +1,323 @@
+/// <reference path="../types/fresh.d.ts" />
+
+/**
+ * Clangd helper plugin
+ *
+ * Provides two commands:
+ *  - Switch Source/Header (uses clangd/textDocument/switchSourceHeader)
+ *  - Open project .clangd configuration file
+ */
+
+import { PanelManager } from "./lib/index.ts";
+
+const languageMap: Record<string, string> = {
+  c: "cpp",
+  h: "cpp",
+  hp: "cpp",
+  hpp: "cpp",
+  hxx: "cpp",
+  hh: "cpp",
+  cpp: "cpp",
+  cxx: "cpp",
+  cc: "cpp",
+  objc: "cpp",
+  mm: "cpp",
+};
+
+function detectLanguage(path: string): string | null {
+  const segments = path.split(".");
+  if (segments.length === 1) {
+    return null;
+  }
+  const ext = segments[segments.length - 1].toLowerCase();
+  return languageMap[ext] ?? null;
+}
+
+function pathToFileUri(path: string): string {
+  let normalized = path.replace(/\\/g, "/");
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  return "file://" + encodeURI(normalized);
+}
+
+function fileUriToPath(uri: string): string {
+  if (!uri.startsWith("file://")) {
+    return uri;
+  }
+  let path = decodeURI(uri.substring("file://".length));
+  if (path.startsWith("/") && path.length > 2 && path[2] === ":") {
+    path = path.substring(1);
+  }
+  return path;
+}
+
+function setClangdStatus(message: string): void {
+  editor.setStatus(message);
+}
+
+globalThis.clangdSwitchSourceHeader = async function(): Promise<void> {
+  const bufferId = editor.getActiveBufferId();
+  const path = editor.getBufferPath(bufferId);
+  if (!path) {
+    setClangdStatus("Clangd: there is no active file to switch");
+    return;
+  }
+
+  const language = detectLanguage(path);
+  if (!language) {
+    setClangdStatus("Clangd: unsupported file type for switch header");
+    return;
+  }
+
+  const uri = pathToFileUri(path);
+  editor.debug(`clangdSwitchSourceHeader: sending request for ${uri}`);
+  try {
+    const result = await editor.sendLspRequest(language, "textDocument/switchSourceHeader", {
+      textDocument: { uri },
+    });
+    editor.debug(`clangdSwitchSourceHeader: got result ${JSON.stringify(result)}`);
+    if (typeof result === "string" && result.length > 0) {
+      const targetPath = fileUriToPath(result);
+      editor.openFile(targetPath, 0, 0);
+      setClangdStatus("Clangd: opened corresponding file");
+      return;
+    }
+    setClangdStatus("Clangd: no matching header/source found");
+  } catch (err) {
+    setClangdStatus(`Clangd switch source/header failed: ${err}`);
+    editor.debug(`clangdSwitchSourceHeader error: ${err}`);
+  }
+};
+
+const projectPanel = new PanelManager("Clangd project setup", "clangd-project-setup");
+
+function pathDesc(path: string): string {
+  if (!path) {
+    return "unknown";
+  }
+  return path;
+}
+
+function detectProjectRoot(): string | null {
+  const roots = new Set<string>();
+  const cwd = editor.getCwd();
+  if (cwd) {
+    roots.add(cwd);
+  }
+  const bufferId = editor.getActiveBufferId();
+  const bufferPath = editor.getBufferPath(bufferId);
+  if (bufferPath) {
+    // Add the buffer directory and a few ancestors
+    let current = editor.pathDirname(bufferPath);
+    let depth = 0;
+    while (current && depth < 5) {
+      roots.add(current);
+      current = editor.pathDirname(current);
+      depth += 1;
+    }
+  }
+  if (roots.size === 0) {
+    return null;
+  }
+  return Array.from(roots)[0];
+}
+
+function analyzeProject(root: string | null) {
+  const lines: string[] = [];
+  const dirCandidates: string[] = [];
+  if (root) {
+    dirCandidates.push(root);
+  }
+  const currentDir = editor.getCwd();
+  if (currentDir && currentDir !== root) {
+    dirCandidates.push(currentDir);
+  }
+  const activeBufferId = editor.getActiveBufferId();
+  const bufferPath = editor.getBufferPath(activeBufferId);
+  if (bufferPath) {
+    const bufferDir = editor.pathDirname(bufferPath);
+    if (bufferDir && !dirCandidates.includes(bufferDir)) {
+      dirCandidates.push(bufferDir);
+    }
+  }
+
+  const compileCandidates = [
+    "compile_commands.json",
+    "build/compile_commands.json",
+    "out/compile_commands.json",
+    "cmake-build-debug/compile_commands.json",
+  ];
+  let compilePath: string | null = null;
+  for (const base of dirCandidates) {
+    for (const relative of compileCandidates) {
+      const candidate = editor.pathJoin(base, relative);
+      if (editor.fileExists(candidate)) {
+        compilePath = candidate;
+        break;
+      }
+    }
+    if (compilePath) {
+      break;
+    }
+  }
+
+  const clangdFileCandidates = [".clangd", ".clangd/compile_flags.txt"];
+  let clangdPath: string | null = null;
+  for (const base of dirCandidates) {
+    for (const relative of clangdFileCandidates) {
+      const candidate = editor.pathJoin(base, relative);
+      if (editor.fileExists(candidate)) {
+        clangdPath = candidate;
+        break;
+      }
+    }
+    if (clangdPath) {
+      break;
+    }
+  }
+
+  const status: string[] = [];
+  if (root) {
+    status.push(`Project root: ${root}`);
+  } else {
+    status.push("Project root: (unknown)");
+  }
+  status.push("");
+
+  if (compilePath) {
+    status.push(`Compile commands: ready (${compilePath})`);
+  } else {
+    status.push("Compile commands: missing");
+    status.push("  Tip: run `cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON` or `bear -- make` to generate compile_commands.json and place it at the project root.");
+  }
+
+  if (clangdPath) {
+    status.push(`.clangd configuration: ${clangdPath}`);
+  } else {
+    status.push(".clangd configuration: missing");
+    status.push("  Tip: create a .clangd file to customize clangd flags, fallback file, etc.");
+  }
+
+  const buildHints: string[] = [];
+  if (root) {
+    if (editor.fileExists(editor.pathJoin(root, "CMakeLists.txt"))) {
+      buildHints.push("CMake project detected (configure with `cmake -S . -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON`).");
+    }
+    if (
+      editor.fileExists(editor.pathJoin(root, "WORKSPACE")) ||
+      editor.fileExists(editor.pathJoin(root, "WORKSPACE.bazel")) ||
+      editor.fileExists(editor.pathJoin(root, "BUILD.bazel"))
+    ) {
+      buildHints.push("Bazel project detected (use `bazel build //...` and attach the generated compile_commands.json).");
+    }
+    if (editor.fileExists(editor.pathJoin(root, "Makefile"))) {
+      buildHints.push("Makefile detected (run `bear -- make` or `intercept-build make` to emit compile_commands.json).");
+    }
+  }
+  if (buildHints.length > 0) {
+    status.push("");
+    status.push("Build system hints:");
+    for (const hint of buildHints) {
+      status.push(`  - ${hint}`);
+    }
+  }
+
+  status.push("");
+  status.push("General tips:");
+  status.push("  * Place compile_commands.json at the project root or point clangd to a custom path.");
+  status.push("  * Use `Clangd: Open Project Config` to edit project-specific overrides.");
+  status.push("  * Use `Clangd: Switch Source/Header` once compile data is available.");
+
+  return status;
+}
+
+globalThis.clangdProjectSetup = async function (): Promise<void> {
+  const projectRoot = detectProjectRoot();
+  const summary = analyzeProject(projectRoot);
+  const entries = summary.map((line) => ({
+    text: line + "\n",
+    properties: {},
+  }));
+  await projectPanel.open({
+    entries,
+    ratio: 0.3,
+  });
+};
+
+editor.registerCommand(
+  "Clangd: Project Setup",
+  "Analyze C/C++ clangd readiness (compile_commands.json, .clangd)",
+  "clangdProjectSetup",
+  ""
+);
+
+globalThis.clangdOpenProjectConfig = function(): void {
+  const bufferId = editor.getActiveBufferId();
+  const targets = new Set<string>();
+  const bufferPath = editor.getBufferPath(bufferId);
+  if (bufferPath) {
+    const dir = editor.pathDirname(bufferPath);
+    targets.add(dir);
+  }
+  const cwd = editor.getCwd();
+  if (cwd) {
+    targets.add(cwd);
+  }
+
+  let opened = false;
+  for (const dir of Array.from(targets)) {
+    const configPath = editor.pathJoin(dir, ".clangd");
+    if (editor.fileExists(configPath)) {
+      editor.openFile(configPath, 0, 0);
+      setClangdStatus("Opened .clangd configuration");
+      opened = true;
+      break;
+    }
+  }
+
+  if (!opened) {
+    setClangdStatus("Could not find .clangd configuration in workspace");
+  }
+};
+
+editor.registerCommand(
+  "Clangd: Switch Source/Header",
+  "Jump to header/source pair using clangd",
+  "clangdSwitchSourceHeader",
+  "normal"
+);
+
+editor.registerCommand(
+  "Clangd: Open Project Config",
+  "Open the nearest .clangd file",
+  "clangdOpenProjectConfig",
+  "normal"
+);
+
+setClangdStatus("Clangd support plugin loaded (switch header + config commands)");
+
+globalThis.onClangdCustomNotification = function(payload: {
+  language: string;
+  method: string;
+  params: Record<string, unknown> | null;
+}): void {
+  if (!payload || payload.language !== "cpp") {
+    return;
+  }
+
+  editor.debug(
+    `clangd notification ${payload.method}: ${JSON.stringify(payload.params)}`,
+  );
+
+  if (payload.method === "textDocument/clangd.fileStatus" && payload.params) {
+    const status = (payload.params as any).status ?? "unknown";
+    editor.debug(`Clangd file status: ${JSON.stringify(status)}`);
+    setClangdStatus(`Clangd file status: ${status}`);
+  } else if (payload.method === "$/memoryUsage" && payload.params) {
+    const usage = (payload.params as any).used ?? "unknown";
+    editor.debug(`Clangd memory usage: ${usage}`);
+  }
+};
+
+editor.on("lsp/custom_notification", "onClangdCustomNotification");