@takara-ai/miru-code 1.1.2 → 1.2.1

package/src/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { type AgentId, writeAgentFile } from "./agents.ts";
+import { clearBenchmarkHistory, resolveBenchmarkHistoryPath } from "./benchmark/history.ts";
 import { clearCache } from "./cache.ts";
 import {
   fail,
@@ -7,8 +8,10 @@ import {
   formatSearchErrorPretty,
   formatSearchResultsPretty,
   hint,
+  info,
   prefersJsonOutput,
   success,
+  writeStdout,
 } from "./cli-ui.ts";
 import { loadStoredCredentials } from "./credentials.ts";
 import { normalizeTakaraApiKeyEnv } from "./env.ts";
@@ -20,9 +23,11 @@ import {
   printFullHelp,
   printMainHelp,
 } 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 { formatLiteralLocate, type LiteralMode } from "./literal.ts";
 import { serveMcp } from "./mcp/serve.ts";
 import { MiruIndex } from "./miru-index.ts";
 import {
@@ -34,6 +39,8 @@ import {
 import { withSpinner } from "./spinner.ts";
 import type { ContentType, SearchResult } from "./types.ts";
 import {
+  DEFAULT_EXPAND_AFTER,
+  DEFAULT_EXPAND_BEFORE,
   expandChunksAtLine,
   formatExpandResults,
   formatResults,
@@ -44,12 +51,15 @@ import {
 } from "./utils.ts";
 import { maybeNotifyUpdate, miruVersion } from "./version.ts";
 
+process.title = "miru";
+
 await loadEnvFiles();
 normalizeTakaraApiKeyEnv();
 await loadStoredCredentials();
 
 const CLI_COMMANDS = new Set([
   "search",
+  "locate",
   "expand",
   "find-related",
   "init",
@@ -57,6 +67,7 @@ const CLI_COMMANDS = new Set([
   "uninstall",
   "setup",
   "clear",
+  "benchmark",
   "hook-guard",
   "help",
   "-h",
@@ -102,7 +113,7 @@ function parseContentArgv(argv: string[]): { content: ContentType[]; rest: strin
       rest.push(arg);
     }
   }
-  return { content: resolveContent(content.length > 0 ? content : ["code"]), rest };
+  return { content: resolveContent(content), rest };
 }
 
 function parseTopK(argv: string[]): { topK: number; rest: string[] } {
@@ -248,6 +259,53 @@ class RelatedChunkNotFoundError extends Error {
   }
 }
 
+async function runLocate(
+  path: string,
+  literal: string,
+  content: ContentType[],
+  jsonFlag: boolean,
+  mode: LiteralMode,
+  limit: number | undefined,
+  ignoreCase: boolean,
+): Promise<void> {
+  await ensureCredentials({ interactive: true });
+
+  const payload = await withSpinner("Locating literal", async () => {
+    const built = await MiruIndex.fromSource(path, content);
+    await built.saveToCache(path);
+    return formatLiteralLocate(
+      built.locateLiteral(literal, {
+        mode,
+        ignore_case: ignoreCase,
+        ...(limit != null ? { limit } : {}),
+      }),
+    );
+  });
+
+  if (prefersJsonOutput(jsonFlag)) {
+    console.log(JSON.stringify(payload));
+    return;
+  }
+
+  const n = Number(payload.n ?? 0);
+  const files = Number(payload.files ?? 0);
+  writeStdout(`literal=${literal}  n=${n}  files=${files}  mode=${mode}`);
+  const hits = payload.hits as Array<{ f: string; l: number; t?: string }> | undefined;
+  if (hits) {
+    for (const hit of hits) {
+      if (hit.t !== undefined) {
+        writeStdout(`  ${hit.f}:${hit.l}: ${hit.t}`);
+      } else {
+        writeStdout(`  ${hit.f}:${hit.l}`);
+      }
+    }
+    if (payload.truncated) {
+      writeStdout(`  … truncated (showing ${hits.length} of ${n})`);
+    }
+  }
+  writeStdout("");
+}
+
 async function runInit(agent: AgentId, force: boolean): Promise<void> {
   try {
     const dest = await writeAgentFile(agent, { force });
@@ -265,6 +323,75 @@ async function runClear(path: string): Promise<void> {
   success(`Cleared cached index for ${path}`);
 }
 
+async function runBenchmarkCommand(rest: string[]): Promise<void> {
+  const action = rest[0];
+  if (!action || action === "-h" || action === "--help") {
+    printCommandHelp("benchmark");
+    return;
+  }
+
+  if (action === "status") {
+    const rows = await getBenchmarkModeStatus();
+    const installed = rows.filter((row) => row.action !== "missing");
+    if (installed.length === 0) {
+      info("No Miru MCP installs found. Run `miru install` first.");
+      return;
+    }
+    for (const row of installed) {
+      writeStdout(`  ${row.enabled ? "on " : "off"}  ${row.agent.padEnd(16)} ${row.path}`);
+    }
+    const onCount = installed.filter((row) => row.enabled).length;
+    writeStdout("");
+    if (onCount > 0) {
+      hint(
+        `Benchmark mode on for ${onCount}/${installed.length}. Run \`miru benchmark off\` to leave.`,
+      );
+    } else {
+      hint("Benchmark mode is off for all installed agents.");
+    }
+    return;
+  }
+
+  if (action === "on" || action === "off") {
+    const enabled = action === "on";
+    const rows = await setBenchmarkMode(enabled);
+    const touched = rows.filter((row) => row.action === "updated" || row.action === "unchanged");
+    if (touched.length === 0) {
+      info("No Miru MCP installs found. Run `miru install` first.");
+      return;
+    }
+    for (const row of touched) {
+      const label = row.action === "updated" ? (enabled ? "enabled" : "disabled") : "unchanged";
+      writeStdout(`  ${label.padEnd(9)} ${row.agent.padEnd(16)} ${row.path}`);
+    }
+    writeStdout("");
+    success(
+      enabled
+        ? "Benchmark mode on. Restart agents to apply."
+        : "Benchmark mode off. Restart agents to apply.",
+    );
+    if (enabled) {
+      hint("Leave anytime with `miru benchmark off`.");
+    }
+    return;
+  }
+
+  if (action === "clear") {
+    const path = resolveBenchmarkHistoryPath();
+    const result = await clearBenchmarkHistory(path);
+    if (result.cleared) {
+      success(`Cleared benchmark report ${result.path}`);
+    } else {
+      info(`No benchmark report at ${result.path}`);
+    }
+    return;
+  }
+
+  fail(`Unknown benchmark action "${action}". Use on, off, status, or clear.`);
+  printCommandHelp("benchmark");
+  process.exit(1);
+}
+
 async function runCli(argv: string[]): Promise<void> {
   const [command, ...rest] = argv;
 
@@ -302,6 +429,11 @@ async function runCli(argv: string[]): Promise<void> {
     return;
   }
 
+  if (command === "benchmark") {
+    await runBenchmarkCommand(rest);
+    return;
+  }
+
   if (command === "init") {
     let agent: AgentId | undefined;
     let force = false;
@@ -390,6 +522,49 @@ async function runCli(argv: string[]): Promise<void> {
     return;
   }
 
+  if (command === "locate") {
+    const literal = sizedRest[0];
+    if (!literal) {
+      printCommandHelp("locate");
+      process.exit(1);
+    }
+    let mode: LiteralMode = "lines";
+    let limit: number | undefined;
+    let ignoreCase = false;
+    const pathArgs: string[] = [];
+    for (let i = 1; i < sizedRest.length; i++) {
+      const arg = sizedRest[i];
+      if (arg === "--mode" && sizedRest[i + 1]) {
+        const value = sizedRest[++i];
+        if (value !== "count" && value !== "locations" && value !== "lines") {
+          fail(`Unknown locate mode "${value}". Use count, locations, or lines.`);
+          process.exit(1);
+        }
+        mode = value;
+        continue;
+      }
+      if (arg === "--limit" && sizedRest[i + 1]) {
+        const raw = Number(sizedRest[++i]);
+        if (!Number.isFinite(raw) || raw < 1) {
+          fail("locate --limit must be a positive integer.");
+          process.exit(1);
+        }
+        limit = Math.floor(raw);
+        continue;
+      }
+      if (arg === "--ignore-case") {
+        ignoreCase = true;
+        continue;
+      }
+      if (arg !== undefined) {
+        pathArgs.push(arg);
+      }
+    }
+    const path = resolveSearchPath(pathArgs[0] ?? process.cwd());
+    await runLocate(path, literal, content, jsonFlag, mode, limit, ignoreCase);
+    return;
+  }
+
   if (command === "expand") {
     const filePath = sizedRest[0];
     const lineRaw = sizedRest[1];
@@ -399,8 +574,8 @@ async function runCli(argv: string[]): Promise<void> {
     }
     const line = Number(lineRaw);
     const path = resolveSearchPath(sizedRest[2] ?? process.cwd());
-    let before = 1;
-    let after = 1;
+    let before = DEFAULT_EXPAND_BEFORE;
+    let after = DEFAULT_EXPAND_AFTER;
     for (let i = 3; i < sizedRest.length; i++) {
       const arg = sizedRest[i];
       if (arg === "--before" && sizedRest[i + 1]) {
@@ -433,10 +608,15 @@ async function runCli(argv: string[]): Promise<void> {
 
 async function runMcp(argv: string[]): Promise<void> {
   let ref: string | null = null;
+  let benchmark = false;
   const contentTokens: string[] = [];
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
+    if (arg === "--benchmark") {
+      benchmark = true;
+      continue;
+    }
     if (arg === "--ref" && argv[i + 1]) {
       ref = argv[++i] ?? null;
       continue;
@@ -457,7 +637,8 @@ async function runMcp(argv: string[]): Promise<void> {
 
   await serveMcp({
     ref,
-    content: resolveContent(contentTokens.length > 0 ? contentTokens : ["code"]),
+    content: resolveContent(contentTokens),
+    benchmark,
   });
 }
 

package/src/credentials.ts

@@ -27,6 +27,14 @@ export function resolveCredentialsDir(): string {
   return join(xdg, "miru");
 }
 
+/**
+ * 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 resolveCredentialsPath(): string {
   return join(resolveCredentialsDir(), CREDENTIALS_FILENAME);
 }

package/src/help.ts

@@ -34,11 +34,13 @@ export function printMainHelp(): void {
 
   section("Commands");
   commandRow("search", "Hybrid search over a codebase");
+  commandRow("locate", "Exact substring location in the index");
   commandRow("expand", "Adjacent chunks in the same file as a hit");
   commandRow("find-related", "Find chunks related to a file:line");
   commandRow("setup", "Save your Takara API key locally");
   commandRow("install", "Configure miru across coding agents");
   commandRow("uninstall", "Remove miru agent configuration");
+  commandRow("benchmark", "Turn MCP benchmark mode on or off");
   commandRow("init", "Write a project-local sub-agent file");
   commandRow("clear", "Remove cached index for a path");
   commandRow("help", "Show help for a command");
@@ -62,6 +64,8 @@ export function printEnvHelp(): void {
   writeStdout(`      Default: ${DEFAULT_EMBEDDING_MODEL}`);
   writeStdout("  MIRU_CONCURRENCY");
   writeStdout(`      Parallel workers (default: CPUs − ${DEFAULT_RESERVE_CORES})`);
+  writeStdout("  MIRU_TOKENIZER_JSON");
+  writeStdout("      Path to tokenizer.json (default: <package>/tokenizer/tokenizer.json)");
   writeStdout("");
 }
 
@@ -78,12 +82,26 @@ export function printCommandHelp(command: string): void {
       writeStdout("  miru search <query> [path] [options]");
       section("Options");
       writeStdout("  -k, --top-k N       Number of results (default: 5)");
-      writeStdout("  --content TYPE      code | docs | config | all");
+      writeStdout("  --content TYPE      code | docs | config | all (default: code config)");
       writeStdout("  --json              JSON output (default when piped)");
       section("Example");
       writeStdout('  miru search "where is auth" ./src -k 10 --content code docs');
       writeStdout("");
       return;
+    case "locate":
+      commandHeader("locate", "Exact substring location over the Miru index.");
+      section("Usage");
+      writeStdout("  miru locate <literal> [path] [options]");
+      section("Options");
+      writeStdout("  --mode MODE         count | locations | lines (default: lines)");
+      writeStdout("  --limit N           Optional hit cap (default: all matches)");
+      writeStdout("  --ignore-case       Case-insensitive match");
+      writeStdout("  --content TYPE      code | docs | config | all (default: code config)");
+      writeStdout("  --json              JSON output (default when piped)");
+      section("Example");
+      writeStdout("  miru locate MIRU_BENCHMARK_HISTORY_PATH . --mode locations");
+      writeStdout("");
+      return;
     case "expand":
       commandHeader("expand", "More context in the same file as a search hit.");
       section("Usage");
@@ -121,6 +139,28 @@ export function printCommandHelp(command: string): void {
     case "uninstall":
       commandHeader("uninstall", "Remove miru configuration from agents.");
       writeStdout("Removes MCP entries, marked instruction blocks, and global sub-agents.");
+      writeStdout("Also deletes the global benchmark report from Miru's state directory.");
+      writeStdout("");
+      return;
+    case "benchmark":
+      commandHeader("benchmark", "Toggle MCP benchmark mode on installed agents.");
+      section("Usage");
+      writeStdout("  miru benchmark on");
+      writeStdout("  miru benchmark off");
+      writeStdout("  miru benchmark status");
+      writeStdout("  miru benchmark clear");
+      writeStdout("");
+      writeStdout("Adds or removes `--benchmark` from Miru MCP args in agent configs.");
+      writeStdout("If `--benchmark` is present, benchmark mode is on — no env overrides.");
+      writeStdout("Restart agents after changing mode. Prefer `off` when finished measuring.");
+      writeStdout("");
+      writeStdout("History is a global report (not per-repo) under Miru's state directory.");
+      writeStdout("Override path with MIRU_BENCHMARK_HISTORY_PATH. Append-only JSONL of savings.");
+      writeStdout("Repo paths in the report are plaintext — use `clear` on shared machines.");
+      writeStdout("");
+      writeStdout("Savings compare Miru workflow tokens to a Grep baseline");
+      writeStdout("(rg search + read of the top matched file), not the agent's full tool chain.");
+      writeStdout("Local paths only — git URL repos skip comparison with benchmark_skipped.");
       writeStdout("");
       return;
     case "init":
@@ -145,9 +185,12 @@ export function printCommandHelp(command: string): void {
     case "mcp":
       commandHeader("mcp", "Stdio MCP server (default with no subcommand).");
       section("Usage");
-      writeStdout("  miru [--ref BRANCH] [--content TYPE ...]");
+      writeStdout("  miru [--ref BRANCH] [--content TYPE ...] [--benchmark]");
+      writeStdout("  Default content: code config");
       writeStdout("");
       writeStdout("Indexes on the first search/expand/find_related tool call (repo argument).");
+      writeStdout("Use --benchmark (or `miru benchmark on`) for token-savings comparisons.");
+      writeStdout("Leave with `miru benchmark off` and restart the agent.");
       writeStdout("");
       return;
     default:

package/src/index/create.ts

@@ -6,7 +6,7 @@ import type { EmbeddingBackend } from "../embeddings/openai.ts";
 import { envOptionalInt } from "../env.ts";
 import { searchImprovementsEnabled } from "../ranking/features.ts";
 import { tokenize } from "../tokens.ts";
-import type { Chunk, ContentType } from "../types.ts";
+import { type Chunk, type ContentType, defaultContentTypes } from "../types.ts";
 import { BM25Index } from "./bm25.ts";
 import { loadRootEntryChunks } from "./entry-chunks.ts";
 import { walkFiles } from "./file-walker.ts";
@@ -33,7 +33,7 @@ function resolveMaxIndexFiles(): number | undefined {
 export async function createIndexFromPath(
   path: string,
   embeddings: EmbeddingBackend,
-  content: ContentType[] = ["code"],
+  content: ContentType[] = defaultContentTypes(),
   displayRoot?: string,
 ): Promise<{ bm25: BM25Index; semantic: SemanticIndex; chunks: Chunk[] }> {
   const profile = process.env.MIRU_PROFILE === "1";

package/src/index/incremental.ts

@@ -1,4 +1,4 @@
-import { join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { chunkSource } from "../chunking/chunking.ts";
 import type { EmbeddingBackend } from "../embeddings/openai.ts";
 import { tokenize } from "../tokens.ts";
@@ -123,8 +123,9 @@ function rebuildBm25(chunks: Chunk[]): BM25Index {
 export function relativePathFromRoot(root: string, absoluteOrRelative: string): string {
   const resolvedRoot = resolve(root);
   const candidate = resolve(resolvedRoot, absoluteOrRelative);
-  if (candidate.startsWith(`${resolvedRoot}/`) || candidate === resolvedRoot) {
-    return normalizeRelativePath(relative(resolvedRoot, candidate));
+  const rel = normalizeRelativePath(relative(resolvedRoot, candidate));
+  if (rel === "" || (!rel.startsWith("../") && rel !== ".." && !isAbsolute(rel))) {
+    return rel;
   }
   return normalizeRelativePath(absoluteOrRelative);
 }

package/src/index.ts

@@ -18,8 +18,10 @@ export { MiruIndex } from "./miru-index.ts";
 export type {
   /** A searchable text span from a source file (path, line range, content). */
   Chunk,
-  /** What to index: source code, markdown docs, or both. */
+  /** What to index: source code, docs, and/or config. */
   ContentType,
   /** Ranked hit returned by `search` or `findRelated`. */
   SearchResult,
 } from "./types.ts";
+
+export { DEFAULT_CONTENT_TYPES, defaultContentTypes } from "./types.ts";