@takara-ai/miru-code 0.4.11 → 0.5.0

package/src/utils.ts

@@ -1,4 +1,5 @@
 import { join, relative, resolve, sep } from "node:path";
+import { applySnippetsToResults, searchSnippetsEnabled } from "./snippet.ts";
 import type { Chunk, ContentType, SearchResult } from "./types.ts";
 import { chunkToDict } from "./types.ts";
 
@@ -66,29 +67,25 @@ export function resolveChunk(
   return fallback;
 }
 
-export type SearchGuidance = {
-  sufficient: boolean;
-  reason: string;
-  suggested_next: "answer" | "expand" | "find_related" | "read_to_edit";
-  expand?: { file_path: string; line: number };
-};
-
-export type ExpandGuidance = {
-  sufficient: boolean;
-  reason: string;
-  suggested_next: "answer" | "search";
-};
-
 export type ExpandResults = {
   file_path: string;
   line: number;
   chunk_count: number;
-  guidance: ExpandGuidance;
   anchor: Record<string, unknown> | null;
   chunks: Record<string, unknown>[];
 };
 
 export const DEFAULT_MCP_TOP_K = 3;
+export const MAX_MCP_TOP_K = 10;
+
+/** Clamp MCP top_k to a sane range; omit for the default. */
+export function clampMcpTopK(topK?: number): number {
+  const value = topK ?? DEFAULT_MCP_TOP_K;
+  if (!Number.isFinite(value) || value < 1) {
+    return DEFAULT_MCP_TOP_K;
+  }
+  return Math.min(Math.floor(value), MAX_MCP_TOP_K);
+}
 
 function chunkToResponseDict(chunk: Chunk, repoRoot?: string | null): Record<string, unknown> {
   const dict = chunkToDict(chunk);
@@ -158,94 +155,38 @@ export function expandChunksAtLine(
   return { anchor, chunks: fileChunks.slice(start, end) };
 }
 
-export function assessSearchGuidance(query: string, results: SearchResult[]): SearchGuidance {
-  if (results.length === 0) {
-    return {
-      sufficient: false,
-      reason: "No results returned.",
-      suggested_next: "find_related",
-    };
-  }
-
-  const top = results[0];
-  if (!top) {
-    return {
-      sufficient: false,
-      reason: "No results returned.",
-      suggested_next: "find_related",
-    };
-  }
-
-  const topChunk = top.chunk;
-  const expandHint = { file_path: topChunk.file_path, line: topChunk.start_line };
-  const second = results[1];
-  const scoreRatio = second && second.score > 0 ? top.score / second.score : Number.POSITIVE_INFINITY;
-  const strongLead = results.length === 1 || scoreRatio >= 1.25;
-
-  const sameFileHits = results.filter((result) => result.chunk.file_path === topChunk.file_path).length;
-  const uniqueFiles = new Set(results.map((result) => result.chunk.file_path)).size;
-  const lineSpan = topChunk.end_line - topChunk.start_line + 1;
-  const narrowQuery = /\b(why|how|what|when|where|does|bug|error|fail)\b/i.test(query);
-
-  if (sameFileHits > 1 && lineSpan < 40) {
-    return {
-      sufficient: false,
-      reason: `${sameFileHits} hits in ${topChunk.file_path}; slices may be incomplete.`,
-      suggested_next: "expand",
-      expand: expandHint,
-    };
-  }
-
-  if (lineSpan < 12 && sameFileHits >= 1) {
-    return {
-      sufficient: false,
-      reason: "Top hit is a short slice; more context may be in adjacent chunks.",
-      suggested_next: "expand",
-      expand: expandHint,
-    };
-  }
-
-  if (uniqueFiles > 2 && !strongLead) {
-    return {
-      sufficient: false,
-      reason: "Results span several files; pick the best hit or use find_related to trace neighbors.",
-      suggested_next: "find_related",
-      expand: expandHint,
-    };
-  }
-
-  if (strongLead && (narrowQuery || lineSpan >= 15)) {
-    return {
-      sufficient: true,
-      reason:
-        results.length === 1
-          ? "Single focused hit — answer from this chunk unless you are editing."
-          : `Top hit leads (${scoreRatio === Number.POSITIVE_INFINITY ? "only result" : `${scoreRatio.toFixed(1)}x`}).`,
-      suggested_next: "answer",
-    };
-  }
-
-  return {
-    sufficient: true,
-    reason: "Top hit is likely enough; call expand if the chunk looks cut off.",
-    suggested_next: "answer",
-    expand: expandHint,
-  };
-}
-
 export function formatResults(
   query: string,
   results: SearchResult[],
-  options?: { repoRoot?: string | null },
-): { query: string; guidance: SearchGuidance; results: Record<string, unknown>[] } {
+  options?: { repoRoot?: string | null; snippet?: boolean },
+): { query: string; results: Record<string, unknown>[] } {
   const repoRoot = options?.repoRoot ?? null;
+  const useSnippet = options?.snippet ?? searchSnippetsEnabled();
+  const payload = useSnippet ? applySnippetsToResults(results, query) : null;
+
   return {
     query,
-    guidance: assessSearchGuidance(query, results),
-    results: results.map((result) => ({
-      chunk: chunkToResponseDict(result.chunk, repoRoot),
-      score: result.score,
-    })),
+    results: results.map((result, index) => {
+      const entry = payload?.[index];
+      const chunk = entry?.result.chunk ?? result.chunk;
+      const dict = chunkToResponseDict(chunk, repoRoot);
+      if (entry?.meta.truncated) {
+        return {
+          chunk: {
+            ...dict,
+            truncated: true,
+            anchor_line: entry.meta.anchor_line,
+            full_start_line: entry.meta.full_start_line,
+            full_end_line: entry.meta.full_end_line,
+          },
+          score: result.score,
+        };
+      }
+      return {
+        chunk: dict,
+        score: result.score,
+      };
+    }),
   };
 }
 
@@ -258,22 +199,11 @@ export function formatExpandResults(
 ): ExpandResults {
   const repoRoot = options?.repoRoot ?? null;
   const indexedPath = toIndexedFilePath(filePath, repoRoot) || filePath;
-  const suggestedNext: ExpandGuidance["suggested_next"] = expanded.length > 0 ? "answer" : "search";
 
   return {
     file_path: indexedPath,
     line,
     chunk_count: expanded.length,
-    guidance: {
-      sufficient: expanded.length > 1,
-      reason:
-        expanded.length === 0
-          ? "No chunks at this location."
-          : expanded.length === 1
-            ? "Single chunk at location; call expand with higher before/after if still truncated."
-            : `Returned ${expanded.length} adjacent chunks in ${indexedPath}.`,
-      suggested_next: suggestedNext,
-    },
     anchor: anchor ? chunkToResponseDict(anchor, repoRoot) : null,
     chunks: expanded.map((chunk) => chunkToResponseDict(chunk, repoRoot)),
   };