fix: preserve doc intent after rerank rebase merge

Author: Helweg

src/indexer/index.ts

@@ -1590,14 +1590,18 @@ export class Indexer {
       return candidates;
     }
 
-    if (options?.definitionIntent === true || options?.hasIdentifierHints === true) {
-      return candidates;
-    }
-
     const queryTokens = Array.from(tokenizeTextForRanking(query));
     const preferSourcePaths = classifyQueryIntentRaw(query) === "source";
     const docIntent = classifyDocIntent(queryTokens) === "docs";
 
+    if (options?.definitionIntent === true) {
+      return candidates;
+    }
+
+    if (options?.hasIdentifierHints === true && preferSourcePaths && !docIntent) {
+      return candidates;
+    }
+
     const topN = Math.min(reranker.topN, candidates.length);
     const head = candidates.slice(0, topN);
     const tail = candidates.slice(topN);
@@ -2867,70 +2871,7 @@ export class Indexer {
       : baseFiltered
     ).slice(0, maxResults);
 
-    // Apply reranking if enabled and available
-    let finalResults = filtered;
-    if (this.reranker?.isAvailable() && filtered.length > 1) {
-      const rerankStartTime = performance.now();
-
-      // Read content for reranking
-      const documentsForRerank = await Promise.all(
-        filtered.map(async (r) => {
-          try {
-            const fileContent = await fsPromises.readFile(r.metadata.filePath, "utf-8");
-            const lines = fileContent.split("\n");
-            return lines.slice(r.metadata.startLine - 1, r.metadata.endLine).join("\n");
-          } catch {
-            return r.metadata.name ?? r.metadata.chunkType;
-          }
-        })
-      );
-
-      try {
-        const rerankResponse = await this.reranker.rerank(
-          query,
-          documentsForRerank,
-          this.config.reranker?.topN ?? filtered.length
-        );
-
-        if (rerankResponse.results.length > 0) {
-          // Create a map of original index to rerank score
-          const rerankScores = new Map<number, number>();
-          for (const result of rerankResponse.results) {
-            rerankScores.set(result.index, result.relevanceScore);
-          }
-
-          // Reorder results based on rerank scores
-          const rerankedIndices = rerankResponse.results
-            .sort((a, b) => b.relevanceScore - a.relevanceScore)
-            .map(r => r.index);
-
-          // Build final results: reranked first, then remaining
-          const rerankedSet = new Set(rerankedIndices);
-          const reranked = rerankedIndices
-            .filter(idx => idx < filtered.length)
-            .map(idx => ({
-              ...filtered[idx],
-              score: rerankScores.get(idx) ?? filtered[idx].score,
-            }));
-          const remaining = filtered
-            .filter((_, idx) => !rerankedSet.has(idx));
-
-          finalResults = [...reranked, ...remaining].slice(0, maxResults);
-        }
-
-        const rerankMs = performance.now() - rerankStartTime;
-        this.logger.search("debug", "Reranking complete", {
-          documentsReranked: documentsForRerank.length,
-          rerankMs: Math.round(rerankMs * 100) / 100,
-          tokensUsed: rerankResponse.tokensUsed,
-        });
-      } catch (error) {
-        // Reranking failed, use original results
-        this.logger.search("warn", "Reranking failed, using original results", {
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
+    const finalResults = filtered;
 
     const totalSearchMs = performance.now() - searchStartTime;
     this.logger.recordSearch(totalSearchMs, {

tests/retrieval-ranking.test.ts

@@ -547,6 +547,65 @@ describe("retrieval ranking", () => {
     globalThis.fetch = fetchSpy;
   });
 
+  it("allows external reranker for documentation intent even when identifier hints are present", async () => {
+    const config = parseConfig({
+      embeddingProvider: "custom",
+      customProvider: {
+        baseUrl: "http://localhost:11434/v1",
+        model: "mock-embed",
+        dimensions: 8,
+      },
+      reranker: {
+        enabled: true,
+        provider: "custom",
+        model: "mock-reranker",
+        baseUrl: "https://rerank.example/v1",
+        topN: 3,
+      },
+    });
+    const indexer = new Indexer("/repo", config);
+
+    const fetchSpy = globalThis.fetch;
+    let rerankCalled = false;
+    let rerankDocuments: string[] | undefined;
+    globalThis.fetch = (async (input, init) => {
+      if (String(input).includes("/rerank")) {
+        rerankCalled = true;
+        rerankDocuments = (JSON.parse(String(init?.body ?? "{}")) as { documents?: string[] }).documents;
+        return new Response(JSON.stringify({
+          results: [
+            { index: 1, relevance_score: 0.99 },
+            { index: 0, relevance_score: 0.6 },
+          ],
+        }), { status: 200 });
+      }
+      return new Response(JSON.stringify({ data: [{ embedding: Array.from({ length: 8 }, () => 0.1) }], usage: { total_tokens: 1 } }), { status: 200 });
+    }) as typeof fetch;
+
+    const candidates: Candidate[] = [
+      { id: "impl", score: 0.9, metadata: meta({ filePath: "/repo/src/indexer/index.ts", name: "rankHybridResults", chunkType: "function", startLine: 1, endLine: 3 }) },
+      { id: "docs-readme", score: 0.89, metadata: meta({ filePath: "/repo/README.md", name: "retrieval documentation", chunkType: "other", startLine: 1, endLine: 3 }) },
+      { id: "docs-guide", score: 0.88, metadata: meta({ filePath: "/repo/docs/guide.md", name: "rankHybridResults guide", chunkType: "other", startLine: 1, endLine: 3 }) },
+    ];
+
+    const reranked = await (indexer as unknown as {
+      rerankCandidatesWithApi(
+        query: string,
+        items: Candidate[],
+        options?: { definitionIntent?: boolean; hasIdentifierHints?: boolean }
+      ): Promise<Candidate[]>;
+    }).rerankCandidatesWithApi("rankHybridResults documentation guide", candidates, {
+      hasIdentifierHints: true,
+    });
+
+    expect(rerankCalled).toBe(true);
+    expect(reranked.map((candidate) => candidate.id)).toEqual(["docs-guide", "docs-readme", "impl"]);
+    expect(rerankDocuments?.length).toBe(2);
+    expect(rerankDocuments?.[0]).toContain("path: /repo/README.md");
+    expect(rerankDocuments?.[1]).toContain("path: /repo/docs/guide.md");
+    globalThis.fetch = fetchSpy;
+  });
+
   it("diversifies external reranker output for exploratory queries", async () => {
     const config = parseConfig({
       embeddingProvider: "custom",

tests/search-integration.test.ts

@@ -133,7 +133,7 @@ export function rerankResults(query: string) { return rankHybridResults(query);
     const indexer = new Indexer(tempDir, config);
     await indexer.index();
 
-    const results = await indexer.search("where is rankHybridResults documentation", 5, {
+    const results = await indexer.search("rankHybridResults documentation guide", 5, {
       metadataOnly: true,
       filterByBranch: false,
     });
@@ -338,7 +338,7 @@ export function rerankResults(query: string) { return rankHybridResults(query);
     const indexer = new Indexer(tempDir, config);
     await indexer.index();
 
-    const results = await indexer.search("where is rankHybridResults documentation", 5, {
+    const results = await indexer.search("rankHybridResults documentation guide", 5, {
       metadataOnly: true,
       filterByBranch: false,
     });