@chiway/contextweaver 1.0.0 → 1.1.0

package/dist/SearchService-MYPOCM3B.js

@@ -0,0 +1,886 @@
+import {
+  getGraphExpander,
+  getIndexer,
+  getVectorStore,
+  scoreChunkTokenOverlap
+} from "./chunk-6QMYML5V.js";
+import {
+  initDb,
+  isChunksFtsInitialized,
+  isFtsInitialized,
+  searchChunksFts,
+  searchFilesFts,
+  segmentQuery
+} from "./chunk-6Z4JEEVJ.js";
+import {
+  isDebugEnabled,
+  logger
+} from "./chunk-AMQQK4P7.js";
+import {
+  getEmbeddingConfig,
+  getRerankerConfig
+} from "./chunk-RJURH22T.js";
+
+// src/api/reranker.ts
+var RerankerClient = class {
+  config;
+  constructor(config) {
+    this.config = config || getRerankerConfig();
+  }
+  /**
+   * 对文档进行重排序
+   * @param query 查询文本
+   * @param documents 待排序的文档文本数组
+   * @param options 选项
+   */
+  async rerank(query, documents, options = {}) {
+    if (documents.length === 0) {
+      return [];
+    }
+    const { topN = this.config.topN, maxChunksPerDoc, chunkOverlap, retries = 3 } = options;
+    const requestBody = {
+      model: this.config.model,
+      query,
+      documents,
+      top_n: Math.min(topN, documents.length),
+      return_documents: false
+    };
+    if (maxChunksPerDoc !== void 0) {
+      requestBody.max_chunks_per_doc = maxChunksPerDoc;
+    }
+    if (chunkOverlap !== void 0) {
+      requestBody.overlap = chunkOverlap;
+    }
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        const response = await fetch(this.config.baseUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.apiKey}`
+          },
+          body: JSON.stringify(requestBody)
+        });
+        const contentType = response.headers.get("content-type") || void 0;
+        const rawText = await response.text();
+        if (!rawText) {
+          throw new Error(`Rerank API \u8FD4\u56DE\u7A7A\u54CD\u5E94: HTTP ${response.status}`);
+        }
+        let data;
+        try {
+          data = JSON.parse(rawText);
+        } catch {
+          const snippet = rawText.slice(0, 200);
+          const meta = contentType ? `, content-type=${contentType}` : "";
+          throw new Error(
+            `Rerank API \u8FD4\u56DE\u975E JSON \u54CD\u5E94: HTTP ${response.status}${meta}, body=${JSON.stringify(snippet)}`
+          );
+        }
+        if (!response.ok || data.error || data.code || data.message) {
+          const errorMsg = data.error?.message || data.message || (data.code ? `${data.code}` : "") || `HTTP ${response.status}`;
+          throw new Error(`Rerank API \u9519\u8BEF: ${errorMsg}`);
+        }
+        const rerankResults = data.results ?? data.output?.results;
+        if (!rerankResults || !Array.isArray(rerankResults)) {
+          throw new Error("Rerank API \u8FD4\u56DE\u683C\u5F0F\u4E0D\u7B26\u5408\u9884\u671F\uFF1A\u7F3A\u5C11 results/output.results");
+        }
+        const results = rerankResults.map((item) => ({
+          originalIndex: item.index,
+          score: item.relevance_score,
+          text: documents[item.index]
+        }));
+        logger.debug(
+          {
+            query: query.slice(0, 50),
+            inputCount: documents.length,
+            outputCount: results.length
+          },
+          "Rerank \u5B8C\u6210"
+        );
+        return results;
+      } catch (err) {
+        const error = err;
+        const isRateLimited = error.message?.includes("429") || error.message?.includes("rate");
+        if (attempt < retries) {
+          const delay = isRateLimited ? 1e3 * attempt : 500 * attempt;
+          logger.warn(
+            { attempt, maxRetries: retries, delay, error: error.message },
+            "Rerank \u8BF7\u6C42\u5931\u8D25\uFF0C\u51C6\u5907\u91CD\u8BD5"
+          );
+          await sleep(delay);
+        } else {
+          logger.error(
+            { error: error.message, stack: error.stack, query: query.slice(0, 50) },
+            "Rerank \u8BF7\u6C42\u6700\u7EC8\u5931\u8D25"
+          );
+          throw err;
+        }
+      }
+    }
+    throw new Error("Rerank \u5904\u7406\u5F02\u5E38");
+  }
+  /**
+   * 对带有元数据的文档进行重排序
+   * @param query 查询文本
+   * @param items 文档项数组
+   * @param textExtractor 从文档项中提取文本的函数
+   * @param options 选项
+   */
+  async rerankWithData(query, items, textExtractor, options = {}) {
+    if (items.length === 0) {
+      return [];
+    }
+    const texts = items.map(textExtractor);
+    const results = await this.rerank(query, texts, options);
+    return results.map((result) => ({
+      ...result,
+      data: items[result.originalIndex]
+    }));
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var defaultClient = null;
+function getRerankerClient() {
+  if (!defaultClient) {
+    defaultClient = new RerankerClient();
+  }
+  return defaultClient;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/search/ContextPacker.ts
+var ContextPacker = class {
+  projectId;
+  config;
+  constructor(projectId, config) {
+    this.projectId = projectId;
+    this.config = config;
+  }
+  /**
+   * 打包：合并 chunks → 按文件聚合段落 → 预算裁剪
+   */
+  async pack(chunks, db) {
+    if (chunks.length === 0) return [];
+    const byFile = this.groupByFile(chunks);
+    const result = [];
+    let totalChars = 0;
+    const sortedFiles = Object.entries(byFile).map(([filePath, fileChunks]) => ({
+      filePath,
+      chunks: fileChunks,
+      maxScore: Math.max(...fileChunks.map((c) => c.score))
+    })).sort((a, b) => b.maxScore - a.maxScore);
+    const allFilePaths = sortedFiles.map((f) => f.filePath);
+    const placeholders = allFilePaths.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT path, content FROM files WHERE path IN (${placeholders})`).all(...allFilePaths);
+    const contentMap = new Map(rows.map((r) => [r.path, r.content]));
+    for (const { filePath, chunks: fileChunks } of sortedFiles) {
+      const content = contentMap.get(filePath);
+      if (!content) continue;
+      const segments = this.mergeAndSlice(fileChunks, content);
+      const topSegments = segments.sort((a, b) => b.score - a.score).slice(0, this.config.maxSegmentsPerFile).sort((a, b) => a.rawStart - b.rawStart);
+      const budgetedSegments = [];
+      for (const seg of topSegments) {
+        if (totalChars + seg.text.length > this.config.maxTotalChars) {
+          break;
+        }
+        totalChars += seg.text.length;
+        budgetedSegments.push(seg);
+      }
+      if (budgetedSegments.length > 0) {
+        result.push({ filePath, segments: budgetedSegments });
+      }
+      if (totalChars >= this.config.maxTotalChars) break;
+    }
+    return result;
+  }
+  /**
+   * 按文件分组
+   */
+  groupByFile(chunks) {
+    const byFile = {};
+    for (const chunk of chunks) {
+      const key = chunk.filePath;
+      if (!byFile[key]) byFile[key] = [];
+      byFile[key].push(chunk);
+    }
+    return byFile;
+  }
+  /**
+   * 合并重叠区间 + 从原文件切片
+   */
+  mergeAndSlice(chunks, content) {
+    if (chunks.length === 0) return [];
+    const sorted = [...chunks].sort((a, b) => a.record.raw_start - b.record.raw_start);
+    const intervals = [];
+    for (const chunk of sorted) {
+      const start = chunk.record.raw_start;
+      const end = chunk.record.raw_end;
+      const last = intervals[intervals.length - 1];
+      if (last && start <= last.end) {
+        last.end = Math.max(last.end, end);
+        last.score = Math.max(last.score, chunk.score);
+        last.chunks.push(chunk);
+      } else {
+        intervals.push({
+          start,
+          end,
+          score: chunk.score,
+          breadcrumb: chunk.record.breadcrumb,
+          chunks: [chunk]
+        });
+      }
+    }
+    return intervals.map((iv) => {
+      const startLine = this.offsetToLine(content, iv.start);
+      const endLine = this.offsetToLine(content, iv.end);
+      return {
+        filePath: chunks[0].filePath,
+        rawStart: iv.start,
+        rawEnd: iv.end,
+        startLine,
+        endLine,
+        score: iv.score,
+        breadcrumb: iv.breadcrumb,
+        text: content.slice(iv.start, iv.end)
+      };
+    });
+  }
+  /**
+   * 将字符偏移量转换为行号（1-indexed）
+   */
+  offsetToLine(content, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < content.length; i++) {
+      if (content[i] === "\n") {
+        line++;
+      }
+    }
+    return line;
+  }
+};
+
+// src/search/config.ts
+var DEFAULT_CONFIG = {
+  // ── Recall (向量 + 词法召回) ──
+  vectorTopK: 80,
+  // Vector ANN candidates before dedup. Range: 40–200. Higher = better recall, more compute.
+  vectorTopM: 60,
+  // Vectors kept after dedup. Range: 30–100.
+  ftsTopKFiles: 20,
+  // Max files returned by FTS5 full-text search. Range: 10–50.
+  lexChunksPerFile: 2,
+  // Chunks to pull per FTS-matched file. Range: 1–5. Low keeps diversity across files.
+  lexTotalChunks: 40,
+  // Hard cap on total lexical chunks. Range: 20–80.
+  // ── RRF Fusion (向量 + 词法分数融合) ──
+  rrfK0: 20,
+  // RRF smoothing constant. Range: 10–60. Lower amplifies top ranks.
+  wVec: 0.6,
+  // Vector weight in fused score. Range: 0.3–0.8. Semantic relevance emphasis.
+  wLex: 0.4,
+  // Lexical weight in fused score. wVec + wLex should equal 1.0.
+  fusedTopM: 60,
+  // Candidates after fusion, fed into reranker. Range: 30–100.
+  // ── Rerank (精排) ──
+  rerankTopN: 10,
+  // Final top-N results after reranking. Range: 5–20.
+  maxRerankChars: 1e3,
+  // Max chars per chunk sent to reranker. Truncated beyond this. Range: 500–2000.
+  maxBreadcrumbChars: 250,
+  // Max chars for breadcrumb context in rerank input. Range: 100–500.
+  headRatio: 0.67,
+  // Ratio of head vs tail when truncating chunks. Range: 0.5–0.8.
+  // ── Expansion (上下文扩展: E1 邻居 / E2 面包屑 / E3 跨文件导入) ──
+  neighborHops: 2,
+  // E1: How many sibling chunks to expand in each direction. Range: 1–3.
+  breadcrumbExpandLimit: 3,
+  // E2: Max ancestor breadcrumbs (class/function scope). Range: 1–5.
+  importFilesPerSeed: 3,
+  // E3: Cross-file import files to resolve per seed chunk. Range: 0–5. Set to 3 to enable import-graph expansion for better cross-file context.
+  chunksPerImportFile: 3,
+  // E3: Chunks to pull from each resolved import file. Range: 1–5. Set to 3 for balanced coverage of imported symbols.
+  decayNeighbor: 0.8,
+  // Score decay per E1 hop. Range: 0.5–0.9. Higher = neighbors stay relevant longer.
+  decayBreadcrumb: 0.7,
+  // Score decay per E2 level. Range: 0.4–0.8.
+  decayImport: 0.6,
+  // Score decay for E3 import chunks. Range: 0.3–0.7. Lower than E1/E2 since cross-file is less certain.
+  decayDepth: 0.7,
+  // General depth decay multiplier. Range: 0.5–0.9.
+  // ── ContextPacker (上下文打包) ──
+  maxSegmentsPerFile: 3,
+  // Max non-contiguous segments per file in output. Range: 1–5. Prevents excessive fragmentation.
+  maxTotalChars: 48e3,
+  // Token budget expressed as chars (~12k tokens). Range: 20000–80000.
+  // ── Smart TopK (动态结果数量) ──
+  enableSmartTopK: true,
+  // Dynamically adjust result count based on score distribution.
+  smartTopScoreRatio: 0.5,
+  // Min score as ratio of top-1 score to remain included. Range: 0.3–0.7.
+  smartTopScoreDeltaAbs: 0.25,
+  // Max absolute score drop from top-1 before cutting off. Range: 0.1–0.4.
+  smartMinScore: 0.25,
+  // Hard floor: chunks below this score are always excluded. Range: 0.1–0.4.
+  smartMinK: 2,
+  // Minimum results to return regardless of scores. Range: 1–3.
+  smartMaxK: 8
+  // Maximum results when smart topK is active. Range: 5–15.
+};
+
+// src/search/SearchService.ts
+var SearchService = class {
+  projectId;
+  indexer = null;
+  vectorStore = null;
+  db = null;
+  config;
+  constructor(projectId, _projectPath, config) {
+    this.projectId = projectId;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  async init() {
+    const embeddingConfig = getEmbeddingConfig();
+    this.indexer = await getIndexer(this.projectId, embeddingConfig.dimensions);
+    this.vectorStore = await getVectorStore(this.projectId, embeddingConfig.dimensions);
+    this.db = initDb(this.projectId);
+  }
+  // 公开接口
+  /**
+   * 构建上下文包（用于问答/生成）
+   */
+  async buildContextPack(query) {
+    const timingMs = {};
+    let t0 = Date.now();
+    const candidates = await this.hybridRetrieve(query);
+    timingMs.retrieve = Date.now() - t0;
+    t0 = Date.now();
+    const topM = candidates.sort((a, b) => b.score - a.score).slice(0, this.config.fusedTopM);
+    const reranked = await this.rerank(query, topM);
+    timingMs.rerank = Date.now() - t0;
+    t0 = Date.now();
+    const seeds = this.applySmartCutoff(reranked);
+    timingMs.smartCutoff = Date.now() - t0;
+    t0 = Date.now();
+    const queryTokens = this.extractQueryTokens(query);
+    const expanded = await this.expand(seeds, queryTokens);
+    timingMs.expand = Date.now() - t0;
+    t0 = Date.now();
+    const packer = new ContextPacker(this.projectId, this.config);
+    const files = await packer.pack([...seeds, ...expanded], this.db);
+    timingMs.pack = Date.now() - t0;
+    return {
+      query,
+      seeds,
+      expanded,
+      files,
+      debug: {
+        wVec: this.config.wVec,
+        wLex: this.config.wLex,
+        timingMs
+      }
+    };
+  }
+  // 召回方法
+  /**
+   * 混合召回：向量 + 词法
+   */
+  async hybridRetrieve(query) {
+    const [vectorResults, lexicalResults] = await Promise.all([
+      this.vectorRetrieve(query),
+      this.lexicalRetrieve(query)
+    ]);
+    logger.debug(
+      {
+        vectorCount: vectorResults.length,
+        lexicalCount: lexicalResults.length
+      },
+      "\u6DF7\u5408\u53EC\u56DE\u5B8C\u6210"
+    );
+    if (lexicalResults.length === 0) {
+      return vectorResults;
+    }
+    return this.fuse(vectorResults, lexicalResults);
+  }
+  /**
+   * 向量召回
+   */
+  async vectorRetrieve(query) {
+    if (!this.indexer) throw new Error("SearchService not initialized");
+    const results = await this.indexer.textSearch(query, this.config.vectorTopK);
+    if (!results) return [];
+    return results.sort((a, b) => a._distance - b._distance).slice(0, this.config.vectorTopM).map((r, rank) => ({
+      filePath: r.file_path,
+      chunkIndex: r.chunk_index,
+      score: 1 / (1 + r._distance),
+      // 转为相似度（用于调试）
+      source: "vector",
+      record: r,
+      _rank: rank
+      // 用于 RRF
+    }));
+  }
+  /**
+   * 词法召回（FTS）
+   *
+   * 优先使用 chunk 级 FTS（更精准）
+   * 如果 chunks_fts 不可用，降级到文件级 FTS + overlap 下钻
+   */
+  async lexicalRetrieve(query) {
+    if (!this.db || !this.vectorStore) return [];
+    if (isChunksFtsInitialized(this.db)) {
+      return this.lexicalRetrieveFromChunksFts(query);
+    }
+    if (isFtsInitialized(this.db)) {
+      return this.lexicalRetrieveFromFilesFts(query);
+    }
+    logger.debug("FTS \u672A\u521D\u59CB\u5316\uFF0C\u8DF3\u8FC7\u8BCD\u6CD5\u53EC\u56DE");
+    return [];
+  }
+  /**
+   * 从 chunks_fts 直接搜索（最优方案）
+   */
+  async lexicalRetrieveFromChunksFts(query) {
+    const chunkResults = searchChunksFts(
+      this.db,
+      query,
+      this.config.lexTotalChunks
+    );
+    if (chunkResults.length === 0) {
+      logger.debug("Chunk FTS \u65E0\u547D\u4E2D");
+      return [];
+    }
+    const allChunks = [];
+    const fileChunksMap = /* @__PURE__ */ new Map();
+    for (const result of chunkResults) {
+      if (!fileChunksMap.has(result.filePath)) {
+        fileChunksMap.set(result.filePath, /* @__PURE__ */ new Map());
+      }
+      fileChunksMap.get(result.filePath)?.set(result.chunkIndex, result.score);
+    }
+    const allFilePaths = Array.from(fileChunksMap.keys());
+    const chunksMap = await this.vectorStore?.getFilesChunks(allFilePaths);
+    if (!chunksMap) return allChunks;
+    for (const [filePath, chunkScores] of fileChunksMap) {
+      const chunks = chunksMap.get(filePath) ?? [];
+      for (const chunk of chunks) {
+        const score = chunkScores.get(chunk.chunk_index);
+        if (score !== void 0) {
+          allChunks.push({
+            filePath: chunk.file_path,
+            chunkIndex: chunk.chunk_index,
+            score,
+            source: "lexical",
+            record: { ...chunk, _distance: 0 }
+          });
+        }
+      }
+    }
+    logger.debug(
+      {
+        totalChunks: allChunks.length,
+        filesWithChunks: fileChunksMap.size
+      },
+      "Chunk FTS \u53EC\u56DE\u5B8C\u6210"
+    );
+    return allChunks.sort((a, b) => b.score - a.score).map((chunk, rank) => ({ ...chunk, _rank: rank }));
+  }
+  /**
+   * 从 files_fts 搜索 + overlap 下钻（降级方案）
+   */
+  async lexicalRetrieveFromFilesFts(query) {
+    const fileResults = searchFilesFts(
+      this.db,
+      query,
+      this.config.ftsTopKFiles
+    );
+    if (fileResults.length === 0) {
+      logger.debug("FTS \u65E0\u547D\u4E2D\u6587\u4EF6");
+      return [];
+    }
+    const queryTokens = this.extractQueryTokens(query);
+    if (isDebugEnabled()) {
+      logger.debug(
+        {
+          fileCount: fileResults.length,
+          queryTokens: Array.from(queryTokens).slice(0, 10)
+        },
+        "FTS \u53EC\u56DE\u5F00\u59CB chunk \u9009\u62E9"
+      );
+    }
+    const allFilePaths = fileResults.map((r) => r.path);
+    const chunksMap = await this.vectorStore?.getFilesChunks(allFilePaths);
+    if (!chunksMap) return [];
+    const allChunks = [];
+    let totalChunks = 0;
+    let skippedFiles = 0;
+    for (const { path: filePath, score: fileScore } of fileResults) {
+      if (totalChunks >= this.config.lexTotalChunks) break;
+      const chunks = chunksMap.get(filePath);
+      if (!chunks || chunks.length === 0) continue;
+      const scoredChunks = chunks.map((chunk) => ({
+        chunk,
+        overlapScore: scoreChunkTokenOverlap(chunk, queryTokens)
+      }));
+      const maxOverlap = Math.max(...scoredChunks.map((c) => c.overlapScore));
+      if (maxOverlap === 0) {
+        skippedFiles++;
+        continue;
+      }
+      const topChunks = scoredChunks.filter((c) => c.overlapScore > 0).sort((a, b) => b.overlapScore - a.overlapScore).slice(0, this.config.lexChunksPerFile);
+      for (const { chunk, overlapScore } of topChunks) {
+        if (totalChunks >= this.config.lexTotalChunks) break;
+        const combinedScore = fileScore * (1 + overlapScore * 0.5);
+        allChunks.push({
+          filePath: chunk.file_path,
+          chunkIndex: chunk.chunk_index,
+          score: combinedScore,
+          source: "lexical",
+          record: { ...chunk, _distance: 0 }
+        });
+        totalChunks++;
+      }
+    }
+    if (skippedFiles > 0) {
+      logger.debug({ skippedFiles }, "FTS \u8DF3\u8FC7 overlap=0 \u7684\u6587\u4EF6");
+    }
+    logger.debug(
+      {
+        totalChunks: allChunks.length,
+        filesWithChunks: new Set(allChunks.map((c) => c.filePath)).size
+      },
+      "FTS chunk \u9009\u62E9\u5B8C\u6210"
+    );
+    return allChunks.sort((a, b) => b.score - a.score).map((chunk, rank) => ({ ...chunk, _rank: rank }));
+  }
+  /**
+   * 提取查询中的 tokens
+   *
+   * 直接复用 fts.ts 中的 segmentQuery，确保召回和评分逻辑一致
+   */
+  extractQueryTokens(query) {
+    const tokens = segmentQuery(query);
+    return new Set(tokens);
+  }
+  // =========================================
+  // 融合方法
+  // =========================================
+  /**
+   * RRF (Reciprocal Rank Fusion) 融合
+   *
+   * 公式: score = Σ w_i / (k + rank_i)
+   * 其中 k 是平滑常数，rank 从 0 开始
+   */
+  fuse(vectorResults, lexicalResults) {
+    const { rrfK0, wVec, wLex } = this.config;
+    const fusedScores = /* @__PURE__ */ new Map();
+    const getKey = (chunk) => `${chunk.filePath}#${chunk.chunkIndex}`;
+    for (const result of vectorResults) {
+      const key = getKey(result);
+      const rank = result._rank ?? 0;
+      const rrfScore = wVec / (rrfK0 + rank);
+      const existing = fusedScores.get(key);
+      if (existing) {
+        existing.score += rrfScore;
+        existing.sources.add("vector");
+      } else {
+        fusedScores.set(key, {
+          score: rrfScore,
+          chunk: result,
+          sources: /* @__PURE__ */ new Set(["vector"])
+        });
+      }
+    }
+    for (const result of lexicalResults) {
+      const key = getKey(result);
+      const rank = result._rank ?? 0;
+      const rrfScore = wLex / (rrfK0 + rank);
+      const existing = fusedScores.get(key);
+      if (existing) {
+        existing.score += rrfScore;
+        existing.sources.add("lexical");
+      } else {
+        fusedScores.set(key, {
+          score: rrfScore,
+          chunk: result,
+          sources: /* @__PURE__ */ new Set(["lexical"])
+        });
+      }
+    }
+    const fused = Array.from(fusedScores.values()).map(({ score, chunk, sources }) => ({
+      ...chunk,
+      score,
+      source: sources.size > 1 ? "vector" : chunk.source
+      // 保留原始来源
+    })).sort((a, b) => b.score - a.score);
+    if (isDebugEnabled()) {
+      logger.debug(
+        {
+          vectorCount: vectorResults.length,
+          lexicalCount: lexicalResults.length,
+          fusedCount: fused.length,
+          bothSources: Array.from(fusedScores.values()).filter((v) => v.sources.size > 1).length
+        },
+        "RRF \u878D\u5408\u5B8C\u6210"
+      );
+    }
+    return fused;
+  }
+  // Rerank 方法
+  /**
+   * Rerank
+   */
+  async rerank(query, candidates) {
+    if (candidates.length === 0) return [];
+    let reranker;
+    try {
+      reranker = getRerankerClient();
+    } catch (err) {
+      const error = err;
+      logger.warn({ error: error.message }, "Reranker \u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7 rerank");
+      return candidates;
+    }
+    const queryTokens = this.extractQueryTokens(query);
+    const textExtractor = (chunk) => {
+      const bc = this.truncateMiddle(chunk.record.breadcrumb, this.config.maxBreadcrumbChars);
+      const budget = Math.max(0, this.config.maxRerankChars - bc.length - 1);
+      const code = this.extractAroundHit(chunk.record.display_code, queryTokens, budget);
+      return `${bc}
+${code}`;
+    };
+    try {
+      const reranked = await reranker.rerankWithData(query, candidates, textExtractor, {
+        topN: this.config.rerankTopN
+      });
+      return reranked.filter((r) => r.data !== void 0).map((r) => ({
+        ...r.data,
+        score: r.score
+      }));
+    } catch (err) {
+      const error = err;
+      logger.warn({ error: error.message }, "Rerank \u5931\u8D25\uFF0C\u964D\u7EA7\u4E3A\u672A rerank \u7684\u5019\u9009\u7ED3\u679C");
+      return candidates;
+    }
+  }
+  // Smart TopK Cutoff
+  /**
+   * 智能截断策略（Anchor & Floor + Safe Harbor + Delta Guard）
+   *
+   * 核心逻辑：
+   * 1. 低置信熔断：topScore < floor → 返回 top1（CLI 友好）或空
+   * 2. 动态阈值：max(floor, min(ratioThreshold, deltaThreshold))
+   * 3. Safe Harbor：前 minK 个只检查 floor，不检查 ratio/delta
+   * 4. 去重 + 补齐：cutoff 后去重，不足 minK 时从后续补齐
+   */
+  applySmartCutoff(candidates) {
+    if (!this.config.enableSmartTopK) {
+      return candidates;
+    }
+    if (candidates.length === 0) return [];
+    const sorted = candidates.slice().sort((a, b) => b.score - a.score);
+    const {
+      smartTopScoreRatio: ratio,
+      smartTopScoreDeltaAbs: deltaAbs,
+      smartMinScore: floor,
+      smartMinK: minK,
+      smartMaxK: maxK
+    } = this.config;
+    const topScore = sorted[0].score;
+    if (topScore < floor) {
+      logger.debug({ topScore, floor }, "SmartTopK: Top1 below floor, returning top1 only");
+      return [sorted[0]];
+    }
+    const ratioThreshold = topScore * ratio;
+    const deltaThreshold = topScore - deltaAbs;
+    const dynamicThreshold = Math.max(floor, Math.min(ratioThreshold, deltaThreshold));
+    const picked = [];
+    for (let i = 0; i < sorted.length; i++) {
+      if (picked.length >= maxK) break;
+      const chunk = sorted[i];
+      if (i < minK) {
+        if (chunk.score >= floor) {
+          picked.push(chunk);
+          continue;
+        }
+        logger.debug(
+          { rank: i, score: chunk.score, floor },
+          "SmartTopK: Safe harbor chunk below floor, breaking"
+        );
+        break;
+      }
+      if (chunk.score < dynamicThreshold) {
+        logger.debug(
+          {
+            rank: i,
+            score: chunk.score,
+            dynamicThreshold,
+            topScore,
+            ratioThreshold,
+            deltaThreshold
+          },
+          "SmartTopK: cutoff at dynamic threshold"
+        );
+        break;
+      }
+      picked.push(chunk);
+    }
+    const deduped = this.dedupChunks(picked);
+    if (deduped.length < Math.min(minK, maxK)) {
+      const seen = new Set(deduped.map((c) => this.chunkKey(c)));
+      for (const c of sorted) {
+        if (deduped.length >= Math.min(minK, maxK)) break;
+        if (c.score < floor) break;
+        const key = this.chunkKey(c);
+        if (!seen.has(key)) {
+          seen.add(key);
+          deduped.push(c);
+        }
+      }
+    }
+    logger.debug(
+      {
+        originalCount: candidates.length,
+        pickedCount: picked.length,
+        finalCount: deduped.length,
+        topScore,
+        floor,
+        ratio,
+        deltaAbs,
+        ratioThreshold: ratioThreshold.toFixed(3),
+        deltaThreshold: deltaThreshold.toFixed(3),
+        dynamicThreshold: dynamicThreshold.toFixed(3)
+      },
+      "SmartTopK: done"
+    );
+    return deduped;
+  }
+  /**
+   * 生成 chunk 唯一键（用于去重）
+   */
+  chunkKey(chunk) {
+    return `${chunk.filePath}#${chunk.chunkIndex}`;
+  }
+  /**
+   * 按 file_path + chunk_index 去重
+   */
+  dedupChunks(list) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const c of list) {
+      const k = this.chunkKey(c);
+      if (seen.has(k)) continue;
+      seen.add(k);
+      out.push(c);
+    }
+    return out;
+  }
+  // 扩展方法
+  /**
+   * 扩展 seed chunks
+   *
+   * 使用 GraphExpander 执行三种扩展策略：
+   * - E1: 同文件邻居
+   * - E2: breadcrumb 补段
+   * - E3: 相对路径 import 解析
+   */
+  async expand(seeds, queryTokens) {
+    if (seeds.length === 0) return [];
+    const expander = await getGraphExpander(this.projectId, this.config);
+    const { chunks, stats } = await expander.expand(seeds, queryTokens);
+    logger.debug(stats, "\u4E0A\u4E0B\u6587\u6269\u5C55\u7EDF\u8BA1");
+    return chunks;
+  }
+  // 工具方法
+  /**
+   * 中间省略截断（保留首尾）
+   */
+  truncateMiddle(text, maxLen) {
+    if (text.length <= maxLen) return text;
+    const half = Math.floor((maxLen - 3) / 2);
+    return `${text.slice(0, half)}...${text.slice(-half)}`;
+  }
+  /**
+   * 头尾截断（备用方法，当无命中行时使用）
+   */
+  truncateHeadTail(text, maxLen, headRatio) {
+    if (text.length <= maxLen) return text;
+    const headLen = Math.floor(maxLen * headRatio);
+    const tailLen = maxLen - headLen - 3;
+    if (tailLen <= 0) return text.slice(0, maxLen);
+    return `${text.slice(0, headLen)}...${text.slice(-tailLen)}`;
+  }
+  /**
+   * 围绕命中行截取
+   *
+   * 找到第一个包含 query token 的行，截取其上下文
+   * 如果没有命中，降级为头尾截断
+   */
+  extractAroundHit(text, queryTokens, maxLen) {
+    if (text.length <= maxLen) return text;
+    const lines = text.split("\n");
+    const _textLower = text.toLowerCase();
+    let hitLineIdx = -1;
+    let bestScore = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lineLower = lines[i].toLowerCase();
+      let lineScore = 0;
+      for (const token of queryTokens) {
+        if (lineLower.includes(token)) {
+          lineScore++;
+        }
+      }
+      if (lineScore > bestScore) {
+        bestScore = lineScore;
+        hitLineIdx = i;
+      }
+    }
+    if (hitLineIdx === -1) {
+      return this.truncateHeadTail(text, maxLen, this.config.headRatio);
+    }
+    let start = hitLineIdx;
+    let end = hitLineIdx;
+    let currentLen = lines[hitLineIdx].length;
+    while (currentLen < maxLen) {
+      const canUp = start > 0;
+      const canDown = end < lines.length - 1;
+      if (!canUp && !canDown) break;
+      if (canUp) {
+        const upLen = lines[start - 1].length + 1;
+        if (currentLen + upLen <= maxLen) {
+          start--;
+          currentLen += upLen;
+        }
+      }
+      if (canDown) {
+        const downLen = lines[end + 1].length + 1;
+        if (currentLen + downLen <= maxLen) {
+          end++;
+          currentLen += downLen;
+        }
+      }
+      if ((start === 0 || lines[start - 1].length + 1 + currentLen > maxLen) && (end === lines.length - 1 || lines[end + 1].length + 1 + currentLen > maxLen)) {
+        break;
+      }
+    }
+    const result = lines.slice(start, end + 1).join("\n");
+    const prefix = start > 0 ? "..." : "";
+    const suffix = end < lines.length - 1 ? "..." : "";
+    return prefix + result + suffix;
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+export {
+  SearchService
+};
+//# sourceMappingURL=SearchService-MYPOCM3B.js.map