diffwiki-core 0.4.0 → 0.5.0-rc.202607230329.fb70592

package/dist/index.cjs

@@ -5,6 +5,9 @@ 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 });
@@ -27,91 +30,67 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// 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
+// src/types.ts
+var NATIVE_ENGINE;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    NATIVE_ENGINE = "native";
+  }
 });
-module.exports = __toCommonJS(index_exports);
 
 // 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}`);
+var DiffwikiError, CollectionExistsError, CollectionNotFoundError, NoDefaultCollectionError, ArticleNotFoundError, InvalidTargetError, PluginError, WorktreeNotAllowedError, CollectionAlreadyAddedError;
+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 {
+    };
+    WorktreeNotAllowedError = class extends DiffwikiError {
+      constructor(root) {
+        super(`refusing to add a linked worktree \u2014 add the source repository instead (${root})`);
+      }
+    };
+    CollectionAlreadyAddedError = class extends DiffwikiError {
+      constructor(name) {
+        super(`this repository is already added as collection "${name}"`);
+      }
+    };
   }
-};
+});
 
 // 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");
@@ -128,15 +107,22 @@ function collectionsDir() {
 function collectionDir(name) {
   return import_node_path.default.join(collectionsDir(), name);
 }
-
-// src/config.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-
-// src/collections.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
+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/registry.ts
-var import_promises = __toESM(require("fs/promises"), 1);
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
@@ -169,18 +155,372 @@ 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;
 }
 async function findCollection(name) {
   return (await readRegistry()).collections.find((c) => c.name === name);
 }
