@takara-ai/miru-code 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",

package/src/benchmark/locate-compare.ts

@@ -47,8 +47,13 @@ export async function benchmarkLocateComparison(options: {
   const miruTok = countTokens(JSON.stringify(payload));
 
   // Unbounded agent-style Grep dump (±context) — the costlier path without locate.
-  const grep = await rgLiteralOutput(options.repoPath, options.literal, {
-    context: GREP_CONTEXT,
+  // Never use less context than the caller actually requested via context_lines,
+  // or a locate call that returns inline context looks artificially expensive
+  // against a baseline that didn't have to fetch that context at all. Likewise,
+  // grep every variant `match_variants`/an array `literal` actually matched —
+  // one grep pattern isn't equivalent recall, so it isn't a fair baseline.
+  const grep = await rgLiteralOutput(options.repoPath, result.literals ?? [options.literal], {
+    context: Math.max(GREP_CONTEXT, locateOpts.context_lines ?? 0),
     maxCount: 0,
     ignoreCase: locateOpts.ignore_case,
   });

package/src/benchmark/rg-literal.ts

@@ -61,13 +61,14 @@ function parsePathLinePrefix(line: string): { path: string; line: number } | nul
 
 export async function rgLiteralOutput(
   repoRoot: string,
-  literal: string,
+  literal: string | readonly string[],
   options: {
     context?: number;
     maxCount?: number;
     ignoreCase?: boolean;
   } = {},
 ): Promise<RgLiteralOutput> {
+  const literals = Array.isArray(literal) ? literal : [literal as string];
   const context = options.context ?? 0;
   const maxCount = options.maxCount ?? 20;
   const tool = selectBenchmarkSearchTool();
@@ -76,7 +77,7 @@ export async function rgLiteralOutput(
   }
   const start = performance.now();
   const proc = Bun.spawn(
-    buildLiteralArgs(tool, repoRoot, literal, context, maxCount, !!options.ignoreCase),
+    buildLiteralArgs(tool, repoRoot, literals, context, maxCount, !!options.ignoreCase),
     {
       stdout: "pipe",
       stderr: "pipe",
@@ -90,10 +91,14 @@ export async function rgLiteralOutput(
   return { text, tokens: countTokens(text), latency_ms, ...stats };
 }
 
+/**
+ * OR-matches every literal, mirroring what an agent without `locate` would have to run
+ * to get the same recall as `literals`/`match_variants` (one pattern isn't equivalent).
+ */
 function buildLiteralArgs(
   tool: "rg" | "grep" | "findstr",
   repoRoot: string,
-  literal: string,
+  literals: readonly string[],
   context: number,
   maxCount: number,
   ignoreCase: boolean,
@@ -109,7 +114,10 @@ function buildLiteralArgs(
     if (maxCount > 0) {
       args.push("-m", String(maxCount));
     }
-    args.push(literal, repoRoot);
+    for (const l of literals) {
+      args.push("-e", l);
+    }
+    args.push(repoRoot);
     return args;
   }
   if (tool === "grep") {
@@ -132,10 +140,17 @@ function buildLiteralArgs(
     if (maxCount > 0) {
       args.push("-m", String(maxCount));
     }
-    args.push(literal, repoRoot);
+    for (const l of literals) {
+      args.push("-e", l);
+    }
+    args.push(repoRoot);
     return args;
   }
-  const args = ["findstr", "/S", "/N", "/P", `/C:${literal}`, "*"];
+  const args = ["findstr", "/S", "/N", "/P"];
+  for (const l of literals) {
+    args.push(`/C:${l}`);
+  }
+  args.push("*");
   if (ignoreCase) {
     args.splice(4, 0, "/I");
   }