@takara-ai/miru-code 1.9.0 → 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"
+  );
+}

package/src/cli.ts

@@ -2,6 +2,7 @@
 import { type AgentId, writeAgentFile } from "./agents.ts";
 import { clearBenchmarkHistory, resolveBenchmarkHistoryPath } from "./benchmark/history.ts";
 import { clearCache } from "./cache.ts";
+import { shouldRunMcp } from "./cli-mode.ts";
 import {
   fail,
   formatRelatedHeader,
@@ -26,7 +27,6 @@ import {
   printSageMakerHelp,
 } from "./help.ts";
 import { getBenchmarkModeStatus, setBenchmarkMode } from "./installer/benchmark-mode.ts";
-import { runSearchGuardFromStdin } from "./installer/hooks/search-guard.ts";
 import { runInstaller } from "./installer/installer.ts";
 import { promptConfirm } from "./installer/prompt.ts";
 import {
@@ -72,27 +72,6 @@ try {
   // Leave recovery to ensureCredentials / setup.
 }
 
-const CLI_COMMANDS = new Set([
-  "search",
-  "locate",
-  "expand",
-  "find-related",
-  "init",
-  "install",
-  "uninstall",
-  "setup",
-  "clear",
-  "benchmark",
-  "env",
-  "environment",
-  "hook-guard",
-  "help",
-  "-h",
-  "--help",
-  "-v",
-  "--version",
-]);
-
 const AGENTS = new Set<AgentId>(AGENT_IDS);
 
 function parseFlagArgv(argv: string[], flag: string): { present: boolean; rest: string[] } {
@@ -392,21 +371,11 @@ async function runBenchmarkCommand(rest: string[]): Promise<void> {
 async function runCli(argv: string[]): Promise<void> {
   const [command, ...rest] = argv;
 
-  if (command === undefined) {
+  if (command === undefined || command === "-h" || command === "--help") {
     printMainHelp();
     return;
   }
 
-  if (command === "-h" || command === "--help") {
-    printMainHelp();
-    return;
-  }
-
-  if (command === "-v" || command === "--version") {
-    console.log(miruVersion());
-    return;
-  }
-
   if (command === "help") {
     const topic = rest[0];
     if (!topic || topic === "-h" || topic === "--help") {
@@ -436,10 +405,6 @@ async function runCli(argv: string[]): Promise<void> {
     return;
   }
 
-  if (command === "hook-guard") {
-    process.exit(await runSearchGuardFromStdin());
-  }
-
   if (command === "install" || command === "uninstall") {
     await runInstaller(command);
     return;
@@ -725,24 +690,24 @@ async function main(): Promise<void> {
   const argv = process.argv.slice(2);
   const first = argv[0];
 
+  // Old hook configs may survive until the next install/uninstall; let their
+  // search commands proceed normally while the installer removes the hooks.
+  if (first === "hook-guard") return;
+
   if (first === "-v" || first === "--version") {
     console.log(miruVersion());
     return;
   }
 
-  if (first === "hook-guard") {
-    process.exit(await runSearchGuardFromStdin());
-  }
-
   const updateNotice = maybeNotifyUpdate();
 
-  if (first && CLI_COMMANDS.has(first)) {
-    await Promise.all([runCli(argv), updateNotice]);
+  if (shouldRunMcp(argv, Boolean(process.stdin.isTTY), Boolean(process.stdout.isTTY))) {
+    await updateNotice;
+    await runMcpWithCredentials(first === "mcp" ? argv.slice(1) : argv);
     return;
   }
 
-  await updateNotice;
-  await runMcpWithCredentials(argv);
+  await Promise.all([runCli(argv), updateNotice]);
 }
 
 main().catch((err) => {

package/src/credentials.ts

@@ -25,17 +25,17 @@ function isUnsubstitutedPlaceholder(value: string): boolean {
   return value.startsWith("${") && value.endsWith("}");
 }
 
-export function resolveCredentialsDir(): string {
+export function resolveCredentialsDir(platform: NodeJS.Platform = process.platform): string {
   const override = process.env.MIRU_CREDENTIALS_DIR;
   if (override && !isUnsubstitutedPlaceholder(override)) {
     return override;
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  if (process.platform === "win32") {
+  if (platform === "win32") {
     const base = process.env.APPDATA ?? join(home, "AppData", "Roaming");
     return join(base, "miru");
   }
-  if (process.platform === "darwin") {
+  if (platform === "darwin") {
     return join(home, "Library", "Application Support", "miru");
   }
   const xdg = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
@@ -46,12 +46,12 @@ export function resolveCredentialsDir(): string {
  * Global Miru state directory (credentials, benchmark history, etc.).
  * Same location as `resolveCredentialsDir()`; prefer this name for non-secret files.
  */
-export function resolveMiruStateDir(): string {
-  return resolveCredentialsDir();
+export function resolveMiruStateDir(platform: NodeJS.Platform = process.platform): string {
+  return resolveCredentialsDir(platform);
 }
 
-export function resolveCredentialsPath(): string {
-  return join(resolveCredentialsDir(), CREDENTIALS_FILENAME);
+export function resolveCredentialsPath(platform: NodeJS.Platform = process.platform): string {
+  return join(resolveCredentialsDir(platform), CREDENTIALS_FILENAME);
 }
 
 export async function readStoredCredentials(): Promise<StoredCredentials | null> {
@@ -267,12 +267,7 @@ export async function clearStoredCredentials(): Promise<{ cleared: boolean; path
   }
 
   // Read for env cleanup, but never let parse errors block deletion.
-  let stored: StoredCredentials | null = null;
-  try {
-    stored = await readStoredCredentials();
-  } catch {
-    // Ignore parse/read errors — removal still proceeds.
-  }
+  const stored = await readStoredCredentials();
   await rm(path, { force: true });
 
   if (stored) {

package/src/embeddings/openai.ts

@@ -353,7 +353,9 @@ export class EmbeddingApiError extends Error {
   }
 }
 
-function createClient(): EmbeddingClient {
+type EmbeddingFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+function createClient(fetchImpl: EmbeddingFetch = fetch): EmbeddingClient {
   const baseUrl = resolveEmbeddingBaseUrl();
   const endpoint = `${baseUrl}/embeddings`;
 
@@ -369,7 +371,7 @@ function createClient(): EmbeddingClient {
       if (dimensions != null) {
         body.dimensions = dimensions;
       }
-      const response = await fetch(endpoint, {
+      const response = await fetchImpl(endpoint, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${apiKey}`,
@@ -407,9 +409,10 @@ export class OpenAIEmbeddingBackend implements EmbeddingBackend {
     maxEmbedChars?: number;
     dimensions?: number;
     client?: EmbeddingClient;
+    fetchImpl?: EmbeddingFetch;
   }) {
     this.model = options?.model ?? resolveEmbeddingModel();
-    this.client = options?.client ?? createClient();
+    this.client = options?.client ?? createClient(options?.fetchImpl);
     this.batchSize = options?.batchSize ?? resolveEmbeddingBatchSize();
     this.maxEmbedChars = options?.maxEmbedChars ?? resolveMaxEmbedChars();
     this.requestedDimensions = options?.dimensions ?? resolveEmbeddingDimensions(this.model);