+async function findCollectionById(id) {
+  return (await readRegistry()).collections.find((c) => c.id === id);
+}
 async function createCollection(name) {
   if (await findCollection(name)) throw new CollectionExistsError(name);
   const dir = collectionDir(name);
-  await import_promises2.default.mkdir(dir, { recursive: true });
+  await import_promises3.default.mkdir(dir, { recursive: true });
   const entry = {
     name,
     type: "global",
@@ -188,6 +528,7 @@ async function createCollection(name) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await registerCollection(entry);
+  void fireHook("collection-added", name);
   return entry;
 }
 async function removeCollection(name) {
@@ -195,32 +536,157 @@ async function removeCollection(name) {
   if (!entry) throw new CollectionNotFoundError(name);
   await unregisterCollection(name);
   if (entry.type === "global") {
-    await import_promises2.default.rm(entry.path, { recursive: true, force: true });
+    await import_promises3.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,
+  CollectionAlreadyAddedError: () => CollectionAlreadyAddedError,
+  CollectionExistsError: () => CollectionExistsError,
+  CollectionNotFoundError: () => CollectionNotFoundError,
+  DiffwikiError: () => DiffwikiError,
+  InvalidTargetError: () => InvalidTargetError,
+  NATIVE_ENGINE: () => NATIVE_ENGINE,
+  NoDefaultCollectionError: () => NoDefaultCollectionError,
+  PluginError: () => PluginError,
+  REPO_CONFIG_FILE: () => REPO_CONFIG_FILE,
+  WorktreeNotAllowedError: () => WorktreeNotAllowedError,
+  addExternalCollection: () => addExternalCollection,
+  addTags: () => addTags,
+  buildArticleTree: () => buildArticleTree,
+  buildCollections: () => buildCollections,
+  buildNavTree: () => buildNavTree,
+  buildSearchIndex: () => buildSearchIndex,
+  collectionDir: () => collectionDir,
+  collectionGitStatus: () => collectionGitStatus,
+  collectionsDir: () => collectionsDir,
+  configPath: () => configPath,
+  createArticle: () => createArticle,
+  createCollection: () => createCollection,
+  currentBranch: () => currentBranch,
+  deregisterPlugin: () => deregisterPlugin,
+  doctor: () => doctor,
+  emitPluginEvent: () => emitPluginEvent,
+  ensureGitRepo: () => ensureGitRepo,
+  ensurePluginRoot: () => ensurePluginRoot,
+  findCollection: () => findCollection,
+  findCollectionById: () => findCollectionById,
+  findEnabledPlugin: () => findEnabledPlugin,
+  findPluginRecord: () => findPluginRecord,
+  getConfigValue: () => getConfigValue,
+  getLogger: () => getLogger,
+  gitToplevel: () => gitToplevel,
+  initRepoWiki: () => initRepoWiki,
+  installPlugin: () => installPlugin,
+  isLinkedWorktree: () => isLinkedWorktree,
+  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,
+  rankDocs: () => rankDocs,
+  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,
+  repoId: () => repoId,
+  repoRemoteName: () => repoRemoteName,
+  resolveCwdCollection: () => resolveCwdCollection,
+  resolveDefaultSearchMode: () => resolveDefaultSearchMode,
+  resolveHome: () => resolveHome,
+  resolveLogLevel: () => resolveLogLevel,
+  resolvePage: () => resolvePage,
+  search: () => search,
+  serializeArticle: () => serializeArticle,
+  setConfigValue: () => setConfigValue,
+  setTags: () => setTags,
+  slugify: () => slugify,
+  toTreeNodes: () => toTreeNodes,
+  tokenize: () => tokenize,
+  unregisterCollection: () => unregisterCollection,
+  updateArticleBody: () => updateArticleBody,
+  upsertPlugin: () => upsertPlugin,
+  upstreamStatus: () => upstreamStatus,
+  writeConfig: () => writeConfig,
+  writePluginRegistry: () => writePluginRegistry,
+  writeRegistry: () => writeRegistry
+});
+module.exports = __toCommonJS(index_exports);
+init_types();
+init_errors();
+init_paths();
 
 // src/config.ts
-function isMissing2(err) {
+var import_promises4 = __toESM(require("fs/promises"), 1);
+init_paths();
+init_collections();
+init_errors();
+init_registry2();
+init_types();
+function isMissing3(err) {
   return err?.code === "ENOENT";
 }
 async function readConfig() {
   try {
-    return JSON.parse(await import_promises3.default.readFile(configPath(), "utf8"));
+    return JSON.parse(await import_promises4.default.readFile(configPath(), "utf8"));
   } catch (err) {
-    if (isMissing2(err)) return {};
+    if (isMissing3(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await import_promises3.default.mkdir(resolveHome(), { recursive: true });
-  await import_promises3.default.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await import_promises4.default.mkdir(resolveHome(), { recursive: true });
+  await import_promises4.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);
@@ -231,6 +697,9 @@ 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, "");
@@ -248,12 +717,33 @@ 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) {
-  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+/, "") };
+  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);
+  }
 }
 function serializeArticle(article) {
   const front = { title: article.title, tags: article.tags };
@@ -262,9 +752,21 @@ function serializeArticle(article) {
   return import_gray_matter.default.stringify(article.body, front, MATTER_OPTS);
 }
 
+// src/index.ts
+init_collections();
+
 // src/articles.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+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 {
+  }
+}
 function parseAddTarget(target) {
   const idx = target.indexOf(":");
   if (idx === -1) {
@@ -297,37 +799,38 @@ async function resolveCollectionDir(name) {
 }
 function ensureMdPath(file) {
   if (/\.mdx?$/.test(file)) return file;
-  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`);
+  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`);
   return rel;
 }
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = import_node_path2.default.join(dir, `${slugify(title)}.md`);
+  const filePath = import_node_path3.default.join(dir, `${slugify(title)}.md`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const body = opts.body ?? `# ${title}
 `;
-  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");
+  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));
   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_path2.default.join(dir, ensureMdPath(file));
