Method collectHybridMatches

src/core/search.ts:834–914

(
    queryVariants: QueryVariant[],
    candidateLimit: number,
    filters: SearchFilters | undefined,
    useSemanticSearch: boolean,
    useKeywordSearch: boolean,
    semanticWeight: number,
    keywordWeight: number
  )

  }

  private async collectHybridMatches(
    queryVariants: QueryVariant[],
    candidateLimit: number,
    filters: SearchFilters | undefined,
    useSemanticSearch: boolean,
    useKeywordSearch: boolean,
    semanticWeight: number,
    keywordWeight: number
  ): Promise<{
    semantic: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
    keyword: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
  }> {
    const semanticRanks: Map<
      string,
      { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }
    > = new Map();
    const keywordRanks: Map<
      string,
      { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }
    > = new Map();

    // RRF uses ranks instead of scores for fusion robustness
    if (useSemanticSearch && this.embeddingProvider && this.storageProvider) {
      try {
        for (const variant of queryVariants) {
          const vectorResults = await this.semanticSearch(variant.query, candidateLimit, filters);

          // Assign ranks based on retrieval order (0-indexed)
          vectorResults.forEach((result, index) => {
            const id = result.chunk.id;
            const rank = index; // 0-indexed rank
            const weight = semanticWeight * variant.weight;
            const existing = semanticRanks.get(id);

            if (existing) {
              existing.ranks.push({ rank, weight });
            } else {
              semanticRanks.set(id, {
                chunk: result.chunk,
                ranks: [{ rank, weight }]
              });
            }
          });
        }
      } catch (error) {
        if (error instanceof IndexCorruptedError) {
          throw error; // Propagate to handler for auto-heal
        }
        console.warn('Semantic search failed:', error);
      }
    }

    if (useKeywordSearch && this.fuseIndex) {
      try {
        for (const variant of queryVariants) {
          const keywordResults = await this.keywordSearch(variant.query, candidateLimit, filters);

          // Assign ranks based on retrieval order (0-indexed)