diffwiki-core 0.4.0-rc.202607221918.a124bf3 → 0.4.0

package/dist/index.js

@@ -1,79 +1,148 @@
-import {
-  runProcess
-} from "./chunk-EEETAETA.js";
-import {
-  ArticleNotFoundError,
-  CollectionExistsError,
-  CollectionNotFoundError,
-  DiffwikiError,
-  InvalidTargetError,
-  LONG_TIMEOUT_MS,
-  NATIVE_ENGINE,
-  NoDefaultCollectionError,
-  PluginError,
-  collectionDir,
-  collectionsDir,
-  configPath,
-  createCollection,
-  deregisterPlugin,
-  emitPluginEvent,
-  findCollection,
-  findEnabledPlugin,
-  findPluginRecord,
-  getLogger,
-  invokePlugin,
-  listCollections,
-  listEnabledPlugins,
-  listSearchModes,
-  loadSearchProvider,
-  pluginsDir,
-  pluginsRegistryPath,
-  readPluginRegistry,
-  readRegistry,
-  registerCollection,
-  registryPath,
-  removeCollection,
-  resolveHome,
-  resolveLogLevel,
-  unregisterCollection,
-  upsertPlugin,
-  writePluginRegistry,
-  writeRegistry
-} from "./chunk-AZ6SZH6P.js";
+// src/errors.ts
+var DiffwikiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var CollectionExistsError = class extends DiffwikiError {
+  constructor(name) {
+    super(`collection "${name}" already exists`);
+  }
+};
+var CollectionNotFoundError = class extends DiffwikiError {
+  constructor(name) {
+    super(`collection "${name}" not found`);
+  }
+};
+var NoDefaultCollectionError = class extends DiffwikiError {
+  constructor() {
+    super("no default collection set (use: diffwiki config-set defaultCollection <name>)");
+  }
+};
+var ArticleNotFoundError = class extends DiffwikiError {
+  constructor(target) {
+    super(`article "${target}" not found`);
+  }
+};
+var InvalidTargetError = class extends DiffwikiError {
+  constructor(target, expected) {
+    super(`invalid target "${target}" \u2014 ${expected}`);
+  }
+};
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+function resolveHome() {
+  const override = process.env.DIFFWIKI_HOME;
+  return override && override.length > 0 ? override : path.join(os.homedir(), ".diffwiki");
+}
+function registryPath() {
+  return path.join(resolveHome(), "registry.json");
+}
+function configPath() {
+  return path.join(resolveHome(), "config.json");
+}
+function collectionsDir() {
+  return path.join(resolveHome(), "collections");
+}
+function collectionDir(name) {
+  return path.join(collectionsDir(), name);
+}
 
 // src/config.ts
