@hsingjui/contextweaver 0.0.1

package/dist/chunk-6C2D5Y4R.js

@@ -0,0 +1,798 @@
+import {
+  batchDeleteFileChunksFts,
+  batchUpdateVectorIndexHash,
+  batchUpsertChunkFts,
+  clearVectorIndexHash,
+  isChunksFtsInitialized,
+  logger
+} from "./chunk-5SRSUMKW.js";
+import {
+  getEmbeddingConfig
+} from "./chunk-PN7DP6XL.js";
+
+// src/vectorStore/index.ts
+import * as lancedb from "@lancedb/lancedb";
+import path from "path";
+import os from "os";
+import fs from "fs";
+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 次循环）
+   */
+  async deleteFiles(filePaths) {
+    if (!this.table || filePaths.length === 0) return;
+    const conditions = filePaths.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 次循环）
+   * 
+   * 适用于 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 conditions = filePaths.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/indexer/index.ts
+import "better-sqlite3";
+
+// src/api/embedding.ts
+var ProgressTracker = class {
+  completed = 0;
+  total;
+  totalTokens = 0;
+  startTime;
+  lastLogTime = 0;
+  logIntervalMs = 2e3;
+  // 每 3 秒输出一次
+  constructor(total) {
+    this.total = total;
+    this.startTime = Date.now();
+  }
+  /** 记录一个批次完成 */
+  recordBatch(tokens) {
+    this.completed++;
+    this.totalTokens += tokens;
+    const now = Date.now();
+    if (now - this.lastLogTime >= this.logIntervalMs) {
+      this.logProgress();
+      this.lastLogTime = now;
+    }
+  }
+  /** 输出进度 */
+  logProgress() {
+    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() {
+    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;
+    const resolvedPromise = this.pausePromise;
+    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）
+   */
+  async embedBatch(texts, batchSize = 20) {
+    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);
+    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) {
+    while (true) {
+      await this.rateLimiter.acquire();
+      try {
+        const result = await this.processBatch(texts, startIndex, progress);
+        this.rateLimiter.releaseSuccess();
+        return result;
+      } catch (err) {
+        const isRateLimited = err.message?.includes("429") || err.message?.includes("rate");
+        if (isRateLimited) {
+          this.rateLimiter.releaseForRetry();
+          await this.rateLimiter.triggerRateLimit();
+        } else {
+          this.rateLimiter.releaseFailure();
+          throw err;
+        }
+      }
+    }
+  }
+  /**
+   * 处理单个批次（单次请求，不含重试逻辑）
+   */
+  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 文件处理结果
+   */
+  async indexFiles(db, results) {
+    if (!this.vectorStore) {
+      await this.init();
+    }
+    const stats = {
+      indexed: 0,
+      deleted: 0,
+      errors: 0,
+      skipped: 0
+    };
+    const toIndex = [];
+    const toDelete = [];
+    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 {
+            toDelete.push(result.relPath);
+            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 (toIndex.length > 0) {
+      const indexResult = await this.batchIndex(db, toIndex);
+      stats.indexed = indexResult.success;
+      stats.errors = indexResult.errors;
+    }
+    logger.info(
+      { indexed: stats.indexed, deleted: stats.deleted, errors: stats.errors, skipped: stats.skipped },
+      "\u5411\u91CF\u7D22\u5F15\u5B8C\u6210"
+    );
+    return stats;
+  }
+  /**
+   * 批量索引文件（性能优化版）
+   * 
+   * 优化策略：
+   * 1. Embedding 已批量化（原有）
+   * 2. LanceDB 写入批量化：N 次 upsertFile → 1 次 batchUpsertFiles
+   * 3. FTS 写入批量化：N 次删除+插入 → 1 次批量删除 + 1 次批量插入
+   * 4. 日志汇总化：逐文件日志 → 汇总日志
+   */
+  async batchIndex(db, files) {
+    if (files.length === 0) {
+      return { success: 0, errors: 0 };
+    }
+    const allTexts = [];
+    const globalIndexByFileChunk = [];
+    for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+      const file = files[fileIdx];
+      globalIndexByFileChunk[fileIdx] = [];
+      for (let chunkIdx = 0; chunkIdx < file.chunks.length; chunkIdx++) {
+        const globalIdx = allTexts.length;
+        allTexts.push(file.chunks[chunkIdx].vectorText);
+        globalIndexByFileChunk[fileIdx][chunkIdx] = globalIdx;
+      }
+    }
+    if (allTexts.length === 0) {
+      return { success: 0, errors: 0 };
+    }
+    logger.info({ count: allTexts.length, files: files.length }, "\u5F00\u59CB\u6279\u91CF Embedding");
+    let embeddings;
+    try {
+      const results = await this.embeddingClient.embedBatch(allTexts);
+      embeddings = results.map((r) => r.embedding);
+    } catch (err) {
+      logger.error({ error: err.message, stack: err.stack }, "Embedding \u5931\u8D25");
+      clearVectorIndexHash(db, files.map((f) => f.path));
+      return { success: 0, errors: files.length };
+    }
+    const filesToUpsert = [];
+    const allFtsChunks = [];
+    const successFiles = [];
+    const errorFiles = [];
+    for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+      const file = files[fileIdx];
+      try {
+        const records = [];
+        for (let chunkIdx = 0; chunkIdx < file.chunks.length; chunkIdx++) {
+          const chunk = file.chunks[chunkIdx];
+          const globalIdx = globalIndexByFileChunk[fileIdx][chunkIdx];
+          if (globalIdx === 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[globalIdx],
+            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);
+          allFtsChunks.push({
+            chunkId: record.chunk_id,
+            filePath: record.file_path,
+            chunkIndex: record.chunk_index,
+            breadcrumb: record.breadcrumb,
+            content: record.breadcrumb + "\n" + record.display_code
+          });
+        }
+        filesToUpsert.push({ path: file.path, hash: file.hash, records });
+        successFiles.push({ path: file.path, hash: file.hash });
+      } catch (err) {
+        logger.error({ path: file.path, error: err.message, stack: err.stack }, "\u7EC4\u88C5 ChunkRecord \u5931\u8D25");
+        errorFiles.push(file.path);
+      }
+    }
+    if (filesToUpsert.length > 0) {
+      try {
+        await this.vectorStore.batchUpsertFiles(filesToUpsert);
+        logger.info({ files: filesToUpsert.length, chunks: allFtsChunks.length }, "LanceDB \u6279\u91CF\u5199\u5165\u5B8C\u6210");
+      } catch (err) {
+        logger.error({ error: err.message, stack: err.stack }, "LanceDB \u6279\u91CF\u5199\u5165\u5931\u8D25");
+        clearVectorIndexHash(db, files.map((f) => f.path));
+        return { success: 0, errors: files.length };
+      }
+    }
+    if (isChunksFtsInitialized(db) && allFtsChunks.length > 0) {
+      try {
+        const pathsToDelete = filesToUpsert.map((f) => f.path);
+        batchDeleteFileChunksFts(db, pathsToDelete);
+        batchUpsertChunkFts(db, allFtsChunks);
+        logger.info({ files: pathsToDelete.length, chunks: allFtsChunks.length }, "FTS \u6279\u91CF\u66F4\u65B0\u5B8C\u6210");
+      } catch (err) {
+        logger.warn({ error: err.message }, "FTS \u6279\u91CF\u66F4\u65B0\u5931\u8D25\uFF08\u5411\u91CF\u7D22\u5F15\u5DF2\u6210\u529F\uFF09");
+      }
+    }
+    if (successFiles.length > 0) {
+      batchUpdateVectorIndexHash(db, successFiles);
+    }
+    logger.info(
+      { success: successFiles.length, errors: errorFiles.length },
+      "\u6279\u91CF\u7D22\u5F15\u5B8C\u6210"
+    );
+    return { success: successFiles.length, errors: errorFiles.length };
+  }
+  /**
+   * 删除文件的向量和 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();
+    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();
+}
+
+export {
+  getVectorStore,
+  closeAllVectorStores,
+  getIndexer,
+  closeAllIndexers
+};