+  const filePath = import_node_path3.default.join(dir, ensureMdPath(file));
   try {
-    return { filePath, raw: await import_promises4.default.readFile(filePath, "utf8"), collection };
+    return { filePath, dir, raw: await import_promises5.default.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
   }
 }
 async function updateArticleBody(target, body) {
-  const { filePath, raw, collection } = await loadArticle(target);
+  const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await import_promises4.default.writeFile(
+  await import_promises5.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -338,13 +841,14 @@ 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, raw, collection } = await loadArticle(target);
+  const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await import_promises4.default.writeFile(
+  await import_promises5.default.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -355,6 +859,7 @@ 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) {
@@ -368,45 +873,108 @@ function setTags(target, tags) {
   return mutateTags(target, () => Array.from(new Set(tags)));
 }
 async function removeArticle(target) {
-  const { filePath } = await loadArticle(target);
-  await import_promises4.default.rm(filePath);
+  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));
   return filePath;
 }
 
 // src/repo.ts
-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_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var import_node_util2 = require("util");
 var import_yaml2 = require("yaml");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
-var REPO_CONFIG_FILE = "diffwiki.yaml";
-async function detectRepoName(cwd) {
+init_collections();
+init_registry();
+
+// src/git.ts
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+async function git(cwd, args) {
   try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return import_node_path3.default.basename(stdout.trim());
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.trim();
   } catch {
-    return import_node_path3.default.basename(import_node_path3.default.resolve(cwd));
+    return void 0;
   }
 }
-async function readRepoConfig(cwd) {
-  try {
-    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_path3.default.basename(import_node_path3.default.resolve(cwd)),
-      path: parsed.path
-    };
+async function gitToplevel(cwd) {
+  return git(cwd, ["rev-parse", "--show-toplevel"]);
+}
+async function isLinkedWorktree(cwd) {
+  const gitDir = await git(cwd, ["rev-parse", "--absolute-git-dir"]);
+  const commonDir = await git(cwd, ["rev-parse", "--git-common-dir"]);
+  if (!gitDir || !commonDir) return false;
+  const commonAbs = import_node_path4.default.isAbsolute(commonDir) ? commonDir : import_node_path4.default.resolve(cwd, commonDir);
+  return import_node_path4.default.resolve(gitDir) !== import_node_path4.default.resolve(commonAbs);
+}
+async function repoRemoteName(cwd) {
+  const url = await git(cwd, ["remote", "get-url", "origin"]);
+  if (!url) return void 0;
+  const base = url.replace(/\/+$/, "").split(/[/:]/).pop() ?? "";
+  const name = base.replace(/\.git$/, "");
+  return name.length > 0 ? name : void 0;
+}
+async function repoId(cwd) {
+  const roots = await git(cwd, ["rev-list", "--max-parents=0", "HEAD"]);
+  if (roots) return `commit:${roots.split("\n")[0]}`;
+  const url = await git(cwd, ["remote", "get-url", "origin"]);
+  if (url) return `remote:${url.replace(/\.git$/, "").replace(/\/+$/, "")}`;
+  return void 0;
+}
+async function currentBranch(cwd) {
+  const name = await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  return name && name !== "HEAD" ? name : void 0;
+}
+async function upstreamStatus(cwd) {
+  const branch = await currentBranch(cwd);
+  const counts = await git(cwd, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]);
+  if (!counts) return { branch, ahead: 0, behind: 0, hasUpstream: false };
+  const [behind, ahead] = counts.split(/\s+/).map((n) => Number.parseInt(n, 10) || 0);
+  return { branch, ahead, behind, hasUpstream: true };
+}
+async function ensureGitRepo(cwd) {
+  const top = await gitToplevel(cwd);
+  if (top) return top;
+  await execFileAsync("git", ["init"], { cwd });
+  const after = await gitToplevel(cwd);
+  if (!after) throw new Error("git init did not produce a repository");
+  return after;
+}
+
+// src/repo.ts
+init_errors();
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process3.execFile);
+var REPO_CONFIG_FILE = "diffwiki.yaml";
+async function detectRepoName(cwd) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["rev-parse", "--show-toplevel"], { cwd });
+    return import_node_path5.default.basename(stdout.trim());
+  } catch {
+    return import_node_path5.default.basename(import_node_path5.default.resolve(cwd));
+  }
+}
+async function readRepoConfig(cwd) {
+  try {
+    const raw = await import_promises6.default.readFile(import_node_path5.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_path5.default.basename(import_node_path5.default.resolve(cwd)),
+      path: parsed.path
+    };
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = import_node_path3.default.resolve(opts.cwd);
+  const cwd = import_node_path5.default.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = import_node_path3.default.join(cwd, wikiPath);
+  const absWiki = import_node_path5.default.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -421,9 +989,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises5.default.mkdir(absWiki, { recursive: true });
+  await import_promises6.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises5.default.writeFile(import_node_path3.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
+  await import_promises6.default.writeFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -433,84 +1001,61 @@ async function initRepoWiki(opts) {
   await registerCollection(entry);
   return entry;
 }
-
-// src/query.ts
-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 = await findCollection(collection);
-    if (!one) throw new CollectionNotFoundError(collection);
-    targets = [one];
-  } else {
-    targets = await listCollections();
-  }
-  const needle = term.toLowerCase();
-  const hits = [];
-  for (const entry of targets) {
-    let files;
-    try {
-      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 });
-      }
-    }
+async function addExternalCollection(opts) {
+  const cwd = import_node_path5.default.resolve(opts.cwd);
+  const root = await ensureGitRepo(cwd);
+  if (await isLinkedWorktree(cwd)) throw new WorktreeNotAllowedError(root);
+  const id = await repoId(root) ?? `path:${root}`;
+  const already = await findCollectionById(id);
+  if (already) throw new CollectionAlreadyAddedError(already.name);
+  const docsRel = opts.docsDir ?? "docs";
+  const contentDir = import_node_path5.default.join(root, docsRel);
+  let name = await repoRemoteName(root) ?? import_node_path5.default.basename(root);
+  if (await findCollection(name)) {
+    let n = 2;
+    while (await findCollection(`${name}-${n}`)) n += 1;
+    name = `${name}-${n}`;
   }
-  return hits;
+  const entry = {
+    name,
+    type: "external",
+    path: contentDir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    id,
+    repoRoot: root,
+    docsDir: docsRel
+  };
+  await registerCollection(entry);
+  return entry;
 }
