@chiway/contextweaver 1.0.0 → 1.1.0

package/dist/chunk-6QMYML5V.js

@@ -0,0 +1,1760 @@
+import {
+  batchDeleteFileChunksFts,
+  batchUpdateVectorIndexHash,
+  batchUpsertChunkFts,
+  clearVectorIndexHash,
+  initDb,
+  isChunksFtsInitialized
+} from "./chunk-6Z4JEEVJ.js";
+import {
+  logger
+} from "./chunk-AMQQK4P7.js";
+import {
+  getEmbeddingConfig
+} from "./chunk-RJURH22T.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");
+    }
+  }
+  /**
+   * 确保表存在（首次插入时调用）
+   */
+  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)}'`
+      );
+    }
+  }
+  /**
+   * 批量 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);
+      }
+    }
+  }
+  /**
+   * 向量搜索
+   */
+  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);
+      }
+    }
+    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();
+  }
+  vectorStores.clear();
+}
+
+// src/api/embedding.ts
+var ProgressTracker = class {
+  completed = 0;
+  total;
+  totalTokens = 0;
+  startTime;
+  lastLogTime = 0;
+  logIntervalMs = 2e3;
+  // 每 2 秒输出一次
+  onProgress;
+  /** 是否跳过日志（单批次时跳过，避免与索引日志混淆） */
+  skipLogs;
+  constructor(total, onProgress) {
+    this.total = total;
+    this.startTime = Date.now();
+    this.onProgress = onProgress;
+    this.skipLogs = total <= 1;
+  }
+  /** 记录一个批次完成 */
+  recordBatch(tokens) {
+    this.completed++;
+    this.totalTokens += tokens;
+    this.onProgress?.(this.completed, this.total);
+    const now = Date.now();
+    if (now - this.lastLogTime >= this.logIntervalMs) {
+      this.logProgress();
+      this.lastLogTime = now;
+    }
+  }
+  /** 输出进度 */
+  logProgress() {
+    if (this.skipLogs) return;
+    const elapsed = (Date.now() - this.startTime) / 1e3;
+    const percent = Math.round(this.completed / this.total * 100);
+    const rate = this.completed / elapsed;
+    const eta = rate > 0 ? Math.round((this.total - this.completed) / rate) : 0;
+    logger.info(
+      {
+        progress: `${this.completed}/${this.total}`,
+        percent: `${percent}%`,
+        tokens: this.totalTokens,
+        elapsed: `${elapsed.toFixed(1)}s`,
+        eta: `${eta}s`
+      },
+      "Embedding \u8FDB\u5EA6"
+    );
+  }
+  /** 完成时输出最终统计 */
+  complete() {
+    if (this.skipLogs) return;
+    const elapsed = (Date.now() - this.startTime) / 1e3;
+    logger.info(
+      {
+        batches: this.total,
+        tokens: this.totalTokens,
+        elapsed: `${elapsed.toFixed(1)}s`,
+        avgTokensPerBatch: Math.round(this.totalTokens / this.total)
+      },
+      "Embedding \u5B8C\u6210"
+    );
+  }
+};
+var RateLimitController = class {
+  /** 是否处于暂停状态 */
+  isPaused = false;
+  /** 暂停恢复的 Promise（所有请求等待此 Promise） */
+  pausePromise = null;
+  /** 当前有效并发数 */
+  currentConcurrency;
+  /** 配置的最大并发数 */
+  maxConcurrency;
+  /** 当前活跃请求数 */
+  activeRequests = 0;
+  /** 连续成功次数（用于渐进恢复并发） */
+  consecutiveSuccesses = 0;
+  /** 当前退避时间（毫秒） */
+  backoffMs = 5e3;
+  /** 恢复并发所需的连续成功次数 */
+  successesPerConcurrencyIncrease = 3;
+  /** 最小退避时间 */
+  minBackoffMs = 5e3;
+  /** 最大退避时间 */
+  maxBackoffMs = 6e4;
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    this.currentConcurrency = maxConcurrency;
+  }
+  /**
+   * 获取执行槽位
+   * 如果当前暂停或并发已满，则等待
+   */
+  async acquire() {
+    if (this.pausePromise) {
+      await this.pausePromise;
+    }
+    while (this.activeRequests >= this.currentConcurrency) {
+      await sleep(50);
+      if (this.pausePromise) {
+        await this.pausePromise;
+      }
+    }
+    this.activeRequests++;
+  }
+  /**
+   * 释放执行槽位（请求成功时调用）
+   */
+  releaseSuccess() {
+    this.activeRequests = Math.max(0, this.activeRequests - 1);
+    this.consecutiveSuccesses++;
+    if (this.currentConcurrency < this.maxConcurrency && this.consecutiveSuccesses >= this.successesPerConcurrencyIncrease) {
+      this.currentConcurrency++;
+      this.consecutiveSuccesses = 0;
+    }
+    if (this.consecutiveSuccesses > 0 && this.consecutiveSuccesses % 10 === 0) {
+      this.backoffMs = Math.max(this.minBackoffMs, this.backoffMs / 2);
+    }
+  }
+  /**
+   * 释放执行槽位（请求失败但非 429 时调用）
+   */
+  releaseFailure() {
+    this.activeRequests = Math.max(0, this.activeRequests - 1);
+  }
+  /**
+   * 释放执行槽位（429 重试前调用）
+   * 释放槽位并重置成功计数
+   */
+  releaseForRetry() {
+    this.activeRequests = Math.max(0, this.activeRequests - 1);
+    this.consecutiveSuccesses = 0;
+  }
+  /**
+   * 触发 429 暂停
+   * 所有请求将等待恢复
+   */
+  async triggerRateLimit() {
+    if (this.isPaused && this.pausePromise) {
+      logger.debug("\u901F\u7387\u9650\u5236\uFF1A\u7B49\u5F85\u73B0\u6709\u6682\u505C\u7ED3\u675F");
+      await this.pausePromise;
+      return;
+    }
+    this.isPaused = true;
+    this.consecutiveSuccesses = 0;
+    const previousConcurrency = this.currentConcurrency;
+    this.currentConcurrency = 1;
+    logger.warn(
+      {
+        backoffMs: this.backoffMs,
+        previousConcurrency,
+        newConcurrency: this.currentConcurrency,
+        activeRequests: this.activeRequests
+      },
+      "\u901F\u7387\u9650\u5236\uFF1A\u89E6\u53D1 429\uFF0C\u6682\u505C\u6240\u6709\u8BF7\u6C42"
+    );
+    let resumeResolve = () => {
+    };
+    this.pausePromise = new Promise((resolve) => {
+      resumeResolve = resolve;
+    });
+    await sleep(this.backoffMs);
+    this.backoffMs = Math.min(this.maxBackoffMs, this.backoffMs * 2);
+    this.isPaused = false;
+    this.pausePromise = null;
+    resumeResolve();
+    logger.info({ waitMs: this.backoffMs }, "\u901F\u7387\u9650\u5236\uFF1A\u6062\u590D\u8BF7\u6C42");
+  }
+  /**
+   * 获取当前状态（用于调试）
+   */
+  getStatus() {
+    return {
+      isPaused: this.isPaused,
+      currentConcurrency: this.currentConcurrency,
+      maxConcurrency: this.maxConcurrency,
+      activeRequests: this.activeRequests,
+      backoffMs: this.backoffMs
+    };
+  }
+};
+var globalRateLimitController = null;
+function getRateLimitController(maxConcurrency) {
+  if (!globalRateLimitController) {
+    globalRateLimitController = new RateLimitController(maxConcurrency);
+  }
+  return globalRateLimitController;
+}
+var EmbeddingClient = class {
+  config;
+  rateLimiter;
+  constructor(config) {
+    this.config = config || getEmbeddingConfig();
+    this.rateLimiter = getRateLimitController(this.config.maxConcurrency);
+  }
+  /**
+   * 获取单个文本的 Embedding
+   */
+  async embed(text) {
+    const results = await this.embedBatch([text]);
+    return results[0].embedding;
+  }
+  /**
+   * 批量获取 Embedding
+   * @param texts 待处理的文本数组
+   * @param batchSize 每批次发送的文本数量（默认 20）
+   * @param onProgress 可选的进度回调 (completed, total) => void
+   */
+  async embedBatch(texts, batchSize = 20, onProgress) {
+    if (texts.length === 0) {
+      return [];
+    }
+    const batches = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      batches.push(texts.slice(i, i + batchSize));
+    }
+    const progress = new ProgressTracker(batches.length, onProgress);
+    const batchResults = await Promise.all(
+      batches.map(
+        (batch, batchIndex) => this.processWithRateLimit(batch, batchIndex * batchSize, progress)
+      )
+    );
+    progress.complete();
+    return batchResults.flat();
+  }
+  /**
+   * 带速率限制和网络错误重试的批次处理
+   * 使用循环而非递归，避免栈溢出和槽位泄漏
+   */
+  async processWithRateLimit(texts, startIndex, progress) {
+    const MAX_NETWORK_RETRIES = 3;
+    const INITIAL_RETRY_DELAY_MS = 1e3;
+    let networkRetries = 0;
+    while (true) {
+      await this.rateLimiter.acquire();
+      try {
+        const result = await this.processBatch(texts, startIndex, progress);
+        this.rateLimiter.releaseSuccess();
+        return result;
+      } catch (err) {
+        const error = err;
+        const errorMessage = error.message || "";
+        const isRateLimited = errorMessage.includes("429") || errorMessage.includes("rate");
+        const isNetworkError = this.isNetworkError(err);
+        if (isRateLimited) {
+          this.rateLimiter.releaseForRetry();
+          await this.rateLimiter.triggerRateLimit();
+          networkRetries = 0;
+        } else if (isNetworkError && networkRetries < MAX_NETWORK_RETRIES) {
+          networkRetries++;
+          const delayMs = INITIAL_RETRY_DELAY_MS * 2 ** (networkRetries - 1);
+          logger.warn(
+            {
+              error: errorMessage,
+              retry: networkRetries,
+              maxRetries: MAX_NETWORK_RETRIES,
+              delayMs
+            },
+            "\u7F51\u7EDC\u9519\u8BEF\uFF0C\u51C6\u5907\u91CD\u8BD5"
+          );
+          this.rateLimiter.releaseForRetry();
+          await sleep(delayMs);
+        } else {
+          this.rateLimiter.releaseFailure();
+          if (isNetworkError) {
+            logger.error({ error: errorMessage, retries: networkRetries }, "\u7F51\u7EDC\u9519\u8BEF\u91CD\u8BD5\u6B21\u6570\u8017\u5C3D");
+          }
+          throw err;
+        }
+      }
+    }
+  }
+  /**
+   * 判断是否为网络错误
+   *
+   * 常见网络错误类型：
+   * - terminated: 连接被中断（TLS 断开）
+   * - ECONNRESET: 连接被远端重置
+   * - ETIMEDOUT: 连接超时
+   * - ENOTFOUND: DNS 解析失败
+   * - fetch failed: 通用 fetch 失败
+   * - socket hang up: 套接字意外关闭
+   */
+  isNetworkError(err) {
+    const error = err;
+    const message = (error.message || "").toLowerCase();
+    const code = error.code || "";
+    const networkErrorPatterns = [
+      "terminated",
+      "econnreset",
+      "etimedout",
+      "enotfound",
+      "econnrefused",
+      "fetch failed",
+      "socket hang up",
+      "network",
+      "aborted"
+    ];
+    for (const pattern of networkErrorPatterns) {
+      if (message.includes(pattern)) {
+        return true;
+      }
+    }
+    const networkErrorCodes = ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EPIPE"];
+    if (networkErrorCodes.includes(code)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 处理单个批次（单次请求，不含重试逻辑）
+   */
+  async processBatch(texts, startIndex, progress) {
+    const requestBody = {
+      model: this.config.model,
+      input: texts,
+      encoding_format: "float"
+    };
+    const response = await fetch(this.config.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify(requestBody)
+    });
+    const data = await response.json();
+    if (!response.ok || data.error) {
+      const errorMsg = data.error?.message || `HTTP ${response.status}`;
+      throw new Error(`Embedding API \u9519\u8BEF: ${errorMsg}`);
+    }
+    const results = data.data.map((item) => ({
+      text: texts[item.index],
+      embedding: item.embedding,
+      index: startIndex + item.index
+    }));
+    progress.recordBatch(data.usage?.total_tokens || 0);
+    return results;
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 获取速率限制器状态（用于调试）
+   */
+  getRateLimiterStatus() {
+    return this.rateLimiter.getStatus();
+  }
+};
+var defaultClient = null;
+function getEmbeddingClient() {
+  if (!defaultClient) {
+    defaultClient = new EmbeddingClient();
+  }
+  return defaultClient;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/indexer/index.ts
+var Indexer = class {
+  projectId;
+  vectorStore = null;
+  embeddingClient;
+  vectorDim;
+  constructor(projectId, vectorDim = 1024) {
+    this.projectId = projectId;
+    this.vectorDim = vectorDim;
+    this.embeddingClient = getEmbeddingClient();
+  }
+  /**
+   * 初始化
+   */
+  async init() {
+    this.vectorStore = await getVectorStore(this.projectId, this.vectorDim);
+  }
+  /**
+   * 处理扫描结果，更新向量索引
+   *
+   * @param db SQLite 数据库实例
+   * @param results 文件处理结果
+   * @param onProgress 可选的进度回调 (indexed, total) => void
+   */
+  async indexFiles(db, results, onProgress) {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    const stats = {
+      indexed: 0,
+      deleted: 0,
+      errors: 0,
+      skipped: 0
+    };
+    const toIndex = [];
+    const toDelete = [];
+    const noChunkSettled = [];
+    for (const result of results) {
+      switch (result.status) {
+        case "added":
+        case "modified":
+          if (result.chunks.length > 0) {
+            toIndex.push({
+              path: result.relPath,
+              hash: result.hash,
+              chunks: result.chunks
+            });
+          } else {
+            if (result.status === "modified") {
+              toDelete.push(result.relPath);
+            }
+            noChunkSettled.push({
+              path: result.relPath,
+              hash: result.hash
+            });
+            stats.skipped++;
+          }
+          break;
+        case "deleted":
+          toDelete.push(result.relPath);
+          break;
+        case "unchanged":
+          stats.skipped++;
+          break;
+        case "skipped":
+        case "error":
+          stats.skipped++;
+          break;
+      }
+    }
+    if (toDelete.length > 0) {
+      await this.deleteFiles(db, toDelete);
+      stats.deleted = toDelete.length;
+    }
+    if (noChunkSettled.length > 0) {
+      batchUpdateVectorIndexHash(db, noChunkSettled);
+      logger.debug({ count: noChunkSettled.length }, "\u65E0\u53EF\u7D22\u5F15 chunk\uFF0C\u6807\u8BB0\u5411\u91CF\u7D22\u5F15\u72B6\u6001\u4E3A\u5DF2\u6536\u655B");
+    }
+    if (toIndex.length > 0) {
+      const indexResult = await this.batchIndex(db, toIndex, onProgress);
+      stats.indexed = indexResult.success;
+      stats.errors = indexResult.errors;
+    }
+    logger.info(
+      {
+        indexed: stats.indexed,
+        vectorRecordsDeleted: stats.deleted,
+        errors: stats.errors,
+        skipped: stats.skipped
+      },
+      "\u5411\u91CF\u7D22\u5F15\u5B8C\u6210"
+    );
+    return stats;
+  }
+  /**
+   * 批量索引文件（内存优化版）
+   *
+   * 优化策略：
+   * 1. 文件按批次处理（每批 100 个文件），避免一次性加载所有 embedding 到内存
+   * 2. 每批独立完成：collect texts → embedBatch → write LanceDB → write FTS → update SQLite
+   * 3. 批次间释放中间数据引用，让 GC 回收内存
+   * 4. ProgressTracker 跨批次累计，总数基于所有文件
+   */
+  async batchIndex(db, files, onProgress) {
+    if (files.length === 0) {
+      return { success: 0, errors: 0 };
+    }
+    const FILE_BATCH_SIZE = 100;
+    let totalSuccess = 0;
+    let totalErrors = 0;
+    const totalChunks = files.reduce((sum, f) => sum + f.chunks.length, 0);
+    if (totalChunks === 0) {
+      return { success: 0, errors: 0 };
+    }
+    let completedChunks = 0;
+    logger.info(
+      { totalFiles: files.length, totalChunks, batches: Math.ceil(files.length / FILE_BATCH_SIZE) },
+      "\u5F00\u59CB\u5206\u6279\u7D22\u5F15"
+    );
+    for (let batchStart = 0; batchStart < files.length; batchStart += FILE_BATCH_SIZE) {
+      const batchFiles = files.slice(batchStart, batchStart + FILE_BATCH_SIZE);
+      const batchNum = Math.floor(batchStart / FILE_BATCH_SIZE) + 1;
+      const totalBatches = Math.ceil(files.length / FILE_BATCH_SIZE);
+      const batchTexts = [];
+      const indexByFileChunk = [];
+      for (let fileIdx = 0; fileIdx < batchFiles.length; fileIdx++) {
+        const file = batchFiles[fileIdx];
+        indexByFileChunk[fileIdx] = [];
+        for (let chunkIdx = 0; chunkIdx < file.chunks.length; chunkIdx++) {
+          const idx = batchTexts.length;
+          batchTexts.push(file.chunks[chunkIdx].vectorText);
+          indexByFileChunk[fileIdx][chunkIdx] = idx;
+        }
+      }
+      if (batchTexts.length === 0) {
+        totalSuccess += batchFiles.length;
+        continue;
+      }
+      logger.info(
+        { batch: `${batchNum}/${totalBatches}`, texts: batchTexts.length, files: batchFiles.length },
+        "\u6279\u6B21 Embedding \u5F00\u59CB"
+      );
+      let embeddings;
+      const EMBED_BATCH_SIZE = 10;
+      try {
+        const batchOnProgress = onProgress ? (_completed, _total) => {
+          onProgress(completedChunks + Math.min(_completed * EMBED_BATCH_SIZE, batchTexts.length), totalChunks);
+        } : void 0;
+        const results = await this.embeddingClient.embedBatch(batchTexts, EMBED_BATCH_SIZE, batchOnProgress);
+        embeddings = results.map((r) => r.embedding);
+      } catch (err) {
+        const error = err;
+        logger.error(
+          { error: error.message, stack: error.stack, batch: `${batchNum}/${totalBatches}` },
+          "\u6279\u6B21 Embedding \u5931\u8D25"
+        );
+        clearVectorIndexHash(
+          db,
+          batchFiles.map((f) => f.path)
+        );
+        totalErrors += batchFiles.length;
+        completedChunks += batchTexts.length;
+        continue;
+      }
+      const filesToUpsert = [];
+      const ftsChunks = [];
+      const successFiles = [];
+      const errorFiles = [];
+      for (let fileIdx = 0; fileIdx < batchFiles.length; fileIdx++) {
+        const file = batchFiles[fileIdx];
+        try {
+          const records = [];
+          for (let chunkIdx = 0; chunkIdx < file.chunks.length; chunkIdx++) {
+            const chunk = file.chunks[chunkIdx];
+            const embIdx = indexByFileChunk[fileIdx][chunkIdx];
+            if (embIdx === void 0) {
+              throw new Error(`\u627E\u4E0D\u5230 chunk \u7684 embedding: ${file.path}#${chunkIdx}`);
+            }
+            const record = {
+              chunk_id: `${file.path}#${file.hash}#${chunkIdx}`,
+              file_path: file.path,
+              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,
+              end_index: chunk.metadata.endIndex,
+              raw_start: chunk.metadata.rawSpan.start,
+              raw_end: chunk.metadata.rawSpan.end,
+              vec_start: chunk.metadata.vectorSpan.start,
+              vec_end: chunk.metadata.vectorSpan.end
+            };
+            records.push(record);
+            ftsChunks.push({
+              chunkId: record.chunk_id,
+              filePath: record.file_path,
+              chunkIndex: record.chunk_index,
+              breadcrumb: record.breadcrumb,
+              content: `${record.breadcrumb}
+${record.display_code}`
+            });
+          }
+          filesToUpsert.push({ path: file.path, hash: file.hash, records });
+          successFiles.push({ path: file.path, hash: file.hash });
+        } catch (err) {
+          const error = err;
+          logger.error(
+            { path: file.path, error: error.message, stack: error.stack },
+            "\u7EC4\u88C5 ChunkRecord \u5931\u8D25"
+          );
+          errorFiles.push(file.path);
+        }
+      }
+      if (filesToUpsert.length > 0) {
+        try {
+          await this.vectorStore?.batchUpsertFiles(filesToUpsert);
+        } catch (err) {
+          const error = err;
+          logger.error({ error: error.message, stack: error.stack }, "LanceDB \u6279\u91CF\u5199\u5165\u5931\u8D25");
+          clearVectorIndexHash(
+            db,
+            batchFiles.map((f) => f.path)
+          );
+          totalErrors += batchFiles.length;
+          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 (successFiles.length > 0) {
+        batchUpdateVectorIndexHash(db, successFiles);
+      }
+      totalSuccess += successFiles.length;
+      totalErrors += errorFiles.length;
+      completedChunks += batchTexts.length;
+      logger.info(
+        {
+          batch: `${batchNum}/${totalBatches}`,
+          success: successFiles.length,
+          errors: errorFiles.length
+        },
+        "\u6279\u6B21\u7D22\u5F15\u5B8C\u6210"
+      );
+    }
+    logger.info({ success: totalSuccess, errors: totalErrors }, "\u5168\u90E8\u6279\u6B21\u7D22\u5F15\u5B8C\u6210");
+    return { success: totalSuccess, errors: totalErrors };
+  }
+  /**
+   * 删除文件的向量和 FTS 索引
+   */
+  async deleteFiles(db, paths) {
+    if (!this.vectorStore) return;
+    await this.vectorStore.deleteFiles(paths);
+    if (isChunksFtsInitialized(db)) {
+      batchDeleteFileChunksFts(db, paths);
+    }
+    logger.debug({ count: paths.length }, "\u5220\u9664\u6587\u4EF6\u7D22\u5F15");
+  }
+  /**
+   * 向量搜索
+   */
+  async search(queryVector, limit = 10, filter) {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    return this.vectorStore?.search(queryVector, limit, filter);
+  }
+  /**
+   * 文本搜索（先 embedding 再向量搜索）
+   */
+  async textSearch(query, limit = 10, filter) {
+    const queryVector = await this.embeddingClient.embed(query);
+    return this.search(queryVector, limit, filter);
+  }
+  /**
+   * 清空索引
+   */
+  async clear() {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    await this.vectorStore?.clear();
+  }
+  /**
+   * 获取索引统计
+   */
+  async getStats() {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    const count = await this.vectorStore?.count() ?? 0;
+    return { totalChunks: count };
+  }
+};
+var indexers = /* @__PURE__ */ new Map();
+async function getIndexer(projectId, vectorDim = 1024) {
+  let indexer = indexers.get(projectId);
+  if (!indexer) {
+    indexer = new Indexer(projectId, vectorDim);
+    await indexer.init();
+    indexers.set(projectId, indexer);
+  }
+  return indexer;
+}
+function closeAllIndexers() {
+  indexers.clear();
+}
+
+// src/search/utils.ts
+var tokenBoundaryRegexCache = /* @__PURE__ */ new Map();
+function getTokenBoundaryRegex(token) {
+  let regex = tokenBoundaryRegexCache.get(token);
+  if (!regex) {
+    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    regex = new RegExp(`\\b${escaped}\\b`);
+    tokenBoundaryRegexCache.set(token, regex);
+  }
+  return regex;
+}
+function scoreChunkTokenOverlap(chunk, queryTokens) {
+  const text = `${chunk.breadcrumb} ${chunk.display_code}`.toLowerCase();
+  let score = 0;
+  for (const token of queryTokens) {
+    if (text.includes(token)) {
+      const regex = getTokenBoundaryRegex(token);
+      if (regex.test(text)) {
+        score += 1;
+      } else {
+        score += 0.5;
+      }
+    }
+  }
+  return score;
+}
+
+// src/search/resolvers/types.ts
+function commonPrefixLength(path1, path2) {
+  const parts1 = path1.split("/");
+  const parts2 = path2.split("/");
+  let count = 0;
+  for (let i = 0; i < Math.min(parts1.length, parts2.length); i++) {
+    if (parts1[i] === parts2[i]) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+// src/search/resolvers/CppResolver.ts
+var CPP_EXTENSIONS = /* @__PURE__ */ new Set([".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"]);
+var CppResolver = class {
+  supports(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf("."));
+    return CPP_EXTENSIONS.has(ext);
+  }
+  extract(content) {
+    const imports = [];
+    const includePattern = /^\s*#\s*include\s+"([^"]+)"/gm;
+    for (const match of content.matchAll(includePattern)) {
+      imports.push(match[1]);
+    }
+    return imports;
+  }
+  resolve(importStr, currentFile, allFiles) {
+    const currentDir = currentFile.split("/").slice(0, -1).join("/");
+    const relativePath = currentDir ? `${currentDir}/${importStr}` : importStr;
+    if (allFiles.has(relativePath)) {
+      return relativePath;
+    }
+    const candidates = [];
+    for (const file of allFiles) {
+      if (file.endsWith(`/${importStr}`) || file === importStr) {
+        candidates.push(file);
+      }
+    }
+    if (candidates.length === 0) {
+      return null;
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    let bestCandidate = candidates[0];
+    let bestPrefixLen = commonPrefixLength(currentFile, bestCandidate);
+    for (let i = 1; i < candidates.length; i++) {
+      const prefixLen = commonPrefixLength(currentFile, candidates[i]);
+      if (prefixLen > bestPrefixLen) {
+        bestPrefixLen = prefixLen;
+        bestCandidate = candidates[i];
+      }
+    }
+    return bestCandidate;
+  }
+};
+
+// src/search/resolvers/CSharpResolver.ts
+var CSharpResolver = class {
+  supports(filePath) {
+    return filePath.endsWith(".cs");
+  }
+  extract(content) {
+    const imports = [];
+    const pattern = /^\s*using\s+(?!static\s)(?!global\s)(?:\w+\s*=\s*)?([\w.]+);/gm;
+    for (const match of content.matchAll(pattern)) {
+      imports.push(match[1]);
+    }
+    return imports;
+  }
+  resolve(importStr, currentFile, allFiles) {
+    const namespacePath = importStr.replace(/\./g, "/");
+    const suffix = `/${namespacePath}.cs`;
+    const candidates = [];
+    for (const filePath of allFiles) {
+      if (filePath.endsWith(suffix)) {
+        candidates.push(filePath);
+      }
+    }
+    if (candidates.length === 0) {
+      const parts = importStr.split(".");
+      const typeName = parts[parts.length - 1];
+      const typeSuffix = `/${typeName}.cs`;
+      for (const filePath of allFiles) {
+        if (filePath.endsWith(typeSuffix)) {
+          candidates.push(filePath);
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      return null;
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    let bestCandidate = candidates[0];
+    let bestPrefixLen = commonPrefixLength(currentFile, bestCandidate);
+    for (let i = 1; i < candidates.length; i++) {
+      const prefixLen = commonPrefixLength(currentFile, candidates[i]);
+      if (prefixLen > bestPrefixLen) {
+        bestPrefixLen = prefixLen;
+        bestCandidate = candidates[i];
+      }
+    }
+    return bestCandidate;
+  }
+};
+
+// src/search/resolvers/GoResolver.ts
+var GoResolver = class {
+  supports(filePath) {
+    return filePath.endsWith(".go");
+  }
+  extract(content) {
+    const imports = [];
+    const singlePattern = /^\s*import\s+"([^"]+)"/gm;
+    for (const match of content.matchAll(singlePattern)) {
+      imports.push(match[1]);
+    }
+    const blockPattern = /import\s*\(\s*([\s\S]*?)\s*\)/g;
+    for (const match of content.matchAll(blockPattern)) {
+      const block = match[1];
+      const linePattern = /"([^"]+)"/g;
+      for (const lineMatch of block.matchAll(linePattern)) {
+        imports.push(lineMatch[1]);
+      }
+    }
+    return imports;
+  }
+  resolve(importStr, _currentFile, allFiles) {
+    if (!importStr.includes("/") && !importStr.includes(".")) {
+      return null;
+    }
+    const suffix = `/${importStr}/`;
+    const candidates = [];
+    for (const filePath of allFiles) {
+      if (filePath.endsWith(".go") && filePath.includes(suffix)) {
+        candidates.push(filePath);
+      }
+    }
+    if (candidates.length === 0) return null;
+    const nonTest = candidates.find((f) => !f.endsWith("_test.go"));
+    return nonTest || candidates[0];
+  }
+};
+
+// src/search/resolvers/JavaResolver.ts
+var JavaResolver = class {
+  supports(filePath) {
+    return filePath.endsWith(".java");
+  }
+  extract(content) {
+    const imports = [];
+    const pattern = /^\s*import\s+(?:static\s+)?([\w.]+);/gm;
+    for (const match of content.matchAll(pattern)) {
+      imports.push(match[1]);
+    }
+    return imports;
+  }
+  resolve(importStr, _currentFile, allFiles) {
+    if (importStr.endsWith(".*")) {
+      const pkgPath = importStr.slice(0, -2).replace(/\./g, "/");
+      const suffix2 = `/${pkgPath}/`;
+      for (const filePath of allFiles) {
+        if (filePath.endsWith(".java") && filePath.includes(suffix2)) {
+          return filePath;
+        }
+      }
+      return null;
+    }
+    const classPath = importStr.replace(/\./g, "/");
+    const suffix = `/${classPath}.java`;
+    for (const filePath of allFiles) {
+      if (filePath.endsWith(suffix)) {
+        return filePath;
+      }
+    }
+    return null;
+  }
+};
+
+// src/search/resolvers/JsTsResolver.ts
+var JsTsResolver = class {
+  exts = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"];
+  // TypeScript ESM 项目使用 .js 扩展名导入，但源文件是 .ts
+  extMapping = {
+    ".js": [".ts", ".tsx", ".js", ".jsx"],
+    ".jsx": [".tsx", ".jsx"],
+    ".mjs": [".mts", ".mjs"],
+    ".cjs": [".cts", ".cjs"]
+  };
+  supports(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return this.exts.includes(`.${ext}` || "");
+  }
+  extract(content) {
+    const imports = [];
+    const patterns = [
+      // import xxx from './foo' 或 import { xxx } from './foo'
+      /(?:import|export)\s+(?:[\w\s{},*]+\s+from\s+)?['"]([^'"]+)['"]/g,
+      // import('./foo') 或 require('./foo')
+      /(?:import|require)\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+    for (const pattern of patterns) {
+      for (const match of content.matchAll(pattern)) {
+        imports.push(match[1]);
+      }
+    }
+    return imports;
+  }
+  resolve(importStr, currentFile, allFiles) {
+    if (!importStr.startsWith(".")) return null;
+    const currentDir = currentFile.split("/").slice(0, -1).join("/");
+    const parts = [...currentDir.split("/"), ...importStr.split("/")];
+    const resolvedParts = [];
+    for (const part of parts) {
+      if (part === "." || part === "") continue;
+      if (part === "..") resolvedParts.pop();
+      else resolvedParts.push(part);
+    }
+    const basePath = resolvedParts.join("/");
+    const existingExt = this.exts.find((ext) => basePath.endsWith(ext));
+    if (existingExt) {
+      const basePathWithoutExt = basePath.slice(0, -existingExt.length);
+      const mappedExts = this.extMapping[existingExt] || [existingExt];
+      for (const mappedExt of mappedExts) {
+        const mappedPath = basePathWithoutExt + mappedExt;
+        if (allFiles.has(mappedPath)) return mappedPath;
+      }
+      return null;
+    }
+    for (const ext of this.exts) {
+      const pathWithExt = basePath + ext;
+      if (allFiles.has(pathWithExt)) return pathWithExt;
+    }
+    for (const ext of this.exts) {
+      const indexPath = `${basePath}/index${ext}`;
+      if (allFiles.has(indexPath)) return indexPath;
+    }
+    return null;
+  }
+};
+
+// src/search/resolvers/PythonResolver.ts
+var PythonResolver = class {
+  supports(filePath) {
+    return filePath.endsWith(".py");
+  }
+  extract(content) {
+    const pattern = /^\s*(?:from\s+(\.{0,3}[\w.]*)\s+import|import\s+([\w.]+))/gm;
+    const imports = [];
+    for (const match of content.matchAll(pattern)) {
+      const importStr = match[1] || match[2];
+      if (importStr) {
+        imports.push(importStr);
+      }
+    }
+    return imports;
+  }
+  resolve(importStr, currentFile, allFiles) {
+    if (importStr.startsWith(".")) {
+      return this.resolveRelativeImport(importStr, currentFile, allFiles);
+    }
+    return this.resolveAbsoluteImport(importStr, currentFile, allFiles);
+  }
+  /**
+   * 解析 Python 相对导入
+   * - from . import foo -> 当前目录的 foo.py 或 foo/__init__.py
+   * - from .. import bar -> 父目录的 bar.py 或 bar/__init__.py
+   * - from ..utils import baz -> 父目录的 utils.py 或 utils/baz.py
+   */
+  resolveRelativeImport(importStr, currentFile, allFiles) {
+    const dotMatch = importStr.match(/^(\.+)/);
+    if (!dotMatch) return null;
+    const dotCount = dotMatch[1].length;
+    const rest = importStr.slice(dotCount);
+    const currentParts = currentFile.split("/");
+    currentParts.pop();
+    const targetDirParts = currentParts.slice(0, currentParts.length - (dotCount - 1));
+    if (targetDirParts.length < 0) return null;
+    const modulePath = rest.replace(/\./g, "/");
+    const basePath = targetDirParts.join("/");
+    const candidates = [];
+    if (modulePath) {
+      candidates.push(`${basePath}/${modulePath}.py`, `${basePath}/${modulePath}/__init__.py`);
+    } else {
+      candidates.push(`${basePath}/__init__.py`);
+    }
+    for (const candidate of candidates) {
+      if (allFiles.has(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  /**
+   * 解析 Python 绝对导入 (后缀模糊匹配 + 路径前缀歧义消解)
+   * - from my.pkg import xxx -> 找到以 /my/pkg.py 或 /my/pkg/__init__.py 结尾的文件
+   * - 如果有多个匹配，优先选择与当前文件路径前缀重叠最多的
+   */
+  resolveAbsoluteImport(importStr, currentFile, allFiles) {
+    const modulePath = importStr.replace(/\./g, "/");
+    const suffixes = [`/${modulePath}.py`, `/${modulePath}/__init__.py`];
+    const candidates = [];
+    for (const filePath of allFiles) {
+      for (const suffix of suffixes) {
+        if (filePath.endsWith(suffix)) {
+          const boundaryIndex = filePath.length - suffix.length;
+          if (boundaryIndex <= 0 || filePath[boundaryIndex - 1] === "/") {
+            candidates.push(filePath);
+            break;
+          }
+        }
+      }
+    }
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    const currentDir = currentFile.split("/").slice(0, -1).join("/");
+    candidates.sort((a, b) => {
+      const overlapA = commonPrefixLength(a, currentDir);
+      const overlapB = commonPrefixLength(b, currentDir);
+      return overlapB - overlapA;
+    });
+    return candidates[0];
+  }
+};
+
+// src/search/resolvers/RustResolver.ts
+var RustResolver = class {
+  supports(filePath) {
+    return filePath.endsWith(".rs");
+  }
+  extract(content) {
+    const imports = [];
+    const modPattern = /^\s*(?:pub\s+)?mod\s+(\w+)\s*;/gm;
+    for (const match of content.matchAll(modPattern)) {
+      imports.push(`mod:${match[1]}`);
+    }
+    const usePattern = /^\s*(?:pub\s+)?use\s+((?:crate|super|self)(?:::\w+)+)/gm;
+    for (const match of content.matchAll(usePattern)) {
+      imports.push(`use:${match[1]}`);
+    }
+    return imports;
+  }
+  resolve(importStr, currentFile, allFiles) {
+    const currentDir = currentFile.split("/").slice(0, -1).join("/");
+    if (importStr.startsWith("mod:")) {
+      const modName = importStr.slice(4);
+      const candidates = [`${currentDir}/${modName}.rs`, `${currentDir}/${modName}/mod.rs`];
+      for (const candidate of candidates) {
+        if (allFiles.has(candidate)) {
+          return candidate;
+        }
+      }
+      return null;
+    }
+    if (importStr.startsWith("use:")) {
+      const usePath = importStr.slice(4);
+      const parts = usePath.split("::");
+      let baseParts;
+      let startIndex;
+      if (parts[0] === "crate") {
+        const srcIndex = currentFile.indexOf("/src/");
+        if (srcIndex !== -1) {
+          baseParts = currentFile.slice(0, srcIndex + 4).split("/");
+        } else {
+          baseParts = currentDir.split("/");
+        }
+        startIndex = 1;
+      } else if (parts[0] === "super") {
+        baseParts = currentDir.split("/").slice(0, -1);
+        startIndex = 1;
+      } else if (parts[0] === "self") {
+        baseParts = currentDir.split("/");
+        startIndex = 1;
+      } else {
+        return null;
+      }
+      const moduleParts = parts.slice(startIndex);
+      const modulePath = [...baseParts, ...moduleParts].join("/");
+      const candidates = [`${modulePath}.rs`, `${modulePath}/mod.rs`];
+      for (const candidate of candidates) {
+        if (allFiles.has(candidate)) {
+          return candidate;
+        }
+      }
+      return null;
+    }
+    return null;
+  }
+};
+
+// src/search/resolvers/index.ts
+function createResolvers() {
+  return [
+    new JsTsResolver(),
+    new PythonResolver(),
+    new GoResolver(),
+    new JavaResolver(),
+    new RustResolver(),
+    new CppResolver(),
+    new CSharpResolver()
+  ];
+}
+
+// src/search/GraphExpander.ts
+var GraphExpander = class {
+  projectId;
+  config;
+  vectorStore = null;
+  db = null;
+  // 缓存所有文件路径 (用于快速查找和模糊匹配)
+  allFilePaths = null;
+  // 注册解析器（按优先级排列）
+  resolvers = createResolvers();
+  constructor(projectId, config) {
+    this.projectId = projectId;
+    this.config = config;
+  }
+  async init() {
+    const embeddingConfig = getEmbeddingConfig();
+    this.vectorStore = await getVectorStore(this.projectId, embeddingConfig.dimensions);
+    this.db = initDb(this.projectId);
+  }
+  /**
+   * 加载文件索引 (Lazy Load)
+   * 相比反复查 DB，一次性加载所有路径到 Set 内存占用极低且速度极快
+   */
+  loadFileIndex() {
+    if (this.allFilePaths) return;
+    if (!this.db) this.db = initDb(this.projectId);
+    const rows = this.db.prepare("SELECT path FROM files").all();
+    this.allFilePaths = new Set(rows.map((r) => r.path));
+    logger.debug({ count: this.allFilePaths.size }, "GraphExpander: \u6587\u4EF6\u7D22\u5F15\u5DF2\u52A0\u8F7D");
+  }
+  /**
+   * 使文件索引失效（用于增量索引后刷新）
+   */
+  invalidateFileIndex() {
+    this.allFilePaths = null;
+  }
+  /**
+   * 扩展 seed chunks
+   */
+  async expand(seeds, queryTokens) {
+    if (!this.vectorStore || !this.db) {
+      await this.init();
+    }
+    this.loadFileIndex();
+    const stats = {
+      neighborCount: 0,
+      breadcrumbCount: 0,
+      importCount: 0,
+      importDepth1Count: 0
+    };
+    if (seeds.length === 0) {
+      return { chunks: [], stats };
+    }
+    const existingKeys = new Set(seeds.map((s) => this.getChunkKey(s)));
+    const expandedChunks = [];
+    const seedsByFile = this.groupByFile(seeds);
+    const neighborChunks = await this.expandNeighbors(seedsByFile, existingKeys);
+    this.addChunks(neighborChunks, expandedChunks, existingKeys);
+    stats.neighborCount = neighborChunks.length;
+    const breadcrumbChunks = await this.expandBreadcrumb(seeds, existingKeys);
+    this.addChunks(breadcrumbChunks, expandedChunks, existingKeys);
+    stats.breadcrumbCount = breadcrumbChunks.length;
+    const importChunks = await this.expandImports(seeds, existingKeys, queryTokens, stats);
+    this.addChunks(importChunks, expandedChunks, existingKeys);
+    stats.importCount = importChunks.length;
+    logger.debug(stats, "\u4E0A\u4E0B\u6587\u6269\u5C55\u5B8C\u6210");
+    return { chunks: expandedChunks, stats };
+  }
+  /**
+   * 添加 chunks 并更新去重集合
+   */
+  addChunks(newChunks, target, keys) {
+    for (const chunk of newChunks) {
+      const key = this.getChunkKey(chunk);
+      if (!keys.has(key)) {
+        keys.add(key);
+        target.push(chunk);
+      }
+    }
+  }
+  // =========================================
+  // E1: 同文件邻居扩展
+  // =========================================
+  /**
+   * 扩展同文件邻居
+   *
+   * 对于每个 seed，获取其前后 ±neighborHops 个 chunks
+   */
+  async expandNeighbors(seedsByFile, existingKeys) {
+    const result = [];
+    const { neighborHops, decayNeighbor } = this.config;
+    const allFilePaths = Array.from(seedsByFile.keys());
+    const allChunksMap = await this.vectorStore?.getFilesChunks(allFilePaths);
+    if (!allChunksMap) return result;
+    for (const [filePath, fileSeeds] of seedsByFile) {
+      const allChunks = allChunksMap.get(filePath) ?? [];
+      if (allChunks.length === 0) continue;
+      const sortedChunks = allChunks.sort((a, b) => a.chunk_index - b.chunk_index);
+      const chunkMap = new Map(sortedChunks.map((c) => [c.chunk_index, c]));
+      const seedIndices = new Set(fileSeeds.map((s) => s.chunkIndex));
+      const neighborIndices = /* @__PURE__ */ new Set();
+      for (const seed of fileSeeds) {
+        const baseIndex = seed.chunkIndex;
+        for (let delta = -neighborHops; delta <= neighborHops; delta++) {
+          if (delta === 0) continue;
+          const neighborIndex = baseIndex + delta;
+          if (!seedIndices.has(neighborIndex) && chunkMap.has(neighborIndex)) {
+            neighborIndices.add(neighborIndex);
+          }
+        }
+      }
+      for (const neighborIndex of neighborIndices) {
+        const chunk = chunkMap.get(neighborIndex);
+        if (!chunk) continue;
+        const key = `${filePath}#${neighborIndex}`;
+        if (existingKeys.has(key)) continue;
+        let minDistance = Infinity;
+        let maxSeedScore = 0;
+        for (const seed of fileSeeds) {
+          const distance = Math.abs(neighborIndex - seed.chunkIndex);
+          if (distance < minDistance) {
+            minDistance = distance;
+            maxSeedScore = seed.score;
+          } else if (distance === minDistance && seed.score > maxSeedScore) {
+            maxSeedScore = seed.score;
+          }
+        }
+        const decayedScore = maxSeedScore * decayNeighbor ** minDistance;
+        result.push({
+          filePath,
+          chunkIndex: neighborIndex,
+          score: decayedScore,
+          source: "neighbor",
+          record: { ...chunk, _distance: 0 }
+        });
+      }
+    }
+    return result;
+  }
+  // =========================================
+  // E2: breadcrumb 补段
+  // =========================================
+  /**
+   * 扩展 breadcrumb 补段
+   *
+   * 对于每个 seed，找到具有相同 breadcrumb 前缀的其他 chunks
+   * 例如：如果 seed 的 breadcrumb 是 "src/foo.ts > class Foo > method bar"
+   * 则会找到 "src/foo.ts > class Foo > ..." 的其他 chunks
+   */
+  async expandBreadcrumb(seeds, existingKeys) {
+    const result = [];
+    const { breadcrumbExpandLimit, decayBreadcrumb } = this.config;
+    const prefixGroups = /* @__PURE__ */ new Map();
+    for (const seed of seeds) {
+      const prefix = this.extractBreadcrumbPrefix(seed.record.breadcrumb);
+      if (!prefix) continue;
+      if (!prefixGroups.has(prefix)) {
+        prefixGroups.set(prefix, []);
+      }
+      prefixGroups.get(prefix)?.push(seed);
+    }
+    const uniqueFilePaths = /* @__PURE__ */ new Set();
+    for (const prefixSeeds of prefixGroups.values()) {
+      uniqueFilePaths.add(prefixSeeds[0].filePath);
+    }
+    const allChunksMap = await this.vectorStore?.getFilesChunks(Array.from(uniqueFilePaths));
+    if (!allChunksMap) return result;
+    for (const [prefix, prefixSeeds] of prefixGroups) {
+      const filePath = prefixSeeds[0].filePath;
+      const allChunks = allChunksMap.get(filePath) ?? [];
+      const chunkPrefixCache = /* @__PURE__ */ new Map();
+      for (const chunk of allChunks) {
+        chunkPrefixCache.set(chunk.chunk_index, this.extractBreadcrumbPrefix(chunk.breadcrumb));
+      }
+      const matchingChunks = allChunks.filter((chunk) => {
+        return chunkPrefixCache.get(chunk.chunk_index) === prefix;
+      });
+      const seedIndices = new Set(prefixSeeds.map((s) => s.chunkIndex));
+      const newChunks = matchingChunks.filter((chunk) => !seedIndices.has(chunk.chunk_index)).filter((chunk) => !existingKeys.has(`${filePath}#${chunk.chunk_index}`)).slice(0, breadcrumbExpandLimit);
+      const maxSeedScore = Math.max(...prefixSeeds.map((s) => s.score));
+      for (const chunk of newChunks) {
+        result.push({
+          filePath,
+          chunkIndex: chunk.chunk_index,
+          score: maxSeedScore * decayBreadcrumb,
+          source: "breadcrumb",
+          record: { ...chunk, _distance: 0 }
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * 提取 breadcrumb 的父级前缀
+   *
+   * 例如：
+   * - "src/foo.ts > class Foo > method bar" → "src/foo.ts > class Foo"
+   * - "src/foo.ts > function baz" → "src/foo.ts"
+   * - "src/foo.ts" → null (没有父级)
+   */
+  extractBreadcrumbPrefix(breadcrumb) {
+    const parts = breadcrumb.split(" > ");
+    if (parts.length <= 1) return null;
+    return parts.slice(0, -1).join(" > ");
+  }
+  // =========================================
+  // E3: 跨文件引用解析（多语言支持）
+  // =========================================
+  /**
+   * 扩展 import 关系
+   *
+   * 解析 seed 文件中的 import 语句，获取被导入文件的 chunks
+   * 支持多语言：TypeScript/JavaScript, Python, Go, Java, Rust
+   */
+  async expandImports(seeds, existingKeys, queryTokens, stats) {
+    const result = [];
+    const { importFilesPerSeed, chunksPerImportFile, decayImport, decayDepth } = this.config;
+    const seedScoreByFile = this.buildSeedScoreByFile(seeds);
+    const queue = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const [filePath, seedScore] of seedScoreByFile.entries()) {
+      queue.push({ filePath, depth: 0, seedScore });
+    }
+    const resolvedImports = [];
+    const allTargetPaths = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) break;
+      const { filePath, depth, seedScore } = item;
+      if (visited.has(filePath)) continue;
+      visited.add(filePath);
+      if (depth > 0 && !this.isBarrelFile(filePath)) continue;
+      const resolver = this.resolvers.find((r) => r.supports(filePath));
+      if (!resolver) continue;
+      const row = this.db?.prepare("SELECT content FROM files WHERE path = ?").get(filePath);
+      if (!row?.content) continue;
+      const importStrs = resolver.extract(row.content);
+      if (importStrs.length === 0) continue;
+      const perFileLimit = depth === 0 ? importFilesPerSeed : Math.min(importFilesPerSeed, 2);
+      let importCount = 0;
+      const processedImports = /* @__PURE__ */ new Set();
+      for (const importStr of importStrs) {
+        if (importCount >= perFileLimit) break;
+        if (processedImports.has(importStr)) continue;
+        processedImports.add(importStr);
+        const targetPath = resolver.resolve(importStr, filePath, this.allFilePaths);
+        if (!targetPath || targetPath === filePath) continue;
+        allTargetPaths.add(targetPath);
+        resolvedImports.push({ targetPath, depth, seedScore, sourceFilePath: filePath });
+        importCount++;
+        if (depth === 0 && this.isBarrelFile(targetPath)) {
+          if (stats) stats.importDepth1Count++;
+          queue.push({ filePath: targetPath, depth: 1, seedScore });
+        }
+      }
+    }
+    if (allTargetPaths.size === 0) return result;
+    const importChunksMap = await this.vectorStore?.getFilesChunks(Array.from(allTargetPaths));
+    if (!importChunksMap) return result;
+    const bestByKey = /* @__PURE__ */ new Map();
+    for (const { targetPath, depth, seedScore } of resolvedImports) {
+      const importChunks = importChunksMap.get(targetPath);
+      if (!importChunks || importChunks.length === 0) continue;
+      const selectedChunks = this.selectImportChunks(
+        importChunks,
+        chunksPerImportFile,
+        queryTokens
+      );
+      const depthDecay = depth === 0 ? 1 : decayDepth;
+      for (const chunk of selectedChunks) {
+        const key = `${targetPath}#${chunk.chunk_index}`;
+        if (existingKeys.has(key)) continue;
+        const score = seedScore * decayImport * depthDecay;
+        const existing = bestByKey.get(key);
+        if (!existing || score > existing.score) {
+          bestByKey.set(key, {
+            filePath: targetPath,
+            chunkIndex: chunk.chunk_index,
+            score,
+            source: "import",
+            record: { ...chunk, _distance: 0 }
+          });
+        }
+      }
+    }
+    return Array.from(bestByKey.values());
+  }
+  // =========================================
+  // 工具方法
+  // =========================================
+  /**
+   * 生成 chunk 唯一键
+   */
+  getChunkKey(chunk) {
+    return `${chunk.filePath}#${chunk.chunkIndex}`;
+  }
+  /**
+   * 按文件分组
+   */
+  groupByFile(chunks) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      if (!groups.has(chunk.filePath)) {
+        groups.set(chunk.filePath, []);
+      }
+      groups.get(chunk.filePath)?.push(chunk);
+    }
+    return groups;
+  }
+  /**
+   * 按文件汇总 seed 最大得分
+   */
+  buildSeedScoreByFile(seeds) {
+    const map = /* @__PURE__ */ new Map();
+    for (const seed of seeds) {
+      const current = map.get(seed.filePath);
+      if (current === void 0 || seed.score > current) {
+        map.set(seed.filePath, seed.score);
+      }
+    }
+    return map;
+  }
+  /**
+   * 选择导入文件的 chunks（优先 query overlap）
+   */
+  selectImportChunks(chunks, limit, queryTokens) {
+    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)
+    }));
+    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);
+  }
+  /**
+   * 判断是否为 barrel/index 文件
+   */
+  isBarrelFile(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith("/__init__.py")) return true;
+    if (lower.endsWith("/mod.rs")) return true;
+    return /\/index\.(ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(lower);
+  }
+};
+var expanders = /* @__PURE__ */ new Map();
+function invalidateAllExpanderCaches() {
+  for (const expander of expanders.values()) {
+    expander.invalidateFileIndex();
+  }
+}
+async function getGraphExpander(projectId, config) {
+  let expander = expanders.get(projectId);
+  if (!expander) {
+    expander = new GraphExpander(projectId, config);
+    await expander.init();
+    expanders.set(projectId, expander);
+  }
+  return expander;
+}
+
+export {
+  getVectorStore,
+  closeAllVectorStores,
+  getIndexer,
+  closeAllIndexers,
+  scoreChunkTokenOverlap,
+  invalidateAllExpanderCaches,
+  getGraphExpander
+};
+//# sourceMappingURL=chunk-6QMYML5V.js.map