diffwiki-qmd 0.4.0-rc.202607220502.c0ac143

package/dist/bin.js

@@ -0,0 +1,412 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { existsSync, readdirSync } from "fs";
+import { stat, readdir } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+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-qmd: 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/qmd.ts
+import { execFile } from "child_process";
+import { join } from "path";
+import { promisify } from "util";
+var INDEX = "diffwiki";
+var nodeExecFileAsync = promisify(execFile);
+var execFileAsync = (file, args, options) => nodeExecFileAsync(file, args, options);
+function qmdEnv(home) {
+  const base = join(home, "qmd");
+  return { ...process.env, XDG_CACHE_HOME: base, XDG_CONFIG_HOME: base };
+}
+function modelsDir(home) {
+  return join(home, "qmd", "qmd", "models");
+}
+async function qmdOnPath(exec, env) {
+  try {
+    await exec("qmd", ["--version"], { env });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runQmd(exec, args, env) {
+  const { stdout } = await exec("qmd", args, { env });
+  return stdout.trim();
+}
+async function runQmdJson(exec, args, env) {
+  const { stdout } = await exec("qmd", args, { env });
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    throw new Error(`qmd ${args.join(" ")} did not return valid JSON: ${stdout.slice(0, 200)}`);
+  }
+}
+
+// src/bin.ts
+var VERSION = "0.3.0";
+var realStatMtime = async (filePath) => {
+  try {
+    const s = await stat(filePath);
+    return s.mtimeMs;
+  } catch {
+    return 0;
+  }
+};
+async function newestMdMtime(dirs, statFn) {
+  let newest = 0;
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
+        const mt = await statFn(full);
+        if (mt > newest) newest = mt;
+      }
+    }
+  }
+  for (const d of dirs) {
+    await walk(d);
+  }
+  return newest;
+}
+function qmdIndexPath(home) {
+  return join2(home, "qmd", "qmd", INDEX, "index.sqlite3");
+}
+function splitQmdPath(row) {
+  let raw = "";
+  if (typeof row.file === "string" && row.file.length > 0) {
+    raw = row.file.replace(/^qmd:\/\//, "");
+  } else if (typeof row.displayPath === "string") {
+    raw = row.displayPath;
+  }
+  raw = raw.replace(/^\/+/, "");
+  const slash = raw.indexOf("/");
+  if (slash === -1) return { collection: raw, relPath: "" };
+  return { collection: raw.slice(0, slash), relPath: raw.slice(slash + 1) };
+}
+function searchSubcommand(type) {
+  switch (type) {
+    case "semantic":
+      return "vsearch";
+    case "hybrid":
+      return "query";
+    case "keyword":
+    default:
+      return "search";
+  }
+}
+function isAlreadyExists(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /already exists/i.test(msg);
+}
+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 }));
+}
+async function addCollections(exec, env, collections, log) {
+  for (const c of collections) {
+    try {
+      await runQmd(exec, ["collection", "add", c.path, "--name", c.name, "--index", INDEX], env);
+      log("info", `added collection ${c.name} (${c.path})`);
+    } catch (err) {
+      if (!isAlreadyExists(err)) throw err;
+      log("info", `collection ${c.name} already present`);
+    }
+  }
+}
+function makeHandlers(deps) {
+  let home = deps.home ?? join2(homedir(), ".diffwiki");
+  const exec = deps.exec;
+  const statMtime = deps.statMtime ?? realStatMtime;
+  async function ensureFresh(collections, searchType, log) {
+    try {
+      const roots = collections.map((c) => c.path);
+      const contentMtime = await newestMdMtime(roots, statMtime);
+      if (contentMtime === 0) return;
+      const indexMtime = await statMtime(qmdIndexPath(home));
+      if (indexMtime >= contentMtime) return;
+      const env = qmdEnv(home);
+      log("info", "index stale \u2014 running qmd update");
+      await runQmd(exec, ["update", "--index", INDEX], env);
+      if (searchType === "semantic" || searchType === "hybrid") {
+        try {
+          const status = await runQmdJson(exec, ["status", "--index", INDEX, "--format", "json"], env);
+          if (typeof status.needsEmbedding === "number" && status.needsEmbedding > 0) {
+            log("info", `${status.needsEmbedding} doc(s) need embedding \u2014 running qmd embed`);
+            await runQmd(exec, ["embed", "--index", INDEX], env);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    initialize(params) {
+      if (typeof params.home === "string" && params.home.length > 0) {
+        home = params.home;
+      }
+      return {
+        name: "diffwiki-qmd",
+        kind: "search",
+        version: VERSION,
+        capabilities: {
+          searchTypes: ["keyword", "semantic", "hybrid"],
+          collectionFilter: true,
+          hooks: true,
+          setup: true
+        }
+      };
+    },
+    async setup(params, log) {
+      const env = qmdEnv(home);
+      const steps = [];
+      const installed = await qmdOnPath(exec, env);
+      if (!installed) {
+        log("error", "qmd not found on PATH \u2014 install with: npm i -g @tobilu/qmd");
+        steps.push({ step: "verify-qmd", ok: false, message: "qmd not on PATH" });
+        return { ready: false, steps };
+      }
+      steps.push({ step: "verify-qmd", ok: true });
+      const collections = asCollections(params);
+      await addCollections(exec, env, collections, log);
+      steps.push({
+        step: "add-collections",
+        ok: true,
+        message: `${collections.length} collection(s)`
+      });
+      try {
+        await runQmd(exec, ["update", "--index", INDEX], env);
+        steps.push({ step: "index", ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        steps.push({ step: "index", ok: false, message });
+      }
+      if (params.embed === true || params.prefetchModels === true) {
+        log("info", "embedding index (may download models on first run)");
+        try {
+          await runQmd(exec, ["embed", "--index", INDEX], env);
+          steps.push({ step: "embed", ok: true });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          steps.push({ step: "embed", ok: false, message });
+        }
+      }
+      return { ready: true, steps };
+    },
+    async index(params, log) {
+      const env = qmdEnv(home);
+      const collections = asCollections(params);
+      await addCollections(exec, env, collections, log);
+      await runQmd(exec, ["update", "--index", INDEX], env);
+      if (params.embed === true) {
+        log("info", "embedding index");
+        await runQmd(exec, ["embed", "--index", INDEX], env);
+      }
+      return { indexed: collections.length };
+    },
+    async notify(params, log) {
+      const env = qmdEnv(home);
+      const collection = params.collection;
+      if (collection && typeof collection.name === "string") {
+        try {
+          await runQmd(exec, ["update", "--index", INDEX, "-c", collection.name], env);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log("warn", `notify update failed for ${collection.name}: ${message}`);
+        }
+      }
+      return { accepted: true };
+    },
+    async search(params, log) {
+      const env = qmdEnv(home);
+      const term = typeof params.term === "string" ? params.term : "";
+      const type = typeof params.type === "string" ? params.type : "keyword";
+      const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : 20;
+      const sub = searchSubcommand(type);
+      const collections = asCollections(params);
+      await ensureFresh(collections, type, log);
+      const args = [sub, term, "--index", INDEX, "--format", "json", "-n", String(limit)];
+      if (typeof params.collection === "string" && params.collection.length > 0) {
+        args.push("-c", params.collection);
+      }
+      const rows = await runQmdJson(exec, args, env);
+      const hits = (Array.isArray(rows) ? rows : []).map((row) => {
+        const { collection, relPath } = splitQmdPath(row);
+        return {
+          collection,
+          relPath,
+          title: typeof row.title === "string" ? row.title : relPath,
+          snippet: row.bestChunk || void 0,
+          score: typeof row.score === "number" ? row.score : void 0,
+          docid: typeof row.docid === "string" ? row.docid : void 0
+        };
+      });
+      return { hits };
+    },
+    async health(params, log) {
+      const env = qmdEnv(home);
+      const diagnostics = [];
+      const toolInstalled = await qmdOnPath(exec, env);
+      if (!toolInstalled) {
+        log("error", "qmd not on PATH");
+        diagnostics.push({
+          level: "error",
+          message: "qmd not installed \u2014 run: npm i -g @tobilu/qmd"
+        });
+        return {
+          ready: false,
+          readiness: {
+            toolInstalled: false,
+            modelsPresent: false,
+            indexBuilt: false,
+            docsIndexed: 0,
+            embeddingsPending: 0,
+            firstSearchCost: "model-download"
+          },
+          diagnostics
+        };
+      }
+      let modelsPresent = false;
+      try {
+        const dir = modelsDir(home);
+        modelsPresent = existsSync(dir) && readdirSync(dir).length > 0;
+      } catch {
+        modelsPresent = false;
+      }
+      let status = {};
+      try {
+        status = await runQmdJson(exec, ["status", "--index", INDEX, "--format", "json"], env);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        diagnostics.push({ level: "warn", message: `qmd status unavailable: ${message}` });
+      }
+      const docsIndexed = typeof status.totalDocuments === "number" ? status.totalDocuments : 0;
+      const embeddingsPending = typeof status.needsEmbedding === "number" ? status.needsEmbedding : 0;
+      const indexBuilt = docsIndexed > 0;
+      const firstSearchCost = indexBuilt ? "instant" : modelsPresent ? "model-load" : "model-download";
+      diagnostics.push({
+        level: "ok",
+        message: `qmd ready \u2014 ${docsIndexed} docs indexed, ${embeddingsPending} pending embeddings`
+      });
+      if (!modelsPresent) {
+        diagnostics.push({
+          level: "warn",
+          message: "semantic/hybrid search will download models (~2GB) on first use \u2014 run: diffwiki index --embed"
+        });
+      }
+      return {
+        ready: indexBuilt || toolInstalled,
+        readiness: {
+          toolInstalled,
+          modelsPresent,
+          indexBuilt,
+          docsIndexed,
+          embeddingsPending,
+          firstSearchCost
+        },
+        diagnostics
+      };
+    },
+    shutdown() {
+      return {};
+    }
+  };
+}
+var isMain = (() => {
+  try {
+    return process.argv[1] === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+})();
+if (isMain) {
+  serve(makeHandlers({ exec: execFileAsync })).then(() => process.exit(0)).catch((err) => {
+    process.stderr.write(`diffwiki-qmd: fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  makeHandlers,
+  newestMdMtime,
+  qmdIndexPath,
+  realStatMtime,
+  searchSubcommand,
+  splitQmdPath
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "diffwiki-qmd",
+  "version": "0.4.0-rc.202607220502.c0ac143",
+  "description": "diffwiki search plugin driving the qmd CLI (keyword/semantic/hybrid)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "diffwiki-qmd": "./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"
+  }
+}