-
-// src/doctor.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
-async function exists(target) {
-  try {
-    await import_promises7.default.access(target);
-    return true;
-  } catch {
-    return false;
+async function resolveCwdCollection(cwd) {
+  const abs = import_node_path5.default.resolve(cwd);
+  const root = await gitToplevel(abs);
+  if (root) {
+    const id = await repoId(root) ?? `path:${root}`;
+    const byId = await findCollectionById(id);
+    if (byId) return byId;
   }
+  const within = (base) => abs === base || abs.startsWith(base + import_node_path5.default.sep);
+  const all = await listCollections();
+  return all.find((c) => within(c.path) || c.repoRoot !== void 0 && within(c.repoRoot));
 }
-async function doctor() {
-  const out = [];
-  const home = resolveHome();
-  out.push(
-    await exists(home) ? { level: "ok", message: `home directory present: ${home}` } : { level: "warn", message: `home directory missing (created on first write): ${home}` }
-  );
-  out.push(
-    await exists(registryPath()) ? { level: "ok", message: `registry present: ${registryPath()}` } : { level: "warn", message: `registry missing: ${registryPath()}` }
-  );
-  const registry = await readRegistry();
-  for (const c of registry.collections) {
-    out.push(
-      await exists(c.path) ? { level: "ok", message: `collection "${c.name}" \u2192 ${c.path}` } : { level: "error", message: `collection "${c.name}" points to missing path: ${c.path}` }
-    );
-  }
-  const config = await readConfig();
-  if (config.defaultCollection) {
-    const found = registry.collections.some((c) => c.name === config.defaultCollection);
-    out.push(
-      found ? { level: "ok", message: `default collection: ${config.defaultCollection}` } : {
-        level: "error",
-        message: `default collection "${config.defaultCollection}" is not registered`
-      }
-    );
-  } else {
-    out.push({ level: "warn", message: "no default collection set" });
-  }
-  return out;
+async function collectionGitStatus(entry) {
+  if (entry.type !== "external" || !entry.repoRoot) return void 0;
+  const top = await gitToplevel(entry.repoRoot);
+  if (!top) return void 0;
+  const s = await upstreamStatus(entry.repoRoot);
+  return { branch: s.branch, ahead: s.ahead, behind: s.behind, hasUpstream: s.hasUpstream };
 }
 
+// src/site.ts
+init_collections();
+
 // src/browse.ts
-var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+init_collections();
+init_errors();
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
 function buildArticleTree(relPaths) {
   const root = {};
@@ -554,7 +1099,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await import_promises8.default.readdir(dir, { withFileTypes: true });
+    dirents = await import_promises7.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -563,7 +1108,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_path5.default.join(dir, d.name), childRel));
+      out.push(...await collectRelPaths(import_node_path6.default.join(dir, d.name), childRel));
     } else if (/\.(mdx?)$/.test(d.name)) {
       out.push(childRel);
     }
@@ -572,7 +1117,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await import_promises8.default.readdir(dir);
+    return await import_promises7.default.readdir(dir);
   } catch {
     return [];
   }
