diffwiki-ripgrep 0.4.0-rc.202607220502.c0ac143

package/dist/bin.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { fileURLToPath } from "url";
+
+// src/protocol.ts
+function toMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function serve(handlers, io = {}) {
+  const input = io.input ?? process.stdin;
+  const output = io.output ?? process.stdout;
+  const write = (obj) => {
+    output.write(`${JSON.stringify(obj)}
+`);
+  };
+  const log = (level, message) => {
+    write({ log: { level, message } });
+  };
+  const dispatch = async (line) => {
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      process.stderr.write(`diffwiki-ripgrep: skipping malformed line: ${line}
+`);
+      return;
+    }
+    const handler = handlers[req.op];
+    if (!handler) {
+      write({ id: req.id, ok: false, error: { message: `unknown op: ${req.op}` } });
+      return;
+    }
+    try {
+      const result = await handler(req.params ?? {}, log);
+      write({ id: req.id, ok: true, result });
+    } catch (err) {
+      write({ id: req.id, ok: false, error: { message: toMessage(err) } });
+    }
+  };
+  return new Promise((resolve) => {
+    let buffer = "";
+    let chain = Promise.resolve();
+    input.setEncoding("utf8");
+    input.on("data", (chunk) => {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (line.length > 0) {
+          chain = chain.then(() => dispatch(line));
+        }
+        nl = buffer.indexOf("\n");
+      }
+    });
+    input.on("end", () => {
+      const tail = buffer.trim();
+      if (tail.length > 0) chain = chain.then(() => dispatch(tail));
+      chain.then(resolve);
+    });
+  });
+}
+
+// src/ripgrep.ts
+import { spawn } from "child_process";
+import { createReadStream } from "fs";
+import { basename, extname } from "path";
+import { createInterface } from "readline";
+var spawnRg = (args) => new Promise((resolve, reject) => {
+  const chunks = [];
+  const proc = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+  proc.stdout.on("data", (chunk) => chunks.push(chunk));
+  proc.on("error", reject);
+  proc.on("close", (code) => {
+    if (code === 0 || code === 1) {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    } else {
+      const stderr = "";
+      reject(new Error(`rg exited with code ${code}${stderr ? ": " + stderr : ""}`));
+    }
+  });
+});
+var readFileLines = (absPath) => new Promise((resolve, reject) => {
+  const lines = [];
+  const stream = createReadStream(absPath, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", (line) => {
+    lines.push(line);
+    if (lines.length >= 20) {
+      rl.close();
+      stream.destroy();
+    }
+  });
+  rl.on("close", () => resolve(lines));
+  rl.on("error", reject);
+  stream.on("error", reject);
+});
+async function rgOnPath(spawnFn = spawnRg) {
+  try {
+    await spawnFn(["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runRg(spawnFn, pattern, roots, opts) {
+  const limit = opts.limit > 0 ? opts.limit : 20;
+  const args = ["--json", "--line-number", "--max-count", String(limit), "--glob", "*.{md,mdx}"];
+  if (opts.fixedStrings) {
+    args.push("--fixed-strings", "-i");
+  }
+  args.push("--", pattern, ...roots);
+  return spawnFn(args);
+}
+async function cheapTitle(absPath, readFn = readFileLines) {
+  let lines;
+  try {
+    lines = await readFn(absPath);
+  } catch {
+    return basename(absPath, extname(absPath));
+  }
+  if (lines.length > 0 && lines[0].trim() === "---") {
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "---" || line.trim() === "...") break;
+      const m = line.match(/^title:\s*(.+)/i);
+      if (m) return m[1].trim().replace(/^['"]|['"]$/g, "");
+    }
+  }
+  for (const line of lines) {
+    const m = line.match(/^#{1,6}\s+(.+)/);
+    if (m) return m[1].trim();
+  }
+  return basename(absPath, extname(absPath));
+}
+
+// src/bin.ts
+var VERSION = "0.3.0";
+function asCollections(params) {
+  const raw = params.collections;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (c) => !!c && typeof c.name === "string" && typeof c.path === "string"
+  ).map((c) => ({ name: c.name, path: c.path }));
+}
+function matchCollection(filePath, collections) {
+  const sorted = [...collections].sort((a, b) => b.path.length - a.path.length);
+  for (const col of sorted) {
+    const prefix = col.path.endsWith("/") ? col.path : col.path + "/";
+    if (filePath.startsWith(prefix)) {
+      return { collection: col.name, relPath: filePath.slice(prefix.length) };
+    }
+    if (filePath === col.path) {
+      return { collection: col.name, relPath: "" };
+    }
+  }
+  return null;
+}
+function parseRgOutput(stdout) {
+  return stdout.split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
+    try {
+      const obj = JSON.parse(line);
+      return obj.type === "match" ? [obj] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+function makeHandlers(deps = {}) {
+  const spawnFn = deps.spawnFn ?? spawnRg;
+  const readFn = deps.readFn ?? readFileLines;
+  return {
+    initialize() {
+      return {
+        name: "diffwiki-ripgrep",
+        kind: "search",
+        version: VERSION,
+        capabilities: {
+          searchTypes: ["text", "regex"],
+          collectionFilter: true,
+          hooks: false,
+          setup: true
+        }
+      };
+    },
+    async setup(params, log) {
+      void params;
+      const rgPresent = await rgOnPath(spawnFn);
+      if (!rgPresent) {
+        log("error", "ripgrep (rg) not found \u2014 install it: https://github.com/BurntSushi/ripgrep");
+        return {
+          ready: false,
+          steps: [
+            {
+              step: "verify-rg",
+              ok: false,
+              message: "rg not on PATH \u2014 install ripgrep: https://github.com/BurntSushi/ripgrep"
+            }
+          ]
+        };
+      }
+      return {
+        ready: true,
+        steps: [{ step: "verify-rg", ok: true }]
+      };
+    },
+    index() {
+      return { indexed: 0 };
+    },
+    notify() {
+      return { accepted: true };
+    },
+    async search(params) {
+      const term = typeof params.term === "string" ? params.term : "";
+      const collections = asCollections(params);
+      const collectionFilter = typeof params.collection === "string" && params.collection.length > 0 ? params.collection : null;
+      const type = typeof params.type === "string" ? params.type : "text";
+      const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : 20;
+      const fixedStrings = type !== "regex";
+      let roots;
+      let activeCollections;
+      if (collectionFilter !== null) {
+        const found = collections.find((c) => c.name === collectionFilter);
+        roots = found ? [found.path] : [];
+        activeCollections = found ? [found] : [];
+      } else {
+        roots = collections.map((c) => c.path);
+        activeCollections = collections;
+      }
+      if (roots.length === 0 || term.length === 0) {
+        return { hits: [] };
+      }
+      const stdout = await runRg(spawnFn, term, roots, { fixedStrings, limit });
+      const events = parseRgOutput(stdout);
+      const seen = /* @__PURE__ */ new Set();
+      const hits = [];
+      for (const event of events) {
+        if (hits.length >= limit) break;
+        const filePath = event.data.path.text;
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        const matched = matchCollection(filePath, activeCollections);
+        if (!matched) continue;
+        const title = await cheapTitle(filePath, readFn);
+        const snippet = (event.data.lines.text || "").trim();
+        hits.push({
+          collection: matched.collection,
+          relPath: matched.relPath,
+          title,
+          snippet: snippet.length > 0 ? snippet : void 0
+        });
+      }
+      return { hits };
+    },
+    async health() {
+      const rgPresent = await rgOnPath(spawnFn);
+      return {
+        ready: rgPresent,
+        readiness: {
+          toolInstalled: rgPresent,
+          modelsPresent: true,
+          indexBuilt: true,
+          docsIndexed: 0,
+          embeddingsPending: 0,
+          firstSearchCost: "instant"
+        },
+        diagnostics: rgPresent ? [{ level: "ok", message: "ripgrep ready" }] : [
+          {
+            level: "error",
+            message: "ripgrep (rg) not found \u2014 install it: https://github.com/BurntSushi/ripgrep"
+          }
+        ]
+      };
+    },
+    shutdown() {
+      return {};
+    }
+  };
+}
+var isMain = (() => {
+  try {
+    return process.argv[1] === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+if (isMain) {
+  serve(makeHandlers({ spawnFn: spawnRg, readFn: readFileLines })).then(() => process.exit(0)).catch((err) => {
+    process.stderr.write(`diffwiki-ripgrep: fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  makeHandlers,
+  matchCollection,
+  parseRgOutput
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "diffwiki-ripgrep",
+  "version": "0.4.0-rc.202607220502.c0ac143",
+  "description": "diffwiki search plugin driving ripgrep (rg) — instant literal/regex search, no index",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "diffwiki-ripgrep": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "diffwiki": {
+    "kind": "search"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "lint": "eslint src tests --no-error-on-unmatched-pattern && tsc --noEmit",
+    "lint:fix": "eslint src tests --no-error-on-unmatched-pattern --fix"
+  }
+}