chattercatcher 0.1.8 → 0.1.10

package/dist/cli.js

@@ -1,160 +1,14 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/config/paths.ts
-import os2 from "os";
-import path2 from "path";
-function getChatterCatcherHome() {
-  return process.env.CHATTERCATCHER_HOME || path2.join(os2.homedir(), ".chattercatcher");
-}
-function resolveHomePath(value) {
-  if (value === "~") {
-    return os2.homedir();
-  }
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path2.join(os2.homedir(), value.slice(2));
-  }
-  return path2.resolve(value);
-}
-function getConfigPath() {
-  return path2.join(getChatterCatcherHome(), "config.json");
-}
-function getSecretsPath() {
-  return path2.join(getChatterCatcherHome(), "secrets.json");
-}
-var init_paths = __esm({
-  "src/config/paths.ts"() {
-    "use strict";
-  }
-});
-
-// src/rag/lancedb-store.ts
-var lancedb_store_exports = {};
-__export(lancedb_store_exports, {
-  LanceDbVectorStore: () => LanceDbVectorStore,
-  getLanceDbPath: () => getLanceDbPath
-});
-import fs6 from "fs/promises";
-import path9 from "path";
-function getLanceDbPath(config) {
-  return path9.join(resolveHomePath(config.storage.dataDir), "vector", "lancedb");
-}
-function toRow(record) {
-  return {
-    id: record.id,
-    vector: record.vector,
-    text: record.evidence.text,
-    source_json: JSON.stringify(record.evidence.source)
-  };
-}
-function toLanceData(rows) {
-  return rows.map((row) => ({
-    id: row.id,
-    vector: row.vector,
-    text: row.text,
-    source_json: row.source_json
-  }));
-}
-function escapeSqlString(value) {
-  return value.replace(/'/g, "''");
-}
-function toEvidence(row) {
-  const distance = row._distance ?? 0;
-  const vectorScore = 1 / (1 + Math.max(0, distance));
-  return {
-    id: row.id,
-    text: row.text,
-    score: vectorScore,
-    vectorScore,
-    source: JSON.parse(row.source_json)
-  };
-}
-var DEFAULT_TABLE_NAME, LanceDbVectorStore;
-var init_lancedb_store = __esm({
-  "src/rag/lancedb-store.ts"() {
-    "use strict";
-    init_paths();
-    DEFAULT_TABLE_NAME = "message_chunks";
-    LanceDbVectorStore = class _LanceDbVectorStore {
-      constructor(connection, tableName) {
-        this.connection = connection;
-        this.tableName = tableName;
-      }
-      connection;
-      tableName;
-      static async connect(uri, tableName = DEFAULT_TABLE_NAME) {
-        await fs6.mkdir(uri, { recursive: true });
-        const lancedb = await import("@lancedb/lancedb");
-        const connection = await lancedb.connect(uri);
-        return new _LanceDbVectorStore(connection, tableName);
-      }
-      static async connectFromConfig(config, tableName = DEFAULT_TABLE_NAME) {
-        return _LanceDbVectorStore.connect(getLanceDbPath(config), tableName);
-      }
-      close() {
-        this.connection.close();
-      }
-      async upsert(records) {
-        if (records.length === 0) {
-          return;
-        }
-        const rows = records.map(toRow);
-        const data2 = toLanceData(rows);
-        const table = await this.ensureTable(data2);
-        const ids = rows.map((row) => `'${escapeSqlString(row.id)}'`).join(", ");
-        await table.delete(`id IN (${ids})`);
-        await table.add(data2);
-      }
-      async search(vector, limit) {
-        const table = await this.openTableIfExists();
-        if (!table) {
-          return [];
-        }
-        const rows = await table.vectorSearch(vector).limit(limit).toArray();
-        return rows.map(toEvidence);
-      }
-      async count() {
-        const table = await this.openTableIfExists();
-        if (!table) {
-          return 0;
-        }
-        return table.countRows();
-      }
-      async ensureTable(initialRows) {
-        const table = await this.openTableIfExists();
-        if (table) {
-          return table;
-        }
-        return this.connection.createTable(this.tableName, initialRows);
-      }
-      async openTableIfExists() {
-        const tableNames = await this.connection.tableNames();
-        if (!tableNames.includes(this.tableName)) {
-          return null;
-        }
-        return this.connection.openTable(this.tableName);
-      }
-    };
-  }
-});
 
 // src/cli.ts
 import { input, password, select, confirm, number } from "@inquirer/prompts";
 import { Command } from "commander";
-import fs14 from "fs/promises";
+import fs13 from "fs/promises";
 
 // package.json
 var package_default = {
   name: "chattercatcher",
-  version: "0.1.8",
+  version: "0.1.9",
   description: "\u672C\u5730\u4F18\u5148\u7684\u98DE\u4E66/Lark \u5BB6\u5EAD\u7FA4\u77E5\u8BC6\u5E93\u673A\u5668\u4EBA",
   type: "module",
   main: "dist/index.js",
@@ -198,7 +52,6 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.4.2",
-    "@lancedb/lancedb": "0.23.0",
     "@larksuiteoapi/node-sdk": "^1.62.0",
     "better-sqlite3": "^12.9.0",
     commander: "^14.0.3",
@@ -287,8 +140,29 @@ function createDefaultSecrets() {
   });
 }
 
