@h-ai/vecdb 0.1.0-alpha5

package/dist/index.js

@@ -0,0 +1,1056 @@
+import { z } from 'zod';
+import { core, ok, err } from '@h-ai/core';
+import { createHash } from 'crypto';
+
+// src/vecdb-config.ts
+
+// messages/en-US.json
+var en_US_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  vecdb_notInitialized: "Vector database not initialized, please call vecdb.init() first",
+  vecdb_initFailed: "Failed to initialize vector database: {error}",
+  vecdb_closeFailed: "Failed to close vector database: {error}",
+  vecdb_configError: "Vector database config validation failed: {error}",
+  vecdb_initInProgress: "Vector database initialization is already in progress",
+  vecdb_unsupportedType: "Unsupported vector database type: {type}",
+  vecdb_driverNotFound: "Vector database driver not installed: {driver}, please run pnpm add {driver}",
+  vecdb_connectionFailed: "Failed to connect to vector database: {error}",
+  vecdb_collectionNotFound: "Collection not found: {name}",
+  vecdb_collectionAlreadyExists: "Collection already exists: {name}",
+  vecdb_dimensionMismatch: "Vector dimension mismatch: expected {expected}, actual {actual}",
+  vecdb_insertFailed: "Failed to insert vectors: {error}",
+  vecdb_deleteFailed: "Failed to delete vectors: {error}",
+  vecdb_updateFailed: "Failed to update vectors: {error}",
+  vecdb_queryFailed: "Failed to query vectors: {error}",
+  vecdb_indexBuildFailed: "Failed to build index: {error}",
+  vecdb_serializationFailed: "Serialization/deserialization failed: {error}",
+  vecdb_configPathRequired: "Database storage path is required",
+  vecdb_configDatabaseRequired: "Database name is required"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  $schema: "https://inlang.com/schema/inlang-message-format",
+  vecdb_notInitialized: "\u5411\u91CF\u6570\u636E\u5E93\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 vecdb.init()",
+  vecdb_initFailed: "\u521D\u59CB\u5316\u5411\u91CF\u6570\u636E\u5E93\u5931\u8D25: {error}",
+  vecdb_closeFailed: "\u5173\u95ED\u5411\u91CF\u6570\u636E\u5E93\u5931\u8D25: {error}",
+  vecdb_configError: "\u5411\u91CF\u6570\u636E\u5E93\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A{error}",
+  vecdb_initInProgress: "\u5411\u91CF\u6570\u636E\u5E93\u521D\u59CB\u5316\u6B63\u5728\u8FDB\u884C\u4E2D",
+  vecdb_unsupportedType: "\u4E0D\u652F\u6301\u7684\u5411\u91CF\u6570\u636E\u5E93\u7C7B\u578B: {type}",
+  vecdb_driverNotFound: "\u5411\u91CF\u6570\u636E\u5E93\u9A71\u52A8\u672A\u5B89\u88C5: {driver}\uFF0C\u8BF7\u6267\u884C pnpm add {driver}",
+  vecdb_connectionFailed: "\u8FDE\u63A5\u5411\u91CF\u6570\u636E\u5E93\u5931\u8D25: {error}",
+  vecdb_collectionNotFound: "\u96C6\u5408\u4E0D\u5B58\u5728: {name}",
+  vecdb_collectionAlreadyExists: "\u96C6\u5408\u5DF2\u5B58\u5728: {name}",
+  vecdb_dimensionMismatch: "\u5411\u91CF\u7EF4\u5EA6\u4E0D\u5339\u914D: \u671F\u671B {expected}\uFF0C\u5B9E\u9645 {actual}",
+  vecdb_insertFailed: "\u63D2\u5165\u5411\u91CF\u5931\u8D25: {error}",
+  vecdb_deleteFailed: "\u5220\u9664\u5411\u91CF\u5931\u8D25: {error}",
+  vecdb_updateFailed: "\u66F4\u65B0\u5411\u91CF\u5931\u8D25: {error}",
+  vecdb_queryFailed: "\u67E5\u8BE2\u5411\u91CF\u5931\u8D25: {error}",
+  vecdb_indexBuildFailed: "\u6784\u5EFA\u7D22\u5F15\u5931\u8D25: {error}",
+  vecdb_serializationFailed: "\u5E8F\u5217\u5316/\u53CD\u5E8F\u5217\u5316\u5931\u8D25: {error}",
+  vecdb_configPathRequired: "\u6570\u636E\u5E93\u5B58\u50A8\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A",
+  vecdb_configDatabaseRequired: "\u6570\u636E\u5E93\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+};
+
+// src/vecdb-i18n.ts
+var vecdbM = core.i18n.createMessageGetter({
+  "zh-CN": zh_CN_default,
+  "en-US": en_US_default
+});
+
+// src/vecdb-config.ts
+var VecdbTypeSchema = z.enum(["lancedb", "pgvector", "qdrant"]);
+var DistanceMetricSchema = z.enum(["cosine", "euclidean", "dot"]).default("cosine");
+var LancedbConfigSchema = z.object({
+  type: z.literal("lancedb"),
+  /** 数据库存储路径（本地目录） */
+  path: z.string().min(1, vecdbM("vecdb_configPathRequired")),
+  /** 距离度量（默认 cosine） */
+  metric: DistanceMetricSchema.optional()
+});
+var PgvectorIndexTypeSchema = z.enum(["ivfflat", "hnsw"]).default("hnsw");
+var PgvectorConfigSchema = z.object({
+  type: z.literal("pgvector"),
+  /** 连接字符串（可选，优先使用） */
+  url: z.string().optional(),
+  /** 数据库主机地址（默认 localhost） */
+  host: z.string().default("localhost"),
+  /** 端口号（默认 5432） */
+  port: z.number().int().min(1).max(65535).default(5432),
+  /** 数据库名称 */
+  database: z.string().min(1, vecdbM("vecdb_configDatabaseRequired")),
+  /** 用户名 */
+  user: z.string().optional(),
+  /** 密码 */
+  password: z.string().optional(),
+  /** 索引类型（默认 hnsw） */
+  indexType: PgvectorIndexTypeSchema.optional(),
+  /** 距离度量（默认 cosine） */
+  metric: DistanceMetricSchema.optional(),
+  /** 表名前缀（默认 'vec_'） */
+  tablePrefix: z.string().default("vec_")
+});
+var QdrantConfigSchema = z.object({
+  type: z.literal("qdrant"),
+  /** Qdrant 服务器 URL */
+  url: z.string().url().default("http://localhost:6333"),
+  /** API Key（可选） */
+  apiKey: z.string().optional(),
+  /** 距离度量（默认 cosine） */
+  metric: DistanceMetricSchema.optional()
+});
+var VecdbConfigSchema = z.discriminatedUnion("type", [
+  LancedbConfigSchema,
+  PgvectorConfigSchema,
+  QdrantConfigSchema
+]);
+var VecdbErrorInfo = {
+  CONNECTION_FAILED: "001:500",
+  QUERY_FAILED: "002:500",
+  COLLECTION_NOT_FOUND: "003:404",
+  COLLECTION_ALREADY_EXISTS: "004:409",
+  DIMENSION_MISMATCH: "005:400",
+  INSERT_FAILED: "006:500",
+  DELETE_FAILED: "007:500",
+  UPDATE_FAILED: "008:500",
+  INDEX_BUILD_FAILED: "009:500",
+  NOT_INITIALIZED: "010:500",
+  CONFIG_ERROR: "011:500",
+  UNSUPPORTED_TYPE: "012:400",
+  DRIVER_NOT_FOUND: "013:500",
+  SERIALIZATION_FAILED: "014:500"
+};
+var HaiVecdbError = core.error.buildHaiErrorsDef("vecdb", VecdbErrorInfo);
+function errorMsgFromCode(def, errorStr) {
+  switch (def) {
+    case HaiVecdbError.DELETE_FAILED:
+      return vecdbM("vecdb_deleteFailed", { params: { error: errorStr } });
+    case HaiVecdbError.INSERT_FAILED:
+      return vecdbM("vecdb_insertFailed", { params: { error: errorStr } });
+    case HaiVecdbError.UPDATE_FAILED:
+      return vecdbM("vecdb_updateFailed", { params: { error: errorStr } });
+    default:
+      return vecdbM("vecdb_queryFailed", { params: { error: errorStr } });
+  }
+}
+async function wrapOp(ctx, fn, errorDef, errorLabel, errorMeta) {
+  if (!ctx.isConnected()) {
+    return err(HaiVecdbError.NOT_INITIALIZED, vecdbM("vecdb_notInitialized"));
+  }
+  try {
+    return await fn();
+  } catch (error) {
+    ctx.logger.error(errorLabel, { ...errorMeta, error });
+    return err(errorDef, errorMsgFromCode(errorDef, String(error)), error);
+  }
+}
+function createBaseCollectionOps(ctx, driver) {
+  return {
+    create: (name, options) => wrapOp(
+      ctx,
+      () => driver.create(name, options),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to create collection",
+      { name }
+    ),
+    drop: (name) => wrapOp(
+      ctx,
+      () => driver.drop(name),
+      HaiVecdbError.DELETE_FAILED,
+      "Failed to drop collection",
+      { name }
+    ),
+    exists: (name) => wrapOp(
+      ctx,
+      () => driver.exists(name),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to check collection",
+      { name }
+    ),
+    info: (name) => wrapOp(
+      ctx,
+      () => driver.info(name),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to get collection info",
+      { name }
+    ),
+    list: () => wrapOp(
+      ctx,
+      () => driver.list(),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to list collections"
+    )
+  };
+}
+function createBaseVectorOps(ctx, driver) {
+  return {
+    insert: (collection, documents) => wrapOp(
+      ctx,
+      () => driver.insert(collection, documents),
+      HaiVecdbError.INSERT_FAILED,
+      "Failed to insert vectors",
+      { collection }
+    ),
+    upsert: (collection, documents) => wrapOp(
+      ctx,
+      () => driver.upsert(collection, documents),
+      HaiVecdbError.UPDATE_FAILED,
+      "Failed to upsert vectors",
+      { collection }
+    ),
+    delete: (collection, ids) => wrapOp(
+      ctx,
+      () => driver.delete(collection, ids),
+      HaiVecdbError.DELETE_FAILED,
+      "Failed to delete vectors",
+      { collection }
+    ),
+    search: (collection, vector, options) => wrapOp(
+      ctx,
+      () => driver.search(collection, vector, options),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to search vectors",
+      { collection }
+    ),
+    count: (collection) => wrapOp(
+      ctx,
+      () => driver.count(collection),
+      HaiVecdbError.QUERY_FAILED,
+      "Failed to count vectors",
+      { collection }
+    )
+  };
+}
+
+// src/providers/vecdb-provider-lancedb.ts
+var logger = core.logger.child({ module: "vecdb", scope: "lancedb" });
+function escapeLanceFilterValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function createLancedbProvider() {
+  let connection = null;
+  let config = null;
+  const collectionMetas = /* @__PURE__ */ new Map();
+  async function loadLancedb() {
+    try {
+      const mod = await import('@lancedb/lancedb');
+      return ok(mod);
+    } catch (error) {
+      logger.error("Failed to load @lancedb/lancedb", { error });
+      return err(HaiVecdbError.DRIVER_NOT_FOUND, vecdbM("vecdb_driverNotFound", { params: { driver: "@lancedb/lancedb" } }), error);
+    }
+  }
+  async function openTable(name) {
+    if (!connection)
+      return null;
+    try {
+      const tableNames = await connection.tableNames();
+      if (tableNames.includes(name)) {
+        return await connection.openTable(name);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  const ctx = { isConnected: () => connection !== null, logger };
+  const collectionDriver = {
+    async create(name, options) {
+      logger.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
+      const tableNames = await connection.tableNames();
+      if (tableNames.includes(name)) {
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+      }
+      const dimension = options.dimension;
+      const metric = options.metric ?? config?.metric ?? "cosine";
+      const initRecord = {
+        id: "__init__",
+        vector: Array.from({ length: dimension }, () => 0),
+        content: "",
+        metadata: "{}"
+      };
+      const table = await connection.createTable(name, [initRecord]);
+      await table.delete('id = "__init__"');
+      collectionMetas.set(name, { dimension, metric });
+      logger.info("Collection created", { name, dimension, metric });
+      return ok(void 0);
+    },
+    async drop(name) {
+      logger.debug("Dropping collection", { name });
+      const tableNames = await connection.tableNames();
+      if (!tableNames.includes(name)) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      await connection.dropTable(name);
+      collectionMetas.delete(name);
+      logger.info("Collection dropped", { name });
+      return ok(void 0);
+    },
+    async exists(name) {
+      logger.debug("Checking collection exists", { name });
+      const tableNames = await connection.tableNames();
+      return ok(tableNames.includes(name));
+    },
+    async info(name) {
+      logger.debug("Getting collection info", { name });
+      const table = await openTable(name);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      const count = await table.countRows();
+      const meta = collectionMetas.get(name);
+      return ok({
+        name,
+        dimension: meta?.dimension ?? 0,
+        metric: meta?.metric ?? config?.metric ?? "cosine",
+        count
+      });
+    },
+    async list() {
+      logger.debug("Listing collections");
+      const tableNames = await connection.tableNames();
+      return ok(tableNames);
+    }
+  };
+  const vectorDriver = {
+    async insert(collection, documents) {
+      logger.debug("Inserting vectors", { collection, count: documents.length });
+      const table = await openTable(collection);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      }
+      const records = documents.map((doc) => ({
+        id: doc.id,
+        vector: doc.vector,
+        content: doc.content ?? "",
+        metadata: JSON.stringify(doc.metadata ?? {})
+      }));
+      await table.add(records);
+      logger.info("Vectors inserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async upsert(collection, documents) {
+      logger.debug("Upserting vectors", { collection, count: documents.length });
+      const table = await openTable(collection);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      }
+      const records = documents.map((doc) => ({
+        id: doc.id,
+        vector: doc.vector,
+        content: doc.content ?? "",
+        metadata: JSON.stringify(doc.metadata ?? {})
+      }));
+      const ids = documents.map((d) => `"${escapeLanceFilterValue(d.id)}"`).join(", ");
+      await table.delete(`id IN (${ids})`);
+      await table.add(records);
+      logger.info("Vectors upserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async delete(collection, ids) {
+      logger.debug("Deleting vectors", { collection, count: ids.length });
+      const table = await openTable(collection);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      }
+      const idList = ids.map((id) => `"${escapeLanceFilterValue(id)}"`).join(", ");
+      await table.delete(`id IN (${idList})`);
+      logger.info("Vectors deleted", { collection, count: ids.length });
+      return ok(void 0);
+    },
+    async search(collection, vector, options) {
+      logger.debug("Searching vectors", { collection, topK: options?.topK, hasFilter: !!options?.filter });
+      const table = await openTable(collection);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      }
+      const topK = options?.topK ?? 10;
+      const minScore = options?.minScore ?? 0;
+      let query = table.search(vector).limit(topK);
+      if (options?.filter) {
+        const filterParts = [];
+        for (const [key, value] of Object.entries(options.filter)) {
+          filterParts.push(`metadata LIKE '%"${escapeLanceFilterValue(key)}":"${escapeLanceFilterValue(String(value))}"%'`);
+        }
+        if (filterParts.length > 0) {
+          query = query.where(filterParts.join(" AND "));
+        }
+      }
+      const results = await query.toArray();
+      const searchResults = results.map((row) => {
+        const distance = row._distance ?? 0;
+        const score = 1 / (1 + distance);
+        return {
+          id: row.id,
+          score,
+          content: row.content || void 0,
+          metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+        };
+      }).filter((r) => r.score >= minScore);
+      return ok(searchResults);
+    },
+    async count(collection) {
+      logger.debug("Counting vectors", { collection });
+      const table = await openTable(collection);
+      if (!table) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name: collection } }));
+      }
+      const count = await table.countRows();
+      return ok(count);
+    }
+  };
+  return {
+    name: "lancedb",
+    async connect(cfg) {
+      if (cfg.type !== "lancedb") {
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+      }
+      const lanceConfig = cfg;
+      const loadResult = await loadLancedb();
+      if (!loadResult.success)
+        return loadResult;
+      const lancedb = loadResult.data;
+      try {
+        connection = await lancedb.connect(lanceConfig.path);
+        config = lanceConfig;
+        const tableNames = await connection.tableNames();
+        await Promise.allSettled(tableNames.map(async (name) => {
+          try {
+            const table = await connection.openTable(name);
+            const count = await table.countRows();
+            if (count === 0)
+              return;
+            const rows = await table.search(Array.from({ length: 1 }).fill(0)).limit(1).toArray();
+            if (rows.length > 0 && rows[0].vector) {
+              collectionMetas.set(name, {
+                dimension: rows[0].vector.length,
+                metric: lanceConfig.metric ?? "cosine"
+              });
+            }
+          } catch {
+          }
+        }));
+        logger.info("LanceDB connected", { path: lanceConfig.path });
+        return ok(void 0);
+      } catch (error) {
+        logger.error("Failed to connect to LanceDB", { error });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: String(error) } }), error);
+      }
+    },
+    async close() {
+      connection = null;
+      config = null;
+      collectionMetas.clear();
+      logger.info("LanceDB connection closed");
+      return ok(void 0);
+    },
+    isConnected() {
+      return connection !== null;
+    },
+    collection: createBaseCollectionOps(ctx, collectionDriver),
+    vector: createBaseVectorOps(ctx, vectorDriver)
+  };
+}
+var logger2 = core.logger.child({ module: "vecdb", scope: "pgvector" });
+function createPgvectorProvider() {
+  let pool = null;
+  let config = null;
+  function tableName(collection) {
+    return `${config?.tablePrefix ?? "vec_"}${collection}`;
+  }
+  function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  function distanceOp() {
+    const metric = config?.metric ?? "cosine";
+    switch (metric) {
+      case "cosine":
+        return "<=>";
+      case "euclidean":
+        return "<->";
+      case "dot":
+        return "<#>";
+      default:
+        return "<=>";
+    }
+  }
+  function distanceToScore(distance) {
+    const metric = config?.metric ?? "cosine";
+    switch (metric) {
+      case "cosine":
+        return 1 - distance / 2;
+      case "euclidean":
+        return 1 / (1 + distance);
+      case "dot":
+        return -distance;
+      default:
+        return 1 / (1 + distance);
+    }
+  }
+  const ctx = { isConnected: () => pool !== null, logger: logger2 };
+  const collectionDriver = {
+    async create(name, options) {
+      const table = tableName(name);
+      const dimension = options.dimension;
+      const metric = options.metric ?? config?.metric ?? "cosine";
+      const indexType = config?.indexType ?? "hnsw";
+      logger2.debug("Creating collection", { name, dimension, metric, indexType });
+      const checkResult = await pool.query(
+        `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
+        [table]
+      );
+      if (checkResult.rows[0].exists) {
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+      }
+      const qi = quoteIdent(table);
+      await pool.query(`
+        CREATE TABLE ${qi} (
+          id TEXT PRIMARY KEY,
+          vector vector(${dimension}),
+          content TEXT,
+          metadata JSONB DEFAULT '{}'::jsonb
+        )
+      `);
+      const distOp = distanceOp();
+      const opsClass = distOp === "<=>" ? "vector_cosine_ops" : distOp === "<->" ? "vector_l2_ops" : "vector_ip_ops";
+      if (indexType === "hnsw") {
+        await pool.query(`
+          CREATE INDEX ON ${qi}
+          USING hnsw (vector ${opsClass})
+        `);
+      } else {
+        await pool.query(`
+          CREATE INDEX ON ${qi}
+          USING ivfflat (vector ${opsClass})
+          WITH (lists = 100)
+        `);
+      }
+      logger2.info("Collection created", { name, dimension, metric, indexType });
+      return ok(void 0);
+    },
+    async drop(name) {
+      const table = tableName(name);
+      logger2.debug("Dropping collection", { name });
+      const checkResult = await pool.query(
+        `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
+        [table]
+      );
+      if (!checkResult.rows[0].exists) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      await pool.query(`DROP TABLE ${quoteIdent(table)}`);
+      logger2.info("Collection dropped", { name });
+      return ok(void 0);
+    },
+    async exists(name) {
+      logger2.debug("Checking collection exists", { name });
+      const result = await pool.query(
+        `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
+        [tableName(name)]
+      );
+      return ok(result.rows[0].exists);
+    },
+    async info(name) {
+      const table = tableName(name);
+      logger2.debug("Getting collection info", { name });
+      const existsResult = await pool.query(
+        `SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = $1)`,
+        [table]
+      );
+      if (!existsResult.rows[0].exists) {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      const countResult = await pool.query(`SELECT COUNT(*) as count FROM ${quoteIdent(table)}`);
+      const count = Number.parseInt(String(countResult.rows[0].count), 10);
+      const dimResult = await pool.query(`
+        SELECT atttypmod FROM pg_attribute
+        WHERE attrelid = $1::regclass AND attname = 'vector'
+      `, [quoteIdent(table)]);
+      const dimension = dimResult.rows.length > 0 ? Number(dimResult.rows[0].atttypmod) : 0;
+      return ok({
+        name,
+        dimension,
+        metric: config?.metric ?? "cosine",
+        count
+      });
+    },
+    async list() {
+      const prefix = config?.tablePrefix ?? "vec_";
+      logger2.debug("Listing collections");
+      const result = await pool.query(
+        `SELECT table_name FROM information_schema.tables WHERE table_name LIKE $1 AND table_schema = 'public'`,
+        [`${prefix}%`]
+      );
+      const names = result.rows.map(
+        (row) => String(row.table_name).slice(prefix.length)
+      );
+      return ok(names);
+    }
+  };
+  const vectorDriver = {
+    async insert(collection, documents) {
+      const table = tableName(collection);
+      logger2.debug("Inserting vectors", { collection, count: documents.length });
+      const qi = quoteIdent(table);
+      const values = [];
+      const params = [];
+      for (let i = 0; i < documents.length; i++) {
+        const base = i * 4;
+        values.push(`($${base + 1}, $${base + 2}::vector, $${base + 3}, $${base + 4}::jsonb)`);
+        const doc = documents[i];
+        params.push(doc.id, `[${doc.vector.join(",")}]`, doc.content ?? "", JSON.stringify(doc.metadata ?? {}));
+      }
+      await pool.query(
+        `INSERT INTO ${qi} (id, vector, content, metadata) VALUES ${values.join(", ")}`,
+        params
+      );
+      logger2.info("Vectors inserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async upsert(collection, documents) {
+      const table = tableName(collection);
+      logger2.debug("Upserting vectors", { collection, count: documents.length });
+      const qi = quoteIdent(table);
+      const values = [];
+      const params = [];
+      for (let i = 0; i < documents.length; i++) {
+        const base = i * 4;
+        values.push(`($${base + 1}, $${base + 2}::vector, $${base + 3}, $${base + 4}::jsonb)`);
+        const doc = documents[i];
+        params.push(doc.id, `[${doc.vector.join(",")}]`, doc.content ?? "", JSON.stringify(doc.metadata ?? {}));
+      }
+      await pool.query(
+        `INSERT INTO ${qi} (id, vector, content, metadata) VALUES ${values.join(", ")}
+         ON CONFLICT (id) DO UPDATE SET
+           vector = EXCLUDED.vector,
+           content = EXCLUDED.content,
+           metadata = EXCLUDED.metadata`,
+        params
+      );
+      logger2.info("Vectors upserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async delete(collection, ids) {
+      const table = tableName(collection);
+      logger2.debug("Deleting vectors", { collection, count: ids.length });
+      const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
+      await pool.query(`DELETE FROM ${quoteIdent(table)} WHERE id IN (${placeholders})`, ids);
+      logger2.info("Vectors deleted", { collection, count: ids.length });
+      return ok(void 0);
+    },
+    async search(collection, vector, options) {
+      const table = tableName(collection);
+      const topK = options?.topK ?? 10;
+      const minScore = options?.minScore ?? 0;
+      const op = distanceOp();
+      logger2.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      const vectorStr = `[${vector.join(",")}]`;
+      let filterSQL = "";
+      const filterParams = [vectorStr, topK];
+      let paramIndex = 3;
+      if (options?.filter) {
+        const filterParts = [];
+        for (const [key, value] of Object.entries(options.filter)) {
+          filterParts.push(`metadata->>$${paramIndex} = $${paramIndex + 1}`);
+          filterParams.push(key, String(value));
+          paramIndex += 2;
+        }
+        if (filterParts.length > 0) {
+          filterSQL = `WHERE ${filterParts.join(" AND ")}`;
+        }
+      }
+      const result = await pool.query(
+        `SELECT id, content, metadata, vector ${op} $1::vector AS distance
+         FROM ${quoteIdent(table)}
+         ${filterSQL}
+         ORDER BY vector ${op} $1::vector
+         LIMIT $2`,
+        filterParams
+      );
+      const searchResults = result.rows.map((row) => {
+        const score = distanceToScore(row.distance);
+        return {
+          id: row.id,
+          score,
+          content: row.content || void 0,
+          metadata: row.metadata
+        };
+      }).filter((r) => r.score >= minScore);
+      return ok(searchResults);
+    },
+    async count(collection) {
+      const table = tableName(collection);
+      logger2.debug("Counting vectors", { collection });
+      const result = await pool.query(`SELECT COUNT(*) as count FROM ${quoteIdent(table)}`);
+      return ok(Number.parseInt(String(result.rows[0].count), 10));
+    }
+  };
+  return {
+    name: "pgvector",
+    async connect(cfg) {
+      if (cfg.type !== "pgvector") {
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+      }
+      const pgConfig = cfg;
+      try {
+        const { Pool } = await import('pg');
+        const poolConfig = pgConfig.url ? { connectionString: pgConfig.url } : {
+          host: pgConfig.host,
+          port: pgConfig.port,
+          database: pgConfig.database,
+          user: pgConfig.user,
+          password: pgConfig.password
+        };
+        pool = new Pool(poolConfig);
+        await pool.query("CREATE EXTENSION IF NOT EXISTS vector");
+        config = pgConfig;
+        logger2.info("pgvector connected", { host: pgConfig.host, database: pgConfig.database });
+        return ok(void 0);
+      } catch (error) {
+        logger2.error("Failed to connect to pgvector", { error: error instanceof Error ? error.message : String(error) });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error);
+      }
+    },
+    async close() {
+      try {
+        if (pool) {
+          await pool.end();
+        }
+        pool = null;
+        config = null;
+        logger2.info("pgvector connection closed");
+        return ok(void 0);
+      } catch (error) {
+        logger2.error("Failed to close pgvector connection", { error: error instanceof Error ? error.message : String(error) });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_closeFailed", { params: { error: String(error) } }), error);
+      }
+    },
+    isConnected() {
+      return pool !== null;
+    },
+    collection: createBaseCollectionOps(ctx, collectionDriver),
+    vector: createBaseVectorOps(ctx, vectorDriver)
+  };
+}
+var logger3 = core.logger.child({ module: "vecdb", scope: "qdrant" });
+function hashToUuid(id) {
+  const hash = createHash("sha256").update(id).digest("hex");
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+}
+function toQdrantDistance(metric) {
+  switch (metric) {
+    case "cosine":
+      return "Cosine";
+    case "euclidean":
+      return "Euclid";
+    case "dot":
+      return "Dot";
+    default:
+      return "Cosine";
+  }
+}
+function createQdrantProvider() {
+  let client = null;
+  let config = null;
+  const ctx = { isConnected: () => client !== null, logger: logger3 };
+  const collectionDriver = {
+    async create(name, options) {
+      logger3.debug("Creating collection", { name, dimension: options.dimension, metric: options.metric });
+      const collections = await client.getCollections();
+      const exists = collections.collections.some((c) => c.name === name);
+      if (exists) {
+        return err(HaiVecdbError.COLLECTION_ALREADY_EXISTS, vecdbM("vecdb_collectionAlreadyExists", { params: { name } }));
+      }
+      const metric = options.metric ?? config?.metric ?? "cosine";
+      await client.createCollection(name, {
+        vectors: {
+          size: options.dimension,
+          distance: toQdrantDistance(metric)
+        }
+      });
+      logger3.info("Collection created", { name, dimension: options.dimension, metric });
+      return ok(void 0);
+    },
+    async drop(name) {
+      logger3.debug("Dropping collection", { name });
+      try {
+        await client.getCollection(name);
+      } catch {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      await client.deleteCollection(name);
+      logger3.info("Collection dropped", { name });
+      return ok(void 0);
+    },
+    async exists(name) {
+      logger3.debug("Checking collection exists", { name });
+      try {
+        await client.getCollection(name);
+        return ok(true);
+      } catch {
+        return ok(false);
+      }
+    },
+    async info(name) {
+      logger3.debug("Getting collection info", { name });
+      let collectionInfo;
+      try {
+        collectionInfo = await client.getCollection(name);
+      } catch {
+        return err(HaiVecdbError.COLLECTION_NOT_FOUND, vecdbM("vecdb_collectionNotFound", { params: { name } }));
+      }
+      const vectorsConfig = collectionInfo.config?.params?.vectors;
+      const dimension = vectorsConfig?.size ?? 0;
+      const qdrantDistance = vectorsConfig?.distance ?? "Cosine";
+      const metric = qdrantDistance === "Euclid" ? "euclidean" : qdrantDistance === "Dot" ? "dot" : "cosine";
+      return ok({
+        name,
+        dimension,
+        metric,
+        count: collectionInfo.points_count ?? 0
+      });
+    },
+    async list() {
+      logger3.debug("Listing collections");
+      const collections = await client.getCollections();
+      const names = collections.collections.map((c) => c.name);
+      return ok(names);
+    }
+  };
+  const vectorDriver = {
+    async insert(collection, documents) {
+      logger3.debug("Inserting vectors", { collection, count: documents.length });
+      const points = documents.map((doc) => ({
+        id: hashToUuid(doc.id),
+        vector: doc.vector,
+        payload: {
+          _id: doc.id,
+          content: doc.content ?? "",
+          ...doc.metadata
+        }
+      }));
+      await client.upsert(collection, { points });
+      logger3.info("Vectors inserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async upsert(collection, documents) {
+      logger3.debug("Upserting vectors", { collection, count: documents.length });
+      const points = documents.map((doc) => ({
+        id: hashToUuid(doc.id),
+        vector: doc.vector,
+        payload: {
+          _id: doc.id,
+          content: doc.content ?? "",
+          ...doc.metadata
+        }
+      }));
+      await client.upsert(collection, { points });
+      logger3.info("Vectors upserted", { collection, count: documents.length });
+      return ok(void 0);
+    },
+    async delete(collection, ids) {
+      logger3.debug("Deleting vectors", { collection, count: ids.length });
+      const uuids = ids.map(hashToUuid);
+      await client.delete(collection, { points: uuids });
+      logger3.info("Vectors deleted", { collection, count: ids.length });
+      return ok(void 0);
+    },
+    async search(collection, vector, options) {
+      const topK = options?.topK ?? 10;
+      const minScore = options?.minScore ?? 0;
+      logger3.debug("Searching vectors", { collection, topK, hasFilter: !!options?.filter });
+      let filter;
+      if (options?.filter && Object.keys(options.filter).length > 0) {
+        const mustConditions = Object.entries(options.filter).map(([key, value]) => ({
+          key,
+          match: { value }
+        }));
+        filter = { must: mustConditions };
+      }
+      const searchResult = await client.search(collection, {
+        vector,
+        limit: topK,
+        score_threshold: minScore > 0 ? minScore : void 0,
+        filter,
+        with_payload: true
+      });
+      const results = searchResult.map((point) => {
+        const payload = point.payload ?? {};
+        const { _id, content, ...metadata } = payload;
+        return {
+          id: _id ?? "",
+          score: point.score,
+          content: content || void 0,
+          metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+        };
+      });
+      return ok(results);
+    },
+    async count(collection) {
+      logger3.debug("Counting vectors", { collection });
+      const info = await client.getCollection(collection);
+      return ok(info.points_count ?? 0);
+    }
+  };
+  return {
+    name: "qdrant",
+    async connect(cfg) {
+      if (cfg.type !== "qdrant") {
+        return err(HaiVecdbError.UNSUPPORTED_TYPE, vecdbM("vecdb_unsupportedType", { params: { type: cfg.type } }));
+      }
+      const qdrantConfig = cfg;
+      try {
+        const { QdrantClient: QdrantClientClass } = await import('@qdrant/js-client-rest');
+        const qdrantClient = new QdrantClientClass({
+          url: qdrantConfig.url,
+          apiKey: qdrantConfig.apiKey
+        });
+        await qdrantClient.getCollections();
+        client = qdrantClient;
+        config = qdrantConfig;
+        logger3.info("Qdrant connected", { url: qdrantConfig.url });
+        return ok(void 0);
+      } catch (error) {
+        logger3.error("Failed to connect to Qdrant", { error: error instanceof Error ? error.message : String(error) });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_connectionFailed", { params: { error: String(error) } }), error);
+      }
+    },
+    async close() {
+      client = null;
+      config = null;
+      logger3.info("Qdrant connection closed");
+      return ok(void 0);
+    },
+    isConnected() {
+      return client !== null;
+    },
+    collection: createBaseCollectionOps(ctx, collectionDriver),
+    vector: createBaseVectorOps(ctx, vectorDriver)
+  };
+}
+
+// src/vecdb-main.ts
+var logger4 = core.logger.child({ module: "vecdb", scope: "main" });
+var currentProvider = null;
+var currentConfig = null;
+var initInProgress = false;
+function createProvider(config) {
+  switch (config.type) {
+    case "lancedb":
+      return createLancedbProvider();
+    case "pgvector":
+      return createPgvectorProvider();
+    case "qdrant":
+      return createQdrantProvider();
+  }
+}
+var notInitialized = core.module.createNotInitializedKit(
+  HaiVecdbError.NOT_INITIALIZED,
+  () => vecdbM("vecdb_notInitialized")
+);
+var notInitializedCollection = notInitialized.proxy();
+var notInitializedVector = notInitialized.proxy();
+var vecdb = {
+  /**
+   * 初始化向量数据库连接
+   *
+   * @param config - 向量数据库配置（允许部分字段，内部会补齐默认值）
+   * @returns 初始化结果，失败时包含错误信息
+   */
+  async init(config) {
+    if (initInProgress) {
+      logger4.warn("Vecdb init already in progress, skipping concurrent call");
+      return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_initInProgress"));
+    }
+    initInProgress = true;
+    try {
+      if (currentProvider) {
+        logger4.warn("Vecdb module is already initialized, reinitializing");
+        await vecdb.close();
+      }
+      logger4.info("Initializing vecdb module");
+      const parseResult = VecdbConfigSchema.safeParse(config);
+      if (!parseResult.success) {
+        logger4.error("Vecdb config validation failed", { error: parseResult.error.message });
+        return err(HaiVecdbError.CONFIG_ERROR, vecdbM("vecdb_configError", { params: { error: parseResult.error.message } }), parseResult.error);
+      }
+      const parsed = parseResult.data;
+      try {
+        const provider = createProvider(parsed);
+        const connectResult = await provider.connect(parsed);
+        if (!connectResult.success) {
+          logger4.error("Vecdb module initialization failed", {
+            code: connectResult.error.code,
+            message: connectResult.error.message
+          });
+          return connectResult;
+        }
+        currentProvider = provider;
+        currentConfig = parsed;
+        logger4.info("Vecdb module initialized", { type: parsed.type });
+        return ok(void 0);
+      } catch (error) {
+        logger4.error("Vecdb module initialization failed", { error });
+        return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_initFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error);
+      }
+    } finally {
+      initInProgress = false;
+    }
+  },
+  /**
+   * 获取集合管理操作接口
+   *
+   * 未初始化时返回占位对象（所有调用返回 NOT_INITIALIZED）。
+   */
+  get collection() {
+    return currentProvider?.collection ?? notInitializedCollection;
+  },
+  /**
+   * 获取向量操作接口
+   *
+   * 未初始化时返回占位对象（所有调用返回 NOT_INITIALIZED）。
+   */
+  get vector() {
+    return currentProvider?.vector ?? notInitializedVector;
+  },
+  /** 获取当前配置（未初始化时为 null） */
+  get config() {
+    return currentConfig;
+  },
+  /** 检查是否已初始化 */
+  get isInitialized() {
+    return currentProvider !== null && currentProvider.isConnected();
+  },
+  /**
+   * 关闭向量数据库连接
+   *
+   * 多次调用安全，未初始化时直接返回。
+   */
+  async close() {
+    if (!currentProvider) {
+      currentConfig = null;
+      logger4.info("Vecdb module already closed, skipping");
+      return ok(void 0);
+    }
+    logger4.info("Closing vecdb module");
+    try {
+      const closeResult = await currentProvider.close();
+      if (!closeResult.success) {
+        logger4.error("Vecdb module close failed", { code: closeResult.error.code, message: closeResult.error.message });
+        return closeResult;
+      }
+      logger4.info("Vecdb module closed");
+      return ok(void 0);
+    } catch (error) {
+      logger4.error("Vecdb module close failed", { error });
+      return err(HaiVecdbError.CONNECTION_FAILED, vecdbM("vecdb_closeFailed", { params: { error: error instanceof Error ? error.message : String(error) } }), error);
+    } finally {
+      currentProvider = null;
+      currentConfig = null;
+    }
+  }
+};
+
+export { DistanceMetricSchema, HaiVecdbError, LancedbConfigSchema, PgvectorConfigSchema, PgvectorIndexTypeSchema, QdrantConfigSchema, VecdbConfigSchema, VecdbTypeSchema, vecdb };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map