diffwiki-core 0.3.0 → 0.4.0-rc.202607220518.0ade9d3

package/dist/chunk-I3PPUXYY.js

@@ -0,0 +1,474 @@
+// src/types.ts
+var NATIVE_ENGINE = "native";
+
+// src/plugins/registry.ts
+import fs from "fs/promises";
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+function resolveHome() {
+  const override = process.env.DIFFWIKI_HOME;
+  return override && override.length > 0 ? override : path.join(os.homedir(), ".diffwiki");
+}
+function registryPath() {
+  return path.join(resolveHome(), "registry.json");
+}
+function configPath() {
+  return path.join(resolveHome(), "config.json");
+}
+function collectionsDir() {
+  return path.join(resolveHome(), "collections");
+}
+function collectionDir(name) {
+  return path.join(collectionsDir(), name);
+}
+function pluginsDir() {
+  return path.join(resolveHome(), "plugins");
+}
+function pluginsRegistryPath() {
+  return path.join(resolveHome(), "plugins.json");
+}
+
+// src/plugins/registry.ts
+function isMissing(err) {
+  return err?.code === "ENOENT";
+}
+async function readPluginRegistry() {
+  try {
+    const parsed = JSON.parse(await fs.readFile(pluginsRegistryPath(), "utf8"));
+    return { version: parsed.version ?? 1, plugins: parsed.plugins ?? [] };
+  } catch (err) {
+    if (isMissing(err)) return { version: 1, plugins: [] };
+    throw err;
+  }
+}
+async function writePluginRegistry(registry) {
+  await fs.mkdir(resolveHome(), { recursive: true });
+  await fs.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];
+}
+
+// src/plugins/client.ts
+import { spawn } from "child_process";
+import path2 from "path";
+var REQUEST_TIMEOUT_MS = 3e4;
+var SHUTDOWN_GRACE_MS = 500;
+function toWireCollections(collections) {
+  return collections.map((c) => ({ name: c.name, path: c.path }));
+}
+async function spawnPluginClient(record) {
+  const child = spawn(record.command[0], record.command.slice(1), {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let buffer = "";
+  let closed = false;
+  const failAll = (err) => {
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    pending.clear();
+  };
+  const handleLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (typeof msg !== "object" || msg === null) return;
+    const payload = msg;
+    if ("log" in payload && !("id" in payload)) return;
+    const id = payload.id;
+    if (typeof id !== "number") return;
+    const p = pending.get(id);
+    if (!p) return;
+    pending.delete(id);
+    clearTimeout(p.timer);
+    if (payload.ok === true) {
+      p.resolve(payload.result);
+    } else {
+      const error = payload.error;
+      const message = typeof error?.message === "string" ? error.message : "plugin request failed";
+      p.reject(new Error(message));
+    }
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      handleLine(line);
+      newlineIndex = buffer.indexOf("\n");
+    }
+  });
+  child.on("error", (err) => {
+    closed = true;
+    failAll(err);
+  });
+  child.on("exit", () => {
+    closed = true;
+    failAll(new Error("plugin process exited"));
+  });
+  const request = (op, params) => {
+    if (closed) return Promise.reject(new Error("plugin process is not running"));
+    return new Promise((resolve, reject) => {
+      const id = nextId++;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`plugin request "${op}" timed out`));
+      }, REQUEST_TIMEOUT_MS);
+      pending.set(id, {
+        resolve: (result) => resolve(result),
+        reject,
+        timer
+      });
+      child.stdin.write(`${JSON.stringify({ id, op, params })}
+`, (err) => {
+        if (!err) return;
+        const p = pending.get(id);
+        if (!p) return;
+        pending.delete(id);
+        clearTimeout(p.timer);
+        p.reject(err);
+      });
+    });
+  };
+  let handshake;
+  try {
+    handshake = await request("initialize", { protocol: 1, home: resolveHome() });
+    if (handshake.kind !== "search") {
+      throw new Error(`plugin "${record.name}" reported kind "${handshake.kind}", expected "search"`);
+    }
+  } catch (err) {
+    closed = true;
+    child.kill("SIGKILL");
+    throw err;
+  }
+  const capabilities = handshake.capabilities;
+  const name = handshake.name;
+  const 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 ? path2.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;
+  };
+  const close = async () => {
+    if (!closed) {
+      try {
+        await request("shutdown", {});
+      } catch {
+      }
+    }
+    closed = true;
+    try {
+      child.stdin.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve();
+      }, SHUTDOWN_GRACE_MS);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  };
+  const provider = {
+    name,
+    capabilities,
+    async setup(collections, opts) {
+      const result = await request("setup", {
+        collections: toWireCollections(collections),
+        embed: opts?.embed,
+        prefetchModels: opts?.prefetchModels
+      });
+      return { ready: result?.ready === true };
+    },
+    async reindex(collections, opts) {
+      const result = await request("index", {
+        collections: toWireCollections(collections),
+        embed: opts?.embed
+      });
+      return result?.indexed ?? 0;
+    },
+    async search(term, collections, opts) {
+      const result = await request("search", {
+        term,
+        collections: toWireCollections(collections),
+        collection: opts?.collection,
+        type: opts?.type,
+        limit: opts?.limit
+      });
+      return mapHits(result, collections);
+    },
+    async notify(event, collection, relPath, collections) {
+      try {
+        const entry = collections.find((c) => c.name === collection);
+        await request("notify", {
+          event,
+          collection: entry ? { name: entry.name, path: entry.path } : { name: collection, path: "" },
+          relPath,
+          collections: toWireCollections(collections)
+        });
+      } catch {
+      }
+    },
+    async health(collections) {
+      const result = await request("health", { collections: toWireCollections(collections) });
+      return {
+        ready: result?.ready === true,
+        readiness: result?.readiness,
+        diagnostics: result?.diagnostics ?? []
+      };
+    },
+    close
+  };
+  return provider;
+}
+
+// src/plugins/loader.ts
+async function loadSearchProvider(name) {
+  const record = await findEnabledPlugin("search", name);
+  if (!record) return null;
+  try {
+    return await spawnPluginClient(record);
+  } catch {
+    return null;
+  }
+}
+async function listSearchModes() {
+  const modes = [{ plugin: NATIVE_ENGINE, type: "basic", label: "native \xB7 bm25" }];
+  const plugins = await listEnabledPlugins("search");
+  for (const record of plugins) {
+    let provider = null;
+    try {
+      provider = await spawnPluginClient(record);
+      for (const type of provider.capabilities.searchTypes) {
+        modes.push({ plugin: record.name, type, label: `${record.name} \xB7 ${type}` });
+      }
+    } catch {
+    } finally {
+      if (provider) {
+        try {
+          await provider.close();
+        } catch {
+        }
+      }
+    }
+  }
+  return modes;
+}
+
+// src/collections.ts
+import fs3 from "fs/promises";
+
+// src/registry.ts
+import fs2 from "fs/promises";
+function isMissing2(err) {
+  return err?.code === "ENOENT";
+}
+async function readRegistry() {
+  try {
+    const parsed = JSON.parse(await fs2.readFile(registryPath(), "utf8"));
+    return { version: parsed.version ?? 1, collections: parsed.collections ?? [] };
+  } catch (err) {
+    if (isMissing2(err)) return { version: 1, collections: [] };
+    throw err;
+  }
+}
+async function writeRegistry(registry) {
+  await fs2.mkdir(resolveHome(), { recursive: true });
+  await fs2.writeFile(registryPath(), `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function registerCollection(entry) {
+  const registry = await readRegistry();
+  const index = registry.collections.findIndex((c) => c.name === entry.name);
+  if (index >= 0) {
+    registry.collections[index] = entry;
+  } else {
+    registry.collections.push(entry);
+  }
+  await writeRegistry(registry);
+}
+async function unregisterCollection(name) {
+  const registry = await readRegistry();
+  registry.collections = registry.collections.filter((c) => c.name !== name);
+  await writeRegistry(registry);
+}
+
+// src/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 PluginError = class extends DiffwikiError {
+};
+
+// src/collections.ts
+async function fireHook(event, collection) {
+  try {
+    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-656CR64Q.js");
+    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 createCollection(name) {
+  if (await findCollection(name)) throw new CollectionExistsError(name);
+  const dir = collectionDir(name);
+  await fs3.mkdir(dir, { recursive: true });
+  const entry = {
+    name,
+    type: "global",
+    path: dir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await registerCollection(entry);
+  void fireHook("collection-added", name);
+  return entry;
+}
+async function removeCollection(name) {
+  const entry = await findCollection(name);
+  if (!entry) throw new CollectionNotFoundError(name);
+  await unregisterCollection(name);
+  if (entry.type === "global") {
+    await fs3.rm(entry.path, { recursive: true, force: true });
+  }
+  void fireHook("collection-removed", name);
+  return entry;
+}
+
+// src/plugins/events.ts
+async function emitPluginEvent(event, collection, relPath) {
+  try {
+    const provider = await loadSearchProvider();
+    try {
+      if (provider?.capabilities.hooks) {
+        await provider.notify(event, collection, relPath, await listCollections());
+      }
+    } finally {
+      await provider?.close();
+    }
+  } catch {
+  }
+}
+
+export {
+  NATIVE_ENGINE,
+  DiffwikiError,
+  CollectionExistsError,
+  CollectionNotFoundError,
+  NoDefaultCollectionError,
+  ArticleNotFoundError,
+  InvalidTargetError,
+  PluginError,
+  resolveHome,
+  registryPath,
+  configPath,
+  collectionsDir,
+  collectionDir,
+  pluginsDir,
+  pluginsRegistryPath,
+  readRegistry,
+  writeRegistry,
+  registerCollection,
+  unregisterCollection,
+  readPluginRegistry,
+  writePluginRegistry,
+  upsertPlugin,
+  deregisterPlugin,
+  listEnabledPlugins,
+  findEnabledPlugin,
+  spawnPluginClient,
+  loadSearchProvider,
+  listSearchModes,
+  emitPluginEvent,
+  listCollections,
+  findCollection,
+  createCollection,
+  removeCollection
+};

package/dist/events-656CR64Q.js

@@ -0,0 +1,6 @@
+import {
+  emitPluginEvent
+} from "./chunk-I3PPUXYY.js";
+export {
+  emitPluginEvent
+};