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

package/dist/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,57 +27,91 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/types.ts
-var NATIVE_ENGINE;
-var init_types = __esm({
-  "src/types.ts"() {
-    "use strict";
-    NATIVE_ENGINE = "native";
-  }
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArticleNotFoundError: () => ArticleNotFoundError,
+  CollectionExistsError: () => CollectionExistsError,
+  CollectionNotFoundError: () => CollectionNotFoundError,
+  DiffwikiError: () => DiffwikiError,
+  InvalidTargetError: () => InvalidTargetError,
+  NoDefaultCollectionError: () => NoDefaultCollectionError,
+  REPO_CONFIG_FILE: () => REPO_CONFIG_FILE,
+  addTags: () => addTags,
+  buildArticleTree: () => buildArticleTree,
+  collectionDir: () => collectionDir,
+  collectionsDir: () => collectionsDir,
+  configPath: () => configPath,
+  createArticle: () => createArticle,
+  createCollection: () => createCollection,
+  doctor: () => doctor,
+  findCollection: () => findCollection,
+  getConfigValue: () => getConfigValue,
+  initRepoWiki: () => initRepoWiki,
+  listArticleTree: () => listArticleTree,
+  listCollections: () => listCollections,
+  parseAddTarget: () => parseAddTarget,
+  parseArticle: () => parseArticle,
+  parsePathTarget: () => parsePathTarget,
+  query: () => query,
+  readArticle: () => readArticle,
+  readConfig: () => readConfig,
+  readRegistry: () => readRegistry,
+  readRepoConfig: () => readRepoConfig,
+  registerCollection: () => registerCollection,
+  registryPath: () => registryPath,
+  removeArticle: () => removeArticle,
+  removeCollection: () => removeCollection,
+  removeTags: () => removeTags,
+  renderArticle: () => renderArticle,
+  resolveHome: () => resolveHome,
+  serializeArticle: () => serializeArticle,
+  setConfigValue: () => setConfigValue,
+  setTags: () => setTags,
+  slugify: () => slugify,
+  unregisterCollection: () => unregisterCollection,
+  updateArticleBody: () => updateArticleBody,
+  writeConfig: () => writeConfig,
+  writeRegistry: () => writeRegistry
 });
+module.exports = __toCommonJS(index_exports);
 
 // src/errors.ts
