diffwiki-ripgrep 0.14.0 → 0.15.0-rc.202608040914.07e70ce

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
-import { definePlugin } from "diffwiki-core/plugin";
+import { definePlugin, ensureTool } from "diffwiki-core/plugin";
 
 // src/ripgrep.ts
 import { spawn } from "child_process";
@@ -22,6 +22,22 @@ var spawnRg = (args) => new Promise((resolve, reject) => {
     }
   });
 });
+var spawnFzf = (args, input) => new Promise((resolve, reject) => {
+  const chunks = [];
+  const proc = spawn("fzf", args, { stdio: ["pipe", "pipe", "ignore"] });
+  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 {
+      reject(new Error(`fzf exited with code ${code}`));
+    }
+  });
+  proc.stdin.on("error", () => {
+  });
+  proc.stdin.end(input);
+});
 var readFileLines = (absPath) => new Promise((resolve, reject) => {
   const lines = [];
   const stream = createReadStream(absPath, { encoding: "utf8" });
@@ -37,26 +53,61 @@ var readFileLines = (absPath) => new Promise((resolve, reject) => {
   rl.on("error", reject);
   stream.on("error", reject);
 });
-async function rgOnPath(spawnFn = spawnRg) {
-  if (spawnFn !== spawnRg) {
+async function toolOnPath(name, probe) {
+  if (probe) {
     try {
-      await spawnFn(["--version"]);
+      await probe();
       return true;
     } catch {
       return false;
     }
   }
-  return commandExists("rg");
+  return commandExists(name);
+}
+async function rgOnPath(spawnFn = spawnRg) {
+  return toolOnPath("rg", spawnFn === spawnRg ? null : () => spawnFn(["--version"]));
+}
+async function fzfOnPath(fzfFn = spawnFzf) {
+  return toolOnPath("fzf", fzfFn === spawnFzf ? null : () => fzfFn(["--version"], ""));
 }
-async function runRg(spawnFn, pattern, roots, opts) {
+function tokenize(query) {
+  return query.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
+}
+function escapeRegex(token) {
+  return token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function runRg(spawnFn, query, roots, opts) {
+  const tokens = tokenize(query);
+  if (tokens.length === 0 || roots.length === 0) return "";
+  const pattern = tokens.map(escapeRegex).join("|");
   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);
+  const args = [
+    "--line-number",
+    "--no-heading",
+    "--with-filename",
+    "--color",
+    "never",
+    "--smart-case",
+    "--max-count",
+    String(limit),
+    "--glob",
+    "*.{md,mdx}",
+    "-e",
+    pattern,
+    "--",
+    ...roots
+  ];
   return spawnFn(args);
 }
+async function fuzzyRank(fzfFn, candidates, query) {
+  if (candidates.trim().length === 0) return "";
+  return fzfFn(["--filter", query], candidates);
+}
+function parseRgLine(line) {
+  const m = /^(.*?):(\d+):(.*)$/.exec(line);
+  if (!m) return null;
+  return { path: m[1], lineNumber: Number(m[2]), text: m[3] };
+}
 async function cheapTitle(absPath, readFn = readFileLines) {
   let lines;
   try {
@@ -80,7 +131,9 @@ async function cheapTitle(absPath, readFn = readFileLines) {
 }
 
 // src/bin.ts
-var VERSION = "0.3.0";
+var VERSION = "0.4.0";
+var RG_INSTALL = "https://github.com/BurntSushi/ripgrep";
+var FZF_INSTALL = "https://github.com/junegunn/fzf";
 function asCollections(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.filter(
@@ -100,27 +153,19 @@ function matchCollection(filePath, collections) {
   }
   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 makePluginDefinition(deps = {}) {
   const spawnFn = deps.spawnFn ?? spawnRg;
+  const fzfFn = deps.fzfFn ?? spawnFzf;
   const readFn = deps.readFn ?? readFileLines;
+  const installFn = deps.installFn ?? ensureTool;
+  const RG_SPEC = { command: "rg", mise: "ripgrep", brew: "ripgrep", apt: "ripgrep", manual: RG_INSTALL };
+  const FZF_SPEC = { command: "fzf", mise: "fzf", brew: "fzf", apt: "fzf", manual: FZF_INSTALL };
   const handlers = {
     async search(params) {
       const term = params.term ?? "";
       const collections = asCollections(params.collections);
       const collectionFilter = typeof params.collection === "string" && params.collection.length > 0 ? params.collection : null;
-      const type = params.type ?? "text";
       const limit = params.limit && params.limit > 0 ? params.limit : 20;
-      const fixedStrings = type !== "regex";
       let roots;
       let activeCollections;
       if (collectionFilter !== null) {
@@ -131,22 +176,35 @@ function makePluginDefinition(deps = {}) {
         roots = collections.map((c) => c.path);
         activeCollections = collections;
       }
-      if (roots.length === 0 || term.length === 0) {
+      if (roots.length === 0 || term.trim().length === 0) {
         return { hits: [] };
       }
-      const stdout = await runRg(spawnFn, term, roots, { fixedStrings, limit });
-      const events = parseRgOutput(stdout);
+      const candidates = await runRg(spawnFn, term, roots, { limit });
+      if (candidates.trim().length === 0) {
+        return { hits: [] };
+      }
+      let ranked = candidates;
+      let fuzzyRanked = false;
+      try {
+        const fzfOut = await fuzzyRank(fzfFn, candidates, term);
+        if (fzfOut.trim().length > 0) {
+          ranked = fzfOut;
+          fuzzyRanked = true;
+        }
+      } catch {
+      }
       const seen = /* @__PURE__ */ new Set();
       const hits = [];
-      for (const event of events) {
+      for (const line of ranked.split("\n")) {
         if (hits.length >= limit) break;
-        const filePath = event.data.path.text;
-        if (seen.has(filePath)) continue;
-        seen.add(filePath);
-        const matched = matchCollection(filePath, activeCollections);
+        const parsed = parseRgLine(line);
+        if (!parsed) continue;
+        if (seen.has(parsed.path)) continue;
+        seen.add(parsed.path);
+        const matched = matchCollection(parsed.path, activeCollections);
         if (!matched) continue;
-        const title = await cheapTitle(filePath, readFn);
-        const snippet = (event.data.lines.text || "").trim();
+        const title = await cheapTitle(parsed.path, readFn);
+        const snippet = parsed.text.trim();
         hits.push({
           collection: matched.collection,
           relPath: matched.relPath,
@@ -154,36 +212,53 @@ function makePluginDefinition(deps = {}) {
           snippet: snippet.length > 0 ? snippet : void 0
         });
       }
+      if (fuzzyRanked && hits.length > 0) {
+        const total = hits.length;
+        hits.forEach((hit, i) => {
+          hit.score = Number(((total - i) / total).toFixed(3));
+        });
+      }
       return { hits };
     },
     async index() {
       return { indexed: 0 };
     },
     async setup(_params, log) {
-      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"
-            }
-          ]
-        };
+      const steps = [];
+      const rg = await installFn(RG_SPEC, { install: true, log });
+      if (!rg.present) {
+        log("error", `ripgrep (rg) unavailable \u2014 ${rg.message}`);
+        steps.push({ step: "verify-rg", ok: false, message: rg.message });
+        return { ready: false, steps };
       }
-      return {
-        ready: true,
-        steps: [{ step: "verify-rg", ok: true }]
-      };
+      steps.push({ step: "verify-rg", ok: true, message: rg.installed ? rg.message : void 0 });
+      const fzf = await installFn(FZF_SPEC, { install: true, log });
+      if (fzf.present) {
+        steps.push({ step: "verify-fzf", ok: true, message: fzf.installed ? fzf.message : void 0 });
+      } else {
+        log("warn", `fzf unavailable \u2014 fuzzy ranking disabled (plain ripgrep results). ${fzf.message}`);
+        steps.push({ step: "verify-fzf", ok: false, message: fzf.message });
+      }
+      return { ready: true, steps };
     },
     async onEvent() {
       return { accepted: true };
     },
     async health() {
       const rgPresent = await rgOnPath(spawnFn);
+      const fzfPresent = rgPresent ? await fzfOnPath(fzfFn) : false;
+      const diagnostics = [];
+      if (rgPresent) {
+        diagnostics.push({ level: "ok", message: "ripgrep ready" });
+        diagnostics.push(
+          fzfPresent ? { level: "ok", message: "fzf ready \u2014 fuzzy ranking enabled" } : {
+            level: "warn",
+            message: `fzf not found \u2014 using plain ripgrep (no fuzzy ranking); install fzf: ${FZF_INSTALL}`
+          }
+        );
+      } else {
+        diagnostics.push({ level: "error", message: `ripgrep (rg) not found \u2014 install it: ${RG_INSTALL}` });
+      }
       return {
         ready: rgPresent,
         readiness: {
@@ -194,12 +269,7 @@ function makePluginDefinition(deps = {}) {
           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"
-          }
-        ]
+        diagnostics
       };
     }
   };
@@ -208,7 +278,7 @@ function makePluginDefinition(deps = {}) {
     kind: "search",
     version: VERSION,
     capabilities: {
-      searchTypes: ["text", "regex"],
+      searchTypes: ["fuzzy"],
       collectionFilter: true,
       events: false
     },
@@ -224,6 +294,5 @@ createPlugin().run();
 export {
   createPlugin,
   makePluginDefinition,
-  matchCollection,
-  parseRgOutput
+  matchCollection
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffwiki-ripgrep",
-  "version": "0.14.0",
+  "version": "0.15.0-rc.202608040914.07e70ce",
   "description": "diffwiki search plugin driving ripgrep (rg) — instant literal/regex search, no index",
   "license": "MIT",
   "type": "module",
@@ -20,7 +20,7 @@
     "access": "public"
   },
   "dependencies": {
-    "diffwiki-core": "0.14.0"
+    "diffwiki-core": "0.15.0-rc.202608040914.07e70ce"
   },
   "devDependencies": {
     "@types/node": "^22.0.0"