1
// src/llm.ts - 嵌入格式化核心逻辑
2

3
/** 检测是否为 Qwen3-Embedding 模型 */
4
export function isQwen3EmbeddingModel(modelUri: string): boolean {
5
  return /qwen.*embed/i.test(modelUri) || /embed.*qwen/i.test(modelUri);
6
}
7

8
/**
9
 * 格式化查询文本用于嵌入
10
 * - embeddinggemma 使用 nomic 风格的 task prefix
11
 * - Qwen3-Embedding 使用 Instruct 格式
12
 */
13
export function formatQueryForEmbedding(query: string, modelUri?: string): string {
14
  const uri = modelUri ?? resolveEmbedModel();
15
  if (isQwen3EmbeddingModel(uri)) {
16
    return `Instruct: Retrieve relevant documents for the given query\nQuery: ${query}`;
17
  }
18
  return `task: search result | query: ${query}`;
19
}
20

21
/**
22
 * 格式化文档文本用于嵌入
23
 * - embeddinggemma 使用 title + text 格式
24
 * - Qwen3-Embedding 直接使用原始文本
25
 */
26
export function formatDocForEmbedding(text: string, title?: string, modelUri?: string): string {
27
  const uri = modelUri ?? resolveEmbedModel();
28
  if (isQwen3EmbeddingModel(uri)) {
29
    return title ? `${title}\n${text}` : text;
30
  }
31
  return `title: ${title || "none"} | text: ${text}`;
32
}

1
// src/store.ts - Position-Aware Blending
2
// 根据 RRF 排名自适应调整 RRF 与 Reranker 的融合比例
3

4
const blended = reranked.map(r => {
5
  const rrfRank = rrfRankMap.get(r.file) || candidateLimit;
6
  let rrfWeight: number;
7

8
  // 位置感知权重：排名越高，越信任传统搜索结果
9
  if (rrfRank <= 3)  rrfWeight = 0.75;   // Top 3: 75% RRF / 25% reranker
10
  else if (rrfRank <= 10) rrfWeight = 0.60; // 4-10: 60% RRF / 40% reranker
11
  else rrfWeight = 0.40;                    // 11+:  40% RRF / 60% reranker
12

13
  const rrfScore = 1 / rrfRank;
14
  const blendedScore = rrfWeight * rrfScore + (1 - rrfWeight) * r.score;
15
  // ...
16
});

1
// src/store.ts - findBestCutoff 核心算法
2
// 在窗口范围内寻找质量最高的切割点
3

4
export function findBestCutoff(
5
  breakPoints: BreakPoint[],
6
  targetCharPos: number,
7
  windowChars: number = CHUNK_WINDOW_CHARS,
8
  decayFactor: number = 0.7,
9
  codeFences: CodeFenceRegion[] = []
10
): number {
11
  const windowStart = targetCharPos - windowChars;
12
  let bestScore = -1;
13
  let bestPos = targetCharPos;
14

15
  for (const bp of breakPoints) {
16
    if (bp.pos < windowStart) continue;
17
    if (bp.pos > targetCharPos) break;  // sorted, can stop
18

19
    // 跳过代码围栏内部的断点
20
    if (isInsideCodeFence(bp.pos, codeFences)) continue;
21

22
    const distance = targetCharPos - bp.pos;
23
    // 平方距离衰减：近处温和，远处陡峭
24
    const normalizedDist = distance / windowChars;
25
    const multiplier = 1.0 - (normalizedDist * normalizedDist) * decayFactor;
26
    const finalScore = bp.score * multiplier;
27

28
    if (finalScore > bestScore) {
29
      bestScore = finalScore;
30
      bestPos = bp.pos;
31
    }
32
  }
33

34
  return bestPos;
35
}

1
// src/store.ts - chunkDocumentWithBreakPoints 完整实现
2

3
export function chunkDocumentWithBreakPoints(
4
  content: string,
5
  breakPoints: BreakPoint[],
6
  codeFences: CodeFenceRegion[],
7
  maxChars: number = CHUNK_SIZE_CHARS,
8
  overlapChars: number = CHUNK_OVERLAP_CHARS,
9
  windowChars: number = CHUNK_WINDOW_CHARS
10
): { text: string; pos: number }[] {
11
  // 短文档直接返回
12
  if (content.length <= maxChars) {
13
    return [{ text: content, pos: 0 }];
14
  }
15

16
  const chunks: { text: string; pos: number }[] = [];
17
  let charPos = 0;
18

19
  while (charPos < content.length) {
20
    const targetEndPos = Math.min(charPos + maxChars, content.length);
21
    let endPos = targetEndPos;
22

23
    // 在窗口内寻找最佳切割点
24
    if (endPos < content.length) {
25
      const bestCutoff = findBestCutoff(
26
        breakPoints, targetEndPos, windowChars, 0.7, codeFences
27
      );
28
      if (bestCutoff > charPos && bestCutoff <= targetEndPos) {
29
        endPos = bestCutoff;
30
      }
31
    }
32

33
    if (endPos <= charPos) {
34
      endPos = Math.min(charPos + maxChars, content.length);
35
    }
36

37
    chunks.push({ text: content.slice(charPos, endPos), pos: charPos });
38

39
    if (endPos >= content.length) break;
40

41
    // 15% 重叠确保跨块语义连续性
42
    charPos = endPos - overlapChars;
43
    const lastChunkPos = chunks.at(-1)!.pos;
44
    if (charPos <= lastChunkPos) {
45
      charPos = endPos;
46
    }
47
  }
48

49
  return chunks;
50
}