-var DiffwikiError, CollectionExistsError, CollectionNotFoundError, NoDefaultCollectionError, ArticleNotFoundError, InvalidTargetError, PluginError;
-var init_errors = __esm({
-  "src/errors.ts"() {
-    "use strict";
-    DiffwikiError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = new.target.name;
-      }
-    };
-    CollectionExistsError = class extends DiffwikiError {
-      constructor(name) {
-        super(`collection "${name}" already exists`);
-      }
-    };
-    CollectionNotFoundError = class extends DiffwikiError {
-      constructor(name) {
-        super(`collection "${name}" not found`);
-      }
-    };
-    NoDefaultCollectionError = class extends DiffwikiError {
-      constructor() {
-        super("no default collection set (use: diffwiki config-set defaultCollection <name>)");
-      }
-    };
-    ArticleNotFoundError = class extends DiffwikiError {
-      constructor(target) {
-        super(`article "${target}" not found`);
-      }
-    };
-    InvalidTargetError = class extends DiffwikiError {
-      constructor(target, expected) {
-        super(`invalid target "${target}" \u2014 ${expected}`);
-      }
-    };
-    PluginError = class extends DiffwikiError {
-    };
+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
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
 function resolveHome() {
   const override = process.env.DIFFWIKI_HOME;
   return override && override.length > 0 ? override : import_node_path.default.join(import_node_os.default.homedir(), ".diffwiki");
@@ -97,22 +128,15 @@ function collectionsDir() {
 function collectionDir(name) {
   return import_node_path.default.join(collectionsDir(), name);
 }
-function pluginsDir() {
-  return import_node_path.default.join(resolveHome(), "plugins");
-}
-function pluginsRegistryPath() {
-  return import_node_path.default.join(resolveHome(), "plugins.json");
-}
-var import_node_os, import_node_path;
-var init_paths = __esm({
-  "src/paths.ts"() {
-    "use strict";
-    import_node_os = __toESM(require("os"), 1);
-    import_node_path = __toESM(require("path"), 1);
-  }
-});
+
+// src/config.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+
+// src/collections.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
 
 // src/registry.ts
+var import_promises = __toESM(require("fs/promises"), 1);
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
@@ -145,359 +169,8 @@ async function unregisterCollection(name) {
   registry.collections = registry.collections.filter((c) => c.name !== name);
   await writeRegistry(registry);
 }
-var import_promises;
-var init_registry = __esm({
-  "src/registry.ts"() {
-    "use strict";
-    import_promises = __toESM(require("fs/promises"), 1);
-    init_paths();
-  }
-});
-
-// src/plugins/registry.ts
-function isMissing2(err) {
-  return err?.code === "ENOENT";
-}
-async function readPluginRegistry() {
-  try {
-    const parsed = JSON.parse(await import_promises2.default.readFile(pluginsRegistryPath(), "utf8"));
-    return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
-  } catch (err) {
-    if (isMissing2(err)) return { version: 1, plugins: [] };
-    throw err;
-  }
-}
-async function writePluginRegistry(registry) {
-  await import_promises2.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises2.default.writeFile(pluginsRegistryPath(), `${JSON.stringify(registry, null, 2)}
-`, "utf8");
-}
-async function upsertPlugin(record) {
-  const registry = await readPluginRegistry();
-  const index = registry.plugins.findIndex((p) => p.name === record.name);
-  if (index >= 0) {
-    registry.plugins[index] = record;
-  } else {
-    registry.plugins.push(record);
-  }
-  await writePluginRegistry(registry);
-}
-async function deregisterPlugin(name) {
-  const registry = await readPluginRegistry();
-  registry.plugins = registry.plugins.filter((p) => p.name !== name);
-  await writePluginRegistry(registry);
-}
-async function listEnabledPlugins(kind) {
-  const registry = await readPluginRegistry();
-  return registry.plugins.filter((p) => p.enabled && p.kind === kind);
-}
-async function findEnabledPlugin(kind, name) {
-  const enabled = await listEnabledPlugins(kind);
-  if (name) return enabled.find((p) => p.name === name);
-  return enabled[0];
-}
-async function findPluginRecord(name) {
-  const registry = await readPluginRegistry();
-  return registry.plugins.find((p) => p.name === name);
-}
-var import_promises2;
-var init_registry2 = __esm({
-  "src/plugins/registry.ts"() {
-    "use strict";
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    init_paths();
-  }
-});
-
-// src/logger.ts
-function getLogger(scope) {
-  const parts = Array.isArray(scope) ? scope : [scope];
-  return (0, import_logtape.getLogger)(["diffwiki", ...parts]);
-}
-function resolveLogLevel(env = process.env) {
-  const raw = (env.DIFFWIKI_LOG ?? "").toLowerCase();
-  return LEVELS.includes(raw) ? raw : DEFAULT_LEVEL;
-}
-var import_logtape, LEVELS, DEFAULT_LEVEL;
-var init_logger = __esm({
-  "src/logger.ts"() {
-    "use strict";
-    import_logtape = require("@logtape/logtape");
-    LEVELS = ["trace", "debug", "info", "warning", "error", "fatal"];
-    DEFAULT_LEVEL = "warning";
-  }
-});
-
-// src/plugins/host.ts
-async function invokePlugin(command, op, params, opts) {
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const scope = opts?.name ?? (0, import_node_path2.basename)(command[1] ?? command[0] ?? "plugin");
-  return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process.spawn)(command[0], command.slice(1), {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let stderrLine = "";
-    let settled = false;
-    const forwardLog = (line) => {
-      const trimmedLine = line.trim();
-      if (!trimmedLine.startsWith("{")) return;
-      let parsed;
-      try {
-        parsed = JSON.parse(trimmedLine);
-      } catch {
-        return;
-      }
-      const entry = parsed.log;
-      if (!entry || typeof entry.message !== "string") return;
-      const rawLevel = typeof entry.level === "string" ? entry.level.toLowerCase() : "";
-      const method = LEVEL_METHOD[rawLevel] ?? "info";
-      getLogger(["plugin", scope])[method](entry.message);
-    };
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      child.kill("SIGKILL");
-      reject(new Error(`plugin "${op}" timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    const settle = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn();
-    };
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-      stderrLine += chunk;
-      let nl;
-      while ((nl = stderrLine.indexOf("\n")) !== -1) {
-        forwardLog(stderrLine.slice(0, nl));
-        stderrLine = stderrLine.slice(nl + 1);
-      }
-    });
-    child.on("error", (err) => {
-      settle(() => reject(new Error(`plugin spawn failed: ${err.message}`)));
-    });
-    child.on("close", (code) => {
-      if (stderrLine.length > 0) {
-        forwardLog(stderrLine);
-        stderrLine = "";
-      }
-      settle(() => {
-        const trimmed = stdout.trim();
-        if (!trimmed) {
-          reject(
-            new Error(`plugin "${op}" produced no output (exit ${code})${stderr ? ": " + stderr.slice(0, 500) : ""}`)
-          );
-          return;
-        }
-        let response;
-        try {
-          response = JSON.parse(trimmed);
-        } catch {
-          reject(new Error(`plugin "${op}" returned invalid JSON: ${trimmed.slice(0, 200)}`));
-          return;
-        }
-        if (response.ok) {
-          resolve(response.result);
-        } else {
-          const message = typeof response.error?.message === "string" ? response.error.message : `plugin "${op}" failed`;
-          reject(new Error(message));
-        }
-      });
-    });
-    const request = JSON.stringify({ op, params });
-    child.stdin.write(request + "\n", (err) => {
-      if (err && !settled) {
-        settle(() => reject(new Error(`failed to write to plugin stdin: ${err.message}`)));
-        return;
-      }
-      child.stdin.end();
-    });
-  });
-}
-function toWireCollections(collections) {
-  return collections.map((c) => ({ name: c.name, path: c.path }));
-}
-function mapHits(result, collections) {
-  const raw = result?.hits;
-  const hits = Array.isArray(raw) ? raw : [];
-  const out = [];
-  for (const item of hits) {
-    if (typeof item !== "object" || item === null) continue;
-    const h = item;
-    if (typeof h.collection !== "string" || typeof h.relPath !== "string") continue;
-    const title = typeof h.title === "string" ? h.title : h.relPath;
-    const coll = collections.find((c) => c.name === h.collection);
-    const abs = coll ? import_node_path2.default.join(coll.path, h.relPath) : h.relPath;
-    out.push({
-      collection: h.collection,
-      path: abs,
-      title,
-      tags: Array.isArray(h.tags) ? h.tags.filter((t) => typeof t === "string") : [],
-      snippet: typeof h.snippet === "string" ? h.snippet : void 0,
-      score: typeof h.score === "number" ? h.score : void 0,
-      docid: typeof h.docid === "string" ? h.docid : void 0
-    });
-  }
-  return out;
-}
-async function loadSearchProvider(name) {
-  const record = await findEnabledPlugin("search", name);
-  if (!record) return null;
-  let capabilities;
-  try {
-    const desc = await invokePlugin(record.command, "describe", {}, { name: record.name });
-    if (desc.kind !== "search") {
-      return null;
-    }
-    capabilities = desc.capabilities;
-  } catch {
-    return null;
-  }
-  const provider = {
-    name: record.name,
-    capabilities,
-    async handleSearch(term, collections, opts) {
-      const result = await invokePlugin(
-        record.command,
-        "search",
-        {
-          term,
-          collections: toWireCollections(collections),
-          collection: opts?.collection,
-          type: opts?.type,
-          limit: opts?.limit
-        },
-        { timeoutMs: SEARCH_TIMEOUT_MS, name: record.name }
-      );
-      return mapHits(result, collections);
-    },
-    async reindex(collections, opts) {
-      const result = await invokePlugin(
-        record.command,
-        "index",
-        {
-          collections: toWireCollections(collections),
-          embed: opts?.embed
-        },
-        { timeoutMs: LONG_TIMEOUT_MS, name: record.name }
-      );
-      return result?.indexed ?? 0;
-    },
-    async emitEvent(event, collection, relPath, collections) {
-      try {
-        const entry = collections.find((c) => c.name === collection);
-        await invokePlugin(
-          record.command,
-          "event",
-          {
-            event,
-            collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
-            relPath,
-            collections: toWireCollections(collections)
-          },
-          { name: record.name }
-        );
-      } catch {
-      }
-    },
-    async health(collections) {
-      const result = await invokePlugin(record.command, "health", { collections: toWireCollections(collections) }, { name: record.name });
-      return {
-        ready: result?.ready === true,
-        readiness: result?.readiness,
-        diagnostics: result?.diagnostics ?? []
-      };
-    }
-  };
-  return provider;
-}
-async function listSearchModes() {
-  const modes = [{ plugin: NATIVE_ENGINE, type: "basic", label: "native \xB7 bm25" }];
-  const plugins = await listEnabledPlugins("search");
-  for (const record of plugins) {
-    const caps = record.capabilities;
-    if (!caps) continue;
-    for (const type of caps.searchTypes) {
-      modes.push({ plugin: record.name, type, label: `${record.name} \xB7 ${type}` });
-    }
-  }
-  return modes;
-}
-var import_node_child_process, import_node_path2, LEVEL_METHOD, DEFAULT_TIMEOUT_MS, SEARCH_TIMEOUT_MS, LONG_TIMEOUT_MS;
-var init_host = __esm({
-  "src/plugins/host.ts"() {
-    "use strict";
-    import_node_child_process = require("child_process");
-    import_node_path2 = __toESM(require("path"), 1);
-    init_logger();
-    init_types();
-    init_registry2();
-    LEVEL_METHOD = {
-      trace: "trace",
-      debug: "debug",
-      info: "info",
-      warn: "warn",
-      warning: "warn",
-      error: "error",
-      fatal: "fatal"
-    };
-    DEFAULT_TIMEOUT_MS = 3e4;
-    SEARCH_TIMEOUT_MS = 12e4;
-    LONG_TIMEOUT_MS = 18e5;
-  }
-});
-
-// src/plugins/events.ts
-var events_exports = {};
-__export(events_exports, {
-  emitPluginEvent: () => emitPluginEvent
-});
-async function emitPluginEvent(event, collection, relPath) {
-  try {
-    const record = await findEnabledPlugin("search");
-    if (!record) return;
-    if (!record.capabilities?.events) return;
-    const collections = await listCollections();
-    const entry = collections.find((c) => c.name === collection);
-    await invokePlugin(
-      record.command,
-      "event",
-      {
-        event,
-        collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
-        relPath,
-        collections: collections.map((c) => ({ name: c.name, path: c.path }))
-      },
-      { name: record.name }
-    );
-  } catch {
-  }
-}
-var init_events = __esm({
-  "src/plugins/events.ts"() {
-    "use strict";
-    init_collections();
-    init_registry2();
-    init_host();
-  }
-});
 
 // src/collections.ts
-async function fireHook(event, collection) {
-  try {
-    const { emitPluginEvent: emitPluginEvent2 } = await Promise.resolve().then(() => (init_events(), events_exports));
-    await emitPluginEvent2(event, collection);
-  } catch {
-  }
-}
 async function listCollections() {
   return (await readRegistry()).collections;
 }
@@ -507,7 +180,7 @@ async function findCollection(name) {
 async function createCollection(name) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await import_promises3.default.mkdir(dir, { recursive: true });
+  await import_promises2.default.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -515,7 +188,6 @@ async function createCollection(name) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await registerCollection(entry);
-  void fireHook("collection-added", name);
   return entry;
 }
 async function removeCollection(name) {
@@ -523,137 +195,32 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await import_promises3.default.rm(entry.path, { recursive: true, force: true });
+    await import_promises2.default.rm(entry.path, { recursive: true, force: true });
   }
-  void fireHook("collection-removed", name);
   return entry;
 }
-var import_promises3;
-var init_collections = __esm({
-  "src/collections.ts"() {
-    "use strict";
-    import_promises3 = __toESM(require("fs/promises"), 1);
-    init_paths();
-    init_registry();
-    init_errors();
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ArticleNotFoundError: () => ArticleNotFoundError,
-  CollectionExistsError: () => CollectionExistsError,
-  CollectionNotFoundError: () => CollectionNotFoundError,
-  DiffwikiError: () => DiffwikiError,
-  InvalidTargetError: () => InvalidTargetError,
-  NATIVE_ENGINE: () => NATIVE_ENGINE,
-  NoDefaultCollectionError: () => NoDefaultCollectionError,
-  PluginError: () => PluginError,
-  REPO_CONFIG_FILE: () => REPO_CONFIG_FILE,
-  addTags: () => addTags,
-  buildArticleTree: () => buildArticleTree,
-  collectionDir: () => collectionDir,
-  collectionsDir: () => collectionsDir,
-  configPath: () => configPath,
-  createArticle: () => createArticle,
-  createCollection: () => createCollection,
-  deregisterPlugin: () => deregisterPlugin,
-  doctor: () => doctor,
-  emitPluginEvent: () => emitPluginEvent,
-  ensurePluginRoot: () => ensurePluginRoot,
-  findCollection: () => findCollection,
-  findEnabledPlugin: () => findEnabledPlugin,
-  findPluginRecord: () => findPluginRecord,
-  getConfigValue: () => getConfigValue,
-  getLogger: () => getLogger,
-  initRepoWiki: () => initRepoWiki,
-  installPlugin: () => installPlugin,
-  listArticleTree: () => listArticleTree,
-  listAvailablePlugins: () => listAvailablePlugins,
-  listCollections: () => listCollections,
-  listEnabledPlugins: () => listEnabledPlugins,
-  listPlugins: () => listPlugins,
-  listSearchModes: () => listSearchModes,
-  loadSearchProvider: () => loadSearchProvider,
-  nativeSearch: () => nativeSearch,
-  parseAddTarget: () => parseAddTarget,
-  parseArticle: () => parseArticle,
-  parsePathTarget: () => parsePathTarget,
-  pluginsDir: () => pluginsDir,
-  pluginsRegistryPath: () => pluginsRegistryPath,
-  query: () => query,
-  readArticle: () => readArticle,
-  readConfig: () => readConfig,
-  readPluginRegistry: () => readPluginRegistry,
-  readRegistry: () => readRegistry,
-  readRepoConfig: () => readRepoConfig,
-  registerCollection: () => registerCollection,
-  registerPlugin: () => registerPlugin,
-  registryPath: () => registryPath,
-  removeArticle: () => removeArticle,
-  removeCollection: () => removeCollection,
-  removePlugin: () => removePlugin,
-  removeTags: () => removeTags,
-  renderArticle: () => renderArticle,
-  resolveDefaultSearchMode: () => resolveDefaultSearchMode,
-  resolveHome: () => resolveHome,
-  resolveLogLevel: () => resolveLogLevel,
-  search: () => search,
-  serializeArticle: () => serializeArticle,
-  setConfigValue: () => setConfigValue,
-  setTags: () => setTags,
-  slugify: () => slugify,
-  unregisterCollection: () => unregisterCollection,
-  updateArticleBody: () => updateArticleBody,
-  upsertPlugin: () => upsertPlugin,
-  writeConfig: () => writeConfig,
-  writePluginRegistry: () => writePluginRegistry,
-  writeRegistry: () => writeRegistry
-});
-module.exports = __toCommonJS(index_exports);
-init_types();
-init_errors();
-init_paths();
 
 // src/config.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-init_paths();
-init_collections();
-init_errors();
-init_registry2();
-init_types();
-function isMissing3(err) {
+function isMissing2(err) {
   return err?.code === "ENOENT";
 }
 async function readConfig() {
   try {
-    return JSON.parse(await import_promises4.default.readFile(configPath(), "utf8"));
+    return JSON.parse(await import_promises3.default.readFile(configPath(), "utf8"));
   } catch (err) {
-    if (isMissing3(err)) return {};
+    if (isMissing2(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises4.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await import_promises3.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises3.default.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);
@@ -664,9 +231,6 @@ async function getConfigValue(key) {
   return typeof value === "string" ? value : void 0;
 }
 
-// src/index.ts
-init_registry();
-
 // src/slugify.ts
 function slugify(input) {
   const slug = input.toLowerCase().replace(/^#+\s*/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/g, "");
@@ -684,33 +248,12 @@ var YAML_ENGINE = {
   stringify: (data) => (0, import_yaml.stringify)(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 } = (0, import_gray_matter.default)(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 } = (0, import_gray_matter.default)(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 };
@@ -719,21 +262,9 @@ function serializeArticle(article) {
   return import_gray_matter.default.stringify(article.body, front, MATTER_OPTS);
 }
 
-// src/index.ts
-init_collections();
-
 // src/articles.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-init_collections();
-init_errors();
-async function fireHook2(event, collection, relPath) {
-  try {
-    const { emitPluginEvent: emitPluginEvent2 } = await Promise.resolve().then(() => (init_events(), events_exports));
-    await emitPluginEvent2(event, collection, relPath);
-  } catch {
-  }
-}
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 function parseAddTarget(target) {
   const idx = target.indexOf(":");
   if (idx === -1) {
@@ -766,38 +297,37 @@ async function resolveCollectionDir(name) {
 }
 function ensureMdPath(file) {
   if (/\.mdx?$/.test(file)) return file;
-  const dir = import_node_path3.default.dirname(file);
-  const base = slugify(import_node_path3.default.basename(file));
-  const rel = dir === "." ? `${base}.md` : import_node_path3.default.join(dir, `${base}.md`);
+  const dir = import_node_path2.default.dirname(file);
+  const base = slugify(import_node_path2.default.basename(file));
+  const rel = dir === "." ? `${base}.md` : import_node_path2.default.join(dir, `${base}.md`);
   return rel;
 }
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path3.default.join(dir, `${slugify(title)}.md`);
+  const filePath = import_node_path2.default.join(dir, `${slugify(title)}.md`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const body = opts.body ?? `# ${title}
 `;
-  await import_promises5.default.mkdir(dir, { recursive: true });
-  await import_promises5.default.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
-  void fireHook2("article-created", name, import_node_path3.default.relative(dir, filePath));
+  await import_promises4.default.mkdir(dir, { recursive: true });
+  await import_promises4.default.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 = import_node_path3.default.join(dir, ensureMdPath(file));
+  const filePath = import_node_path2.default.join(dir, ensureMdPath(file));
   try {
-    return { filePath, dir, raw: await import_promises5.default.readFile(filePath, "utf8"), collection };
+    return { filePath, raw: await import_promises4.default.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 import_promises5.default.writeFile(
+  await import_promises4.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -808,14 +338,13 @@ async function updateArticleBody(target, body) {
     }),
     "utf8"
   );
-  void fireHook2("article-updated", collection, import_node_path3.default.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 import_promises5.default.writeFile(
+  await import_promises4.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -826,7 +355,6 @@ async function mutateTags(target, fn) {
     }),
     "utf8"
   );
-  void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
 function addTags(target, tags) {
@@ -840,37 +368,34 @@ function setTags(target, tags) {
   return mutateTags(target, () => Array.from(new Set(tags)));
 }
 async function removeArticle(target) {
-  const { filePath, dir, collection } = await loadArticle(target);
-  await import_promises5.default.rm(filePath);
-  void fireHook2("article-removed", collection, import_node_path3.default.relative(dir, filePath));
+  const { filePath } = await loadArticle(target);
+  await import_promises4.default.rm(filePath);
   return filePath;
 }
 
 // src/repo.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-var import_node_child_process2 = require("child_process");
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_child_process = require("child_process");
 var import_node_util = require("util");
 var import_yaml2 = require("yaml");
-init_collections();
-init_registry();
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
 var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return import_node_path4.default.basename(stdout.trim());
+    return import_node_path3.default.basename(stdout.trim());
   } catch {
-    return import_node_path4.default.basename(import_node_path4.default.resolve(cwd));
+    return import_node_path3.default.basename(import_node_path3.default.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await import_promises6.default.readFile(import_node_path4.default.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const raw = await import_promises5.default.readFile(import_node_path3.default.join(cwd, REPO_CONFIG_FILE), "utf8");
     const parsed = (0, import_yaml2.parse)(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? import_node_path4.default.basename(import_node_path4.default.resolve(cwd)),
+      collection: parsed.collection ?? import_node_path3.default.basename(import_node_path3.default.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -879,9 +404,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = import_node_path4.default.resolve(opts.cwd);
+  const cwd = import_node_path3.default.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = import_node_path4.default.join(cwd, wikiPath);
+  const absWiki = import_node_path3.default.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -896,9 +421,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises6.default.mkdir(absWiki, { recursive: true });
+  await import_promises5.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises6.default.writeFile(import_node_path4.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
+  await import_promises5.default.writeFile(import_node_path3.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -910,422 +435,44 @@ async function initRepoWiki(opts) {
 }
 
 // src/query.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-init_collections();
-init_errors();
-init_logger();
-init_host();
-init_registry2();
-init_types();
-var log = getLogger("query");
-async function collectMarkdownFiles(dir) {
-  let entries;
-  try {
-    entries = await import_promises7.default.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const full = import_node_path5.default.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;
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+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 = import_node_path5.default.basename(full).replace(/\.mdx?$/, "");
-      let title = fallbackTitle;
-      let tags = [];
-      let body = "";
-      try {
-        const parsed = parseArticle(await import_promises7.default.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
-var import_promises9 = __toESM(require("fs/promises"), 1);
-init_paths();
-init_registry();
-init_collections();
-
-// src/plugins/manager.ts
-var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-init_paths();
-init_errors();
-init_collections();
-init_registry2();
-init_host();
-
-// src/plugins/sdk.ts
-var import_node_child_process3 = require("child_process");
-var import_node_util2 = require("util");
-var import_node_fs = require("fs");
-var import_node_path6 = require("path");
-var import_node_url = require("url");
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
-async function runProcess(file, args, opts) {
-  const { stdout, stderr } = await execFileAsync2(file, args, {
-    env: opts?.env,
-    timeout: opts?.timeout,
-    // Large: qmd emits multi-MB JSON search payloads that overflow the default 1 MB.
-    maxBuffer: 50 * 1024 * 1024
-  });
-  return { stdout, stderr };
-}
-
-// src/plugins/manager.ts
-async function readPackageJson(file) {
-  try {
-    return JSON.parse(await import_promises8.default.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 import_promises8.default.readdir(nodeModules);
-  } catch {
-    return [];
-  }
-  const dirs = [];
-  for (const entry of entries) {
-    if (entry.startsWith(".")) continue;
-    if (entry.startsWith("@")) {
-      let scoped;
-      try {
-        scoped = await import_promises8.default.readdir(import_node_path7.default.join(nodeModules, entry));
-      } catch {
-        continue;
-      }
-      for (const pkg of scoped) {
-        if (pkg.startsWith(".")) continue;
-        dirs.push(import_node_path7.default.join(nodeModules, entry, pkg));
-      }
-    } else {
-      dirs.push(import_node_path7.default.join(nodeModules, entry));
-    }
-  }
-  return dirs;
-}
-async function ensurePluginRoot() {
-  const dir = pluginsDir();
-  await import_promises8.default.mkdir(dir, { recursive: true });
-  const pkgPath = import_node_path7.default.join(dir, "package.json");
-  if (await readPackageJson(pkgPath) === null) {
-    const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await import_promises8.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
-`, "utf8");
-  }
-  return dir;
-}
-async function discoverSearchPackage(dir) {
-  const nodeModules = import_node_path7.default.join(dir, "node_modules");
-  for (const pkgDir of await pluginManifestDirs(nodeModules)) {
-    const manifest = await readPackageJson(import_node_path7.default.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: import_node_path7.default.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 import_promises6.default.readdir(entry.path);
     } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!/\.mdx?$/.test(file)) continue;
+      const full = import_node_path4.default.join(entry.path, file);
+      const parsed = parseArticle(await import_promises6.default.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
-init_host();
-init_types();
+var import_promises7 = __toESM(require("fs/promises"), 1);
 async function exists(target) {
   try {
-    await import_promises9.default.access(target);
+    await import_promises7.default.access(target);
     return true;
   } catch {
     return false;
@@ -1358,86 +505,12 @@ 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/index.ts
-init_logger();
 
 // src/browse.ts
-var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-init_collections();
-init_errors();
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
 function buildArticleTree(relPaths) {
   const root = {};
@@ -1481,7 +554,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await import_promises10.default.readdir(dir, { withFileTypes: true });
+    dirents = await import_promises8.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1490,7 +563,7 @@ async function collectRelPaths(dir, rel = "") {
     if (d.name.startsWith(".")) continue;
     const childRel = rel ? `${rel}/${d.name}` : d.name;
     if (d.isDirectory()) {
-      out.push(...await collectRelPaths(import_node_path8.default.join(dir, d.name), childRel));
+      out.push(...await collectRelPaths(import_node_path5.default.join(dir, d.name), childRel));
     } else if (/\.(mdx?)$/.test(d.name)) {
       out.push(childRel);
     }
@@ -1499,7 +572,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await import_promises10.default.readdir(dir);
+    return await import_promises8.default.readdir(dir);
   } catch {
     return [];
   }
@@ -1516,7 +589,7 @@ function pickIndexFile(names) {
 async function cheapTitle(absPath) {
   let handle;
   try {
-    handle = await import_promises10.default.open(absPath, "r");
+    handle = await import_promises8.default.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");
@@ -1535,14 +608,14 @@ async function enrichTitles(nodes, collDir) {
         const children = await enrichTitles(node.children, collDir);
         let title = node.title;
         if (node.slug) {
-          const dir = import_node_path8.default.join(collDir, node.slug);
+          const dir = import_node_path5.default.join(collDir, node.slug);
           const idx = pickIndexFile(await readdirSafe(dir));
-          if (idx) title = await cheapTitle(import_node_path8.default.join(dir, idx)) ?? title;
+          if (idx) title = await cheapTitle(import_node_path5.default.join(dir, idx)) ?? title;
         }
         return { ...node, title, children };
       }
       for (const ext of [".mdx", ".md"]) {
-        const title = await cheapTitle(import_node_path8.default.join(collDir, `${node.slug}${ext}`));
+        const title = await cheapTitle(import_node_path5.default.join(collDir, `${node.slug}${ext}`));
         if (title) return { ...node, title };
       }
       return node;
@@ -1553,38 +626,38 @@ async function listArticleTree(coll) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
   const rels = await collectRelPaths(entry.path);
-  return enrichTitles(buildArticleTree(rels), import_node_path8.default.resolve(entry.path));
+  return enrichTitles(buildArticleTree(rels), import_node_path5.default.resolve(entry.path));
 }
 async function readArticle(coll, slug) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
-  const collDir = import_node_path8.default.resolve(entry.path);
+  const collDir = import_node_path5.default.resolve(entry.path);
   const normalized = slug.replace(/\\/g, "/");
   if (normalized.split("/").some((s) => s === "..")) {
     throw new InvalidTargetError(slug, "path traversal detected");
   }
   const safeSlug = normalized.split("/").filter((s) => s !== "" && s !== ".").join("/");
-  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path8.default.sep);
+  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path5.default.sep);
   let abs;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
-    const candidate = import_node_path8.default.resolve(collDir, rel);
+    const candidate = import_node_path5.default.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await import_promises10.default.access(candidate);
+      await import_promises8.default.access(candidate);
       abs = candidate;
       break;
     } catch {
     }
   }
   if (!abs) {
-    const dir = import_node_path8.default.resolve(collDir, safeSlug);
+    const dir = import_node_path5.default.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
-      if (idx) abs = import_node_path8.default.join(dir, idx);
+      if (idx) abs = import_node_path5.default.join(dir, idx);
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await import_promises10.default.readFile(abs, "utf8"));
+  const parsed = parseArticle(await import_promises8.default.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 };
 }
@@ -1652,34 +725,6 @@ async function renderArticle(body) {
   }).use(import_rehype_stringify.default).process(body);
   return { html: String(file), toc };
 }
-
-// src/plugins/index.ts
-init_host();
-init_events();
-
-// 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];
-}
-
-// src/plugins/index.ts
-init_registry2();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArticleNotFoundError,
@@ -1687,9 +732,7 @@ init_registry2();
   CollectionNotFoundError,
   DiffwikiError,
   InvalidTargetError,
-  NATIVE_ENGINE,
   NoDefaultCollectionError,
-  PluginError,
   REPO_CONFIG_FILE,
   addTags,
   buildArticleTree,
@@ -1698,56 +741,33 @@ init_registry2();
   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
 });