@chiway/contextweaver 1.1.0 → 1.4.0

package/dist/{chunk-6QMYML5V.js → chunk-AB24E3Z7.js}

@@ -1,270 +1,145 @@
+import {
+  getVectorStore,
+  sampleCheckDisplayCode
+} from "./chunk-ZOMGPIU6.js";
 import {
   batchDeleteFileChunksFts,
   batchUpdateVectorIndexHash,
   batchUpsertChunkFts,
+  clearAllVectorIndexHash,
   clearVectorIndexHash,
+  deletePendingMarks,
+  getLanceDbMigrationState,
   initDb,
-  isChunksFtsInitialized
-} from "./chunk-6Z4JEEVJ.js";
+  insertPendingMarks,
+  isChunksFtsInitialized,
+  releaseLanceDbMigrationLock,
+  replayPendingMarks,
+  setLanceDbMigrationState,
+  tryAcquireLanceDbMigrationLock
+} from "./chunk-RGJSXUFS.js";
 import {
   logger
-} from "./chunk-AMQQK4P7.js";
+} from "./chunk-JVKVSTQ3.js";
 import {
   getEmbeddingConfig
-} from "./chunk-RJURH22T.js";
+} from "./chunk-SKBAE26T.js";
 
-// src/vectorStore/index.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-import * as lancedb from "@lancedb/lancedb";
-var BASE_DIR = path.join(os.homedir(), ".contextweaver");
-var VectorStore = class {
-  db = null;
-  table = null;
-  projectId;
-  dbPath;
-  vectorDim;
-  constructor(projectId, vectorDim = 1024) {
-    this.projectId = projectId;
-    this.dbPath = path.join(BASE_DIR, projectId, "vectors.lance");
-    this.vectorDim = vectorDim;
-  }
-  /**
-   * 初始化连接
-   */
-  async init() {
-    if (this.db) return;
-    const projectDir = path.join(BASE_DIR, this.projectId);
-    if (!fs.existsSync(projectDir)) {
-      fs.mkdirSync(projectDir, { recursive: true });
-    }
-    this.db = await lancedb.connect(this.dbPath);
-    const tableNames = await this.db.tableNames();
-    if (tableNames.includes("chunks")) {
-      this.table = await this.db.openTable("chunks");
+// src/db/bootstrap.ts
+async function bootstrap(db, vectorStore, options = {}) {
+  const result = {
+    replay: { applied: 0, discarded: 0 },
+    migration: { migrated: false, totalRows: 0 }
+  };
+  try {
+    result.replay = replayPendingMarks(db);
+    if (result.replay.applied > 0 || result.replay.discarded > 0) {
+      logger.info(result.replay, "pending_marks \u542F\u52A8\u91CD\u653E\uFF1A\u6807\u8BB0\u4E0A\u6B21\u672A\u6536\u655B\u7684\u7D22\u5F15\u72B6\u6001");
     }
+  } catch (err) {
+    const error = err;
+    logger.warn({ error: error.message }, "pending_marks \u91CD\u653E\u5931\u8D25\uFF0C\u672C\u6B21\u8DF3\u8FC7");
   }
-  /**
-   * 确保表存在（首次插入时调用）
-   */
-  async ensureTable(records) {
-    if (this.table) return;
-    if (!this.db) throw new Error("VectorStore not initialized");
-    if (records.length === 0) return;
-    this.table = await this.db.createTable(
-      "chunks",
-      records
-    );
-  }
-  /**
-   * 单调版本更新：先插入新版本，再删除旧版本
-   *
-   * 这保证了：
-   * - 最坏情况（崩溃）是新旧版本共存（不缺失）
-   * - 正常情况下旧版本被清理
-   */
-  async upsertFile(filePath, newHash, records) {
-    if (!this.db) throw new Error("VectorStore not initialized");
-    if (records.length === 0) {
-      await this.deleteFile(filePath);
-      return;
-    }
-    if (!this.table) {
-      await this.ensureTable(records);
-    } else {
-      await this.table.add(records);
-    }
-    if (this.table) {
-      await this.table.delete(
-        `file_path = '${this.escapeString(filePath)}' AND file_hash != '${this.escapeString(newHash)}'`
+  try {
+    result.migration = await migrateRemoveDisplayCode(db, vectorStore, options);
+    if (result.migration.migrated) {
+      logger.info(
+        { totalRows: result.migration.totalRows, reason: result.migration.reason },
+        "LanceDB schema \u8FC1\u79FB\u5B8C\u6210\uFF1Achunks \u8868\u5DF2\u79FB\u9664 display_code/vector_text"
+      );
+    } else if (result.migration.reason?.startsWith("mismatch_ratio_")) {
+      logger.error(
+        { reason: result.migration.reason, mismatched: result.migration.mismatched },
+        "LanceDB schema \u8FC1\u79FB\u4E2D\u6B62\uFF1Adisplay_code \u4E0E files.content \u62BD\u6837\u5DEE\u5F02\u8FC7\u5927\uFF0C\u8BF7\u68C0\u67E5\u7D22\u5F15\u4E00\u81F4\u6027\u6216\u8FD0\u884C `contextweaver migrate --reset`"
       );
     }
+  } catch (err) {
+    const error = err;
+    logger.warn({ error: error.message }, "LanceDB schema \u8FC1\u79FB\u5931\u8D25\uFF0C\u672C\u6B21\u8DF3\u8FC7");
   }
-  /**
-   * 批量 upsert 多个文件（性能优化版，带分批机制）
-   *
-   * 流程：
-   * 1. 将文件分成小批次（每批最多 BATCH_FILES 个文件或 BATCH_RECORDS 条记录）
-   * 2. 每批执行：插入新 records → 删除旧版本
-   *
-   * 分批是必要的，因为 LanceDB native 模块在处理超大数据时可能崩溃
-   *
-   * @param files 文件列表，每个包含 path、hash 和 records
-   */
-  async batchUpsertFiles(files) {
-    if (!this.db) throw new Error("VectorStore not initialized");
-    if (files.length === 0) return;
-    const BATCH_FILES = 50;
-    const BATCH_RECORDS = 5e3;
-    const batches = [];
-    let currentBatch = [];
-    let currentRecordCount = 0;
-    for (const file of files) {
-      if (currentBatch.length >= BATCH_FILES || currentRecordCount + file.records.length > BATCH_RECORDS) {
-        if (currentBatch.length > 0) {
-          batches.push(currentBatch);
-        }
-        currentBatch = [];
-        currentRecordCount = 0;
-      }
-      currentBatch.push(file);
-      currentRecordCount += file.records.length;
-    }
-    if (currentBatch.length > 0) {
-      batches.push(currentBatch);
-    }
-    for (const batch of batches) {
-      const batchRecords = [];
-      for (const file of batch) {
-        batchRecords.push(...file.records);
-      }
-      if (batchRecords.length === 0) {
-        const pathsToDelete = batch.map((f) => f.path);
-        await this.deleteFiles(pathsToDelete);
-        continue;
-      }
-      if (!this.table) {
-        await this.ensureTable(batchRecords);
-      } else {
-        await this.table.add(batchRecords);
-      }
-      if (this.table && batch.length > 0) {
-        const deleteConditions = batch.map(
-          (f) => `(file_path = '${this.escapeString(f.path)}' AND file_hash != '${this.escapeString(f.hash)}')`
-        ).join(" OR ");
-        await this.table.delete(deleteConditions);
-      }
-    }
-  }
-  /**
-   * 删除文件的所有 chunks
-   */
-  async deleteFile(filePath) {
-    if (!this.table) return;
-    await this.table.delete(`file_path = '${this.escapeString(filePath)}'`);
-  }
-  /**
-   * 批量删除文件（性能优化：单次 DELETE 替代 N 次循环）
-   * 当文件数超过 500 时分批处理，防止 LanceDB filter 字符串过长
-   */
-  async deleteFiles(filePaths) {
-    if (!this.table || filePaths.length === 0) return;
-    const BATCH_SIZE = 500;
-    if (filePaths.length <= BATCH_SIZE) {
-      const conditions = filePaths.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
-      await this.table.delete(conditions);
-    } else {
-      for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-        const batch = filePaths.slice(i, i + BATCH_SIZE);
-        const conditions = batch.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
-        await this.table.delete(conditions);
+  return result;
+}
+async function migrateRemoveDisplayCode(db, vectorStore, options = {}) {
+  const earlyState = getLanceDbMigrationState(db);
+  if (earlyState === "done") {
+    return { migrated: false, totalRows: 0, reason: "already_migrated_persisted" };
+  }
+  if (earlyState === "aborted") {
+    return { migrated: false, totalRows: 0, reason: "aborted_awaiting_manual" };
+  }
+  if (!tryAcquireLanceDbMigrationLock(db)) {
+    return { migrated: false, totalRows: 0, reason: "lock_held_by_other_process" };
+  }
+  try {
+    const persistedState = getLanceDbMigrationState(db);
+    if (persistedState === "done") {
+      return { migrated: false, totalRows: 0, reason: "already_migrated_persisted" };
+    }
+    if (persistedState === "aborted") {
+      return { migrated: false, totalRows: 0, reason: "aborted_awaiting_manual" };
+    }
+    const hasCol = await vectorStore.hasDisplayCodeColumn();
+    if (persistedState === "pending") {
+      if (hasCol === null) {
+        setLanceDbMigrationState(db, "done");
+        return { migrated: true, totalRows: 0, reason: "recovered_pending_no_table" };
       }
     }
-  }
-  /**
-   * 向量搜索
-   */
-  async search(queryVector, limit = 10, filter) {
-    if (!this.table) return [];
-    let query = this.table.vectorSearch(queryVector).limit(limit);
-    if (filter) {
-      query = query.where(filter);
-    }
-    const results = await query.toArray();
-    return results;
-  }
-  /**
-   * 获取文件的所有 chunks（按 chunk_index 排序）
-   */
-  async getFileChunks(filePath) {
-    if (!this.table) return [];
-    const results = await this.table.query().where(`file_path = '${this.escapeString(filePath)}'`).toArray();
-    const chunks = results;
-    return chunks.sort((a, b) => a.chunk_index - b.chunk_index);
-  }
-  /**
-   * 批量获取多个文件的 chunks（性能优化：单次查询替代 N 次循环）
-   * 当文件数超过 500 时分批处理，防止 LanceDB filter 字符串过长
-   *
-   * 适用于 GraphExpander 扩展、词法召回等需要批量获取的场景
-   * @returns Map<filePath, ChunkRecord[]>，每个文件的 chunks 已按 chunk_index 排序
-   */
-  async getFilesChunks(filePaths) {
-    const result = /* @__PURE__ */ new Map();
-    if (!this.table || filePaths.length === 0) return result;
-    const BATCH_SIZE = 500;
-    for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-      const batch = filePaths.slice(i, i + BATCH_SIZE);
-      const conditions = batch.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
-      const rows = await this.table.query().where(conditions).toArray();
-      for (const row of rows) {
-        let arr = result.get(row.file_path);
-        if (!arr) {
-          arr = [];
-          result.set(row.file_path, arr);
-        }
-        arr.push(row);
+    if (hasCol === null) {
+      setLanceDbMigrationState(db, "done");
+      return { migrated: false, totalRows: 0, reason: "empty" };
+    }
+    if (!hasCol) {
+      setLanceDbMigrationState(db, "done");
+      return { migrated: false, totalRows: 0, reason: "already_migrated" };
+    }
+    const sampleSize = options.sampleSize ?? 100;
+    const maxMismatchRatio = options.sampleMaxMismatchRatio ?? 0.01;
+    const oldRows = await vectorStore.readAllRowsRaw();
+    const totalRows = oldRows.length;
+    if (totalRows > 0) {
+      const stmt = db.prepare("SELECT content FROM files WHERE path = ?");
+      const getContent = (path) => {
+        const row = stmt.get(path);
+        return row?.content ?? null;
+      };
+      const check = sampleCheckDisplayCode(oldRows, getContent, {
+        sampleSize,
+        maxMismatchRatio
+      });
+      if (check.abort) {
+        setLanceDbMigrationState(db, "aborted");
+        return {
+          migrated: false,
+          totalRows,
+          mismatched: check.mismatched,
+          reason: `mismatch_ratio_${check.ratio.toFixed(3)}_exceeds_${maxMismatchRatio}`
+        };
       }
     }
-    for (const arr of result.values()) {
-      arr.sort((a, b) => a.chunk_index - b.chunk_index);
-    }
-    return result;
-  }
-  /**
-   * 获取表的总记录数
-   */
-  async count() {
-    if (!this.table) return 0;
-    return await this.table.countRows();
-  }
-  /**
-   * 清空所有数据
-   */
-  async clear() {
-    if (!this.db) return;
-    try {
-      await this.db.dropTable("chunks");
-      this.table = null;
-    } catch {
-    }
-  }
-  /**
-   * 获取向量维度
-   */
-  getVectorDim() {
-    return this.vectorDim;
-  }
-  /**
-   * 转义字符串（防止 SQL 注入）
-   */
-  escapeString(str) {
-    return str.replace(/'/g, "''");
-  }
-  /**
-   * 关闭连接
-   */
-  async close() {
-    this.db = null;
-    this.table = null;
-  }
-};
-var vectorStores = /* @__PURE__ */ new Map();
-async function getVectorStore(projectId, vectorDim = 1024) {
-  let store = vectorStores.get(projectId);
-  if (!store) {
-    store = new VectorStore(projectId, vectorDim);
-    await store.init();
-    vectorStores.set(projectId, store);
-  }
-  return store;
-}
-async function closeAllVectorStores() {
-  for (const store of vectorStores.values()) {
-    await store.close();
+    const newRows = oldRows.map((r) => ({
+      chunk_id: r.chunk_id,
+      file_path: r.file_path,
+      file_hash: r.file_hash,
+      chunk_index: r.chunk_index,
+      vector: Array.from(r.vector),
+      language: r.language,
+      breadcrumb: r.breadcrumb,
+      start_index: r.start_index,
+      end_index: r.end_index,
+      raw_start: r.raw_start,
+      raw_end: r.raw_end,
+      vec_start: r.vec_start,
+      vec_end: r.vec_end
+    }));
+    const cleared = clearAllVectorIndexHash(db);
+    setLanceDbMigrationState(db, "pending");
+    await vectorStore.dropAndRecreateChunks(newRows);
+    setLanceDbMigrationState(db, "done");
+    return { migrated: true, totalRows, reason: `cleared_${cleared}_vector_index_hash` };
+  } finally {
+    releaseLanceDbMigrationLock(db);
   }
-  vectorStores.clear();
 }
 
 // src/api/embedding.ts
@@ -634,6 +509,8 @@ var Indexer = class {
   vectorStore = null;
   embeddingClient;
   vectorDim;
+  /** bootstrap（pending_marks 重放 + LanceDB 迁移）只在每个 db 上执行一次 */
+  bootstrappedDbs = /* @__PURE__ */ new WeakSet();
   constructor(projectId, vectorDim = 1024) {
     this.projectId = projectId;
     this.vectorDim = vectorDim;
@@ -656,6 +533,31 @@ var Indexer = class {
     if (!this.vectorStore) {
       await this.init();
     }
+    if (!this.bootstrappedDbs.has(db)) {
+      this.bootstrappedDbs.add(db);
+      try {
+        await bootstrap(db, this.vectorStore);
+      } catch (err) {
+        const error = err;
+        logger.warn({ error: error.message }, "bootstrap \u5931\u8D25\uFF0C\u672C\u6B21\u8DF3\u8FC7");
+      }
+    }
+    const migrationState = getLanceDbMigrationState(db);
+    if (migrationState === "aborted") {
+      const errorCount = results.filter(
+        (r) => r.status === "added" || r.status === "modified"
+      ).length;
+      logger.error(
+        { migrationState, blockedFiles: errorCount },
+        "LanceDB \u5904\u4E8E aborted \u72B6\u6001\uFF0C\u62D2\u7EDD\u5199\u5165\u4EE5\u9632\u6B62 schema \u6C61\u67D3\u3002\u8FD0\u884C `contextweaver migrate --reset` \u6E05\u7A7A LanceDB \u5E76\u91CD\u65B0\u7D22\u5F15\u3002"
+      );
+      return {
+        indexed: 0,
+        deleted: 0,
+        errors: errorCount,
+        skipped: results.length - errorCount
+      };
+    }
     const stats = {
       indexed: 0,
       deleted: 0,
@@ -699,8 +601,17 @@ var Indexer = class {
       }
     }
     if (toDelete.length > 0) {
-      await this.deleteFiles(db, toDelete);
-      stats.deleted = toDelete.length;
+      try {
+        await this.deleteFiles(db, toDelete);
+        stats.deleted = toDelete.length;
+      } catch (err) {
+        const error = err;
+        logger.error(
+          { error: error.message, count: toDelete.length },
+          "\u5220\u9664\u9636\u6BB5\u5931\u8D25\uFF0C\u5DF2\u6807\u8BB0\u91CD\u8BD5"
+        );
+        stats.errors += toDelete.length;
+      }
     }
     if (noChunkSettled.length > 0) {
       batchUpdateVectorIndexHash(db, noChunkSettled);
@@ -812,8 +723,6 @@ var Indexer = class {
               file_hash: file.hash,
               chunk_index: chunkIdx,
               vector: embeddings[embIdx],
-              display_code: chunk.displayCode,
-              vector_text: chunk.vectorText,
               language: chunk.metadata.language,
               breadcrumb: chunk.metadata.contextPath.join(" > "),
               start_index: chunk.metadata.startIndex,
@@ -830,7 +739,7 @@ var Indexer = class {
               chunkIndex: record.chunk_index,
               breadcrumb: record.breadcrumb,
               content: `${record.breadcrumb}
-${record.display_code}`
+${chunk.displayCode}`
             });
           }
           filesToUpsert.push({ path: file.path, hash: file.hash, records });
@@ -858,19 +767,64 @@ ${record.display_code}`
           completedChunks += batchTexts.length;
           continue;
         }
-      }
-      if (isChunksFtsInitialized(db) && ftsChunks.length > 0) {
-        try {
-          const pathsToDelete = filesToUpsert.map((f) => f.path);
-          batchDeleteFileChunksFts(db, pathsToDelete);
-          batchUpsertChunkFts(db, ftsChunks);
-        } catch (err) {
-          const error = err;
-          logger.warn({ error: error.message }, "FTS \u6279\u91CF\u66F4\u65B0\u5931\u8D25\uFF08\u5411\u91CF\u7D22\u5F15\u5DF2\u6210\u529F\uFF09");
+        if (isChunksFtsInitialized(db) && ftsChunks.length > 0) {
+          try {
+            const ftsAndOutboxTx = db.transaction(() => {
+              batchUpsertChunkFts(db, ftsChunks);
+              insertPendingMarks(db, successFiles);
+            });
+            ftsAndOutboxTx();
+          } catch (err) {
+            const error = err;
+            logger.error(
+              { error: error.message, stack: error.stack, batch: `${batchNum}/${totalBatches}` },
+              "FTS/outbox \u5199\u5165\u5931\u8D25\uFF0C\u56DE\u6EDA LanceDB \u65B0\u7248\u672C"
+            );
+            try {
+              await this.vectorStore?.deleteFilesByHash(
+                filesToUpsert.map((f) => ({ path: f.path, hash: f.hash }))
+              );
+            } catch (rollbackErr) {
+              const rbError = rollbackErr;
+              logger.error(
+                { error: rbError.message },
+                "LanceDB \u56DE\u6EDA\u5931\u8D25\uFF0C\u5B64\u513F\u6570\u636E\u5C06\u7531\u4E0B\u6B21 GC \u6E05\u7406"
+              );
+            }
+            clearVectorIndexHash(
+              db,
+              batchFiles.map((f) => f.path)
+            );
+            totalErrors += batchFiles.length;
+            completedChunks += batchTexts.length;
+            continue;
+          }
+        } else if (successFiles.length > 0) {
+          try {
+            insertPendingMarks(db, successFiles);
+          } catch (err) {
+            const error = err;
+            logger.warn({ error: error.message }, "outbox \u5199\u5165\u5931\u8D25\uFF08\u65E0 FTS \u8DEF\u5F84\uFF09\uFF0C\u7EE7\u7EED stage6");
+          }
+        }
+        if (successFiles.length > 0) {
+          try {
+            const markTx = db.transaction(() => {
+              batchUpdateVectorIndexHash(db, successFiles);
+              deletePendingMarks(
+                db,
+                successFiles.map((f) => f.path)
+              );
+            });
+            markTx();
+          } catch (err) {
+            const error = err;
+            logger.warn(
+              { error: error.message, batch: `${batchNum}/${totalBatches}` },
+              "stage6 mark \u5931\u8D25\uFF0Coutbox \u5DF2\u4FDD\u7559\uFF0C\u4E0B\u6B21\u542F\u52A8\u5C06\u91CD\u653E"
+            );
+          }
         }
-      }
-      if (successFiles.length > 0) {
-        batchUpdateVectorIndexHash(db, successFiles);
       }
       totalSuccess += successFiles.length;
       totalErrors += errorFiles.length;
@@ -889,12 +843,29 @@ ${record.display_code}`
   }
   /**
    * 删除文件的向量和 FTS 索引
+   *
+   * 顺序：先删 FTS（SQLite 事务，可靠）→ 再删 LanceDB（可能失败）
+   * 任一阶段失败均通过 clearVectorIndexHash 触发下次扫描自愈
    */
   async deleteFiles(db, paths) {
-    if (!this.vectorStore) return;
-    await this.vectorStore.deleteFiles(paths);
+    if (!this.vectorStore || paths.length === 0) return;
     if (isChunksFtsInitialized(db)) {
-      batchDeleteFileChunksFts(db, paths);
+      try {
+        batchDeleteFileChunksFts(db, paths);
+      } catch (err) {
+        const error = err;
+        logger.error({ error: error.message, paths }, "FTS \u5220\u9664\u5931\u8D25");
+        clearVectorIndexHash(db, paths);
+        throw err;
+      }
+    }
+    try {
+      await this.vectorStore.deleteFiles(paths);
+    } catch (err) {
+      const error = err;
+      logger.error({ error: error.message, paths }, "LanceDB \u5220\u9664\u5931\u8D25\uFF0C\u5B64\u513F\u6570\u636E\u5C06\u7531 GC \u6E05\u7406");
+      clearVectorIndexHash(db, paths);
+      throw err;
     }
     logger.debug({ count: paths.length }, "\u5220\u9664\u6587\u4EF6\u7D22\u5F15");
   }
@@ -923,6 +894,67 @@ ${record.display_code}`
     }
     await this.vectorStore?.clear();
   }
+  /**
+   * 垃圾回收：清理 LanceDB 中的孤儿 chunks
+   *
+   * 孤儿来源：
+   * - 事务补偿失败遗留（FTS 回滚成功但 LanceDB 删除失败）
+   * - 跨进程崩溃导致的 hash 不匹配残留
+   * - 删除流程失败遗留
+   *
+   * 算法：以 SQLite files 表 (path, hash) 为权威源，删除 LanceDB 中不存在的组合。
+   * 同步清理 chunks_fts：仅当 path 在 SQLite 完全不存在时才删（hash 变化的 FTS 由 upsert 覆盖）。
+   *
+   * 性能护栏：time budget 默认 5s，超时则跳过避免阻塞扫描主流程。
+   */
+  async gc(db, options = {}) {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    const startTime = Date.now();
+    const timeBudget = options.maxScanMs ?? 5e3;
+    let vectorPairs;
+    try {
+      vectorPairs = await this.vectorStore?.listFileHashes() ?? [];
+    } catch (err) {
+      const error = err;
+      logger.warn({ error: error.message }, "GC: listFileHashes \u5931\u8D25\uFF0C\u8DF3\u8FC7");
+      return { orphans: 0 };
+    }
+    if (vectorPairs.length === 0) return { orphans: 0 };
+    if (Date.now() - startTime > timeBudget) {
+      logger.warn(
+        { elapsed: Date.now() - startTime, budget: timeBudget },
+        "GC \u8D85\u65F6\uFF08\u62C9\u53D6\u9636\u6BB5\uFF09\uFF0C\u672C\u6B21\u8DF3\u8FC7"
+      );
+      return { orphans: 0, truncated: true };
+    }
+    const sqliteRows = db.prepare("SELECT path, hash FROM files").all();
+    const validPairs = new Set(sqliteRows.map((r) => `${r.path} ${r.hash}`));
+    const sqlitePaths = new Set(sqliteRows.map((r) => r.path));
+    const orphans = vectorPairs.filter((p) => !validPairs.has(`${p.path} ${p.hash}`));
+    if (orphans.length === 0) return { orphans: 0 };
+    logger.info({ count: orphans.length }, "GC: \u53D1\u73B0\u5B64\u513F chunks");
+    try {
+      await this.vectorStore?.deleteFilesByHash(orphans);
+    } catch (err) {
+      const error = err;
+      logger.warn({ error: error.message }, "GC: LanceDB \u5220\u9664\u5931\u8D25\uFF0C\u4E0B\u6B21\u91CD\u8BD5");
+      return { orphans: 0 };
+    }
+    const pathsToFtsClean = Array.from(new Set(orphans.map((o) => o.path))).filter(
+      (p) => !sqlitePaths.has(p)
+    );
+    if (pathsToFtsClean.length > 0 && isChunksFtsInitialized(db)) {
+      try {
+        batchDeleteFileChunksFts(db, pathsToFtsClean);
+      } catch (err) {
+        const error = err;
+        logger.warn({ error: error.message }, "GC: chunks_fts \u6E05\u7406\u5931\u8D25");
+      }
+    }
+    return { orphans: orphans.length };
+  }
   /**
    * 获取索引统计
    */
@@ -959,8 +991,8 @@ function getTokenBoundaryRegex(token) {
   }
   return regex;
 }
-function scoreChunkTokenOverlap(chunk, queryTokens) {
-  const text = `${chunk.breadcrumb} ${chunk.display_code}`.toLowerCase();
+function scoreChunkTokenOverlap(chunk, code, queryTokens) {
+  const text = `${chunk.breadcrumb} ${code}`.toLowerCase();
   let score = 0;
   for (const token of queryTokens) {
     if (text.includes(token)) {
@@ -975,6 +1007,60 @@ function scoreChunkTokenOverlap(chunk, queryTokens) {
   return score;
 }
 
+// src/search/ChunkContentLoader.ts
+var ChunkContentLoader = class _ChunkContentLoader {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * 生成 cache key
+   */
+  static key(slice) {
+    return `${slice.filePath}#${slice.start_index}#${slice.end_index}`;
+  }
+  /**
+   * 批量加载 chunk 正文
+   *
+   * @returns Map<key, code>，key 由 ChunkContentLoader.key 生成
+   */
+  loadMany(slices) {
+    const result = /* @__PURE__ */ new Map();
+    if (slices.length === 0) return result;
+    const byPath = /* @__PURE__ */ new Map();
+    for (const s of slices) {
+      let arr = byPath.get(s.filePath);
+      if (!arr) {
+        arr = [];
+        byPath.set(s.filePath, arr);
+      }
+      arr.push(s);
+    }
+    const stmt = this.db.prepare("SELECT content FROM files WHERE path = ?");
+    for (const [path, spans] of byPath) {
+      const row = stmt.get(path);
+      const content = row?.content ?? null;
+      for (const s of spans) {
+        const k = _ChunkContentLoader.key(s);
+        if (content === null) {
+          result.set(k, "");
+          continue;
+        }
+        const safeStart = Math.max(0, Math.min(s.start_index, content.length));
+        const safeEnd = Math.max(safeStart, Math.min(s.end_index, content.length));
+        result.set(k, content.slice(safeStart, safeEnd));
+      }
+    }
+    return result;
+  }
+  /**
+   * 加载单个 chunk 正文（便捷方法，不推荐在批量场景使用）
+   */
+  loadOne(slice) {
+    const map = this.loadMany([slice]);
+    return map.get(_ChunkContentLoader.key(slice)) ?? "";
+  }
+};
+
 // src/search/resolvers/types.ts
 function commonPrefixLength(path1, path2) {
   const parts1 = path1.split("/");
@@ -1643,6 +1729,20 @@ var GraphExpander = class {
     if (allTargetPaths.size === 0) return result;
     const importChunksMap = await this.vectorStore?.getFilesChunks(Array.from(allTargetPaths));
     if (!importChunksMap) return result;
+    const sharedLoader = new ChunkContentLoader(this.db);
+    const allSlices = [];
+    if (queryTokens && queryTokens.size > 0) {
+      for (const chunks of importChunksMap.values()) {
+        for (const c of chunks) {
+          allSlices.push({
+            filePath: c.file_path,
+            start_index: c.start_index,
+            end_index: c.end_index
+          });
+        }
+      }
+    }
+    const sharedCodeMap = sharedLoader.loadMany(allSlices);
     const bestByKey = /* @__PURE__ */ new Map();
     for (const { targetPath, depth, seedScore } of resolvedImports) {
       const importChunks = importChunksMap.get(targetPath);
@@ -1650,7 +1750,8 @@ var GraphExpander = class {
       const selectedChunks = this.selectImportChunks(
         importChunks,
         chunksPerImportFile,
-        queryTokens
+        queryTokens,
+        sharedCodeMap
       );
       const depthDecay = depth === 0 ? 1 : decayDepth;
       for (const chunk of selectedChunks) {
@@ -1709,16 +1810,38 @@ var GraphExpander = class {
   /**
    * 选择导入文件的 chunks（优先 query overlap）
    */
-  selectImportChunks(chunks, limit, queryTokens) {
+  selectImportChunks(chunks, limit, queryTokens, sharedCodeMap) {
     if (limit <= 0) return [];
     const sortedByIndex = chunks.slice().sort((a, b) => a.chunk_index - b.chunk_index);
     if (!queryTokens || queryTokens.size === 0) {
       return sortedByIndex.slice(0, limit);
     }
-    const scored = sortedByIndex.map((chunk) => ({
-      chunk,
-      score: scoreChunkTokenOverlap(chunk, queryTokens)
-    }));
+    let codeMap;
+    if (sharedCodeMap) {
+      codeMap = sharedCodeMap;
+    } else {
+      const loader = new ChunkContentLoader(this.db);
+      codeMap = loader.loadMany(
+        sortedByIndex.map((c) => ({
+          filePath: c.file_path,
+          start_index: c.start_index,
+          end_index: c.end_index
+        }))
+      );
+    }
+    const scored = sortedByIndex.map((chunk) => {
+      const code = codeMap.get(
+        ChunkContentLoader.key({
+          filePath: chunk.file_path,
+          start_index: chunk.start_index,
+          end_index: chunk.end_index
+        })
+      ) ?? "";
+      return {
+        chunk,
+        score: scoreChunkTokenOverlap(chunk, code, queryTokens)
+      };
+    });
     const overlapped = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.chunk);
     return overlapped.length > 0 ? overlapped : sortedByIndex.slice(0, limit);
   }
@@ -1749,12 +1872,11 @@ async function getGraphExpander(projectId, config) {
 }
 
 export {
-  getVectorStore,
-  closeAllVectorStores,
+  bootstrap,
   getIndexer,
   closeAllIndexers,
   scoreChunkTokenOverlap,
+  ChunkContentLoader,
   invalidateAllExpanderCaches,
   getGraphExpander
 };
-//# sourceMappingURL=chunk-6QMYML5V.js.map