@ppagent/memory 0.1.2 → 0.3.1

package/dist/provider.resolver-ZLQ766IO.js

@@ -0,0 +1,585 @@
+// src/db/provider.resolver.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/db/providers/lancedb.provider.ts
+async function lancedbAvailable() {
+  try {
+    await import("@lancedb/lancedb");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function esc(value) {
+  return String(value).replace(/'/g, "''");
+}
+function literal(value) {
+  if (typeof value === "string") return `'${esc(value)}'`;
+  return String(value);
+}
+function filterToSql(filter) {
+  if (!filter || filter.length === 0) return void 0;
+  const parts = filter.map((c) => {
+    switch (c.op) {
+      case "eq":
+        return `${c.field} = ${literal(c.value)}`;
+      case "gt":
+        return `${c.field} > ${literal(c.value)}`;
+      case "gte":
+        return `${c.field} >= ${literal(c.value)}`;
+      case "in":
+        if (c.values.length === 0) return "1 = 0";
+        return `${c.field} IN (${c.values.map((v) => literal(v)).join(", ")})`;
+      case "jsonContains": {
+        const jsonValue = typeof c.value === "string" ? `"${c.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : String(c.value);
+        return `${c.field} LIKE '%${esc(`"${c.key}":${jsonValue}`)}%'`;
+      }
+    }
+  });
+  return parts.join(" AND ");
+}
+var LanceDbProvider = class {
+  kind = "lancedb";
+  path;
+  lancedb;
+  conn;
+  tables = /* @__PURE__ */ new Map();
+  defs = /* @__PURE__ */ new Map();
+  /**
+   * 空表无法创建 btree 标量索引（LanceDB 限制），新建的表记录在此，
+   * 首次写入后补建索引。
+   */
+  pendingIndexTables = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.path = opts.path;
+  }
+  async init(tables) {
+    this.lancedb = await import("@lancedb/lancedb");
+    const arrow = await import("apache-arrow");
+    this.conn = await this.lancedb.connect(this.path);
+    const existing = await this.conn.tableNames();
+    for (const def of tables) {
+      this.defs.set(def.name, def);
+      if (existing.includes(def.name)) {
+        const table = await this.conn.openTable(def.name);
+        this.tables.set(def.name, table);
+        await this.ensureColumns(table, def);
+      } else {
+        const table = await this.conn.createEmptyTable(def.name, this.buildSchema(arrow, def));
+        this.tables.set(def.name, table);
+        this.pendingIndexTables.add(def.name);
+      }
+      await this.ensureIndexes(def.name);
+    }
+  }
+  buildSchema(arrow, def) {
+    const { Field, FixedSizeList, Float32, Int32, Int64, Schema, Utf8 } = arrow;
+    const fields = def.columns.map((col) => {
+      switch (col.type) {
+        case "text":
+          return new Field(col.name, new Utf8(), col.nullable ?? false);
+        case "int":
+          return new Field(col.name, new Int32(), col.nullable ?? false);
+        case "long":
+          return new Field(col.name, new Int64(), col.nullable ?? false);
+        case "vector": {
+          if (!def.vectorDimension) {
+            throw new Error(`Table ${def.name} has vector column but no vectorDimension`);
+          }
+          return new Field(
+            col.name,
+            new FixedSizeList(def.vectorDimension, new Field("item", new Float32(), false)),
+            col.nullable ?? false
+          );
+        }
+      }
+    });
+    return new Schema(fields);
+  }
+  /**
+   * schema 演进：为存量表补齐缺失的 nullable 列（如 messages.parts、topics.title）。
+   * 旧版本不支持 addColumns 时忽略；读取端映射需自带 ?? 兜底。
+   */
+  async ensureColumns(table, def) {
+    try {
+      const schema = await table.schema();
+      const existing = new Set(
+        (schema.fields ?? []).map((f) => f.name)
+      );
+      const missing = def.columns.filter((c) => c.nullable && !existing.has(c.name));
+      if (missing.length === 0) return;
+      await table.addColumns(
+        missing.map((c) => ({
+          name: c.name,
+          valueSql: c.type === "text" ? "CAST(NULL AS STRING)" : "CAST(NULL AS BIGINT)"
+        }))
+      );
+    } catch {
+    }
+  }
+  /**
+   * 按需补齐索引：先经 listIndices 判存在，缺失的列才 createIndex（且 replace:false）。
+   * createIndex 默认 replace:true 会在每次启动时全量重建索引并提交新表版本——
+   * 这正是历史上「启动越来越慢 + _versions 目录膨胀」的根源，绝不可回退到无条件 createIndex。
+   */
+  async ensureIndexes(tableName) {
+    const table = this.mustTable(tableName);
+    const def = this.defs.get(tableName);
+    let indexed;
+    try {
+      indexed = new Set((await table.listIndices()).flatMap((i) => i.columns));
+    } catch {
+      indexed = /* @__PURE__ */ new Set();
+    }
+    for (const spec of def.indexes) {
+      if (spec.kind === "vector") continue;
+      if (indexed.has(spec.column)) continue;
+      try {
+        await table.createIndex(
+          spec.column,
+          spec.kind === "fts" ? { config: this.lancedb.Index.fts(), replace: false } : { replace: false }
+        );
+      } catch {
+      }
+    }
+  }
+  mustTable(name) {
+    const table = this.tables.get(name);
+    if (!table) throw new Error(`Table not initialized: ${name}`);
+    return table;
+  }
+  async add(table, rows) {
+    if (rows.length === 0) return;
+    await this.mustTable(table).add(rows);
+    if (this.pendingIndexTables.has(table)) {
+      await this.ensureIndexes(table);
+      this.pendingIndexTables.delete(table);
+    }
+  }
+  async update(table, values, filter) {
+    const where = filterToSql(filter);
+    if (!where) throw new Error(`update on ${table} requires a non-empty filter`);
+    await this.mustTable(table).update({
+      values,
+      where
+    });
+  }
+  async deleteWhere(table, filter) {
+    const where = filterToSql(filter);
+    if (!where) throw new Error(`deleteWhere on ${table} requires a non-empty filter`);
+    await this.mustTable(table).delete(where);
+  }
+  async query(table, opts) {
+    const q = this.mustTable(table).query();
+    const where = filterToSql(opts?.filter);
+    if (where) q.where(where);
+    if (opts?.select) q.select(opts.select);
+    if (opts?.orderBy?.length) {
+      q.orderBy(opts.orderBy.map((o) => ({ columnName: o.column, ascending: o.ascending })));
+    }
+    if (opts?.limit !== void 0) q.limit(opts.limit);
+    return await q.toArray();
+  }
+  async vectorSearch(table, vector, opts) {
+    const q = this.mustTable(table).vectorSearch(vector).limit(opts.limit);
+    const where = filterToSql(opts.filter);
+    if (where) q.where(where);
+    const rows = await q.toArray();
+    return rows.map((r) => ({ ...r, _distance: Number(r._distance) }));
+  }
+  async ftsSearch(table, query, opts) {
+    const q = this.mustTable(table).query().fullTextSearch(query).limit(opts.limit);
+    const where = filterToSql(opts.filter);
+    if (where) q.where(where);
+    const rows = await q.toArray();
+    return rows.map((r) => ({ ...r, _score: Number(r._score ?? 0) }));
+  }
+  async count(table, filter) {
+    return this.mustTable(table).countRows(filterToSql(filter));
+  }
+  /**
+   * 存储压实：逐表执行碎片合并 + 清理 retentionMs 之前的历史版本。
+   * 嵌入式场景下 LanceDB 不会自动做这件事，长期运行后版本/碎片无限累积会显著拖慢启动与查询。
+   */
+  async optimize(retentionMs) {
+    const cutoff = new Date(Date.now() - Math.max(0, retentionMs));
+    const results = [];
+    for (const [name, table] of this.tables) {
+      try {
+        const stats = await table.optimize({ cleanupOlderThan: cutoff });
+        results.push({
+          table: name,
+          fragmentsRemoved: stats.compaction.fragmentsRemoved,
+          fragmentsAdded: stats.compaction.fragmentsAdded,
+          filesRemoved: stats.compaction.filesRemoved,
+          oldVersionsRemoved: stats.prune.oldVersionsRemoved,
+          bytesRemoved: Number(stats.prune.bytesRemoved)
+        });
+      } catch (err) {
+        console.warn(`[LanceDbProvider] optimize table "${name}" failed:`, err);
+      }
+    }
+    return results;
+  }
+  capabilities() {
+    return { fts: true, ann: false, optimize: true };
+  }
+  async close() {
+    try {
+      this.conn?.close();
+    } catch {
+    }
+    this.tables.clear();
+  }
+};
+
+// src/db/providers/sqlite.provider.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { cut_for_search } from "jieba-wasm";
+import * as path from "node:path";
+import * as fs from "node:fs";
+function tokenizeForIndex(text) {
+  if (!text) return "";
+  return cut_for_search(text, true).map((t) => t.trim()).filter(Boolean).join(" ");
+}
+function tokenizeForQuery(text) {
+  const tokens = cut_for_search(text, true).map((t) => t.trim()).filter(Boolean);
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" OR ");
+}
+function escLike(s) {
+  return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function filterToWhere(filter, columnPrefix = "") {
+  if (!filter || filter.length === 0) return { sql: "", params: [] };
+  const parts = [];
+  const params = [];
+  for (const c of filter) {
+    const col = `${columnPrefix}"${c.field}"`;
+    switch (c.op) {
+      case "eq":
+        parts.push(`${col} = ?`);
+        params.push(c.value);
+        break;
+      case "gt":
+        parts.push(`${col} > ?`);
+        params.push(c.value);
+        break;
+      case "gte":
+        parts.push(`${col} >= ?`);
+        params.push(c.value);
+        break;
+      case "in":
+        if (c.values.length === 0) {
+          parts.push("0 = 1");
+        } else {
+          parts.push(`${col} IN (${c.values.map(() => "?").join(", ")})`);
+          params.push(...c.values);
+        }
+        break;
+      case "jsonContains": {
+        const jsonValue = typeof c.value === "string" ? `"${c.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : String(c.value);
+        parts.push(`${col} LIKE ? ESCAPE '\\'`);
+        params.push(`%${escLike(`"${c.key}":${jsonValue}`)}%`);
+        break;
+      }
+    }
+  }
+  return { sql: parts.join(" AND "), params };
+}
+function vectorToBlob(v) {
+  return Buffer.from(new Float32Array(v).buffer);
+}
+function blobToVector(b) {
+  if (Array.isArray(b)) return b;
+  const buf = b;
+  return Array.from(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
+}
+var SqliteProvider = class {
+  kind = "sqlite";
+  dbPath;
+  db;
+  defs = /* @__PURE__ */ new Map();
+  /** 表名 → fts 列名列表（无 fts 索引的表不在此 map） */
+  ftsColumns = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.dbPath = opts.path;
+  }
+  async init(tables) {
+    fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+    this.db = new Database(this.dbPath);
+    sqliteVec.load(this.db);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    for (const def of tables) {
+      this.defs.set(def.name, def);
+      this.createOrMigrateTable(def);
+    }
+  }
+  createOrMigrateTable(def) {
+    const colSql = (c) => {
+      const type = c.type === "text" ? "TEXT" : c.type === "vector" ? "BLOB" : "INTEGER";
+      return `"${c.name}" ${type}`;
+    };
+    this.db.exec(
+      `CREATE TABLE IF NOT EXISTS "${def.name}" (${def.columns.map(colSql).join(", ")})`
+    );
+    const existing = new Set(
+      this.db.pragma(`table_info("${def.name}")`).map((r) => r.name)
+    );
+    for (const c of def.columns) {
+      if (!existing.has(c.name)) {
+        this.db.exec(`ALTER TABLE "${def.name}" ADD COLUMN ${colSql(c)}`);
+      }
+    }
+    for (const idx of def.indexes) {
+      if (idx.kind === "scalar") {
+        this.db.exec(
+          `CREATE INDEX IF NOT EXISTS "idx_${def.name}_${idx.column}" ON "${def.name}"("${idx.column}")`
+        );
+      }
+    }
+    const ftsCols = def.indexes.filter((i) => i.kind === "fts").map((i) => i.column);
+    if (ftsCols.length > 0) {
+      this.ftsColumns.set(def.name, ftsCols);
+      this.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS "${def.name}_fts" USING fts5(${ftsCols.map((c) => `"${c}"`).join(", ")})`
+      );
+    }
+  }
+  mustDef(table) {
+    const def = this.defs.get(table);
+    if (!def) throw new Error(`Table not initialized: ${table}`);
+    return def;
+  }
+  async add(table, rows) {
+    if (rows.length === 0) return;
+    const def = this.mustDef(table);
+    const cols = def.columns.map((c) => c.name);
+    const insert = this.db.prepare(
+      `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`
+    );
+    const ftsCols = this.ftsColumns.get(table);
+    const insertFts = ftsCols ? this.db.prepare(
+      `INSERT INTO "${table}_fts" (rowid, ${ftsCols.map((c) => `"${c}"`).join(", ")}) VALUES (${[
+        "?",
+        ...ftsCols.map(() => "?")
+      ].join(", ")})`
+    ) : null;
+    const encode = (colName, row) => {
+      const def0 = def.columns.find((c) => c.name === colName);
+      const v = row[colName];
+      if (v === void 0 || v === null) return null;
+      if (def0.type === "vector") return vectorToBlob(v);
+      return v;
+    };
+    this.db.transaction(() => {
+      for (const row of rows) {
+        const info = insert.run(...cols.map((c) => encode(c, row)));
+        if (insertFts && ftsCols) {
+          insertFts.run(
+            info.lastInsertRowid,
+            ...ftsCols.map((c) => tokenizeForIndex(String(row[c] ?? "")))
+          );
+        }
+      }
+    })();
+  }
+  async update(table, values, filter) {
+    const def = this.mustDef(table);
+    const where = filterToWhere(filter);
+    if (!where.sql) throw new Error(`update on ${table} requires a non-empty filter`);
+    const cols = Object.keys(values);
+    const encode = (colName) => {
+      const cd = def.columns.find((c) => c.name === colName);
+      const v = values[colName];
+      if (v === void 0 || v === null) return null;
+      if (cd?.type === "vector") return vectorToBlob(v);
+      return v;
+    };
+    const ftsCols = this.ftsColumns.get(table);
+    const touchedFts = ftsCols?.filter((c) => cols.includes(c)) ?? [];
+    this.db.transaction(() => {
+      this.db.prepare(
+        `UPDATE "${table}" SET ${cols.map((c) => `"${c}" = ?`).join(", ")} WHERE ${where.sql}`
+      ).run(...cols.map(encode), ...where.params);
+      if (touchedFts.length > 0) {
+        const rowids = this.db.prepare(`SELECT rowid FROM "${table}" WHERE ${where.sql}`).all(...where.params);
+        const upd = this.db.prepare(
+          `UPDATE "${table}_fts" SET ${touchedFts.map((c) => `"${c}" = ?`).join(", ")} WHERE rowid = ?`
+        );
+        for (const { rowid } of rowids) {
+          upd.run(...touchedFts.map((c) => tokenizeForIndex(String(values[c] ?? ""))), rowid);
+        }
+      }
+    })();
+  }
+  async deleteWhere(table, filter) {
+    this.mustDef(table);
+    const where = filterToWhere(filter);
+    if (!where.sql) throw new Error(`deleteWhere on ${table} requires a non-empty filter`);
+    const hasFts = this.ftsColumns.has(table);
+    this.db.transaction(() => {
+      if (hasFts) {
+        this.db.prepare(
+          `DELETE FROM "${table}_fts" WHERE rowid IN (SELECT rowid FROM "${table}" WHERE ${where.sql})`
+        ).run(...where.params);
+      }
+      this.db.prepare(`DELETE FROM "${table}" WHERE ${where.sql}`).run(...where.params);
+    })();
+  }
+  async query(table, opts) {
+    const def = this.mustDef(table);
+    const select = opts?.select?.length ? opts.select.map((c) => `"${c}"`).join(", ") : "*";
+    const where = filterToWhere(opts?.filter);
+    let sql = `SELECT ${select} FROM "${table}"`;
+    if (where.sql) sql += ` WHERE ${where.sql}`;
+    if (opts?.orderBy?.length) {
+      sql += ` ORDER BY ${opts.orderBy.map((o) => `"${o.column}" ${o.ascending ? "ASC" : "DESC"}`).join(", ")}`;
+    }
+    if (opts?.limit !== void 0) sql += ` LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+    const rows = this.db.prepare(sql).all(...where.params);
+    return rows.map((r) => this.decodeRow(def, r));
+  }
+  async vectorSearch(table, vector, opts) {
+    const def = this.mustDef(table);
+    if (!def.vectorDimension) throw new Error(`Table ${table} has no vector column`);
+    const where = filterToWhere(opts.filter);
+    let sql = `SELECT *, vec_distance_l2("vector", ?) AS _distance FROM "${table}"`;
+    if (where.sql) sql += ` WHERE ${where.sql}`;
+    sql += ` ORDER BY _distance ASC LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+    const rows = this.db.prepare(sql).all(vectorToBlob(vector), ...where.params);
+    return rows.map((r) => {
+      const decoded = this.decodeRow(def, r);
+      const d = Number(r._distance);
+      decoded._distance = d * d;
+      return decoded;
+    });
+  }
+  async ftsSearch(table, query, opts) {
+    const def = this.mustDef(table);
+    if (!this.ftsColumns.has(table)) return [];
+    const match = tokenizeForQuery(query);
+    if (!match) return [];
+    const where = filterToWhere(opts.filter, `"${table}".`);
+    let sql = `SELECT "${table}".*, -bm25("${table}_fts") AS _score FROM "${table}_fts" JOIN "${table}" ON "${table}".rowid = "${table}_fts".rowid WHERE "${table}_fts" MATCH ?`;
+    if (where.sql) sql += ` AND ${where.sql}`;
+    sql += ` ORDER BY bm25("${table}_fts") LIMIT ${Math.max(0, Math.floor(opts.limit))}`;
+    const rows = this.db.prepare(sql).all(match, ...where.params);
+    return rows.map((r) => {
+      const decoded = this.decodeRow(def, r);
+      decoded._score = Number(r._score);
+      return decoded;
+    });
+  }
+  async count(table, filter) {
+    this.mustDef(table);
+    const where = filterToWhere(filter);
+    let sql = `SELECT count(*) AS c FROM "${table}"`;
+    if (where.sql) sql += ` WHERE ${where.sql}`;
+    const row = this.db.prepare(sql).get(...where.params);
+    return Number(row.c);
+  }
+  /** SQLite 无版本概念：checkpoint WAL + 查询计划统计刷新，返回空结果集 */
+  async optimize(_retentionMs) {
+    try {
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+      this.db.pragma("optimize");
+    } catch (err) {
+      console.warn("[SqliteProvider] optimize failed:", err);
+    }
+    return [];
+  }
+  capabilities() {
+    return { fts: true, ann: false, optimize: false };
+  }
+  async close() {
+    try {
+      this.db?.close();
+    } catch {
+    }
+  }
+  decodeRow(def, r) {
+    const out = { ...r };
+    for (const c of def.columns) {
+      if (c.type === "vector" && out[c.name] != null) {
+        out[c.name] = blobToVector(out[c.name]);
+      }
+    }
+    return out;
+  }
+};
+
+// src/db/provider.resolver.ts
+function markerPath(config) {
+  return path2.join(path2.dirname(config.lancedbPath), ".memory-provider");
+}
+function readMarker(config) {
+  try {
+    const v = fs2.readFileSync(markerPath(config), "utf-8").trim();
+    if (v === "lancedb" || v === "sqlite") return v;
+  } catch {
+  }
+  return void 0;
+}
+function writeMarker(config, kind) {
+  try {
+    fs2.mkdirSync(path2.dirname(markerPath(config)), { recursive: true });
+    fs2.writeFileSync(markerPath(config), kind, "utf-8");
+  } catch (err) {
+    console.warn("[memory] \u5199\u5165 provider marker \u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u8FD0\u884C\uFF09:", err);
+  }
+}
+function lanceDataExists(config) {
+  try {
+    return fs2.readdirSync(config.lancedbPath).some((f) => f.endsWith(".lance"));
+  } catch {
+    return false;
+  }
+}
+async function resolveProviderKind(config) {
+  const requested = config.provider;
+  if (requested !== "auto") {
+    const marker2 = readMarker(config);
+    if (marker2 && marker2 !== requested) {
+      console.warn(
+        `[memory] \u663E\u5F0F\u914D\u7F6E provider=${requested} \u4E0E\u6B64\u524D\u4F7F\u7528\u7684 ${marker2} \u4E0D\u4E00\u81F4\uFF0C\u4E24\u4E2A\u540E\u7AEF\u7684\u6570\u636E\u4E92\u4E0D\u76F8\u901A\uFF0C\u5982\u9700\u4FDD\u7559\u65E7\u6570\u636E\u8BF7\u5148\u5BFC\u51FA\u8FC1\u79FB\u3002`
+      );
+    }
+    writeMarker(config, requested);
+    return requested;
+  }
+  const detected = await lancedbAvailable() ? "lancedb" : "sqlite";
+  const marker = readMarker(config);
+  if (!marker) {
+    if (detected === "sqlite" && lanceDataExists(config)) {
+      console.warn(
+        `[memory] \u68C0\u6D4B\u5230\u5B58\u91CF LanceDB \u6570\u636E\uFF08${config.lancedbPath}\uFF09\uFF0C\u4F46\u672C\u673A\u65E0\u6CD5\u52A0\u8F7D @lancedb/lancedb \u539F\u751F\u7ED1\u5B9A\uFF08\u5982 Intel Mac \u65E0\u9884\u7F16\u8BD1\u4E8C\u8FDB\u5236\uFF09\uFF0C\u5C06\u6539\u7528 sqlite \u540E\u7AEF\u4ECE\u7A7A\u5E93\u5F00\u59CB\u3002\u65E7\u6570\u636E\u4E0D\u4F1A\u4E22\u5931\u4F46\u5728\u672C\u673A\u4E0D\u53EF\u8BFB\uFF0C\u53EF\u5728\u652F\u6301 lancedb \u7684\u673A\u5668\u4E0A\u5BFC\u51FA\u8FC1\u79FB\u3002`
+      );
+    }
+    writeMarker(config, detected);
+    return detected;
+  }
+  if (marker === detected) return detected;
+  if (marker === "sqlite") {
+    console.info(
+      "[memory] \u672C\u673A\u53EF\u52A0\u8F7D lancedb\uFF0C\u4F46\u6570\u636E\u76EE\u5F55\u6B64\u524D\u4F7F\u7528 sqlite \u540E\u7AEF\uFF0C\u4E3A\u4FDD\u6570\u636E\u8FDE\u7EED\u6027\u7EE7\u7EED\u4F7F\u7528 sqlite\u3002\u5982\u9700\u5207\u6362\u8BF7\u663E\u5F0F\u914D\u7F6E provider \u5E76\u81EA\u884C\u8FC1\u79FB\u6570\u636E\u3002"
+    );
+    return "sqlite";
+  }
+  throw new Error(
+    `[memory] \u6570\u636E\u76EE\u5F55\u6B64\u524D\u4F7F\u7528 lancedb \u540E\u7AEF\uFF0C\u4F46\u672C\u673A\u65E0\u6CD5\u52A0\u8F7D @lancedb/lancedb \u539F\u751F\u7ED1\u5B9A\uFF08Intel Mac / musl \u7B49\u65E0\u9884\u7F16\u8BD1\u4E8C\u8FDB\u5236\u7684\u5E73\u53F0\uFF09\u3002\u4E3A\u907F\u514D\u9759\u9ED8\u6253\u5F00\u7A7A\u5E93\u9020\u6210\u300C\u8BB0\u5FC6\u4E22\u5931\u300D\u7684\u5047\u8C61\uFF0C\u5DF2\u4E2D\u6B62\u542F\u52A8\u3002\u53EF\u9009\u5904\u7406\uFF1A1) \u5728\u652F\u6301 lancedb \u7684\u673A\u5668\u4E0A\u5BFC\u51FA\u6570\u636E\u540E\u8FC1\u79FB\uFF1B2) \u663E\u5F0F\u914D\u7F6E provider="sqlite" \u4ECE\u7A7A\u5E93\u5F00\u59CB\uFF1B3) \u4FEE\u590D lancedb \u5B89\u88C5\uFF08\u68C0\u67E5 Node \u67B6\u6784\u4E0E optional dependencies\uFF09\u3002`
+  );
+}
+async function createProvider(config) {
+  const kind = await resolveProviderKind(config);
+  if (kind === "lancedb") {
+    return new LanceDbProvider({ path: config.lancedbPath });
+  }
+  return new SqliteProvider({ path: config.sqlitePath });
+}
+export {
+  createProvider,
+  resolveProviderKind
+};