wiki-graph-sdk 0.7.0

package/dist/embedding.cjs

@@ -0,0 +1,1091 @@
+globalThis.__WIKIGRAPH_DATA_DIR__ ??= require("path").resolve(__dirname, "data");
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/embedding.ts
+var embedding_exports = {};
+__export(embedding_exports, {
+  buildSearchIndexEmbeddingProvider: () => buildSearchIndexEmbeddingProvider,
+  embedQueryText: () => embedQueryText,
+  embedQueryTextWithLocalConfig: () => embedQueryTextWithLocalConfig,
+  readWikiGraphEmbeddingConfig: () => readWikiGraphEmbeddingConfig
+});
+module.exports = __toCommonJS(embedding_exports);
+var import_ai = require("ai");
+var import_openai = require("@ai-sdk/openai");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+
+// src/local-config.ts
+var import_wiki_graph_core = require("wiki-graph-core");
+
+// src/runtime-context.ts
+var import_async_hooks = require("async_hooks");
+var RUNTIME_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("wiki-graph-sdk.runtime-context.v1");
+var runtimeContext = getRuntimeContextStorage();
+function getRuntimeContextStorage() {
+  const runtimeGlobal = globalThis;
+  const existing = runtimeGlobal[RUNTIME_CONTEXT_KEY];
+  if (existing !== void 0) {
+    return existing;
+  }
+  const storage = new import_async_hooks.AsyncLocalStorage();
+  Object.defineProperty(runtimeGlobal, RUNTIME_CONTEXT_KEY, {
+    configurable: false,
+    enumerable: false,
+    value: storage,
+    writable: false
+  });
+  return storage;
+}
+function getWikiGraphSDKRuntimeContext() {
+  return runtimeContext.getStore() ?? {
+    cwd: process.cwd(),
+    env: process.env,
+    envPolicy: "production"
+  };
+}
+function getWikiGraphSDKStateDir() {
+  return getWikiGraphSDKRuntimeContext().stateDir;
+}
+
+// src/node-platform.ts
+var asyncHooks = __toESM(require("async_hooks"), 1);
+var crypto = __toESM(require("crypto"), 1);
+var fs = __toESM(require("fs"), 1);
+var fsPromises = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var pathModule = __toESM(require("path"), 1);
+var process2 = __toESM(require("process"), 1);
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+var sqlite3 = __toESM(require("sqlite3"), 1);
+var yauzl = __toESM(require("yauzl"), 1);
+var yazl = __toESM(require("yazl"), 1);
+var import_nunjucks = require("nunjucks");
+var import_platform = require("wiki-graph-core/platform");
+var nodeProcess = process2.default ?? process2;
+var nodeSqlite3 = sqlite3.default ?? sqlite3;
+var NODE_RESOURCE_KIND = /* @__PURE__ */ Symbol.for("wiki-graph-sdk.node-resource.v1");
+var NodeFile = class {
+  constructor(path, name = pathModule.basename(path)) {
+    this.path = path;
+    this.identity = encodeNodeResourceIdentity("file", path);
+    this.name = name;
+  }
+  path;
+  kind = "file";
+  [NODE_RESOURCE_KIND] = "file";
+  identity;
+  name;
+  async openReader() {
+    const handle = await fsPromises.open(this.path, "r");
+    let closed = false;
+    try {
+      const stats = await handle.stat();
+      if (!stats.isFile())
+        throw new Error("File reader requires a regular file");
+      const { size } = stats;
+      return {
+        size,
+        close: async () => {
+          if (!closed) await handle.close();
+          closed = true;
+        },
+        read: async (offset, length) => {
+          if (closed) throw new Error("Cannot read from a closed FileReader");
+          assertFileRange(offset, length, size);
+          const buffer = Buffer.allocUnsafe(length);
+          let bytesRead = 0;
+          while (bytesRead < length) {
+            const result = await handle.read(
+              buffer,
+              bytesRead,
+              length - bytesRead,
+              offset + bytesRead
+            );
+            if (result.bytesRead === 0) {
+              throw new Error("File changed while reading its byte range");
+            }
+            bytesRead += result.bytesRead;
+          }
+          return new Uint8Array(buffer.buffer, buffer.byteOffset, bytesRead);
+        }
+      };
+    } catch (error) {
+      await handle.close();
+      throw error;
+    }
+  }
+  async getLastModified() {
+    try {
+      return (await fsPromises.stat(this.path)).mtimeMs;
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async openWriter() {
+    await fsPromises.mkdir(pathModule.dirname(this.path), { recursive: true });
+    const temporary = `${this.path}.tmp-${crypto.randomUUID()}`;
+    const handle = await fsPromises.open(temporary, "wx");
+    let closed = false;
+    return {
+      write: async (data) => {
+        if (closed) throw new Error("Cannot write to a closed FileWriter");
+        await writeNodeFileHandle(handle, data);
+      },
+      writeAt: async (offset, data) => {
+        if (closed) throw new Error("Cannot write to a closed FileWriter");
+        assertFileOffset(offset);
+        await writeNodeFileHandle(handle, data, offset);
+      },
+      commit: async () => {
+        if (!closed) {
+          await handle.close();
+          await fsPromises.rename(temporary, this.path);
+        }
+        closed = true;
+      },
+      abort: async () => {
+        if (!closed) {
+          await handle.close();
+          await fsPromises.rm(temporary, { force: true });
+        }
+        closed = true;
+      }
+    };
+  }
+};
+async function writeNodeFileHandle(handle, data, position) {
+  const buffer = Buffer.from(data);
+  let written = 0;
+  while (written < buffer.byteLength) {
+    const result = await handle.write(
+      buffer,
+      written,
+      buffer.byteLength - written,
+      position === void 0 ? null : position + written
+    );
+    if (result.bytesWritten === 0) {
+      throw new Error("File writer made no progress");
+    }
+    written += result.bytesWritten;
+  }
+}
+function assertFileRange(offset, length, size) {
+  assertFileOffset(offset);
+  if (!Number.isSafeInteger(length) || length < 0) {
+    throw new RangeError(
+      "File read length must be a non-negative safe integer"
+    );
+  }
+  if (offset > size || length > size - offset) {
+    throw new RangeError("File read range exceeds the file size");
+  }
+}
+function assertFileOffset(offset) {
+  if (!Number.isSafeInteger(offset) || offset < 0) {
+    throw new RangeError("File offset must be a non-negative safe integer");
+  }
+}
+var NodeDirectory = class _NodeDirectory {
+  constructor(path) {
+    this.path = path;
+    this.identity = encodeNodeResourceIdentity("directory", path);
+    this.name = pathModule.basename(path);
+  }
+  path;
+  kind = "directory";
+  [NODE_RESOURCE_KIND] = "directory";
+  identity;
+  name;
+  async getFile(name) {
+    assertChildName(name);
+    const file = new NodeFile(pathModule.join(this.path, name));
+    try {
+      return (await fsPromises.stat(file.path)).isFile() ? file : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async getLastModified() {
+    try {
+      return (await fsPromises.stat(this.path)).mtimeMs;
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getDirectory(name) {
+    assertChildName(name);
+    const directory = new _NodeDirectory(pathModule.join(this.path, name));
+    try {
+      return (await fsPromises.stat(directory.path)).isDirectory() ? directory : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async list() {
+    const entries = await fsPromises.readdir(this.path, {
+      withFileTypes: true
+    });
+    return entries.map(
+      (entry) => entry.isDirectory() ? new _NodeDirectory(pathModule.join(this.path, entry.name)) : new NodeFile(pathModule.join(this.path, entry.name), entry.name)
+    );
+  }
+  async createFile(name) {
+    assertChildName(name);
+    await fsPromises.mkdir(this.path, { recursive: true });
+    const file = new NodeFile(pathModule.join(this.path, name));
+    await fsPromises.writeFile(file.path, "", { flag: "wx" });
+    return file;
+  }
+  async createDirectory(name) {
+    assertChildName(name);
+    await fsPromises.mkdir(this.path, { recursive: true });
+    const directory = new _NodeDirectory(pathModule.join(this.path, name));
+    await fsPromises.mkdir(directory.path);
+    return directory;
+  }
+  async remove(name, options) {
+    assertChildName(name);
+    await fsPromises.rm(pathModule.join(this.path, name), {
+      force: true,
+      recursive: options?.recursive === true
+    });
+  }
+};
+function encodeNodeResourceIdentity(kind, path) {
+  return `node-${kind}:${Buffer.from(pathModule.resolve(path), "utf8").toString("base64url")}`;
+}
+function decodeNodeResourceIdentity(identity, kind) {
+  const prefix = `node-${kind}:`;
+  if (!identity.startsWith(prefix)) {
+    return pathModule.isAbsolute(identity) ? identity : void 0;
+  }
+  try {
+    return Buffer.from(identity.slice(prefix.length), "base64url").toString(
+      "utf8"
+    );
+  } catch {
+    return void 0;
+  }
+}
+function assertChildName(name) {
+  if (name.length === 0 || name === "." || name === ".." || pathModule.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    throw new TypeError(`Directory child must be a relative name: ${name}`);
+  }
+}
+var NodeDatabaseConnection = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  async close() {
+    await new Promise((resolve2, reject) => {
+      this.database.close((error) => {
+        if (error) reject(error);
+        else resolve2();
+      });
+    });
+  }
+  async execute(sql) {
+    await new Promise((resolve2, reject) => {
+      this.database.exec(sql, (error) => {
+        if (error) reject(error);
+        else resolve2();
+      });
+    });
+  }
+  async queryAll(sql, params = []) {
+    return await new Promise((resolve2, reject) => {
+      this.database.all(sql, [...params], (error, rows) => {
+        if (error) reject(error);
+        else resolve2(rows);
+      });
+    });
+  }
+  async queryOne(sql, params = []) {
+    return await new Promise((resolve2, reject) => {
+      this.database.get(sql, [...params], (error, row) => {
+        if (error) reject(error);
+        else resolve2(row);
+      });
+    });
+  }
+  async run(sql, params = []) {
+    await new Promise((resolve2, reject) => {
+      this.database.run(sql, [...params], (error) => {
+        if (error) reject(error);
+        else resolve2();
+      });
+    });
+  }
+};
+async function openNodeDatabase(file, options) {
+  const flags = (options.mode === "readonly" ? nodeSqlite3.OPEN_READONLY : nodeSqlite3.OPEN_READWRITE | (options.create ? nodeSqlite3.OPEN_CREATE : 0)) | nodeSqlite3.OPEN_FULLMUTEX;
+  return new NodeDatabaseConnection(await openNativeNodeDatabase(file, flags));
+}
+async function openNativeNodeDatabase(file, flags) {
+  const path = getBrandedNodeResourcePath(file, "file");
+  if (path === void 0) {
+    throw new TypeError("The Node database adapter requires a NodeFile");
+  }
+  return await new Promise((resolve2, reject) => {
+    const database = new nodeSqlite3.Database(path, flags, (error) => {
+      if (error) reject(error);
+      else resolve2(database);
+    });
+  });
+}
+async function openNodeZip(file) {
+  const path = getBrandedNodeResourcePath(file, "file");
+  if (path === void 0) {
+    throw new TypeError("The Node ZIP adapter requires a NodeFile");
+  }
+  const zipFile = await new Promise((resolve2, reject) => {
+    yauzl.open(
+      path,
+      { autoClose: false, lazyEntries: true },
+      (error, opened) => {
+        if (error || opened === void 0)
+          reject(error ?? new Error("Cannot open ZIP"));
+        else resolve2(opened);
+      }
+    );
+  });
+  const entries = await new Promise(
+    (resolve2, reject) => {
+      const discovered = /* @__PURE__ */ new Map();
+      const rejectAndClose = (error) => {
+        zipFile.close();
+        reject(
+          error instanceof Error ? error : new Error("Cannot scan ZIP central directory")
+        );
+      };
+      const resolveEntries = () => {
+        zipFile.off("error", rejectAndClose);
+        resolve2(discovered);
+      };
+      zipFile.on("entry", (entry) => {
+        if (!entry.fileName.endsWith("/")) {
+          discovered.set(entry.fileName, entry);
+        }
+        zipFile.readEntry();
+      });
+      zipFile.once("error", rejectAndClose);
+      zipFile.once("end", resolveEntries);
+      zipFile.readEntry();
+    }
+  );
+  let closed = false;
+  return {
+    close: () => {
+      if (!closed) zipFile.close();
+      closed = true;
+      return Promise.resolve();
+    },
+    copyEntry: async (name, target) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return false;
+      await copyNodeZipEntry(zipFile, entry, target);
+      return true;
+    },
+    getEntrySize: (name) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      return Promise.resolve(entries.get(name)?.uncompressedSize);
+    },
+    listEntries: () => Promise.resolve([...entries.keys()]),
+    readEntryRange: async (name, offset, length) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return void 0;
+      return await readNodeZipEntryRange(zipFile, entry, offset, length);
+    },
+    readEntry: async (name) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return void 0;
+      return await readNodeZipEntry(zipFile, entry);
+    }
+  };
+}
+async function copyNodeZipEntry(zipFile, entry, target) {
+  const writer = await target.openWriter();
+  try {
+    const stream = await openNodeZipEntryStream(zipFile, entry);
+    await writeNodeStream(stream, writer);
+    await writer.commit();
+  } catch (error) {
+    await writer.abort().catch(() => void 0);
+    throw error;
+  }
+}
+async function readNodeZipEntry(zipFile, entry) {
+  return await collectNodeStream(await openNodeZipEntryStream(zipFile, entry));
+}
+async function readNodeZipEntryRange(zipFile, entry, offset, length) {
+  assertFileRange(offset, length, entry.uncompressedSize);
+  if (length === 0) return new Uint8Array();
+  if (entry.compressionMethod !== 0) {
+    const content2 = await collectDecodedNodeStreamRange(
+      await openNodeZipEntryStream(zipFile, entry),
+      offset,
+      length
+    );
+    return new Uint8Array(
+      content2.buffer,
+      content2.byteOffset,
+      content2.byteLength
+    );
+  }
+  const content = await collectNodeStream(
+    await openNodeZipEntryStream(zipFile, entry, {
+      decompress: null,
+      decrypt: null,
+      end: offset + length,
+      start: offset
+    })
+  );
+  return new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+}
+async function collectDecodedNodeStreamRange(input, offset, length) {
+  const chunks = [];
+  const end = offset + length;
+  let position = 0;
+  let collected = 0;
+  for await (const value of input) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    const chunkEnd = position + chunk.byteLength;
+    if (chunkEnd > offset && position < end) {
+      const selected = chunk.subarray(
+        Math.max(0, offset - position),
+        Math.min(chunk.byteLength, end - position)
+      );
+      chunks.push(selected);
+      collected += selected.byteLength;
+    }
+    position = chunkEnd;
+    if (position >= end) break;
+  }
+  if (collected !== length) {
+    throw new Error("ZIP entry changed while reading its byte range");
+  }
+  return Buffer.concat(chunks, collected);
+}
+async function openNodeZipEntryStream(zipFile, entry, options) {
+  return await new Promise((resolve2, reject) => {
+    const callback = (error, opened) => {
+      if (error || opened === void 0) {
+        reject(error ?? new Error(`Cannot read ZIP entry: ${entry.fileName}`));
+      } else {
+        resolve2(opened);
+      }
+    };
+    if (options === void 0) zipFile.openReadStream(entry, callback);
+    else zipFile.openReadStream(entry, options, callback);
+  });
+}
+async function writeNodeZip(file, entries) {
+  const zipFile = new yazl.ZipFile();
+  const writer = await file.openWriter();
+  const outputStream = zipFile.outputStream;
+  const outputDone = writeNodeStream(outputStream, writer);
+  const entryState = { cancelled: false, complete: false };
+  let iterator;
+  try {
+    iterator = getNodeZipEntryIterator(entries);
+    const entriesDone = addNodeZipEntries(zipFile, iterator, entryState);
+    await Promise.race([entriesDone, outputDone]);
+    if (!entryState.complete) {
+      throw new Error("ZIP output ended before entry production completed");
+    }
+    zipFile.end();
+    await outputDone;
+    await writer.commit();
+  } catch (error) {
+    entryState.cancelled = true;
+    if (!entryState.complete && iterator !== void 0) {
+      closeNodeZipEntryIterator(iterator);
+    }
+    if (!outputStream.destroyed) {
+      outputStream.destroy(
+        error instanceof Error ? error : new Error("Cannot write ZIP archive")
+      );
+    }
+    await outputDone.catch(() => void 0);
+    await writer.abort().catch(() => void 0);
+    throw error;
+  }
+}
+async function addNodeZipEntries(zipFile, iterator, state) {
+  while (!state.cancelled) {
+    const result = await iterator.next();
+    if (state.cancelled) return;
+    if (result.done) {
+      state.complete = true;
+      return;
+    }
+    if ("file" in result.value) {
+      zipFile.addReadStream(
+        createNodeFileReadStream(result.value.file),
+        result.value.name,
+        { compress: false }
+      );
+    } else if ("data" in result.value) {
+      zipFile.addBuffer(Buffer.from(result.value.data), result.value.name, {
+        compress: false
+      });
+    } else {
+      zipFile.addReadStream(
+        createNodeRangeReadStream(result.value),
+        result.value.name,
+        { compress: false, size: result.value.size }
+      );
+    }
+  }
+}
+function createNodeFileReadStream(file) {
+  return import_node_stream.Readable.from(
+    (async function* () {
+      const reader = await file.openReader();
+      try {
+        for (let offset = 0; offset < reader.size; ) {
+          const chunk = await reader.read(
+            offset,
+            Math.min(64 * 1024, reader.size - offset)
+          );
+          offset += chunk.byteLength;
+          yield chunk;
+        }
+      } finally {
+        await reader.close();
+      }
+    })()
+  );
+}
+function getBrandedNodeResourcePath(resource, kind) {
+  if (typeof resource !== "object" || resource === null) return void 0;
+  const candidate = resource;
+  return candidate[NODE_RESOURCE_KIND] === kind && typeof candidate.path === "string" ? candidate.path : void 0;
+}
+function createNodeRangeReadStream(entry) {
+  return import_node_stream.Readable.from(
+    (async function* () {
+      for (let offset = 0; offset < entry.size; ) {
+        const chunk = await entry.read(
+          offset,
+          Math.min(64 * 1024, entry.size - offset)
+        );
+        offset += chunk.byteLength;
+        yield chunk;
+      }
+    })()
+  );
+}
+function getNodeZipEntryIterator(entries) {
+  const asyncIterator = entries[Symbol.asyncIterator];
+  return asyncIterator === void 0 ? entries[Symbol.iterator]() : asyncIterator.call(entries);
+}
+function closeNodeZipEntryIterator(iterator) {
+  if (iterator.return === void 0) return;
+  try {
+    void Promise.resolve(iterator.return()).catch(() => void 0);
+  } catch {
+  }
+}
+async function writeNodeStream(input, writer) {
+  await (0, import_promises.pipeline)(
+    input,
+    new import_node_stream.Writable({
+      write: (chunk, _encoding, callback) => {
+        void writer.write(chunk).then(
+          () => callback(),
+          (error) => callback(
+            error instanceof Error ? error : new Error("Cannot stream ZIP archive")
+          )
+        );
+      }
+    })
+  );
+}
+async function collectNodeStream(input) {
+  return await new Promise((resolve2, reject) => {
+    const chunks = [];
+    input.on("data", (chunk) => chunks.push(chunk));
+    input.once("error", reject);
+    input.once("end", () => resolve2(Buffer.concat(chunks)));
+  });
+}
+var nodeWikiGraphPlatform = {
+  asyncContext: {
+    create: () => new asyncHooks.AsyncLocalStorage()
+  },
+  database: { open: openNodeDatabase },
+  lifecycle: {
+    instanceId: `node-process:${nodeProcess.pid}`,
+    isInstanceAlive: (instanceId) => {
+      const match = /^node-process:(\d+)$/u.exec(instanceId);
+      if (match === null) return Promise.resolve(void 0);
+      try {
+        nodeProcess.kill(Number(match[1]), 0);
+        return Promise.resolve(true);
+      } catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH") {
+          return Promise.resolve(false);
+        }
+        return Promise.resolve(true);
+      }
+    }
+  },
+  resources: {
+    getDirectory: (identity) => {
+      const path = decodeNodeResourceIdentity(identity, "directory");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeDirectory(path)
+      );
+    },
+    getFile: (identity) => {
+      const path = decodeNodeResourceIdentity(identity, "file");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeFile(path)
+      );
+    },
+    resolveLegacyDirectory: (reference) => {
+      const path = decodeNodeResourceIdentity(reference, "directory");
+      return Promise.resolve(
+        path === void 0 ? void 0 : new NodeDirectory(path)
+      );
+    }
+  },
+  templates: {
+    createEnvironment: (options) => new import_nunjucks.Environment(new NodeTemplateLoader(), options)
+  },
+  zip: {
+    open: openNodeZip,
+    write: writeNodeZip
+  }
+};
+var NodeTemplateLoader = class extends import_nunjucks.Loader {
+  #dataDirectory;
+  constructor(dataDirectory) {
+    super();
+    this.#dataDirectory = dataDirectory;
+  }
+  getSource(templateName) {
+    const name = (0, import_platform.normalizeTemplateName)(templateName);
+    const filePath = pathModule.join(
+      this.#dataDirectory ?? resolveNodeDataDirectory(),
+      name
+    );
+    return {
+      noCache: false,
+      path: name,
+      src: fs.readFileSync(filePath, "utf8")
+    };
+  }
+};
+function resolveNodeDataDirectory() {
+  const injected = globalThis.__WIKIGRAPH_DATA_DIR__;
+  if (typeof injected === "string" && injected !== "") return injected;
+  let directory = nodeProcess.cwd();
+  while (true) {
+    for (const candidate of [
+      pathModule.join(directory, "data"),
+      pathModule.join(directory, "packages", "core", "data")
+    ]) {
+      try {
+        if (fs.statSync(candidate).isDirectory()) return candidate;
+      } catch {
+      }
+    }
+    const parent = pathModule.dirname(directory);
+    if (parent === directory)
+      throw new Error("Could not locate data directory");
+    directory = parent;
+  }
+}
+
+// src/local-config.ts
+var import_path = require("path");
+var import_os = require("os");
+var LOCAL_CONFIG_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS config_sections (
+  section TEXT PRIMARY KEY,
+  value_json TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+`;
+async function readLocalConfigSection(section) {
+  return await withLocalConfigDatabase(async (database) => {
+    return await readLocalConfigSectionInDatabase(database, section);
+  });
+}
+function validateLocalConfigSection(section, value) {
+  switch (section) {
+    case "embeddings":
+      return validateEmbeddingsConfig(value);
+    case "llm":
+      return validateLLMConfig(value);
+    case "concurrent":
+      return validateConcurrentConfig(value);
+    case "wikimedia":
+      return validateWikimediaConfig(value);
+    case "wikispine":
+      return validateWikispineConfig(value);
+  }
+}
+async function withLocalConfigDatabase(operation) {
+  const database = await (0, import_wiki_graph_core.openSharedStateDatabase)(
+    new NodeFile(
+      (0, import_path.join)(
+        getWikiGraphSDKStateDir() ?? (0, import_path.join)((0, import_os.homedir)(), ".wikigraph"),
+        "core.sqlite"
+      )
+    ),
+    LOCAL_CONFIG_SCHEMA_SQL
+  );
+  try {
+    return await operation(database);
+  } finally {
+    await database.close();
+  }
+}
+async function readLocalConfigSectionInDatabase(database, section) {
+  const value = await database.queryOne(
+    "SELECT value_json FROM config_sections WHERE section = ?",
+    [section],
+    (row) => String(row.value_json)
+  );
+  return value === void 0 ? {} : parseSectionJSON(section, value);
+}
+function parseSectionJSON(section, value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(
+      `Invalid local config JSON for ${section}: ${formatError(error)}`
+    );
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      `Invalid local config section ${section}: expected object.`
+    );
+  }
+  return validateLocalConfigSection(section, parsed);
+}
+function validateEmbeddingsConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "apiKey",
+    "baseURL",
+    "dimensions",
+    "model",
+    "name",
+    "provider"
+  ]);
+  const allowedProviders = /* @__PURE__ */ new Set(["openai", "openai-compatible"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown embeddings config key: ${key}`);
+    }
+    if (key === "dimensions") {
+      const parsed = typeof entry === "number" ? entry : typeof entry === "string" ? Number(entry) : NaN;
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error("embeddings.dimensions must be a positive integer.");
+      }
+      next[key] = parsed;
+      continue;
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`embeddings.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown embeddings.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateLLMConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "apiKey",
+    "baseURL",
+    "model",
+    "name",
+    "provider"
+  ]);
+  const allowedProviders = /* @__PURE__ */ new Set([
+    "anthropic",
+    "google",
+    "openai",
+    "openai-compatible"
+  ]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown llm config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`llm.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown llm.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateConcurrentConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["job", "request"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown concurrent config key: ${key}`);
+    }
+    const parsed = typeof entry === "number" ? entry : typeof entry === "string" ? Number(entry) : NaN;
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+      throw new Error(`concurrent.${key} must be a positive integer.`);
+    }
+    next[key] = parsed;
+  }
+  return next;
+}
+function validateWikispineConfig(value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["endpoint", "provider", "token"]);
+  const allowedProviders = /* @__PURE__ */ new Set(["cli", "fetch"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown wikispine config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`wikispine.${key} must be a non-empty string.`);
+    }
+    const normalized = entry.trim();
+    if (key === "provider" && !allowedProviders.has(normalized)) {
+      throw new Error(`Unknown wikispine.provider: ${normalized}`);
+    }
+    next[key] = normalized;
+  }
+  return next;
+}
+function validateWikimediaConfig(value) {
+  return validateEndpointConfig("wikimedia", value);
+}
+function validateEndpointConfig(section, value) {
+  const allowedKeys = /* @__PURE__ */ new Set(["endpoint", "token"]);
+  const next = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!allowedKeys.has(key)) {
+      throw new Error(`Unknown ${section} config key: ${key}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+      throw new Error(`${section}.${key} must be a non-empty string.`);
+    }
+    next[key] = entry.trim();
+  }
+  return next;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/embedding.ts
+var EMBEDDING_BATCH_SIZE = 10;
+async function readWikiGraphEmbeddingConfig() {
+  const config = await readLocalConfigSection("embeddings");
+  return {
+    ...typeof config.apiKey === "string" ? { apiKey: config.apiKey } : {},
+    ...typeof config.baseURL === "string" ? { baseURL: config.baseURL } : {},
+    ...typeof config.dimensions === "number" ? { dimensions: config.dimensions } : {},
+    ...typeof config.model === "string" ? { model: config.model } : {},
+    ...typeof config.name === "string" ? { name: config.name } : {},
+    ...typeof config.provider === "string" ? { provider: parseEmbeddingProvider(config.provider) } : {}
+  };
+}
+async function embedQueryText(value, config = {}) {
+  const normalized = value.trim();
+  if (normalized === "") {
+    throw new Error("Query text cannot be empty.");
+  }
+  const provider = requireEmbeddingProvider(config.provider);
+  const model = requireEmbeddingModel(config.model);
+  const embeddingModel = createEmbeddingModel(provider, model, config);
+  const providerOptions = createEmbeddingProviderOptions(provider, config);
+  const result = await (0, import_ai.embed)({
+    model: embeddingModel,
+    ...providerOptions === void 0 ? {} : { providerOptions },
+    value: normalized
+  });
+  return {
+    dimensions: result.embedding.length,
+    embedding: result.embedding,
+    model,
+    provider,
+    ...result.usage.tokens === void 0 ? {} : { usage: { tokens: result.usage.tokens } }
+  };
+}
+function buildSearchIndexEmbeddingProvider(config) {
+  const provider = requireEmbeddingProvider(config.provider);
+  const model = requireEmbeddingModel(config.model);
+  const embeddingModel = createEmbeddingModel(provider, model, config);
+  const providerOptions = createEmbeddingProviderOptions(provider, config);
+  return {
+    ...config.dimensions === void 0 ? {} : { dimensions: config.dimensions },
+    identity: createEmbeddingIdentity(provider, model, config),
+    model,
+    embedTexts: async (texts, options) => {
+      const embeddings = [];
+      let tokens = 0;
+      for (const batch of chunkTexts(texts, EMBEDDING_BATCH_SIZE)) {
+        options?.signal?.throwIfAborted();
+        const result = await (0, import_ai.embedMany)({
+          ...options?.signal === void 0 ? {} : { abortSignal: options.signal },
+          model: embeddingModel,
+          ...providerOptions === void 0 ? {} : { providerOptions },
+          values: [...batch]
+        });
+        embeddings.push(...result.embeddings);
+        tokens += result.usage.tokens ?? 0;
+      }
+      return {
+        embeddings,
+        ...tokens === 0 ? {} : { tokens }
+      };
+    }
+  };
+}
+function createEmbeddingIdentity(provider, model, config) {
+  return JSON.stringify({
+    ...config.baseURL === void 0 ? {} : { baseURL: config.baseURL },
+    ...config.dimensions === void 0 ? {} : { dimensions: config.dimensions },
+    model,
+    provider
+  });
+}
+function* chunkTexts(texts, size) {
+  for (let index = 0; index < texts.length; index += size) {
+    yield texts.slice(index, index + size);
+  }
+}
+async function embedQueryTextWithLocalConfig(value) {
+  return await embedQueryText(value, await readWikiGraphEmbeddingConfig());
+}
+function createEmbeddingModel(provider, model, config) {
+  switch (provider) {
+    case "openai": {
+      if (config.baseURL !== void 0) {
+        throw new Error(
+          "openai does not accept embeddings.baseURL. Use openai-compatible for third-party OpenAI-style embeddings APIs."
+        );
+      }
+      return (0, import_openai.createOpenAI)({
+        ...config.apiKey === void 0 ? {} : { apiKey: config.apiKey },
+        ...config.name === void 0 ? {} : { name: config.name }
+      }).embeddingModel(model);
+    }
+    case "openai-compatible": {
+      if (config.baseURL === void 0) {
+        throw new Error("openai-compatible requires embeddings.baseURL.");
+      }
+      return (0, import_openai_compatible.createOpenAICompatible)({
+        baseURL: config.baseURL,
+        name: config.name ?? createOpenAICompatibleName(config.baseURL),
+        ...config.apiKey === void 0 ? {} : { apiKey: config.apiKey }
+      }).embeddingModel(model);
+    }
+  }
+}
+function createEmbeddingProviderOptions(provider, config) {
+  if (config.dimensions === void 0) {
+    return void 0;
+  }
+  return {
+    [getEmbeddingProviderOptionsName(provider, config)]: {
+      dimensions: config.dimensions
+    }
+  };
+}
+function getEmbeddingProviderOptionsName(provider, _config) {
+  if (provider === "openai") {
+    return "openai";
+  }
+  return "openaiCompatible";
+}
+function requireEmbeddingProvider(provider) {
+  if (provider !== void 0) {
+    return provider;
+  }
+  throw new Error(
+    "Missing embeddings configuration. Configure `wikg://local/config/embeddings` with provider and model."
+  );
+}
+function requireEmbeddingModel(model) {
+  if (model !== void 0) {
+    return model;
+  }
+  throw new Error(
+    "Missing embeddings.model. Configure `wikg://local/config/embeddings` before using Dense search."
+  );
+}
+function parseEmbeddingProvider(value) {
+  switch (value) {
+    case "openai":
+    case "openai-compatible":
+      return value;
+    default:
+      throw new Error(
+        `Invalid embeddings.provider: ${value}. Expected openai or openai-compatible.`
+      );
+  }
+}
+function createOpenAICompatibleName(baseURL) {
+  try {
+    return new URL(baseURL).hostname;
+  } catch {
+    return "openai-compatible";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildSearchIndexEmbeddingProvider,
+  embedQueryText,
+  embedQueryTextWithLocalConfig,
+  readWikiGraphEmbeddingConfig
+});
+//# sourceMappingURL=embedding.cjs.map