Method search

src/core/embeddings.ts:490–539

(query: string, optionsOrTopK?: number | SearchQueryOptions)

  }

  async search(query: string, optionsOrTopK?: number | SearchQueryOptions): Promise<SearchResult[]> {
    const options = resolveSearchOptions(optionsOrTopK);
    const [queryVec] = await fetchEmbedding(query);
    const queryTerms = new Set(splitCamelCase(query));
    const scores: {
      idx: number;
      score: number;
      semanticScore: number;
      keywordScore: number;
      matchedSymbols: string[];
      matchedSymbolLocations: string[];
    }[] = [];

    for (let i = 0; i < this.vectors.length; i++) {
      if (!this.vectors[i]) continue;
      const doc = this.documents[i];
      const semanticScore = cosine(queryVec, this.vectors[i]);
      const matchedEntries = doc.symbolEntries ? getMatchedSymbolEntries(doc.symbolEntries, queryTerms) : [];
      const matchedSymbols = matchedEntries.length > 0
        ? matchedEntries.map((entry) => entry.name)
        : getMatchedSymbols(doc.symbols, queryTerms);
      const matchedSymbolLocations = matchedEntries.map((entry) => `${entry.name}@${formatLineRange(entry.line, entry.endLine)}`);
      const keywordScore = computeKeywordScore(query, queryTerms, doc, matchedSymbols);
      const score = computeCombinedScore(semanticScore, keywordScore, options);

      if (options.requireSemanticMatch && semanticScore <= 0) continue;
      if (options.requireKeywordMatch && keywordScore <= 0) continue;
      if (Math.max(semanticScore, 0) < options.minSemanticScore) continue;
      if (keywordScore < options.minKeywordScore) continue;
      if (score < options.minCombinedScore) continue;

      scores.push({ idx: i, score, semanticScore, keywordScore, matchedSymbols, matchedSymbolLocations });
    }

    return scores
      .sort((a, b) => b.score - a.score || b.keywordScore - a.keywordScore || b.semanticScore - a.semanticScore)
      .slice(0, options.topK)
      .map(({ idx, score, semanticScore, keywordScore, matchedSymbols, matchedSymbolLocations }) => {
        const doc = this.documents[idx];
        return {
          path: doc.path,
          score: Math.round(score * 1000) / 10,
          semanticScore: Math.round(Math.max(semanticScore, 0) * 1000) / 10,
          keywordScore: Math.round(keywordScore * 1000) / 10,
          header: doc.header,
          matchedSymbols,
          matchedSymbolLocations,
        };
      });
  }

  getDocumentCount(): number {
    return this.documents.length;