@takara-ai/miru-code 1.8.2 → 1.10.0

package/src/benchmark/grep.ts

@@ -147,7 +147,7 @@ function normalizeRepoFile(repoRoot: string, filePath: string): string {
   return rel;
 }
 
-function parsePathLinePrefix(line: string): { path: string; line: number } | null {
+export function parsePathLinePrefix(line: string): { path: string; line: number } | null {
   for (let i = 0; i < line.length; i++) {
     const delim = line[i];
     if (delim !== ":" && delim !== "-") {
@@ -161,14 +161,12 @@ function parsePathLinePrefix(line: string): { path: string; line: number } | nul
       continue;
     }
     const trailing = line[j];
-    if (trailing !== ":" && trailing !== "-") {
-      continue;
-    }
-    const lineNo = Number(line.slice(i + 1, j));
-    if (!Number.isFinite(lineNo)) {
-      continue;
+    if (trailing === ":" || trailing === "-") {
+      const lineNo = Number(line.slice(i + 1, j));
+      if (Number.isFinite(lineNo)) {
+        return { path: line.slice(0, i), line: lineNo };
+      }
     }
-    return { path: line.slice(0, i), line: lineNo };
   }
   return null;
 }
@@ -177,6 +175,10 @@ export async function grepSearch(
   repoRoot: string,
   query: string,
   topK: number,
+  options: {
+    tool?: BenchmarkSearchTool | null;
+    spawn?: typeof spawnBenchmarkSearch;
+  } = {},
 ): Promise<GrepSearchResult> {
   const keywords = queryKeywords(query);
   const pattern = buildGrepPattern(keywords);
@@ -184,17 +186,18 @@ export async function grepSearch(
     return { files: [], hits: [], tokens: 0, pattern: null, keywords };
   }
 
-  const tool = selectBenchmarkSearchTool();
+  const tool = Object.hasOwn(options, "tool") ? options.tool : selectBenchmarkSearchTool();
   if (!tool) {
     throw new Error("No search tool found in PATH (tried rg, grep, and findstr on Windows)");
   }
+  const spawn = options.spawn ?? spawnBenchmarkSearch;
 
   const ranked =
     tool === "rg"
-      ? await rgRankedMatches(repoRoot, pattern, topK)
+      ? await rgRankedMatches(repoRoot, pattern, topK, spawn)
       : tool === "grep"
-        ? await grepRankedMatches(repoRoot, pattern, topK)
-        : await findstrRankedMatches(repoRoot, keywords, topK);
+        ? await grepRankedMatches(repoRoot, pattern, topK, spawn)
+        : await findstrRankedMatches(repoRoot, keywords, topK, spawn);
 
   const hits: GrepFileHit[] = [];
   let tokens = 0;
@@ -202,10 +205,10 @@ export async function grepSearch(
   for (const row of ranked) {
     const output =
       tool === "rg"
-        ? await rgFilePreview(row.absPath, pattern)
+        ? await rgFilePreview(row.absPath, pattern, spawn)
         : tool === "grep"
-          ? await grepFilePreview(row.absPath, pattern)
-          : await findstrFilePreview(row.absPath, keywords);
+          ? await grepFilePreview(row.absPath, pattern, spawn)
+          : await findstrFilePreview(row.absPath, keywords, spawn);
     hits.push({ file: row.file, matchCount: row.matchCount, output });
     tokens += countTokens(output);
   }
@@ -219,8 +222,13 @@ export async function grepSearch(
   };
 }
 
-async function rgRankedMatches(repoRoot: string, pattern: string, topK: number) {
-  const countText = await spawnBenchmarkSearch([
+async function rgRankedMatches(
+  repoRoot: string,
+  pattern: string,
+  topK: number,
+  spawn: typeof spawnBenchmarkSearch,
+) {
+  const countText = await spawn([
     "rg",
     "-i",
     "--count-matches",
@@ -231,8 +239,13 @@ async function rgRankedMatches(repoRoot: string, pattern: string, topK: number)
   return parseCountMatches(repoRoot, countText, topK);
 }
 
-async function grepRankedMatches(repoRoot: string, pattern: string, topK: number) {
-  const countText = await spawnBenchmarkSearch([
+async function grepRankedMatches(
+  repoRoot: string,
+  pattern: string,
+  topK: number,
+  spawn: typeof spawnBenchmarkSearch,
+) {
+  const countText = await spawn([
     "grep",
     "-R",
     "-I",
@@ -285,13 +298,15 @@ function splitSearchToolLine(line: string): { path: string; rest: string } | nul
   return { path: line.slice(0, colon), rest: line.slice(colon + 1) };
 }
 
-async function findstrRankedMatches(repoRoot: string, keywords: string[], topK: number) {
+async function findstrRankedMatches(
+  repoRoot: string,
+  keywords: string[],
+  topK: number,
+  spawn: typeof spawnBenchmarkSearch,
+) {
   const counts = new Map<string, number>();
   for (const keyword of keywords) {
-    const text = await spawnBenchmarkSearch(
-      ["findstr", "/S", "/N", "/I", "/P", `/C:${keyword}`, "*"],
-      repoRoot,
-    );
+    const text = await spawn(["findstr", "/S", "/N", "/I", "/P", `/C:${keyword}`, "*"], repoRoot);
     for (const line of text.split("\n")) {
       const parsed = parsePathLinePrefix(line);
       if (!parsed?.path) {
@@ -346,8 +361,19 @@ function parseCountMatches(repoRoot: string, countText: string, topK: number) {
     .slice(0, topK);
 }
 
-async function rgFilePreview(absPath: string, pattern: string): Promise<string> {
-  return spawnBenchmarkSearch([
+export const grepTestUtils = {
+  buildGrepPattern,
+  normalizeRepoFile,
+  splitSearchToolLine,
+  parseCountMatches,
+};
+
+async function rgFilePreview(
+  absPath: string,
+  pattern: string,
+  spawn: typeof spawnBenchmarkSearch,
+): Promise<string> {
+  return spawn([
     "rg",
     "-i",
     "-n",
@@ -360,8 +386,12 @@ async function rgFilePreview(absPath: string, pattern: string): Promise<string>
   ]);
 }
 
-async function grepFilePreview(absPath: string, pattern: string): Promise<string> {
-  return spawnBenchmarkSearch([
+async function grepFilePreview(
+  absPath: string,
+  pattern: string,
+  spawn: typeof spawnBenchmarkSearch,
+): Promise<string> {
+  return spawn([
     "grep",
     "-I",
     "-i",
@@ -376,13 +406,10 @@ async function grepFilePreview(absPath: string, pattern: string): Promise<string
   ]);
 }
 
-async function findstrFilePreview(absPath: string, keywords: string[]): Promise<string> {
-  return spawnBenchmarkSearch([
-    "findstr",
-    "/N",
-    "/I",
-    "/P",
-    ...keywords.map((k) => `/C:${k}`),
-    absPath,
-  ]);
+async function findstrFilePreview(
+  absPath: string,
+  keywords: string[],
+  spawn: typeof spawnBenchmarkSearch,
+): Promise<string> {
+  return spawn(["findstr", "/N", "/I", "/P", ...keywords.map((k) => `/C:${k}`), absPath]);
 }

package/src/benchmark/locate-compare.ts

@@ -42,13 +42,20 @@ export async function benchmarkLocateComparison(options: {
   repoPath: string;
   index: MiruIndex;
   locate?: LiteralLocateOptions;
+  dependencies?: {
+    selectComparableLiteralSearchTool?: typeof selectComparableLiteralSearchTool;
+  };
 }): Promise<LocateBenchmarkComparison> {
   if (options.locate?.limit != null) {
     throw new Error(
       "Cannot benchmark a limited locate response against native grep: rg/grep limits are per file, while locate.limit is global. Omit limit to keep token and recall comparisons valid.",
     );
   }
-  if (!selectComparableLiteralSearchTool()) {
+  if (
+    !(
+      options.dependencies?.selectComparableLiteralSearchTool ?? selectComparableLiteralSearchTool
+    )()
+  ) {
     throw new Error(
       "A comparable literal benchmark requires rg or compatible grep; findstr is not equivalent for scoped locate output.",
     );

package/src/benchmark/rg-literal.ts

@@ -135,11 +135,16 @@ export async function rgLiteralOutput(
   repoRoot: string,
   literal: string | readonly string[],
   options: RgLiteralOptions = {},
+  dependencies: {
+    tool?: "rg" | "grep" | null;
+    spawn?: (args: string[]) => Promise<string>;
+  } = {},
 ): Promise<RgLiteralOutput> {
   const literals = Array.isArray(literal) ? literal : [literal as string];
   const context = options.context ?? 0;
   const maxCount = options.maxCount ?? 20;
-  const tool = selectComparableLiteralSearchTool();
+  const tool =
+    dependencies.tool === undefined ? selectComparableLiteralSearchTool() : dependencies.tool;
   if (!tool) {
     throw new Error(
       "A comparable literal benchmark requires rg or compatible grep; findstr cannot preserve locate scope, context, and count semantics.",
@@ -150,7 +155,7 @@ export async function rgLiteralOutput(
   const output: string[] = [];
   for (const paths of pathBatches) {
     output.push(
-      await spawnBenchmarkSearch(
+      await (dependencies.spawn ?? spawnBenchmarkSearch)(
         buildLiteralArgs(
           tool,
           repoRoot,
@@ -178,8 +183,8 @@ export async function rgLiteralOutput(
  * 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",
+export function buildLiteralArgs(
+  tool: string,
   repoRoot: string,
   literals: readonly string[],
   context: number,

package/src/cache.ts

@@ -23,7 +23,7 @@ import { computeSourceCacheKey } from "./utils.ts";
 import { indexCacheEpoch } from "./version.ts";
 
 /** Platform cache root; override with `MIRU_CACHE_HOME`. */
-export function resolveCacheFolder(): string {
+export function resolveCacheFolder(platform: NodeJS.Platform = process.platform): string {
   const override = process.env.MIRU_CACHE_HOME?.trim();
   if (override) {
     return override;
@@ -31,10 +31,10 @@ export function resolveCacheFolder(): string {
   const name = "miru";
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   let base: string;
-  if (process.platform === "win32") {
+  if (platform === "win32") {
     base = process.env.LOCALAPPDATA ?? process.env.APPDATA ?? join(home, "AppData", "Local");
     base = join(base, name, "Cache");
-  } else if (process.platform === "darwin") {
+  } else if (platform === "darwin") {
     base = join(home, "Library", "Caches", name);
   } else {
     base = process.env.XDG_CACHE_HOME

package/src/chunking/ast.ts

@@ -1,4 +1,4 @@
-import type { Node } from "web-tree-sitter";
+import type { Language, Node } from "web-tree-sitter";
 import { Parser } from "web-tree-sitter";
 import { getLanguageForFile } from "./grammars.ts";
 import { type ChunkBoundary, mergeAdjacentChunks } from "./lines.ts";
@@ -87,17 +87,35 @@ export async function chunkAst(
   filePath: string,
   language: string | null,
   desiredLength: number,
+  dependencies: {
+    getLanguage?: typeof getLanguageForFile;
+    createParser?: () => Pick<Parser, "setLanguage" | "parse"> & Partial<Pick<Parser, "delete">>;
+  } = {},
 ): Promise<ChunkBoundary[] | null> {
   if (!source.trim() || !astChunkingEnabled()) {
     return null;
   }
 
-  const languageObj = await getLanguageForFile(filePath, language);
+  const languageObj = await (dependencies.getLanguage ?? getLanguageForFile)(filePath, language);
   if (!languageObj) {
     return null;
   }
 
-  const parser = new Parser();
+  // A Parser owns wasm memory the JS GC can't free, so it must be deleted explicitly.
+  const parser = dependencies.createParser?.() ?? new Parser();
+  try {
+    return parseBoundaries(parser, languageObj, source, desiredLength);
+  } finally {
+    parser.delete?.();
+  }
+}
+
+function parseBoundaries(
+  parser: Pick<Parser, "setLanguage" | "parse">,
+  languageObj: Language,
+  source: string,
+  desiredLength: number,
+): ChunkBoundary[] | null {
   parser.setLanguage(languageObj);
 
   let tree: ReturnType<Parser["parse"]>;

package/src/chunking/grammars.ts

@@ -36,13 +36,17 @@ export function wasmPathForLanguage(language: string | null): string | null {
 }
 
 /** Pick grammar wasm for a file (e.g. tsx vs typescript). */
-export function wasmPathForFile(filePath: string, language: string | null): string | null {
+export function wasmPathForFile(
+  filePath: string,
+  language: string | null,
+  pathExists: (path: string) => boolean = existsSync,
+): string | null {
   if (!language) {
     return null;
   }
   if (language === "typescript" && filePath.toLowerCase().endsWith(".tsx")) {
     const tsxPath = join(grammarsDir(), "tree-sitter-tsx.wasm");
-    if (existsSync(tsxPath)) {
+    if (pathExists(tsxPath)) {
       return tsxPath;
     }
   }
@@ -86,13 +90,14 @@ async function loadLanguage(wasmPath: string): Promise<Language> {
 export async function getLanguageForFile(
   filePath: string,
   language: string | null,
+  load: typeof loadLanguage = loadLanguage,
 ): Promise<Language | null> {
   const wasmPath = wasmPathForFile(filePath, language);
   if (!wasmPath || !existsSync(wasmPath)) {
     return null;
   }
   try {
-    return await loadLanguage(wasmPath);
+    return await load(wasmPath);
   } catch {
     return null;
   }

package/src/chunking/structural.ts

@@ -14,8 +14,6 @@ const SUPPORTED_STRUCTURAL_LANGUAGES = new Set([
   "c",
 ]);
 
-const BRACE_FAMILY_LANGUAGES = new Set(["cpp", "c"]);
-
 export function chunkStructural(
   source: string,
   language: string | null,
@@ -55,18 +53,6 @@ function stripLine(text: string): string {
   return text.replace(/[\r\n]+$/, "");
 }
 
-function _isBlank(text: string): boolean {
-  return stripLine(text).trim().length === 0;
-}
-
-function _isCommentLine(text: string, language: string): boolean {
-  const trimmed = stripLine(text).trim();
-  if (language === "python") {
-    return trimmed.startsWith("#");
-  }
-  return trimmed.startsWith("//");
-}
-
 function pythonUnits(lines: LineGroup[]): ChunkBoundary[] {
   const units: ChunkBoundary[] = [];
   let firstDeclStart: number | null = null;
@@ -182,16 +168,21 @@ function declPattern(language: string): RegExp {
   return /^\s*(export\s+)?(async\s+function\b|function\b|class\b|interface\b|type\b|(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)(?:\s*:\s*[^=]+)?\s*=>)/;
 }
 
-function isBraceFamilyTypeDecl(text: string, language: string): boolean {
+function isBraceFamilyTypeDecl(text: string, language: "cpp" | "c"): boolean {
   if (language === "cpp") {
     return /^\s*(?:(?:template\s*<[^>]*>\s*)?(?:class|struct|namespace|enum(?:\s+class)?)\b)/.test(
       text,
     );
   }
-  if (language === "c") {
-    return /^\s*(?:struct|enum|union)\b/.test(text);
-  }
-  return false;
+  return /^\s*(?:struct|enum|union)\b/.test(text);
+}
+
+function shouldSkipNestedBraceDecl(text: string, language: string): boolean {
+  return (
+    (language === "cpp" || language === "c") &&
+    lineIndent(text) > 0 &&
+    !isBraceFamilyTypeDecl(text, language)
+  );
 }
 
 function braceUnits(lines: LineGroup[], language: string): ChunkBoundary[] {
@@ -205,11 +196,7 @@ function braceUnits(lines: LineGroup[], language: string): ChunkBoundary[] {
     if (!re.test(text)) {
       continue;
     }
-    if (
-      BRACE_FAMILY_LANGUAGES.has(language) &&
-      lineIndent(text) > 0 &&
-      !isBraceFamilyTypeDecl(text, language)
-    ) {
+    if (shouldSkipNestedBraceDecl(text, language)) {
       continue;
     }
     if (firstDeclStart === null) {
@@ -263,6 +250,8 @@ function braceUnits(lines: LineGroup[], language: string): ChunkBoundary[] {
   return dedupeAndSort(units);
 }
 
+export const structuralTestUtils = { shouldSkipNestedBraceDecl };
+
 function dedupeAndSort(units: ChunkBoundary[]): ChunkBoundary[] {
   const out: ChunkBoundary[] = [];
   const seen = new Set<string>();

package/src/cli-mode.ts

@@ -0,0 +1,18 @@
+/** Keep older stdio MCP configs working when they launch Miru without a subcommand. */
+export function shouldRunMcp(
+  argv: readonly string[],
+  stdinIsTTY: boolean,
+  stdoutIsTTY: boolean,
+): boolean {
+  if (argv[0] === "mcp") return argv[1] !== "-h" && argv[1] !== "--help";
+  if (stdinIsTTY || stdoutIsTTY) return false;
+  const first = argv[0];
+  return (
+    first === undefined ||
+    first === "--benchmark" ||
+    first === "--benchmark=true" ||
+    first === "--benchmark=false" ||
+    first === "--ref" ||
+    first === "--content"
+  );
+}