@@ -589,7 +1134,7 @@ function pickIndexFile(names) {
 async function cheapTitle(absPath) {
   let handle;
   try {
-    handle = await import_promises8.default.open(absPath, "r");
+    handle = await import_promises7.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");
@@ -608,14 +1153,14 @@ async function enrichTitles(nodes, collDir) {
         const children = await enrichTitles(node.children, collDir);
         let title = node.title;
         if (node.slug) {
-          const dir = import_node_path5.default.join(collDir, node.slug);
+          const dir = import_node_path6.default.join(collDir, node.slug);
           const idx = pickIndexFile(await readdirSafe(dir));
-          if (idx) title = await cheapTitle(import_node_path5.default.join(dir, idx)) ?? title;
+          if (idx) title = await cheapTitle(import_node_path6.default.join(dir, idx)) ?? title;
         }
         return { ...node, title, children };
       }
       for (const ext of [".mdx", ".md"]) {
-        const title = await cheapTitle(import_node_path5.default.join(collDir, `${node.slug}${ext}`));
+        const title = await cheapTitle(import_node_path6.default.join(collDir, `${node.slug}${ext}`));
         if (title) return { ...node, title };
       }
       return node;
@@ -626,38 +1171,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_path5.default.resolve(entry.path));
+  return enrichTitles(buildArticleTree(rels), import_node_path6.default.resolve(entry.path));
 }
 async function readArticle(coll, slug) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
-  const collDir = import_node_path5.default.resolve(entry.path);
+  const collDir = import_node_path6.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_path5.default.sep);
+  const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path6.default.sep);
   let abs;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
-    const candidate = import_node_path5.default.resolve(collDir, rel);
+    const candidate = import_node_path6.default.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await import_promises8.default.access(candidate);
+      await import_promises7.default.access(candidate);
       abs = candidate;
       break;
     } catch {
     }
   }
   if (!abs) {
-    const dir = import_node_path5.default.resolve(collDir, safeSlug);
+    const dir = import_node_path6.default.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
-      if (idx) abs = import_node_path5.default.join(dir, idx);
+      if (idx) abs = import_node_path6.default.join(dir, idx);
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await import_promises8.default.readFile(abs, "utf8"));
+  const parsed = parseArticle(await import_promises7.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 };
 }
@@ -725,49 +1270,771 @@ async function renderArticle(body) {
   }).use(import_rehype_stringify.default).process(body);
   return { html: String(file), toc };
 }