+import fs3 from "fs/promises";
+
+// src/collections.ts
+import fs2 from "fs/promises";
+
+// src/registry.ts
 import fs from "fs/promises";
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
+async function readRegistry() {
+  try {
+    const parsed = JSON.parse(await fs.readFile(registryPath(), "utf8"));
+    return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
+  } catch (err) {
+    if (isMissing(err)) return { version: 1, collections: [] };
+    throw err;
+  }
+}
+async function writeRegistry(registry) {
+  await fs.mkdir(resolveHome(), { recursive: true });
+  await fs.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function registerCollection(entry) {
+  const registry = await readRegistry();
+  const index = registry.collections.findIndex((c) => c.name === entry.name);
+  if (index >= 0) {
+    registry.collections[index] = entry;
+  } else {
+    registry.collections.push(entry);
+  }
+  await writeRegistry(registry);
+}
+async function unregisterCollection(name) {
+  const registry = await readRegistry();
+  registry.collections = registry.collections.filter((c) => c.name !== name);
+  await writeRegistry(registry);
+}
+
+// src/collections.ts
+async function listCollections() {
+  return (await readRegistry()).collections;
+}
+async function findCollection(name) {
+  return (await readRegistry()).collections.find((c) => c.name === name);
+}
+async function createCollection(name) {
+  if (await findCollection(name)) throw new CollectionExistsError(name);
+  const dir = collectionDir(name);
+  await fs2.mkdir(dir, { recursive: true });
+  const entry = {
+    name,
+    type: "global",
+    path: dir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await registerCollection(entry);
+  return entry;
+}
+async function removeCollection(name) {
+  const entry = await findCollection(name);
+  if (!entry) throw new CollectionNotFoundError(name);
+  await unregisterCollection(name);
+  if (entry.type === "global") {
+    await fs2.rm(entry.path, { recursive: true, force: true });
+  }
+  return entry;
+}
+
+// src/config.ts
+function isMissing2(err) {
+  return err?.code === "ENOENT";
+}
 async function readConfig() {
   try {
-    return JSON.parse(await fs.readFile(configPath(), "utf8"));
+    return JSON.parse(await fs3.readFile(configPath(), "utf8"));
   } catch (err) {
-    if (isMissing(err)) return {};
+    if (isMissing2(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await fs.mkdir(resolveHome(), { recursive: true });
-  await fs.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await fs3.mkdir(resolveHome(), { recursive: true });
+  await fs3.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function setConfigValue(key, value) {
   if (key === "defaultCollection" && !await findCollection(value)) {
     throw new CollectionNotFoundError(value);
   }
-  if (key === "defaultSearch") {
-    const engine = value.split(":")[0];
-    if (engine !== NATIVE_ENGINE) {
-      const enabled = await listEnabledPlugins("search");
-      if (!enabled.some((p) => p.name === engine)) {
-        console.warn(
-          `! defaultSearch "${value}" names an engine that is not installed/enabled \u2014 native will be used until it is`
-        );
-      }
-    }
-  }
   const config = await readConfig();
   config[key] = value;
   await writeConfig(config);
@@ -101,33 +170,12 @@ var YAML_ENGINE = {
   stringify: (data) => stringifyYaml(data)
 };
 var MATTER_OPTS = { engines: { yaml: YAML_ENGINE } };
-function parseFallback(raw) {
-  const fenceRe = /^---[ \t]*\n([\s\S]*?)\n---[ \t]*\n/;
-  const fenceMatch = fenceRe.exec(raw);
-  let title = "";
-  let body;
-  if (fenceMatch) {
-    const inner = fenceMatch[1];
-    const titleMatch = /^title:\s*(.+)$/m.exec(inner);
-    if (titleMatch) {
-      title = titleMatch[1].trim().replace(/^["']|["']$/g, "");
-    }
-    body = raw.slice(fenceMatch[0].length);
-  } else {
-    body = raw;
-  }
-  return { title, tags: [], body: body.replace(/^\n+/, "") };
-}
 function parseArticle(raw) {
-  try {
-    const { data, content } = matter(raw, MATTER_OPTS);
-    const title = typeof data.title === "string" ? data.title : "";
-    const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t)) : [];
-    const created = typeof data.created === "string" ? data.created : void 0;
-    return { title, tags, created, body: content.replace(/^\n+/, "") };
-  } catch {
-    return parseFallback(raw);
-  }
+  const { data, content } = matter(raw, MATTER_OPTS);
+  const title = typeof data.title === "string" ? data.title : "";
+  const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t)) : [];
+  const created = typeof data.created === "string" ? data.created : void 0;
+  return { title, tags, created, body: content.replace(/^\n+/, "") };
 }
 function serializeArticle(article) {
   const front = { title: article.title, tags: article.tags };
@@ -137,15 +185,8 @@ function serializeArticle(article) {
 }
 
 // src/articles.ts
-import fs2 from "fs/promises";
-import path from "path";
-async function fireHook(event, collection, relPath) {
-  try {
-    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-H3D7FT4O.js");
-    await emitPluginEvent2(event, collection, relPath);
-  } catch {
-  }
-}
+import fs4 from "fs/promises";
+import path2 from "path";
 function parseAddTarget(target) {
   const idx = target.indexOf(":");
   if (idx === -1) {
@@ -178,38 +219,37 @@ async function resolveCollectionDir(name) {
 }
 function ensureMdPath(file) {
   if (/\.mdx?$/.test(file)) return file;
-  const dir = path.dirname(file);
-  const base = slugify(path.basename(file));
-  const rel = dir === "." ? `${base}.md` : path.join(dir, `${base}.md`);
+  const dir = path2.dirname(file);
+  const base = slugify(path2.basename(file));
+  const rel = dir === "." ? `${base}.md` : path2.join(dir, `${base}.md`);
   return rel;
 }
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = path.join(dir, `${slugify(title)}.md`);
+  const filePath = path2.join(dir, `${slugify(title)}.md`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const body = opts.body ?? `# ${title}
 `;
-  await fs2.mkdir(dir, { recursive: true });
-  await fs2.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
-  void fireHook("article-created", name, path.relative(dir, filePath));
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
   return { title, tags: opts.tags, path: filePath, collection: name };
 }
 async function loadArticle(target) {
   const { collection, file } = parsePathTarget(target);
   const { dir } = await resolveCollectionDir(collection);
-  const filePath = path.join(dir, ensureMdPath(file));
+  const filePath = path2.join(dir, ensureMdPath(file));
   try {
-    return { filePath, dir, raw: await fs2.readFile(filePath, "utf8"), collection };
+    return { filePath, raw: await fs4.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
   }
 }
 async function updateArticleBody(target, body) {
-  const { filePath, dir, raw, collection } = await loadArticle(target);
+  const { filePath, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await fs2.writeFile(
+  await fs4.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -220,14 +260,13 @@ async function updateArticleBody(target, body) {
     }),
     "utf8"
   );
-  void fireHook("article-updated", collection, path.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function mutateTags(target, fn) {
-  const { filePath, dir, raw, collection } = await loadArticle(target);
+  const { filePath, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await fs2.writeFile(
+  await fs4.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -238,7 +277,6 @@ async function mutateTags(target, fn) {
     }),
     "utf8"
   );
-  void fireHook("article-updated", collection, path.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
 function addTags(target, tags) {
@@ -252,15 +290,14 @@ function setTags(target, tags) {
   return mutateTags(target, () => Array.from(new Set(tags)));
 }
 async function removeArticle(target) {
-  const { filePath, dir, collection } = await loadArticle(target);
-  await fs2.rm(filePath);
-  void fireHook("article-removed", collection, path.relative(dir, filePath));
+  const { filePath } = await loadArticle(target);
+  await fs4.rm(filePath);
   return filePath;
 }
 
 // src/repo.ts
-import fs3 from "fs/promises";
-import path2 from "path";
+import fs5 from "fs/promises";
+import path3 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
@@ -269,18 +306,18 @@ var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return path2.basename(stdout.trim());
+    return path3.basename(stdout.trim());
   } catch {
-    return path2.basename(path2.resolve(cwd));
+    return path3.basename(path3.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await fs3.readFile(path2.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const raw = await fs5.readFile(path3.join(cwd, REPO_CONFIG_FILE), "utf8");
     const parsed = parseYaml2(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? path2.basename(path2.resolve(cwd)),
+      collection: parsed.collection ?? path3.basename(path3.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -289,9 +326,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = path2.resolve(opts.cwd);
+  const cwd = path3.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = path2.join(cwd, wikiPath);
+  const absWiki = path3.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -306,9 +343,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await fs3.mkdir(absWiki, { recursive: true });
+  await fs5.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await fs3.writeFile(path2.join(cwd, REPO_CONFIG_FILE), stringifyYaml2(config), "utf8");
+  await fs5.writeFile(path3.join(cwd, REPO_CONFIG_FILE), stringifyYaml2(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -320,387 +357,44 @@ async function initRepoWiki(opts) {
 }
 
 // src/query.ts
-import fs4 from "fs/promises";
-import path3 from "path";
-var log = getLogger("query");
-async function collectMarkdownFiles(dir) {
-  let entries;
-  try {
-    entries = await fs4.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const full = path3.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await collectMarkdownFiles(full));
-    } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-var K1 = 1.5;
-var B = 0.75;
-var FIELD_WEIGHTS = { title: 3, tags: 2, collection: 1.5, body: 1 };
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0);
-}
-function termFreqs(tokens) {
-  const freqs = /* @__PURE__ */ new Map();
-  for (const t of tokens) {
-    freqs.set(t, (freqs.get(t) ?? 0) + 1);
-  }
-  return freqs;
-}
-function bm25FieldScore(queryTerms, fieldTokens, avgFieldLen, idf) {
-  const tf = termFreqs(fieldTokens);
-  const dl = fieldTokens.length;
-  const avgDl = avgFieldLen || 1;
-  let score = 0;
-  for (const term of queryTerms) {
-    const freq = tf.get(term) ?? 0;
-    if (freq === 0) continue;
-    const termIdf = idf.get(term) ?? 0;
-    const numerator = freq * (K1 + 1);
-    const denominator = freq + K1 * (1 - B + B * (dl / avgDl));
-    score += termIdf * (numerator / denominator);
-  }
-  return score;
-}
-async function nativeSearch(term, collections, collection) {
-  let targets = collections;
+import fs6 from "fs/promises";
+import path4 from "path";
+async function query(term, collection) {
+  let targets;
   if (collection) {
-    const one = collections.find((c) => c.name === collection);
+    const one = await findCollection(collection);
     if (!one) throw new CollectionNotFoundError(collection);
     targets = [one];
+  } else {
+    targets = await listCollections();
   }
-  const docs = [];
+  const needle = term.toLowerCase();
+  const hits = [];
   for (const entry of targets) {
-    for (const full of await collectMarkdownFiles(entry.path)) {
-      const fallbackTitle = path3.basename(full).replace(/\.mdx?$/, "");
-      let title = fallbackTitle;
-      let tags = [];
-      let body = "";
-      try {
-        const parsed = parseArticle(await fs4.readFile(full, "utf8"));
-        if (parsed.title) title = parsed.title;
-        tags = parsed.tags;
-        body = parsed.body;
-      } catch {
-      }
-      docs.push({
-        collectionName: entry.name,
-        filePath: full,
-        title,
-        tags,
-        fields: {
-          title: tokenize(title),
-          tags: tokenize(tags.join(" ")),
-          collection: tokenize(entry.name),
-          body: tokenize(body)
-        }
-      });
-    }
-  }
-  if (!term.trim()) {
-    return docs.map((d) => ({
-      collection: d.collectionName,
-      path: d.filePath,
-      title: d.title,
-      tags: d.tags
-    }));
-  }
-  const queryTerms = tokenize(term);
-  if (queryTerms.length === 0) {
-    return docs.map((d) => ({
-      collection: d.collectionName,
-      path: d.filePath,
-      title: d.title,
-      tags: d.tags
-    }));
-  }
-  const docTokenSets = docs.map(
-    (doc) => /* @__PURE__ */ new Set([...doc.fields.title, ...doc.fields.tags, ...doc.fields.collection, ...doc.fields.body])
-  );
-  const N = docs.length;
-  const idf = /* @__PURE__ */ new Map();
-  for (const qt of queryTerms) {
-    let docFreq = 0;
-    for (const tokenSet of docTokenSets) {
-      if (tokenSet.has(qt)) docFreq++;
-    }
-    idf.set(qt, Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1));
-  }
-  const avgLens = {
-    title: docs.reduce((sum, d) => sum + d.fields.title.length, 0) / (N || 1),
-    tags: docs.reduce((sum, d) => sum + d.fields.tags.length, 0) / (N || 1),
-    collection: docs.reduce((sum, d) => sum + d.fields.collection.length, 0) / (N || 1),
-    body: docs.reduce((sum, d) => sum + d.fields.body.length, 0) / (N || 1)
-  };
-  const scored = [];
-  for (const doc of docs) {
-    const titleScore = bm25FieldScore(queryTerms, doc.fields.title, avgLens.title, idf) * FIELD_WEIGHTS.title;
-    const tagsScore = bm25FieldScore(queryTerms, doc.fields.tags, avgLens.tags, idf) * FIELD_WEIGHTS.tags;
-    const collScore = bm25FieldScore(queryTerms, doc.fields.collection, avgLens.collection, idf) * FIELD_WEIGHTS.collection;
-    const bodyScore = bm25FieldScore(queryTerms, doc.fields.body, avgLens.body, idf) * FIELD_WEIGHTS.body;
-    const total = titleScore + tagsScore + collScore + bodyScore;
-    if (total > 0) {
-      scored.push({ doc, score: total });
-    }
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.map((s) => ({
-    collection: s.doc.collectionName,
-    path: s.doc.filePath,
-    title: s.doc.title,
-    tags: s.doc.tags,
-    score: s.score
-  }));
-}
-async function resolveDefaultEngine() {
-  const config = await readConfig();
-  const enabled = await listEnabledPlugins("search");
-  const configured = config.defaultSearch?.split(":")[0];
-  if (configured && enabled.some((p) => p.name === configured)) return configured;
-  if (enabled.length > 0) return enabled[0].name;
-  return NATIVE_ENGINE;
-}
-async function resolveDefaultSearchMode() {
-  const config = await readConfig();
-  const enabled = await listEnabledPlugins("search");
-  const configured = config.defaultSearch?.split(":")[0];
-  const configuredType = config.defaultSearch?.split(":")[1];
-  let engine = NATIVE_ENGINE;
-  if (configured && enabled.some((p) => p.name === configured)) engine = configured;
-  else if (enabled.length > 0) engine = enabled[0].name;
-  if (engine === NATIVE_ENGINE) return { engine, type: "basic" };
-  const record = enabled.find((p) => p.name === engine);
-  const searchTypes = record?.capabilities?.searchTypes ?? [];
-  if (searchTypes.length === 0) return { engine: NATIVE_ENGINE, type: "basic" };
-  if (configuredType && searchTypes.includes(configuredType)) {
-    return { engine, type: configuredType };
-  }
-  return { engine, type: searchTypes[0] };
-}
-async function search(term, opts) {
-  const collections = await listCollections();
-  const engine = opts?.engine ?? await resolveDefaultEngine();
-  log.debug(`resolved search engine "${engine}"`);
-  if (engine === NATIVE_ENGINE) {
-    const hits = await nativeSearch(term, collections, opts?.collection);
-    return { hits, engine, fellBackToNative: false };
-  }
-  const provider = await loadSearchProvider(engine);
-  if (!provider) {
-    const error = `no provider found for engine "${engine}"`;
-    log.warn(`engine "${engine}" unavailable, falling back to native: ${error}`);
-    const hits = await nativeSearch(term, collections, opts?.collection);
-    return { hits, engine, fellBackToNative: true, error };
-  }
-  try {
-    const hits = await provider.handleSearch(term, collections, opts);
-    return { hits, engine, fellBackToNative: false };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.warn(`engine "${engine}" failed, falling back to native: ${message}`);
-    const hits = await nativeSearch(term, collections, opts?.collection);
-    return { hits, engine, fellBackToNative: true, error: message };
-  }
-}
-async function query(term, opts) {
-  return (await search(term, opts)).hits;
-}
-
-// src/doctor.ts
-import fs6 from "fs/promises";
-
-// src/plugins/manager.ts
-import fs5 from "fs/promises";
-import path4 from "path";
-async function readPackageJson(file) {
-  try {
-    return JSON.parse(await fs5.readFile(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function binOf(manifest) {
-  if (typeof manifest.bin === "string") return manifest.bin;
-  if (manifest.bin && typeof manifest.bin === "object") {
-    const first = Object.values(manifest.bin)[0];
-    return typeof first === "string" ? first : null;
-  }
-  return null;
-}
-async function pluginManifestDirs(nodeModules) {
-  let entries;
-  try {
-    entries = await fs5.readdir(nodeModules);
-  } catch {
-    return [];
-  }
-  const dirs = [];
-  for (const entry of entries) {
-    if (entry.startsWith(".")) continue;
-    if (entry.startsWith("@")) {
-      let scoped;
-      try {
-        scoped = await fs5.readdir(path4.join(nodeModules, entry));
-      } catch {
-        continue;
-      }
-      for (const pkg of scoped) {
-        if (pkg.startsWith(".")) continue;
-        dirs.push(path4.join(nodeModules, entry, pkg));
-      }
-    } else {
-      dirs.push(path4.join(nodeModules, entry));
-    }
-  }
-  return dirs;
-}
-async function ensurePluginRoot() {
-  const dir = pluginsDir();
-  await fs5.mkdir(dir, { recursive: true });
-  const pkgPath = path4.join(dir, "package.json");
-  if (await readPackageJson(pkgPath) === null) {
-    const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await fs5.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
-`, "utf8");
-  }
-  return dir;
-}
-async function discoverSearchPackage(dir) {
-  const nodeModules = path4.join(dir, "node_modules");
-  for (const pkgDir of await pluginManifestDirs(nodeModules)) {
-    const manifest = await readPackageJson(path4.join(pkgDir, "package.json"));
-    if (!manifest?.name || manifest.diffwiki?.kind !== "search") continue;
-    const bin = binOf(manifest);
-    if (!bin) continue;
-    return { name: manifest.name, version: manifest.version, binAbs: path4.resolve(pkgDir, bin) };
-  }
-  return null;
-}
-async function describePlugin(command, name) {
-  return invokePlugin(command, "describe", {}, { name });
-}
-async function runSetup(command, name) {
-  try {
-    const collections = await listCollections();
-    const result = await invokePlugin(
-      command,
-      "setup",
-      {
-        collections: collections.map((c) => ({ name: c.name, path: c.path })),
-        embed: false,
-        prefetchModels: false
-      },
-      { timeoutMs: LONG_TIMEOUT_MS, name }
-    );
-    return { ready: result?.ready === true, steps: result?.steps ?? [] };
-  } catch (err) {
-    return { ready: false, steps: [{ step: "setup", ok: false, message: err.message }] };
-  }
-}
-async function installPlugin(spec, opts) {
-  const dir = await ensurePluginRoot();
-  try {
-    await runProcess("npm", ["install", spec, "--prefix", dir]);
-  } catch (err) {
-    throw new PluginError(`npm install ${spec} failed: ${err.message}`);
-  }
-  const discovered = await discoverSearchPackage(dir);
-  if (!discovered) {
-    throw new PluginError(
-      `no diffwiki search plugin found in "${spec}" (need package.json diffwiki.kind === "search" + bin)`
-    );
-  }
-  const command = ["node", discovered.binAbs];
-  let capabilities;
-  try {
-    const desc = await describePlugin(command, discovered.name);
-    if (desc.kind !== "search") {
-      throw new PluginError(`plugin "${discovered.name}" reported kind "${desc.kind}", expected "search"`);
-    }
-    capabilities = desc.capabilities;
-  } catch (err) {
-    if (err instanceof PluginError) throw err;
-    throw new PluginError(`plugin "${discovered.name}" failed describe: ${err.message}`);
-  }
-  const record = {
-    name: discovered.name,
-    kind: "search",
-    command,
-    version: discovered.version,
-    capabilities,
-    enabled: true,
-    managed: true
-  };
-  await upsertPlugin(record);
-  const setup = opts?.setup !== false ? await runSetup(command, discovered.name) : void 0;
-  return { record, setup };
-}
-async function registerPlugin(name, command) {
-  if (command.length === 0) throw new PluginError(`register "${name}": --command must not be empty`);
-  let capabilities;
-  try {
-    const desc = await describePlugin(command, name);
-    if (desc.kind !== "search") {
-      throw new PluginError(`plugin "${name}" reported kind "${desc.kind}", expected "search"`);
-    }
-    capabilities = desc.capabilities;
-  } catch (err) {
-    if (err instanceof PluginError) throw err;
-    throw new PluginError(`plugin "${name}" did not respond to describe (command: ${command.join(" ")})`);
-  }
-  const record = {
-    name,
-    kind: "search",
-    command,
-    capabilities,
-    enabled: true,
-    managed: false
-  };
-  await upsertPlugin(record);
-  await runSetup(command, name);
-  return record;
-}
-async function removePlugin(name) {
-  const record = (await readPluginRegistry()).plugins.find((p) => p.name === name);
-  if (!record) throw new PluginError(`plugin "${name}" is not registered`);
-  if (record.managed) {
-    const dir = await ensurePluginRoot();
+    let files;
     try {
-      await runProcess("npm", ["uninstall", name, "--prefix", dir]);
+      files = await fs6.readdir(entry.path);
     } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!/\.mdx?$/.test(file)) continue;
+      const full = path4.join(entry.path, file);
+      const parsed = parseArticle(await fs6.readFile(full, "utf8"));
+      const haystack = [parsed.title, file, ...parsed.tags].join(" ").toLowerCase();
+      if (!needle || haystack.includes(needle)) {
+        hits.push({ collection: entry.name, path: full, title: parsed.title, tags: parsed.tags });
+      }
     }
   }
-  await deregisterPlugin(name);
-}
-async function probeDescribable(command, name) {
-  try {
-    await describePlugin(command, name);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listPlugins() {
-  const registry = await readPluginRegistry();
-  const out = [];
-  for (const record of registry.plugins) {
-    const spawnable = record.enabled ? await probeDescribable(record.command, record.name) : false;
-    out.push({ ...record, spawnable });
-  }
-  return out;
+  return hits;
 }
 
 // src/doctor.ts
+import fs7 from "fs/promises";
 async function exists(target) {
   try {
-    await fs6.access(target);
+    await fs7.access(target);
     return true;
   } catch {
     return false;
@@ -733,80 +427,11 @@ async function doctor() {
   } else {
     out.push({ level: "warn", message: "no default collection set" });
   }
-  await appendPluginDiagnostics(out, config);
   return out;
 }
-function readinessLine(name, health) {
-  const r = health.readiness;
-  if (!r) {
-    return { level: health.ready ? "ok" : "warn", message: `plugin "${name}" ${health.ready ? "ready" : "not ready"}` };
-  }
-  if (r.firstSearchCost === "model-download") {
-    return {
-      level: "warn",
-      message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search will download models (~2GB)`
-    };
-  }
-  if (r.firstSearchCost === "model-load") {
-    return {
-      level: "warn",
-      message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search loads models (a few seconds)`
-    };
-  }
-  return { level: "ok", message: `plugin "${name}": ${r.docsIndexed} doc(s) indexed \u2014 first search is instant` };
-}
-async function appendPluginDiagnostics(out, config) {
-  let plugins = [];
-  try {
-    plugins = await listPlugins();
-  } catch (err) {
-    out.push({ level: "error", message: `failed to read plugin registry: ${err.message}` });
-    return;
-  }
-  if (plugins.length === 0) {
-    out.push({ level: "warn", message: "no search plugins installed \u2014 using built-in native search" });
-  }
-  const collections = await listCollections();
-  for (const p of plugins) {
-    if (!p.enabled) {
-      out.push({ level: "warn", message: `plugin "${p.name}" registered but disabled` });
-      continue;
-    }
-    if (!p.spawnable) {
-      out.push({
-        level: "error",
-        message: `plugin "${p.name}" registered but its command is not spawnable: ${p.command.join(" ")}`
-      });
-      continue;
-    }
-    out.push({ level: "ok", message: `plugin "${p.name}" enabled and spawnable` });
-    try {
-      const provider = await loadSearchProvider(p.name);
-      if (!provider) {
-        out.push({ level: "error", message: `plugin "${p.name}" failed to load for a health check` });
-        continue;
-      }
-      const health = await provider.health(collections);
-      for (const d of health.diagnostics) out.push({ level: d.level, message: `${p.name} \xB7 ${d.message}` });
-      out.push(readinessLine(p.name, health));
-    } catch (err) {
-      out.push({ level: "error", message: `plugin "${p.name}" health check failed: ${err.message}` });
-    }
-  }
-  if (config.defaultSearch) {
-    const engine = config.defaultSearch.split(":")[0];
-    const known = engine === NATIVE_ENGINE || plugins.some((p) => p.name === engine && p.enabled);
-    if (!known) {
-      out.push({
-        level: "warn",
-        message: `defaultSearch "${config.defaultSearch}" is not installed/enabled \u2014 using native`
-      });
-    }
-  }
-}
 
 // src/browse.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import path5 from "path";
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
 function buildArticleTree(relPaths) {
@@ -851,7 +476,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await fs7.readdir(dir, { withFileTypes: true });
+    dirents = await fs8.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -869,7 +494,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await fs7.readdir(dir);
+    return await fs8.readdir(dir);
   } catch {
     return [];
   }
@@ -886,7 +511,7 @@ function pickIndexFile(names) {
 async function cheapTitle(absPath) {
   let handle;
   try {
-    handle = await fs7.open(absPath, "r");
+    handle = await fs8.open(absPath, "r");
     const buf = Buffer.alloc(512);
     const { bytesRead } = await handle.read(buf, 0, 512, 0);
     const snippet = buf.subarray(0, bytesRead).toString("utf8");
@@ -940,7 +565,7 @@ async function readArticle(coll, slug) {
     const candidate = path5.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await fs7.access(candidate);
+      await fs8.access(candidate);
       abs = candidate;
       break;
     } catch {
@@ -954,7 +579,7 @@ async function readArticle(coll, slug) {
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await fs7.readFile(abs, "utf8"));
+  const parsed = parseArticle(await fs8.readFile(abs, "utf8"));
   const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
   return { coll, slug: safeSlug, title, tags: parsed.tags, body: parsed.body, path: abs };
 }
@@ -1022,36 +647,13 @@ async function renderArticle(body) {
   }).use(rehypeStringify).process(body);
   return { html: String(file), toc };
 }
-
-// src/plugins/catalog.ts
-var KNOWN_PLUGINS = [
-  {
-    name: "diffwiki-qmd",
-    kind: "search",
-    spec: "diffwiki-qmd",
-    description: "Local hybrid search \u2014 keyword, semantic, and reranked hybrid via the qmd CLI",
-    requires: "qmd (npm i -g @tobilu/qmd)"
-  },
-  {
-    name: "diffwiki-ripgrep",
-    kind: "search",
-    spec: "diffwiki-ripgrep",
-    description: "Instant literal/regex search via ripgrep \u2014 no index, no models",
-    requires: "rg (ripgrep)"
-  }
-];
-function listAvailablePlugins() {
-  return [...KNOWN_PLUGINS];
-}
 export {
   ArticleNotFoundError,
   CollectionExistsError,
   CollectionNotFoundError,
   DiffwikiError,
   InvalidTargetError,
-  NATIVE_ENGINE,
   NoDefaultCollectionError,
-  PluginError,
   REPO_CONFIG_FILE,
   addTags,
   buildArticleTree,
@@ -1060,56 +662,33 @@ export {
   configPath,
   createArticle,
   createCollection,
-  deregisterPlugin,
   doctor,
-  emitPluginEvent,
-  ensurePluginRoot,
   findCollection,
-  findEnabledPlugin,
-  findPluginRecord,
   getConfigValue,
-  getLogger,
   initRepoWiki,
-  installPlugin,
   listArticleTree,
-  listAvailablePlugins,
   listCollections,
-  listEnabledPlugins,
-  listPlugins,
-  listSearchModes,
-  loadSearchProvider,
-  nativeSearch,
   parseAddTarget,
   parseArticle,
   parsePathTarget,
-  pluginsDir,
-  pluginsRegistryPath,
   query,
   readArticle,
   readConfig,
-  readPluginRegistry,
   readRegistry,
   readRepoConfig,
   registerCollection,
-  registerPlugin,
   registryPath,
   removeArticle,
   removeCollection,
-  removePlugin,
   removeTags,
   renderArticle,
-  resolveDefaultSearchMode,
   resolveHome,
-  resolveLogLevel,
-  search,
   serializeArticle,
   setConfigValue,
   setTags,
   slugify,
   unregisterCollection,
   updateArticleBody,
-  upsertPlugin,
   writeConfig,
-  writePluginRegistry,
   writeRegistry
 };