+// src/config/paths.ts
+import os2 from "os";
+import path2 from "path";
+function getChatterCatcherHome() {
+  return process.env.CHATTERCATCHER_HOME || path2.join(os2.homedir(), ".chattercatcher");
+}
+function resolveHomePath(value) {
+  if (value === "~") {
+    return os2.homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path2.join(os2.homedir(), value.slice(2));
+  }
+  return path2.resolve(value);
+}
+function getConfigPath() {
+  return path2.join(getChatterCatcherHome(), "config.json");
+}
+function getSecretsPath() {
+  return path2.join(getChatterCatcherHome(), "secrets.json");
+}
+
 // src/config/store.ts
-init_paths();
 async function readJsonFile(filePath, fallback) {
   try {
     const raw = await fs.readFile(filePath, "utf8");
@@ -351,11 +225,7 @@ function resolveEmbeddingApiKey(input2) {
   return explicit || input2.llmApiKey;
 }
 
-// src/cli.ts
-init_paths();
-
 // src/data/deletion.ts
-init_paths();
 import fs2 from "fs/promises";
 import path4 from "path";
 function emptyResult(targetType, targetId) {
@@ -481,7 +351,6 @@ async function deleteLocalData(input2) {
 }
 
 // src/db/database.ts
-init_paths();
 import Database from "better-sqlite3";
 import fs3 from "fs";
 import path5 from "path";
@@ -542,6 +411,18 @@ function migrateDatabase(database) {
       tokenize = 'unicode61'
     );
 
+    CREATE TABLE IF NOT EXISTS message_chunk_embeddings (
+      chunk_id TEXT NOT NULL REFERENCES message_chunks(id) ON DELETE CASCADE,
+      model TEXT NOT NULL,
+      dimension INTEGER NOT NULL,
+      embedding_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (chunk_id, model)
+    );
+
+    CREATE INDEX IF NOT EXISTS message_chunk_embeddings_model_idx
+    ON message_chunk_embeddings(model, dimension);
+
     CREATE TABLE IF NOT EXISTS file_jobs (
       id TEXT PRIMARY KEY,
       source_path TEXT NOT NULL,
@@ -561,8 +442,7 @@ function migrateDatabase(database) {
 }
 
 // src/doctor/checks.ts
-init_paths();
-import fs7 from "fs/promises";
+import fs6 from "fs/promises";
 
 // src/files/jobs.ts
 import crypto from "crypto";
@@ -704,12 +584,10 @@ var FileJobRepository = class {
 };
 
 // src/gateway/runtime.ts
-init_paths();
 import fs5 from "fs";
 import path8 from "path";
 
 // src/logs/reader.ts
-init_paths();
 import fs4 from "fs/promises";
 import { watch } from "fs";
 import path7 from "path";
@@ -1458,6 +1336,119 @@ var MessageFtsRetriever = class {
   }
 };
 
+// src/rag/embedding.ts
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || right.length === 0 || left.length !== right.length) {
+    return 0;
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index2 = 0; index2 < left.length; index2 += 1) {
+    const leftValue = left[index2] ?? 0;
+    const rightValue = right[index2] ?? 0;
+    dot += leftValue * rightValue;
+    leftNorm += leftValue * leftValue;
+    rightNorm += rightValue * rightValue;
+  }
+  if (leftNorm === 0 || rightNorm === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+
+// src/rag/sqlite-vector-store.ts
+function parseEmbeddingJson(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "number") ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function toEvidenceSource2(row) {
+  return {
+    type: "message",
+    label: row.chatName,
+    sender: row.senderName,
+    timestamp: row.sentAt
+  };
+}
+var SqliteVectorStore = class {
+  constructor(database, options) {
+    this.database = database;
+    this.options = options;
+  }
+  database;
+  options;
+  async upsert(records) {
+    if (records.length === 0) {
+      return;
+    }
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const statement = this.database.prepare(`
+      INSERT INTO message_chunk_embeddings (chunk_id, model, dimension, embedding_json, updated_at)
+      VALUES (@chunkId, @model, @dimension, @embeddingJson, @updatedAt)
+      ON CONFLICT(chunk_id, model)
+      DO UPDATE SET
+        dimension = excluded.dimension,
+        embedding_json = excluded.embedding_json,
+        updated_at = excluded.updated_at
+    `);
+    const transaction = this.database.transaction((input2) => {
+      for (const record of input2) {
+        statement.run({
+          chunkId: record.id,
+          model: this.options.model,
+          dimension: record.vector.length,
+          embeddingJson: JSON.stringify(record.vector),
+          updatedAt
+        });
+      }
+    });
+    transaction(records);
+  }
+  async search(vector, limit) {
+    if (limit <= 0) {
+      return [];
+    }
+    const rows = this.database.prepare(
+      `
+        SELECT
+          mc.id AS chunkId,
+          mc.text AS text,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt,
+          e.embedding_json AS embeddingJson
+        FROM message_chunk_embeddings e
+        JOIN message_chunks mc ON mc.id = e.chunk_id
+        JOIN messages m ON m.id = mc.message_id
+        JOIN chats c ON c.id = m.chat_id
+        WHERE e.model = ?
+      `
+    ).all(this.options.model);
+    return rows.flatMap((row) => {
+      const storedVector = parseEmbeddingJson(row.embeddingJson);
+      if (storedVector.length === 0) {
+        return [];
+      }
+      const vectorScore = cosineSimilarity(vector, storedVector);
+      return {
+        id: row.chunkId,
+        text: row.text,
+        score: vectorScore,
+        vectorScore,
+        source: toEvidenceSource2(row)
+      };
+    }).sort((left, right) => right.vectorScore - left.vectorScore).slice(0, limit);
+  }
+  count() {
+    const row = this.database.prepare("SELECT COUNT(*) AS count FROM message_chunk_embeddings WHERE model = ?").get(this.options.model);
+    return row.count;
+  }
+};
+
 // src/rag/vector-retriever.ts
 var VectorRetriever = class {
   constructor(embedding, store, limit = 8) {
@@ -1482,10 +1473,10 @@ async function createHybridRetriever(input2) {
   const retrievers = [new MessageFtsRetriever(input2.messages, { excludeMessageIds: input2.excludeMessageIds })];
   const closers = [];
   if (hasEmbeddingConfig(input2.config, input2.secrets)) {
-    const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
-    const vectorStore = await LanceDbVectorStore2.connectFromConfig(input2.config);
+    const vectorStore = new SqliteVectorStore(input2.database, {
+      model: input2.config.embedding.model
+    });
     retrievers.push(new VectorRetriever(createEmbeddingModel(input2.config, input2.secrets), vectorStore));
-    closers.push(() => vectorStore.close());
   }
   return {
     retriever: new HybridRetriever(retrievers),
@@ -1515,7 +1506,7 @@ async function runDoctor(config, secrets, options = {}) {
   checks.push(checkEmbeddingConfig(config, secrets));
   checks.push(await checkSqlite(config));
   checks.push(await checkFilePipeline(config));
-  checks.push(await checkLanceDb(config));
+  checks.push(await checkSqliteVectorIndex(config));
   checks.push(checkRagPolicy());
   if (options.online) {
     checks.push(await checkChatModel(config, secrets));
@@ -1526,8 +1517,8 @@ async function runDoctor(config, secrets, options = {}) {
 async function checkHomeDirectory() {
   const home = getChatterCatcherHome();
   try {
-    await fs7.mkdir(home, { recursive: true });
-    await fs7.access(home);
+    await fs6.mkdir(home, { recursive: true });
+    await fs6.access(home);
     return pass("\u914D\u7F6E\u76EE\u5F55", home);
   } catch (error) {
     return fail("\u914D\u7F6E\u76EE\u5F55", error instanceof Error ? error.message : String(error));
@@ -1548,7 +1539,7 @@ function checkLlmConfig(config, secrets) {
 }
 function checkEmbeddingConfig(config, secrets) {
   if (!hasEmbeddingConfig(config, secrets)) {
-    return warn("Embedding \u914D\u7F6E", "\u672A\u914D\u7F6E\u5B8C\u6574\uFF1BRAG \u4F1A\u4F7F\u7528 SQLite FTS\uFF0C\u65E0\u6CD5\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\u3002");
+    return warn("Embedding \u914D\u7F6E", "\u672A\u914D\u7F6E\u5B8C\u6574\uFF1BRAG \u4F1A\u4F7F\u7528 SQLite FTS\uFF0C\u65E0\u6CD5\u542F\u7528 SQLite embedding \u8BED\u4E49\u68C0\u7D22\u3002");
   }
   return pass("Embedding \u914D\u7F6E", `${config.embedding.model} @ ${config.embedding.baseUrl || config.llm.baseUrl}`);
 }
@@ -1582,17 +1573,22 @@ async function checkFilePipeline(config) {
     database?.close();
   }
 }
-async function checkLanceDb(config) {
-  let store = null;
+async function checkSqliteVectorIndex(config) {
+  let database = null;
   try {
-    const { getLanceDbPath: getLanceDbPath2, LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
-    store = await LanceDbVectorStore2.connectFromConfig(config);
-    const count = await store.count();
-    return pass("LanceDB", `${getLanceDbPath2(config)}\uFF1Bvectors=${count}`);
+    database = openDatabase(config);
+    const defaultModel = config.embedding.model || "default";
+    const vectorStore = new SqliteVectorStore(database, { model: defaultModel });
+    const vectors = vectorStore.count();
+    const availableModels = database.prepare("SELECT COUNT(DISTINCT model) AS count FROM message_chunk_embeddings").get();
+    return pass(
+      "SQLite embedding \u5411\u91CF\u7D22\u5F15",
+      `${getDatabasePath(config)}\uFF1Bvectors=${vectors}\uFF1Bmodels=${availableModels.count}${config.embedding.model ? `\uFF1Bactive_model=${config.embedding.model}` : "\uFF1Bactive_model=\u672A\u914D\u7F6E"}`
+    );
   } catch (error) {
-    return fail("LanceDB", error instanceof Error ? error.message : String(error));
+    return fail("SQLite embedding \u5411\u91CF\u7D22\u5F15", error instanceof Error ? error.message : String(error));
   } finally {
-    store?.close();
+    database?.close();
   }
 }
 function checkRagPolicy() {
@@ -1633,9 +1629,8 @@ function formatDoctorChecks(checks) {
 }
 
 // src/export/data-export.ts
-init_paths();
-import fs8 from "fs/promises";
-import path10 from "path";
+import fs7 from "fs/promises";
+import path9 from "path";
 function parseJsonObject(value) {
   try {
     const parsed = JSON.parse(value);
@@ -1654,11 +1649,11 @@ function parseJsonArray(value) {
 }
 function defaultExportPath(config, exportedAt) {
   const fileName = `chattercatcher-export-${exportedAt.replace(/[:.]/g, "-")}.json`;
-  return path10.join(resolveHomePath(config.storage.dataDir), "exports", fileName);
+  return path9.join(resolveHomePath(config.storage.dataDir), "exports", fileName);
 }
 async function exportLocalData(input2) {
   const exportedAt = input2.exportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const outputPath = path10.resolve(input2.outputPath ?? defaultExportPath(input2.config, exportedAt));
+  const outputPath = path9.resolve(input2.outputPath ?? defaultExportPath(input2.config, exportedAt));
   const chats = input2.database.prepare(
     `
       SELECT
@@ -1745,8 +1740,8 @@ async function exportLocalData(input2) {
       fileJobs
     }
   };
-  await fs8.mkdir(path10.dirname(outputPath), { recursive: true });
-  await fs8.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}
+  await fs7.mkdir(path9.dirname(outputPath), { recursive: true });
+  await fs7.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return {
     outputPath,
@@ -1758,8 +1753,8 @@ async function exportLocalData(input2) {
 }
 
 // src/export/data-restore.ts
-import fs9 from "fs/promises";
-import path11 from "path";
+import fs8 from "fs/promises";
+import path10 from "path";
 function asObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -1807,8 +1802,8 @@ function clearDatabase(database) {
   database.prepare("DELETE FROM chats").run();
 }
 async function restoreLocalData(input2) {
-  const inputPath = path11.resolve(input2.inputPath);
-  const payload = parsePayload(await fs9.readFile(inputPath, "utf8"));
+  const inputPath = path10.resolve(input2.inputPath);
+  const payload = parsePayload(await fs8.readFile(inputPath, "utf8"));
   const mode = input2.replace ? "replace" : "merge";
   const restore = input2.database.transaction(() => {
     if (input2.replace) {
@@ -2190,6 +2185,7 @@ var FeishuQuestionHandler = class {
     const { retriever, close } = await createHybridRetriever({
       config: this.options.config,
       secrets: this.options.secrets,
+      database: this.options.database,
       messages: new MessageRepository(this.options.database),
       excludeMessageIds: options.excludeMessageIds
     });
@@ -2400,10 +2396,9 @@ function createFeishuGateway(options) {
 }
 
 // src/feishu/resource-downloader.ts
-init_paths();
 import * as lark3 from "@larksuiteoapi/node-sdk";
-import fs10 from "fs/promises";
-import path12 from "path";
+import fs9 from "fs/promises";
+import path11 from "path";
 var RESOURCE_TYPE_BY_KIND = {
   file: "file",
   image: "image",
@@ -2441,10 +2436,10 @@ var FeishuResourceDownloader = class _FeishuResourceDownloader {
   }
   async download(input2) {
     const resourceType = RESOURCE_TYPE_BY_KIND[input2.attachment.kind];
-    const targetDir = path12.join(this.dataDir, "files", "feishu");
-    await fs10.mkdir(targetDir, { recursive: true });
+    const targetDir = path11.join(this.dataDir, "files", "feishu");
+    await fs9.mkdir(targetDir, { recursive: true });
     const fileName = buildStoredFileName(input2);
-    const storedPath = path12.join(targetDir, fileName);
+    const storedPath = path11.join(targetDir, fileName);
     const payload = {
       params: { type: resourceType },
       path: { message_id: input2.messageId, file_key: input2.attachment.fileKey }
@@ -2466,31 +2461,30 @@ var FeishuResourceDownloader = class _FeishuResourceDownloader {
 };
 
 // src/files/ingest.ts
-init_paths();
 import crypto3 from "crypto";
-import fs12 from "fs/promises";
-import path14 from "path";
-
-// src/files/parser.ts
 import fs11 from "fs/promises";
 import path13 from "path";
+
+// src/files/parser.ts
+import fs10 from "fs/promises";
+import path12 from "path";
 import mammoth from "mammoth";
 import { PDFParse } from "pdf-parse";
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".txt", ".md", ".markdown", ".json", ".csv", ".tsv", ".log"]);
 var DOCX_EXTENSIONS = /* @__PURE__ */ new Set([".docx"]);
 var PDF_EXTENSIONS = /* @__PURE__ */ new Set([".pdf"]);
 function isSupportedParseFile(filePath) {
-  const extension = path13.extname(filePath).toLowerCase();
+  const extension = path12.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(extension) || DOCX_EXTENSIONS.has(extension) || PDF_EXTENSIONS.has(extension);
 }
 function describeSupportedParseTypes() {
   return "txt\u3001md\u3001json\u3001csv\u3001tsv\u3001log\u3001docx\u3001pdf";
 }
 async function parseFileToText(filePath) {
-  const extension = path13.extname(filePath).toLowerCase();
+  const extension = path12.extname(filePath).toLowerCase();
   if (TEXT_EXTENSIONS.has(extension)) {
     return {
-      text: await fs11.readFile(filePath, "utf8"),
+      text: await fs10.readFile(filePath, "utf8"),
       parser: "text",
       warnings: []
     };
@@ -2504,7 +2498,7 @@ async function parseFileToText(filePath) {
     };
   }
   if (PDF_EXTENSIONS.has(extension)) {
-    const buffer = await fs11.readFile(filePath);
+    const buffer = await fs10.readFile(filePath);
     const parser = new PDFParse({ data: buffer });
     try {
       const result = await parser.getText();
@@ -2526,7 +2520,7 @@ function isSupportedTextFile(filePath) {
 }
 function ensureSupportedTextFile(filePath) {
   if (!isSupportedTextFile(filePath)) {
-    const extension = path14.extname(filePath).toLowerCase();
+    const extension = path13.extname(filePath).toLowerCase();
     throw new Error(`\u6682\u4E0D\u652F\u6301\u8BE5\u6587\u4EF6\u7C7B\u578B\uFF1A${extension || "\u65E0\u6269\u5C55\u540D"}\u3002\u5F53\u524D\u652F\u6301 ${describeSupportedParseTypes()}\u3002`);
   }
 }
@@ -2535,12 +2529,12 @@ function stableStoredName(sourcePath, fileName) {
   return `${digest}-${fileName}`;
 }
 async function ingestLocalFile(input2) {
-  const sourcePath = path14.resolve(input2.filePath);
-  const fileName = path14.basename(sourcePath);
+  const sourcePath = path13.resolve(input2.filePath);
+  const fileName = path13.basename(sourcePath);
   const jobId = input2.jobs?.start({ sourcePath, fileName });
   try {
     ensureSupportedTextFile(sourcePath);
-    const stat = await fs12.stat(sourcePath);
+    const stat = await fs11.stat(sourcePath);
     if (!stat.isFile()) {
       throw new Error(`\u4E0D\u662F\u6587\u4EF6\uFF1A${sourcePath}`);
     }
@@ -2549,10 +2543,10 @@ async function ingestLocalFile(input2) {
     if (!text) {
       throw new Error(`\u6587\u4EF6\u6CA1\u6709\u53EF\u7D22\u5F15\u6587\u672C\uFF1A${sourcePath}`);
     }
-    const fileDir = path14.join(resolveHomePath(input2.config.storage.dataDir), "files");
-    await fs12.mkdir(fileDir, { recursive: true });
-    const storedPath = path14.join(fileDir, stableStoredName(sourcePath, fileName));
-    await fs12.copyFile(sourcePath, storedPath);
+    const fileDir = path13.join(resolveHomePath(input2.config.storage.dataDir), "files");
+    await fs11.mkdir(fileDir, { recursive: true });
+    const storedPath = path13.join(fileDir, stableStoredName(sourcePath, fileName));
+    await fs11.copyFile(sourcePath, storedPath);
     const messageId = input2.messages.ingest({
       platform: "local-file",
       platformChatId: "local-files",
@@ -2835,8 +2829,9 @@ var GatewayIngestor = class {
 
 // src/gateway/detached.ts
 import { spawn } from "child_process";
-import fs13 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path14 from "path";
+var START_FAILURE_GRACE_MS = 250;
 function buildGatewayForegroundSpawnCommand(argv = process.argv) {
   const [command = process.execPath, ...rawArgs] = argv;
   const args = [...rawArgs];
@@ -2851,7 +2846,37 @@ function buildGatewayForegroundSpawnCommand(argv = process.argv) {
     args: [...args, "gateway", "start", "--foreground"]
   };
 }
-function startDetachedGateway(input2) {
+function describeImmediateChildFailure(event) {
+  if (event.type === "error") {
+    return event.error.message;
+  }
+  return event.signal ? `signal=${event.signal}` : `exitCode=${event.code ?? "unknown"}`;
+}
+function waitForImmediateChildFailure(child, graceMs = START_FAILURE_GRACE_MS) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const cleanup = () => {
+      clearTimeout(timer);
+      child.off("error", onError);
+      child.off("exit", onExit);
+    };
+    const settle = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    const onError = (error) => settle({ type: "error", error });
+    const onExit = (code, signal) => settle({ type: "exit", code, signal });
+    child.once("error", onError);
+    child.once("exit", onExit);
+    timer = setTimeout(() => settle(null), graceMs);
+  });
+}
+async function startDetachedGateway(input2) {
   const status = getGatewayStatus(input2.config, input2.secrets);
   const logFile = getGatewayLogPath();
   if (status.connection === "running") {
@@ -2862,7 +2887,7 @@ function startDetachedGateway(input2) {
       ...status.pid ? { pid: status.pid } : {}
     };
   }
-  fs13.mkdirSync(path15.dirname(logFile), { recursive: true });
+  fs12.mkdirSync(path14.dirname(logFile), { recursive: true });
   let out;
   let err;
   let stdioClosed = false;
@@ -2872,22 +2897,31 @@ function startDetachedGateway(input2) {
     }
     stdioClosed = true;
     if (typeof out === "number") {
-      fs13.closeSync(out);
+      fs12.closeSync(out);
     }
     if (typeof err === "number") {
-      fs13.closeSync(err);
+      fs12.closeSync(err);
     }
   };
   try {
-    out = fs13.openSync(logFile, "a");
-    err = fs13.openSync(logFile, "a");
+    out = fs12.openSync(logFile, "a");
+    err = fs12.openSync(logFile, "a");
     const foreground = buildGatewayForegroundSpawnCommand(input2.argv);
     const child = spawn(foreground.command, foreground.args, {
       detached: true,
       stdio: ["ignore", out, err],
       windowsHide: true
     });
+    const immediateFailure = await waitForImmediateChildFailure(child);
     closeStdio();
+    if (immediateFailure) {
+      return {
+        started: false,
+        message: `\u98DE\u4E66 Gateway \u542F\u52A8\u5931\u8D25\uFF1A${describeImmediateChildFailure(immediateFailure)}\u3002\u8BF7\u67E5\u770B\u65E5\u5FD7\uFF1A${logFile}`,
+        pid: child.pid,
+        logFile
+      };
+    }
     child.unref();
     return {
       started: true,
@@ -2921,7 +2955,7 @@ async function indexMessageChunks(input2) {
         id: chunk.chunkId,
         text: chunk.text,
         score: 1,
-        source: toEvidenceSource2(chunk)
+        source: toEvidenceSource3(chunk)
       }
     });
   }
@@ -2931,7 +2965,7 @@ async function indexMessageChunks(input2) {
     vectors: records.length
   };
 }
-function toEvidenceSource2(chunk) {
+function toEvidenceSource3(chunk) {
   if (chunk.messageType === "file") {
     return {
       type: "file",
@@ -2960,25 +2994,23 @@ async function processMessagesNow(input2) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
-  const vectorStore = await LanceDbVectorStore2.connectFromConfig(input2.config);
-  try {
-    const stats = await indexMessageChunks({
-      messages: new MessageRepository(input2.database),
-      embedding: createEmbeddingModel(input2.config, input2.secrets),
-      store: vectorStore,
-      limit: input2.limit
-    });
-    return {
-      status: "completed",
-      chunks: stats.chunks,
-      vectors: stats.vectors,
-      startedAt,
-      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } finally {
-    vectorStore.close();
-  }
+  const vectorStore = new SqliteVectorStore(input2.database, {
+    model: input2.config.embedding.model
+  });
+  const embedding = input2.embedding ?? createEmbeddingModel(input2.config, input2.secrets);
+  const stats = await indexMessageChunks({
+    messages: new MessageRepository(input2.database),
+    embedding,
+    store: vectorStore,
+    limit: input2.limit
+  });
+  return {
+    status: "completed",
+    chunks: stats.chunks,
+    vectors: stats.vectors,
+    startedAt,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
 
 // src/update/npm-updater.ts
@@ -3480,7 +3512,7 @@ function createWebApp(config) {
       note: "\u95EE\u7B54\u5FC5\u987B\u5148\u68C0\u7D22\u8BC1\u636E\uFF0C\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0\u3002",
       retrieval: {
         keyword: "SQLite FTS5",
-        vector: "LanceDB",
+        vector: "SQLite embedding",
         hybrid: true
       }
     },
@@ -3688,8 +3720,7 @@ async function startGatewayForegroundCommand() {
     mode: "gateway"
   });
   const database = openDatabase(config);
-  const { LanceDbVectorStore: LanceDbVectorStore2 } = hasEmbeddingConfig(config, secrets) ? await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports)) : { LanceDbVectorStore: null };
-  const vectorStore = LanceDbVectorStore2 ? await LanceDbVectorStore2.connectFromConfig(config) : null;
+  const vectorStore = hasEmbeddingConfig(config, secrets) ? new SqliteVectorStore(database, { model: config.embedding.model }) : null;
   const gatewayRuntime = createFeishuGateway({
     config,
     secrets,
@@ -3711,7 +3742,6 @@ async function startGatewayForegroundCommand() {
   });
   const cleanup = () => {
     gatewayRuntime.stop();
-    vectorStore?.close();
     database.close();
     removeGatewayPidRecord();
   };
@@ -3739,7 +3769,7 @@ async function startGatewayCommand(options = {}) {
   }
   const config = await loadConfig();
   const secrets = await loadSecrets();
-  const result = startDetachedGateway({ config, secrets });
+  const result = await startDetachedGateway({ config, secrets });
   console.log(result.message);
   if (result.pid) {
     console.log(`PID\uFF1A${result.pid}`);
@@ -3789,7 +3819,7 @@ async function deleteDataCommand(targetType, targetId, options) {
     if (result.skippedStoredFiles.length > 0) {
       console.log(`\u8DF3\u8FC7\u975E\u6570\u636E\u76EE\u5F55\u6587\u4EF6\uFF1A${result.skippedStoredFiles.join("\uFF1B")}`);
     }
-    console.log("SQLite FTS \u5DF2\u540C\u6B65\u5220\u9664\uFF1B\u5982\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
+    console.log("SQLite FTS \u5DF2\u540C\u6B65\u5220\u9664\uFF1B\u5982\u4F7F\u7528 SQLite embedding \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
   } finally {
     database.close();
   }
@@ -3803,55 +3833,63 @@ index.command("status").description("\u67E5\u770B\u7D22\u5F15\u72B6\u6001").acti
   const config = await loadConfig();
   const secrets = await loadSecrets();
   const database = openDatabase(config);
-  const messages = new MessageRepository(database);
-  const { getLanceDbPath: getLanceDbPath2, LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
-  const vectorStore = await LanceDbVectorStore2.connectFromConfig(config);
-  const vectors = await vectorStore.count();
-  console.log(JSON.stringify(
-    {
-      database: getDatabasePath(config),
-      vectorDatabase: getLanceDbPath2(config),
-      chats: messages.getChatCount(),
-      messages: messages.getMessageCount(),
-      vectors,
-      retrieval: {
-        keyword: "SQLite FTS5",
-        vector: hasEmbeddingConfig(config, secrets) ? "LanceDB \u5DF2\u53EF\u7528\u4E8E\u8BED\u4E49\u68C0\u7D22" : "LanceDB \u5DF2\u63A5\u5165\uFF1B\u9700\u914D\u7F6E embedding \u540E\u542F\u7528\u8BED\u4E49\u68C0\u7D22",
-        hybrid: "\u542F\u7528\uFF1ASQLite FTS + LanceDB Vector",
-        rag: "\u5F3A\u5236\u5148\u68C0\u7D22\u8BC1\u636E\u518D\u56DE\u7B54\uFF0C\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0"
-      }
-    },
-    null,
-    2
-  ));
-  vectorStore.close();
-  database.close();
+  try {
+    const messages = new MessageRepository(database);
+    const vectorStore = new SqliteVectorStore(database, { model: config.embedding.model });
+    const vectors = vectorStore.count();
+    console.log(JSON.stringify(
+      {
+        database: getDatabasePath(config),
+        chats: messages.getChatCount(),
+        messages: messages.getMessageCount(),
+        embeddings: {
+          backend: "SQLite embedding \u5411\u91CF\u7D22\u5F15",
+          configured: hasEmbeddingConfig(config, secrets),
+          model: config.embedding.model,
+          vectors,
+          status: hasEmbeddingConfig(config, secrets) ? "SQLite embedding \u5411\u91CF\u7D22\u5F15\u5DF2\u53EF\u7528\u4E8E\u8BED\u4E49\u68C0\u7D22" : "SQLite embedding \u5411\u91CF\u7D22\u5F15\u5DF2\u63A5\u5165\uFF1B\u9700\u914D\u7F6E embedding \u540E\u542F\u7528\u8BED\u4E49\u68C0\u7D22"
+        },
+        retrieval: {
+          keyword: "SQLite FTS5",
+          vector: "SQLite embedding \u5411\u91CF\u7D22\u5F15",
+          hybrid: "\u542F\u7528\uFF1ASQLite FTS + SQLite embedding \u5411\u91CF\u68C0\u7D22",
+          rag: "\u5F3A\u5236\u5148\u68C0\u7D22\u8BC1\u636E\u518D\u56DE\u7B54\uFF0C\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0"
+        }
+      },
+      null,
+      2
+    ));
+  } finally {
+    database.close();
+  }
 });
-index.command("rebuild").description("\u91CD\u5EFA LanceDB \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u7D22\u5F15\u7684 chunk \u6570", "10000").action(async (options) => {
+index.command("rebuild").description("\u91CD\u5EFA\u8BED\u4E49\u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u7D22\u5F15\u7684 chunk \u6570", "10000").action(async (options) => {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   if (!hasEmbeddingConfig(config, secrets)) {
-    console.log("Embedding \u914D\u7F6E\u4E0D\u5B8C\u6574\uFF0C\u65E0\u6CD5\u91CD\u5EFA\u5411\u91CF\u7D22\u5F15\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002");
+    console.log("Embedding \u914D\u7F6E\u4E0D\u5B8C\u6574\uFF0C\u65E0\u6CD5\u91CD\u5EFA SQLite embedding \u5411\u91CF\u7D22\u5F15\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002");
     return;
   }
   const database = openDatabase(config);
-  const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
-  const vectorStore = await LanceDbVectorStore2.connectFromConfig(config);
+  const limit = Number(options.limit);
   try {
-    const stats = await indexMessageChunks({
-      messages: new MessageRepository(database),
-      embedding: createEmbeddingModel(config, secrets),
-      store: vectorStore,
-      limit: Number(options.limit)
+    const result = await processMessagesNow({
+      config,
+      secrets,
+      database,
+      limit: Number.isFinite(limit) ? limit : 1e4
     });
-    console.log(`\u5411\u91CF\u7D22\u5F15\u5B8C\u6210\uFF1Achunks=${stats.chunks}, vectors=${stats.vectors}`);
+    if (result.status === "skipped") {
+      console.log(`\u5904\u7406\u8DF3\u8FC7\uFF1A${result.reason}`);
+      return;
+    }
+    console.log(`SQLite embedding \u5411\u91CF\u7D22\u5F15\u5B8C\u6210\uFF1Achunks=${result.chunks}, vectors=${result.vectors}`);
   } finally {
-    vectorStore.close();
     database.close();
   }
 });
 var processCommand = program.command("process").description("\u7ACB\u5373\u5904\u7406\u540E\u53F0\u4EFB\u52A1");
-processCommand.command("messages").description("\u7ACB\u5373\u5904\u7406\u6D88\u606F\u7D22\u5F15\u4EFB\u52A1\uFF0C\u628A\u6D88\u606F chunks \u5199\u5165 LanceDB \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u5904\u7406\u7684 chunk \u6570", "10000").action(async (options) => {
+processCommand.command("messages").description("\u7ACB\u5373\u5904\u7406\u6D88\u606F\u7D22\u5F15\u4EFB\u52A1\uFF0C\u628A\u6D88\u606F chunks \u5199\u5165 SQLite embedding \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u5904\u7406\u7684 chunk \u6570", "10000").action(async (options) => {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   const database = openDatabase(config);
@@ -3885,7 +3923,7 @@ files.command("add").description("\u628A\u672C\u5730\u6587\u4EF6\u89E3\u6790\u30
         `\u5DF2\u5BFC\u5165\u6587\u4EF6\uFF1A${result.fileName}\uFF0C\u89E3\u6790\u5668=${result.parser}\uFF0C\u5B57\u7B26\u6570=${result.characters}\uFF0C\u6D88\u606FID=${result.messageId}`
       );
     }
-    console.log("\u6587\u4EF6\u5DF2\u8FDB\u5165 SQLite FTS \u68C0\u7D22\uFF1B\u5982\u5DF2\u914D\u7F6E embedding\uFF0C\u53EF\u8FD0\u884C chattercatcher index rebuild \u66F4\u65B0 LanceDB \u5411\u91CF\u7D22\u5F15\u3002");
+    console.log("\u6587\u4EF6\u5DF2\u8FDB\u5165 SQLite FTS \u68C0\u7D22\uFF1B\u5982\u5DF2\u914D\u7F6E embedding\uFF0C\u53EF\u8FD0\u884C chattercatcher index rebuild \u66F4\u65B0 SQLite embedding \u5411\u91CF\u7D22\u5F15\u3002");
   } finally {
     database.close();
   }
@@ -4014,7 +4052,7 @@ program.command("restore").description("\u4ECE ChatterCatcher \u5BFC\u51FA\u6587
     console.log(`\u6062\u590D\u5B8C\u6210\uFF1A${result.inputPath}`);
     console.log(`\u6A21\u5F0F\uFF1A${result.mode === "replace" ? "\u66FF\u6362" : "\u5408\u5E76"}`);
     console.log(`\u5305\u542B\uFF1A\u7FA4\u804A=${result.chats}\uFF0C\u6D88\u606F=${result.messages}\uFF0Cchunks=${result.chunks}\uFF0C\u6587\u4EF6\u4EFB\u52A1=${result.fileJobs}`);
-    console.log("SQLite FTS \u5DF2\u91CD\u5EFA\uFF1B\u5982\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
+    console.log("SQLite FTS \u5DF2\u91CD\u5EFA\uFF1B\u5982\u4F7F\u7528 SQLite embedding \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
   } finally {
     database.close();
   }
@@ -4044,7 +4082,7 @@ dev.command("ingest-feishu-event").description("\u4ECE JSON \u6587\u4EF6\u6A21\u
   const config = await loadConfig();
   const database = openDatabase(config);
   try {
-    const raw = await fs14.readFile(options.file, "utf8");
+    const raw = await fs13.readFile(options.file, "utf8");
     const payload = JSON.parse(raw);
     const result = new GatewayIngestor(database).ingestFeishuEvent(payload);
     if (!result.accepted) {
@@ -4063,6 +4101,7 @@ dev.command("search").description("\u901A\u8FC7\u672C\u5730 FTS \u68C0\u7D22\u6D
   const { retriever, close } = await createHybridRetriever({
     config,
     secrets,
+    database,
     messages: new MessageRepository(database)
   });
   const evidence = await retriever.retrieve(question);
@@ -4083,6 +4122,7 @@ dev.command("ask").description("\u901A\u8FC7\u672C\u5730\u68C0\u7D22\u8BC1\u636E
   const { retriever, close } = await createHybridRetriever({
     config,
     secrets,
+    database,
     messages: new MessageRepository(database)
   });
   try {