+
+// src/site.ts
+init_errors();
+var isStatic = () => process.env.DIFFWIKI_STATIC === "1";
+function toTreeNodes(coll, nodes) {
+  return nodes.map(
+    (n) => n.children ? {
+      name: n.name,
+      title: n.title ?? n.name,
+      path: n.slug ? `/${coll}/${n.slug}` : void 0,
+      children: toTreeNodes(coll, n.children)
+    } : { name: n.name, title: n.title ?? n.name, path: `/${coll}/${n.slug}` }
+  );
+}
+async function gitInfo(e) {
+  if (isStatic()) {
+    if (e.type === "external") console.warn(`[diffwiki] static build: omitting branch info for "${e.name}"`);
+    return {};
+  }
+  const s = await collectionGitStatus(e);
+  return s ? { branch: s.branch, behind: s.hasUpstream ? s.behind : void 0 } : {};
+}
+async function buildCollections() {
+  const entries = await listCollections();
+  return Promise.all(
+    entries.map(async (e) => ({
+      name: e.name,
+      type: e.type,
+      path: e.path,
+      ...await gitInfo(e)
+    }))
+  );
+}
+async function buildNavTree() {
+  const entries = await listCollections();
+  return Promise.all(
+    entries.map(async (e) => ({
+      collection: { name: e.name, type: e.type, path: e.path, ...await gitInfo(e) },
+      nodes: toTreeNodes(e.name, await listArticleTree(e.name))
+    }))
+  );
+}
+function findNode(nodes, slug) {
+  for (const n of nodes) {
+    if (n.slug === slug) return n;
+    if (n.children) {
+      const found = findNode(n.children, slug);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+async function resolvePage(coll, slug) {
+  try {
+    const art = await readArticle(coll, slug);
+    const { html, toc } = await renderArticle(art.body);
+    return {
+      kind: "doc",
+      coll: art.coll,
+      slug: art.slug,
+      title: art.title,
+      tags: art.tags,
+      html,
+      toc,
+      path: `/${art.coll}/${art.slug}`
+    };
+  } catch (err) {
+    if (err instanceof CollectionNotFoundError) return null;
+    if (!(err instanceof ArticleNotFoundError)) throw err;
+    let nodes;
+    try {
+      nodes = await listArticleTree(coll);
+    } catch (e) {
+      if (e instanceof CollectionNotFoundError) return null;
+      throw e;
+    }
+    const folder = slug ? findNode(nodes, slug) : { title: void 0, children: nodes };
+    if (!folder?.children) return null;
+    const entries = folder.children.map((n) => ({
+      name: n.name,
+      title: n.title ?? n.name,
+      path: `/${coll}/${n.slug ?? n.name}`,
+      isDir: Array.isArray(n.children)
+    }));
+    return {
+      kind: "listing",
+      coll,
+      slug,
+      title: folder.title ?? (slug ? slug.split("/").pop() ?? slug : coll),
+      entries
+    };
+  }
+}
+
+// src/query.ts
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+init_collections();
+init_errors();
+init_logger();
+init_host();
+init_registry2();
+init_types();
+
+// src/bm25.ts
+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;
+}
+function rankDocs(term, docs) {
+  const queryTerms = tokenize(term);
+  if (queryTerms.length === 0) return docs.map((d) => ({ ...d }));
+  const N = docs.length;
+  const docTokenSets = docs.map(
+    (d) => /* @__PURE__ */ new Set([...d.fields.title, ...d.fields.tags, ...d.fields.collection, ...d.fields.body])
+  );
+  const idf = /* @__PURE__ */ new Map();
+  for (const qt of queryTerms) {
+    let docFreq = 0;
+    for (const set of docTokenSets) if (set.has(qt)) docFreq++;
+    idf.set(qt, Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1));
+  }
+  const avg = (sel) => docs.reduce((s, d) => s + sel(d), 0) / (N || 1);
+  const avgLens = {
+    title: avg((d) => d.fields.title.length),
+    tags: avg((d) => d.fields.tags.length),
+    collection: avg((d) => d.fields.collection.length),
+    body: avg((d) => d.fields.body.length)
+  };
+  const scored = [];
+  for (const d of docs) {
+    const total = bm25FieldScore(queryTerms, d.fields.title, avgLens.title, idf) * FIELD_WEIGHTS.title + bm25FieldScore(queryTerms, d.fields.tags, avgLens.tags, idf) * FIELD_WEIGHTS.tags + bm25FieldScore(queryTerms, d.fields.collection, avgLens.collection, idf) * FIELD_WEIGHTS.collection + bm25FieldScore(queryTerms, d.fields.body, avgLens.body, idf) * FIELD_WEIGHTS.body;
+    if (total > 0) scored.push({ ...d, score: total });
+  }
+  scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  return scored;
+}
+
+// src/query.ts
+var log = getLogger("query");
+async function collectMarkdownFiles(dir) {
+  let entries;
+  try {
+    entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const full = import_node_path7.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;
+}
+async function nativeSearch(term, collections, collection) {
+  let targets = collections;
+  if (collection) {
+    const one = collections.find((c) => c.name === collection);
+    if (!one) throw new CollectionNotFoundError(collection);
+    targets = [one];
+  }
+  const docs = [];
+  for (const entry of targets) {
+    for (const full of await collectMarkdownFiles(entry.path)) {
+      const fallbackTitle = import_node_path7.default.basename(full).replace(/\.mdx?$/, "");
+      let title = fallbackTitle;
+      let tags = [];
+      let body = "";
+      try {
+        const parsed = parseArticle(await import_promises8.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)
+        }
+      });
+    }
+  }
+  return rankDocs(term, docs).map((d) => ({
+    collection: d.collectionName,
+    path: d.filePath,
+    title: d.title,
+    tags: d.tags,
+    ...d.score === void 0 ? {} : { score: d.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/search.ts
+var import_promises9 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+init_collections();
+async function readArticleParts(collDir, slug) {
+  for (const ext of [".mdx", ".md"]) {
+    try {
+      const parsed = parseArticle(await import_promises9.default.readFile(import_node_path8.default.join(collDir, `${slug}${ext}`), "utf8"));
+      return { tags: parsed.tags, body: parsed.body };
+    } catch {
+    }
+  }
+  return { tags: [], body: "" };
+}
+async function flatten(coll, collDir, nodes, out) {
+  for (const n of nodes) {
+    if (n.slug && !n.children) {
+      const title = n.title ?? n.name;
+      const { tags, body } = await readArticleParts(collDir, n.slug);
+      out.push({
+        collection: coll,
+        slug: n.slug,
+        title,
+        tags,
+        fields: {
+          title: tokenize(title),
+          tags: tokenize(tags.join(" ")),
+          collection: tokenize(coll),
+          body: tokenize(body)
+        }
+      });
+    }
+    if (n.children) await flatten(coll, collDir, n.children, out);
+  }
+}
+async function buildSearchIndex(collection) {
+  const entries = collection ? (await listCollections()).filter((c) => c.name === collection) : await listCollections();
+  const out = [];
+  for (const e of entries) {
+    try {
+      const collEntry = await findCollection(e.name);
+      const collDir = import_node_path8.default.resolve(collEntry?.path ?? e.path);
+      await flatten(e.name, collDir, await listArticleTree(e.name), out);
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/doctor.ts
+var import_promises11 = __toESM(require("fs/promises"), 1);
+init_paths();
+init_registry();
+init_collections();
+
+// src/plugins/manager.ts
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+init_paths();
+init_errors();
+init_collections();
+init_registry2();
+init_host();
+
+// src/plugins/sdk.ts
+var import_node_child_process4 = require("child_process");
+var import_node_util3 = require("util");
+var import_node_fs = require("fs");
+var import_node_path9 = require("path");
+var import_node_url = require("url");
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+async function runProcess(file, args, opts) {
+  const { stdout, stderr } = await execFileAsync3(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_promises10.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_promises10.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_promises10.default.readdir(import_node_path10.default.join(nodeModules, entry));
+      } catch {
+        continue;
+      }
+      for (const pkg of scoped) {
+        if (pkg.startsWith(".")) continue;
+        dirs.push(import_node_path10.default.join(nodeModules, entry, pkg));
+      }
+    } else {
+      dirs.push(import_node_path10.default.join(nodeModules, entry));
+    }
+  }
+  return dirs;
+}
+async function ensurePluginRoot() {
+  const dir = pluginsDir();
+  await import_promises10.default.mkdir(dir, { recursive: true });
+  const pkgPath = import_node_path10.default.join(dir, "package.json");
+  if (await readPackageJson(pkgPath) === null) {
+    const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
+    await import_promises10.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  }
+  return dir;
+}
+async function discoverSearchPackage(dir) {
+  const nodeModules = import_node_path10.default.join(dir, "node_modules");
+  for (const pkgDir of await pluginManifestDirs(nodeModules)) {
+    const manifest = await readPackageJson(import_node_path10.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_path10.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();
+    try {
+      await runProcess("npm", ["uninstall", name, "--prefix", dir]);
+    } catch {
+    }
+  }
+  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;
+}
+
+// src/doctor.ts
+init_host();
+init_types();
+async function exists(target) {
+  try {
+    await import_promises11.default.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function doctor() {
+  const out = [];
+  const home = resolveHome();
+  out.push(
+    await exists(home) ? { level: "ok", message: `home directory present: ${home}` } : { level: "warn", message: `home directory missing (created on first write): ${home}` }
+  );
+  out.push(
+    await exists(registryPath()) ? { level: "ok", message: `registry present: ${registryPath()}` } : { level: "warn", message: `registry missing: ${registryPath()}` }
+  );
+  const registry = await readRegistry();
+  for (const c of registry.collections) {
+    out.push(
+      await exists(c.path) ? { level: "ok", message: `collection "${c.name}" \u2192 ${c.path}` } : { level: "error", message: `collection "${c.name}" points to missing path: ${c.path}` }
+    );
+  }
+  const config = await readConfig();
+  if (config.defaultCollection) {
+    const found = registry.collections.some((c) => c.name === config.defaultCollection);
+    out.push(
+      found ? { level: "ok", message: `default collection: ${config.defaultCollection}` } : {
+        level: "error",
+        message: `default collection "${config.defaultCollection}" is not registered`
+      }
+    );
+  } 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/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,
+  CollectionAlreadyAddedError,
   CollectionExistsError,
   CollectionNotFoundError,
   DiffwikiError,
   InvalidTargetError,
+  NATIVE_ENGINE,
   NoDefaultCollectionError,
+  PluginError,
   REPO_CONFIG_FILE,
+  WorktreeNotAllowedError,
+  addExternalCollection,
   addTags,
   buildArticleTree,
+  buildCollections,
+  buildNavTree,
+  buildSearchIndex,
   collectionDir,
+  collectionGitStatus,
   collectionsDir,
   configPath,
   createArticle,
   createCollection,
+  currentBranch,
+  deregisterPlugin,
   doctor,
+  emitPluginEvent,
+  ensureGitRepo,
+  ensurePluginRoot,
   findCollection,
+  findCollectionById,
+  findEnabledPlugin,
+  findPluginRecord,
   getConfigValue,
+  getLogger,
+  gitToplevel,
   initRepoWiki,
+  installPlugin,
+  isLinkedWorktree,
   listArticleTree,
+  listAvailablePlugins,
   listCollections,
+  listEnabledPlugins,
+  listPlugins,
+  listSearchModes,
+  loadSearchProvider,
+  nativeSearch,
   parseAddTarget,
   parseArticle,
   parsePathTarget,
+  pluginsDir,
+  pluginsRegistryPath,
   query,
+  rankDocs,
   readArticle,
   readConfig,
+  readPluginRegistry,
   readRegistry,
   readRepoConfig,
   registerCollection,
+  registerPlugin,
   registryPath,
   removeArticle,
   removeCollection,
+  removePlugin,
   removeTags,
   renderArticle,
+  repoId,
+  repoRemoteName,
+  resolveCwdCollection,
+  resolveDefaultSearchMode,
   resolveHome,
+  resolveLogLevel,
+  resolvePage,
+  search,
   serializeArticle,
   setConfigValue,
   setTags,
   slugify,
+  toTreeNodes,
+  tokenize,
   unregisterCollection,
   updateArticleBody,
+  upsertPlugin,
+  upstreamStatus,
   writeConfig,
+  writePluginRegistry,
   writeRegistry
 });