@peaske7/readit 0.3.3-rc.1 → 0.3.3-rc.2

package/README.md

@@ -42,6 +42,7 @@ readit <file> --clean         # Clear existing comments
 readit list                   # List all files with comments
 readit show <file>            # Show comments for a file
 readit open <files...>        # Add files to running server
+readit zed-open <file>        # Open from a Zed task or extension
 readit completion zsh         # Output shell integration script
 ```
 
@@ -129,6 +130,40 @@ require("readit").setup({
 
 Run `:checkhealth readit` to verify your setup.
 
+## Zed
+
+Zed can open the current Markdown file in readit through a task. The preview opens in your browser because Zed extensions do not currently expose arbitrary preview webviews like the VS Code extension API.
+
+Add this to `.zed/tasks.json` in a project:
+
+```json
+[
+  {
+    "label": "readit: open preview",
+    "command": "readit",
+    "args": ["zed-open", "$ZED_FILE"],
+    "save": "current",
+    "reveal": "never",
+    "hide": "on_success"
+  }
+]
+```
+
+Then add a keybinding in `~/.config/zed/keymap.json`:
+
+```json
+[
+  {
+    "context": "Workspace",
+    "bindings": {
+      "cmd-shift-r": ["task::Spawn", { "task_name": "readit: open preview" }]
+    }
+  }
+]
+```
+
+Run `readit zed-open README.md` manually if the task fails. Check that `readit` is on `PATH`, Bun is installed, and `~/.readit/server.json` points to a healthy server process.
+
 ## Live Reload
 
 readit watches open documents for changes and automatically refreshes the browser. This works with any editor:

package/dist/index.js

@@ -3,6 +3,7 @@
 var __require = import.meta.require;
 
 // src/cli.ts
+import { spawn as spawn2 } from "child_process";
 import {
   existsSync,
   lstatSync,
@@ -19,7 +20,7 @@ import open2 from "open";
 // package.json
 var package_default = {
   name: "@peaske7/readit",
-  version: "0.3.3-rc.1",
+  version: "0.3.3-rc.2",
   description: "A CLI tool to review Markdown documents with inline comments",
   author: "Jay Shimada <peaske@pm.me>",
   license: "MIT",
@@ -1764,31 +1765,36 @@ Browser disconnected, shutting down...`);
       return null;
     }
   }
-  let pageCache = null;
-  let pageCacheGz = null;
+  const pageCache = new Map;
+  const pageCacheGz = new Map;
   function invalidatePageCache() {
-    pageCache = null;
-    pageCacheGz = null;
+    pageCache.clear();
+    pageCacheGz.clear();
   }
   async function serveAppPage(req) {
     const acceptGzip = req.headers.get("accept-encoding")?.includes("gzip") ?? false;
+    const url = new URL(req.url);
+    const requestedPath = url.searchParams.get("path");
+    const activePath = requestedPath && fileMap.has(requestedPath) ? requestedPath : defaultPath;
     try {
-      if (pageCache) {
-        if (acceptGzip && pageCacheGz) {
-          return new Response(pageCacheGz, {
+      const cachedPage = pageCache.get(activePath);
+      if (cachedPage) {
+        const cachedPageGz = pageCacheGz.get(activePath);
+        if (acceptGzip && cachedPageGz) {
+          return new Response(cachedPageGz, {
             headers: {
               "Content-Type": "text/html; charset=utf-8",
               "Content-Encoding": "gzip"
             }
           });
         }
-        return new Response(pageCache, {
+        return new Response(cachedPage, {
           headers: { "Content-Type": "text/html; charset=utf-8" }
         });
       }
-      const { html, headings } = await ensureRenderedHtml(defaultPath);
-      const content = await ensureFileContent(defaultPath);
-      const comments = await readCommentsFromFile(defaultPath, content, html);
+      const { html, headings } = await ensureRenderedHtml(activePath);
+      const content = await ensureFileContent(activePath);
+      const comments = await readCommentsFromFile(activePath, content, html);
       const settings = await readSettings();
       const files = fileOrder.map((fp) => ({
         path: fp,
@@ -1796,10 +1802,10 @@ Browser disconnected, shutting down...`);
       }));
       const inlineData = {
         files,
-        activeFile: defaultPath,
+        activeFile: activePath,
         settings,
         documents: {
-          [defaultPath]: {
+          [activePath]: {
             headings,
             comments
           }
@@ -1820,7 +1826,7 @@ Browser disconnected, shutting down...`);
         }
       }
       const body = renderTemplate({
-        title: basename(defaultPath),
+        title: basename(activePath),
         cssPath,
         jsPath,
         documentHtml: html,
@@ -1829,11 +1835,12 @@ Browser disconnected, shutting down...`);
         fontFamily: settings.fontFamily
       });
       if (!isDev) {
-        pageCache = body;
-        pageCacheGz = Bun.gzipSync(new TextEncoder().encode(body));
+        const gz = Bun.gzipSync(new TextEncoder().encode(body));
+        pageCache.set(activePath, body);
+        pageCacheGz.set(activePath, gz);
       }
       if (acceptGzip) {
-        const gz = pageCacheGz ?? Bun.gzipSync(new TextEncoder().encode(body));
+        const gz = pageCacheGz.get(activePath) ?? Bun.gzipSync(new TextEncoder().encode(body));
         return new Response(gz, {
           headers: {
             "Content-Type": "text/html; charset=utf-8",
@@ -2164,6 +2171,231 @@ async function startServer(options) {
   throw new Error(`No available port found starting from ${options.port}`);
 }
 
+// src/zed-lsp.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+var OPEN_PREVIEW_COMMAND = "readit.openPreview";
+var OPEN_PREVIEW_IN_BROWSER_COMMAND = "readit.openPreviewInBrowser";
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+function filePathFromUri(uri) {
+  if (!uri.startsWith("file://"))
+    return null;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}
+function isMarkdownUri(uri) {
+  const filePath = filePathFromUri(uri);
+  return filePath !== null && isMarkdownFile(filePath);
+}
+function hasId(message) {
+  return Object.hasOwn(message, "id");
+}
+function send(message) {
+  const body = JSON.stringify(message);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+\r
+${body}`);
+}
+function sendResponse(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+function sendError(id, code, message) {
+  send({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message }
+  });
+}
+function getTextDocumentUri(params) {
+  const p = params;
+  const uri = p?.textDocument?.uri;
+  return typeof uri === "string" ? uri : null;
+}
+function codeActionsFor(uri) {
+  if (!isMarkdownUri(uri))
+    return [];
+  return [
+    {
+      title: "readit: Open Preview",
+      kind: "source",
+      command: {
+        title: "readit: Open Preview",
+        command: OPEN_PREVIEW_COMMAND,
+        arguments: [uri]
+      }
+    },
+    {
+      title: "readit: Open Preview in Browser",
+      kind: "source",
+      command: {
+        title: "readit: Open Preview in Browser",
+        command: OPEN_PREVIEW_IN_BROWSER_COMMAND,
+        arguments: [uri]
+      }
+    }
+  ];
+}
+function cliInvocation(args) {
+  if (!process.versions.bun) {
+    throw new Error("Bun is required to run readit. Install Bun and retry.");
+  }
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    throw new Error("readit CLI entrypoint is unavailable");
+  }
+  return {
+    command: process.execPath,
+    args: [entrypoint, ...args]
+  };
+}
+async function runReaditZedOpen(filePath) {
+  const invocation = cliInvocation(["zed-open", filePath]);
+  const child = spawn(invocation.command, invocation.args, {
+    cwd: process.cwd(),
+    env: { ...process.env },
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString("utf8");
+  });
+  const code = await new Promise((resolve3, reject) => {
+    child.on("error", reject);
+    child.on("exit", resolve3);
+  });
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `readit zed-open exited with status ${code}`);
+  }
+}
+async function executeCommand(params) {
+  const p = params;
+  if (p.command !== OPEN_PREVIEW_COMMAND && p.command !== OPEN_PREVIEW_IN_BROWSER_COMMAND) {
+    throw new Error(`unsupported command: ${String(p.command)}`);
+  }
+  const uri = p.arguments?.[0];
+  if (typeof uri !== "string") {
+    throw new Error("missing document URI");
+  }
+  const filePath = filePathFromUri(uri);
+  if (!filePath) {
+    throw new Error(`unsupported URI: ${uri}`);
+  }
+  if (!isMarkdownFile(filePath)) {
+    throw new Error(`unsupported file type: ${filePath}`);
+  }
+  await runReaditZedOpen(filePath);
+}
+async function handleMessage(message, state) {
+  if (typeof message.method !== "string") {
+    if (hasId(message)) {
+      sendError(message.id, INVALID_PARAMS, "missing method");
+    }
+    return;
+  }
+  const requestHasId = hasId(message);
+  try {
+    switch (message.method) {
+      case "initialize":
+        if (requestHasId) {
+          sendResponse(message.id, {
+            capabilities: {
+              codeActionProvider: true,
+              executeCommandProvider: {
+                commands: [
+                  OPEN_PREVIEW_COMMAND,
+                  OPEN_PREVIEW_IN_BROWSER_COMMAND
+                ]
+              }
+            },
+            serverInfo: {
+              name: "readit-zed-lsp",
+              version: package_default.version
+            }
+          });
+        }
+        return;
+      case "initialized":
+        return;
+      case "textDocument/codeAction": {
+        const uri = getTextDocumentUri(message.params);
+        if (requestHasId) {
+          sendResponse(message.id, uri ? codeActionsFor(uri) : []);
+        }
+        return;
+      }
+      case "workspace/executeCommand":
+        await executeCommand(message.params);
+        if (requestHasId) {
+          sendResponse(message.id, null);
+        }
+        return;
+      case "shutdown":
+        state.shuttingDown = true;
+        if (requestHasId) {
+          sendResponse(message.id, null);
+        }
+        return;
+      case "exit":
+        process.exit(state.shuttingDown ? 0 : 1);
+        return;
+      default:
+        if (requestHasId) {
+          sendError(message.id, METHOD_NOT_FOUND, `method not found: ${message.method}`);
+        }
+    }
+  } catch (err) {
+    if (requestHasId) {
+      sendError(message.id, message.method === "workspace/executeCommand" ? INVALID_PARAMS : INTERNAL_ERROR, err instanceof Error ? err.message : String(err));
+    }
+  }
+}
+function processBuffer(buffer, onMessage) {
+  let remaining = buffer;
+  while (true) {
+    const headerEnd = remaining.indexOf(`\r
+\r
+`);
+    if (headerEnd === -1)
+      return remaining;
+    const header = remaining.subarray(0, headerEnd).toString("ascii");
+    const lengthMatch = header.match(/content-length:\s*(\d+)/i);
+    if (!lengthMatch) {
+      remaining = remaining.subarray(headerEnd + 4);
+      continue;
+    }
+    const contentLength = Number.parseInt(lengthMatch[1], 10);
+    const bodyStart = headerEnd + 4;
+    const bodyEnd = bodyStart + contentLength;
+    if (remaining.length < bodyEnd)
+      return remaining;
+    const body = remaining.subarray(bodyStart, bodyEnd).toString("utf8");
+    remaining = remaining.subarray(bodyEnd);
+    try {
+      onMessage(JSON.parse(body));
+    } catch {
+      sendError(null, INVALID_PARAMS, "invalid JSON-RPC payload");
+    }
+  }
+}
+function startZedLspServer() {
+  let buffer = Buffer.alloc(0);
+  const state = { shuttingDown: false };
+  return new Promise((resolve3) => {
+    process.stdin.on("data", (chunk) => {
+      buffer = processBuffer(Buffer.concat([buffer, chunk]), (message) => {
+        handleMessage(message, state);
+      });
+    });
+    process.stdin.on("end", resolve3);
+    process.stdin.resume();
+  });
+}
+
 // src/cli.ts
 var program = new Command;
 function isPermissionError(err) {
@@ -2175,6 +2407,8 @@ var SERVER_LOCK_PATH = join4(READIT_DIR, "server.lock");
 var SERVER_LOCK_MAX_AGE_MS = 30000;
 var SERVER_LOCK_TIMEOUT_MS = 1e4;
 var SERVER_LOCK_WAIT_MS = 100;
+var BACKGROUND_SERVER_TIMEOUT_MS = 1e4;
+var BACKGROUND_SERVER_WAIT_MS = 100;
 function isAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -2189,6 +2423,52 @@ function getErrnoCode(err) {
 function sleep(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
+function parsePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    throw new Error(`invalid port number: ${value}`);
+  }
+  return port;
+}
+function readRawOption(name, shortName) {
+  const args = process.argv.slice(2);
+  const longName = `--${name}`;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === longName || shortName && arg === shortName) {
+      const value = args[i + 1];
+      return value && !value.startsWith("-") ? value : undefined;
+    }
+    if (arg.startsWith(`${longName}=`)) {
+      return arg.slice(longName.length + 1);
+    }
+  }
+  return;
+}
+function hasRawFlag(name) {
+  return process.argv.slice(2).includes(`--${name}`);
+}
+function resolveExistingPath(arg) {
+  const inputPath = resolve3(process.cwd(), arg);
+  if (!existsSync(inputPath)) {
+    console.error(`error: not found: ${inputPath}`);
+    process.exit(1);
+  }
+  return realpathSync(inputPath);
+}
+function resolveMarkdownFile(arg) {
+  const filePath = resolveExistingPath(arg);
+  const stat3 = statSync(filePath);
+  if (stat3.isDirectory()) {
+    console.error(`error: expected a Markdown file, got directory: ${arg}`);
+    process.exit(1);
+  }
+  if (!isMarkdownFile(filePath)) {
+    console.error(`error: unsupported file type: ${arg} (expected .md or .markdown)`);
+    process.exit(1);
+  }
+  return filePath;
+}
 async function clearStaleServerLock() {
   try {
     const [stats, content] = await Promise.all([
@@ -2259,31 +2539,82 @@ async function discoverServer() {
     return null;
   }
 }
-async function attachFiles(server, files) {
+async function addDocumentToServer(server, file) {
+  const res = await fetch(`http://127.0.0.1:${server.port}/api/documents`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ path: file.path })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`failed to add ${file.path}: ${data.error ?? res.statusText}`);
+  }
+  return data;
+}
+async function attachFiles(server, files, opts = {}) {
   for (const file of files) {
     try {
-      const res = await fetch(`http://127.0.0.1:${server.port}/api/documents`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ path: file.path })
-      });
-      if (!res.ok) {
-        const data2 = await res.json();
-        console.error(`error: failed to add ${file.path}: ${data2.error}`);
-        process.exit(1);
-      }
-      const data = await res.json();
-      if (data.status === "added") {
-        console.log(`Added: ${data.fileName}`);
-      } else {
-        console.log(`Present: ${data.fileName}`);
+      const data = await addDocumentToServer(server, file);
+      if (!opts.quiet) {
+        if (data.status === "added") {
+          console.log(`Added: ${data.fileName}`);
+        } else {
+          console.log(`Present: ${data.fileName}`);
+        }
       }
     } catch (err) {
-      console.error("error: failed to connect to server:", err instanceof Error ? err.message : err);
+      console.error("error: failed to add document:", err instanceof Error ? err.message : err);
       process.exit(1);
     }
   }
 }
+function readitUrlForFile(port, filePath) {
+  return `http://127.0.0.1:${port}/?path=${encodeURIComponent(filePath)}`;
+}
+function getCurrentCliInvocation(args) {
+  if (!process.versions.bun) {
+    throw new Error("Bun is required to start readit. Install Bun and retry.");
+  }
+  const entrypoint = process.argv[1];
+  if (!entrypoint) {
+    throw new Error("failed to locate the readit CLI entrypoint");
+  }
+  return {
+    command: process.execPath,
+    args: [entrypoint, ...args]
+  };
+}
+async function waitForBackgroundServer(pid) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < BACKGROUND_SERVER_TIMEOUT_MS) {
+    const server = await discoverServer();
+    if (server)
+      return server;
+    if (pid !== undefined && !isAlive(pid)) {
+      throw new Error("readit server process exited before becoming healthy");
+    }
+    await sleep(BACKGROUND_SERVER_WAIT_MS);
+  }
+  throw new Error("timed out waiting for readit server to start");
+}
+async function startBackgroundServer(files, port, host) {
+  const invocation = getCurrentCliInvocation([
+    "--port",
+    String(port),
+    "--host",
+    host,
+    "--no-open",
+    ...files.map((file) => file.filePath)
+  ]);
+  const child = spawn2(invocation.command, invocation.args, {
+    cwd: process.cwd(),
+    detached: true,
+    env: { ...process.env },
+    stdio: "ignore"
+  });
+  child.unref();
+  return waitForBackgroundServer(child.pid);
+}
 async function getServerTarget(files, port, host) {
   return withServerLock(async () => {
     const server = await discoverServer();
@@ -2365,12 +2696,7 @@ function resolveFiles(args) {
   const seen = new Set;
   const files = [];
   for (const arg of args) {
-    const inputPath = resolve3(process.cwd(), arg);
-    if (!existsSync(inputPath)) {
-      console.error(`error: not found: ${inputPath}`);
-      process.exit(1);
-    }
-    const filePath = realpathSync(inputPath);
+    const filePath = resolveExistingPath(arg);
     const stat3 = statSync(filePath);
     if (stat3.isDirectory()) {
       const found = findReviewableFiles(filePath);
@@ -2567,9 +2893,11 @@ program.argument("[files...]", "Markdown files/directories to review").option("-
       process.exit(1);
     }
   }
-  const preferredPort = Number.parseInt(options.port, 10);
-  if (Number.isNaN(preferredPort) || preferredPort < 1 || preferredPort > 65535) {
-    console.error(`error: invalid port number: ${options.port}`);
+  let preferredPort;
+  try {
+    preferredPort = parsePort(options.port);
+  } catch (err) {
+    console.error("error:", err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
   let previousPort;
@@ -2631,25 +2959,55 @@ Shutting down...`);
     process.exit(1);
   }
 });
+program.command("zed-open").argument("<file>", "Markdown file to open in readit from Zed").description("Open a Markdown file in readit and return after launch").option("-p, --port <number>", "Port for new server (if starting)", "4567").option("--host <address>", "Host for new server (if starting)", "127.0.0.1").option("--no-open", "Don't automatically open browser").action(async (fileArg, options) => {
+  const filePath = resolveMarkdownFile(fileArg);
+  const host = readRawOption("host") ?? options.host;
+  const shouldOpen = options.open && !hasRawFlag("no-open");
+  let preferredPort;
+  try {
+    preferredPort = parsePort(readRawOption("port", "-p") ?? options.port);
+  } catch (err) {
+    console.error("error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  try {
+    const file = { path: filePath };
+    const server = await withServerLock(async () => {
+      const existing = await discoverServer();
+      if (existing)
+        return existing;
+      return startBackgroundServer([{ filePath }], preferredPort, host);
+    });
+    await attachFiles(server, [file], { quiet: true });
+    const url = readitUrlForFile(server.port, filePath);
+    if (shouldOpen) {
+      await open2(url);
+    }
+    console.log(`Opened: ${url}`);
+  } catch (err) {
+    console.error("error: failed to open readit from Zed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("zed-lsp").description("Run the readit Zed LSP bridge").action(async () => {
+  await startZedLspServer();
+});
 program.command("open").argument("<files...>", "Markdown files to add to running server").description("Add files to a running readit server, or start a new one").option("-p, --port <number>", "Port for new server (if starting)", "4567").option("--host <address>", "Host for new server (if starting)", "127.0.0.1").action(async (fileArgs, options) => {
   const resolvedFiles = [];
   for (const arg of fileArgs) {
-    const inputPath = resolve3(process.cwd(), arg);
-    if (!existsSync(inputPath)) {
-      console.error(`error: not found: ${inputPath}`);
-      process.exit(1);
-    }
-    const filePath = realpathSync(inputPath);
-    if (!isMarkdownFile(filePath)) {
-      console.error(`error: unsupported file type: ${arg} (expected .md or .markdown)`);
-      process.exit(1);
-    }
+    const filePath = resolveMarkdownFile(arg);
     resolvedFiles.push({ path: filePath });
   }
   const files = resolvedFiles.map((f) => ({
     filePath: f.path
   }));
-  const preferredPort = Number.parseInt(options.port, 10);
+  let preferredPort;
+  try {
+    preferredPort = parsePort(options.port);
+  } catch (err) {
+    console.error("error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
   try {
     const target = await getServerTarget(files, preferredPort, options.host);
     if (target.kind === "existing") {
@@ -2749,6 +3107,8 @@ _readit() {
     cmd_or_files)
       local -a commands=(
         'open:Add files to running server'
+        'zed-open:Open a Markdown file from Zed'
+        'zed-lsp:Run the Zed LSP bridge'
         'list:List files with comments'
         'show:Show comments for a file'
         'completion:Output shell completion script'
@@ -2757,7 +3117,7 @@ _readit() {
       ;;
     args)
       case "\${line[1]}" in
-        open) _arguments '*:file:_readit_markdown_files' ;;
+        open|zed-open) _arguments '*:file:_readit_markdown_files' ;;
         show) _arguments '1:file:_files -g "*.md *.markdown"' ;;
         *) _arguments '*:file:_readit_markdown_files' ;;
       esac
@@ -2777,7 +3137,7 @@ _readit_completions() {
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  commands="open list show completion"
+  commands="open zed-open zed-lsp list show completion"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
     COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
@@ -2789,7 +3149,7 @@ _readit_completions() {
   fi
 
   case "\${COMP_WORDS[1]}" in
-    open|show)
+    open|zed-open|show)
       local files=$(find . -type f \\( -name '*.md' -o -name '*.markdown' \\) \\
         -not -path '*/.*' -not -path '*/node_modules/*' 2>/dev/null | sed 's|^\\./||')
       COMPREPLY=( $(compgen -W "\${files}" -- "\${cur}") )
@@ -2814,6 +3174,8 @@ complete -c readit -f
 
 # Subcommands
 complete -c readit -n '__fish_use_subcommand' -a 'open' -d 'Add files to running server'
+complete -c readit -n '__fish_use_subcommand' -a 'zed-open' -d 'Open a Markdown file from Zed'
+complete -c readit -n '__fish_use_subcommand' -a 'zed-lsp' -d 'Run the Zed LSP bridge'
 complete -c readit -n '__fish_use_subcommand' -a 'list' -d 'List files with comments'
 complete -c readit -n '__fish_use_subcommand' -a 'show' -d 'Show comments for a file'
 complete -c readit -n '__fish_use_subcommand' -a 'completion' -d 'Output shell completion script'
@@ -2827,6 +3189,7 @@ complete -c readit -l clean -d 'Clear existing comments'
 # File arguments for default command and open
 complete -c readit -n '__fish_use_subcommand' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
 complete -c readit -n '__fish_seen_subcommand_from open' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
+complete -c readit -n '__fish_seen_subcommand_from zed-open' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
 complete -c readit -n '__fish_seen_subcommand_from show' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
 
 # Shell completions for completion subcommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaske7/readit",
-  "version": "0.3.3-rc.1",
+  "version": "0.3.3-rc.2",
   "description": "A CLI tool to review Markdown documents with inline comments",
   "author": "Jay Shimada <peaske@pm.me>",
   "license": "MIT",

package/shell/_readit

@@ -111,6 +111,8 @@ _readit() {
       local -a commands
       commands=(
         'open:Add files to a running server or start a new one'
+        'zed-open:Open a Markdown file from Zed'
+        'zed-lsp:Run the Zed LSP bridge'
         'list:List all files with comments'
         'show:Show comments for a file'
         'completion:Output shell completion script'
@@ -128,6 +130,17 @@ _readit() {
             '--host[Host for new server]:host:' \
             '*:file:_readit_markdown_files'
           ;;
+        zed-open)
+          _arguments \
+            '-p[Port for new server]:port:' \
+            '--port[Port for new server]:port:' \
+            '--host[Host for new server]:host:' \
+            '--no-open[Do not automatically open browser]' \
+            '1:file:_readit_markdown_files'
+          ;;
+        zed-lsp)
+          # Internal command used by the Zed extension.
+          ;;
         show)
           _arguments \
             '1:file:_readit_commented_files'