@takara-ai/miru-code 0.1.0 → 0.1.2

package/README.md

@@ -8,15 +8,14 @@ Indexes a local directory, combines semantic search with BM25, RRF fusion, and c
 
 ## Install
 
-Miru ships **Bun as a dependency** so `miru` uses a compatible runtime after install. You still need [Node.js](https://nodejs.org) on your PATH for the install step (Bun’s `postinstall`); do not use `--ignore-scripts`.
+Requires [Bun](https://bun.sh) 1.1+ on your PATH (`curl -fsSL https://bun.sh/install | bash`).
 
 ```bash
 # Run once without installing
-bunx @takara-ai/miru-code search "auth middleware" ./src
+bun x @takara-ai/miru-code search "auth middleware" ./src
 
-# Global CLI (npm or bun)
+# Global CLI
 bun add -g @takara-ai/miru-code
-# or: npm install -g @takara-ai/miru-code
 miru search "auth middleware" ./src
 
 # Library
@@ -78,19 +77,21 @@ Run with **no arguments** to start the stdio MCP server. It indexes the **curren
 ```bash
 bun /path/to/miru/src/cli.ts
 # or after bun add -g @takara-ai/miru-code:  miru
-# or without installing:           bunx @takara-ai/miru-code
+# or without installing:           bun x @takara-ai/miru-code
 ```
 
 **Tools:** `search`, `find_related` — pass `repo` only when querying a different path or git URL.
 
 Cursor `~/.cursor/mcp.json` (or project `.cursor/mcp.json`):
 
+Use **`bun x`** (not `bunx` as the command) so Cursor does not pull the `bun` npm package postinstall, which breaks in MCP sandboxes:
+
 ```json
 {
   "mcpServers": {
     "miru": {
-      "command": "bunx",
-      "args": ["@takara-ai/miru-code"],
+      "command": "bun",
+      "args": ["x", "@takara-ai/miru-code"],
       "env": {
         "TAKARA_API_KEY": "your-takara-bearer-token",
         "MIRU_OPENAI_BASE_URL": "https://infer.dev.takara.ai/v1",
@@ -133,7 +134,7 @@ Local development (path to this repo):
 }
 ```
 
-No project path in `args` for `bunx` / global install — Cursor runs the server with `cwd` set to the open workspace, which becomes the default index. Put the bearer token in `env`; MCP will not read `.env.local` unless those vars are unset.
+No project path in `args` for `bun x` / global install — Cursor runs the server with `cwd` set to the open workspace, which becomes the default index. Put the bearer token in `env`; MCP will not read `.env.local` unless those vars are unset.
 
 ## Library
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",
@@ -26,11 +26,8 @@
   "engines": {
     "bun": ">=1.1.0"
   },
-  "trustedDependencies": [
-    "bun"
-  ],
   "bin": {
-    "miru": "bin/miru.cjs"
+    "miru": "./src/cli.ts"
   },
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -38,7 +35,6 @@
     ".": "./src/index.ts"
   },
   "files": [
-    "bin",
     "src",
     "README.md",
     "LICENSE"
@@ -60,7 +56,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "bun": "^1.1.0",
     "ignore": "^7.0.5",
     "zod": "^4.4.3"
   },

package/src/mcp/index-cache.ts

@@ -1,16 +1,73 @@
 import { watch } from "node:fs";
 import { resolve } from "node:path";
 import { MiruIndex } from "../miru-index.ts";
+import { envOptionalInt } from "../env.ts";
 import type { ContentType } from "../types.ts";
 import { computeSourceCacheKey, isGitUrl } from "../utils.ts";
 
 const CACHE_MAX_SIZE = 10;
+const DEFAULT_REINDEX_DEBOUNCE_MS = 3000;
 
-type IndexTask = Promise<MiruIndex>;
+/** Directory names we skip for MCP fs.watch re-index triggers (aligned with file-walker). */
+const WATCH_IGNORED_DIR_NAMES = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "__pycache__",
+  "node_modules",
+  ".venv",
+  "venv",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".cache",
+  ".miru",
+  ".next",
+  "dist",
+  "build",
+  ".eggs",
+]);
+
+class StaleIndexError extends Error {
+  constructor() {
+    super("Index build superseded by a newer change");
+    this.name = "StaleIndexError";
+  }
+}
+
+type CacheEntry = {
+  generation: number;
+  task: Promise<MiruIndex> | null;
+};
+
+function resolveReindexDebounceMs(): number {
+  return envOptionalInt(["MIRU_MCP_REINDEX_DEBOUNCE_MS"], 0) ?? DEFAULT_REINDEX_DEBOUNCE_MS;
+}
+
+export function mcpWatchEnabled(): boolean {
+  const raw = process.env.MIRU_MCP_WATCH ?? process.env.SEMBLE_MCP_WATCH;
+  return raw !== "0" && raw !== "false";
+}
+
+/** Returns true when a watch event path should not trigger a re-index. */
+export function shouldIgnoreWatchPath(relativePath: string | null | undefined): boolean {
+  if (!relativePath) {
+    return false;
+  }
+  const normalized = relativePath.replace(/\\/g, "/");
+  for (const segment of normalized.split("/")) {
+    if (segment && WATCH_IGNORED_DIR_NAMES.has(segment)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 export class IndexCache {
   private readonly content: ContentType[];
-  private readonly tasks = new Map<string, IndexTask>();
+  private readonly entries = new Map<string, CacheEntry>();
+  private readonly reindexTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private watcher: ReturnType<typeof watch> | null = null;
 
   constructor(content: ContentType[] = ["code"]) {
@@ -18,46 +75,128 @@ export class IndexCache {
   }
 
   evict(source: string, ref?: string | null): void {
-    this.tasks.delete(computeSourceCacheKey(source, ref));
+    this.invalidate(computeSourceCacheKey(source, ref));
   }
 
-  async get(source: string, ref?: string | null): Promise<MiruIndex> {
-    const cacheKey = computeSourceCacheKey(source, ref);
-    let task = this.tasks.get(cacheKey);
-    if (!task) {
-      if (this.tasks.size >= CACHE_MAX_SIZE) {
-        const oldest = this.tasks.keys().next().value;
+  private invalidate(cacheKey: string): void {
+    const entry = this.entries.get(cacheKey);
+    if (entry) {
+      entry.generation++;
+      entry.task = null;
+    }
+  }
+
+  private ensureEntry(cacheKey: string): CacheEntry {
+    let entry = this.entries.get(cacheKey);
+    if (!entry) {
+      if (this.entries.size >= CACHE_MAX_SIZE) {
+        const oldest = this.entries.keys().next().value;
         if (oldest) {
-          this.tasks.delete(oldest);
+          this.clearEntry(oldest);
         }
       }
-      task = MiruIndex.fromSource(source, this.content, undefined, ref);
-      this.tasks.set(cacheKey, task);
+      entry = { generation: 0, task: null };
+      this.entries.set(cacheKey, entry);
     }
+    return entry;
+  }
+
+  private clearEntry(cacheKey: string): void {
+    const timer = this.reindexTimers.get(cacheKey);
+    if (timer) {
+      clearTimeout(timer);
+      this.reindexTimers.delete(cacheKey);
+    }
+    this.entries.delete(cacheKey);
+  }
 
-    try {
-      return await task;
-    } catch (err) {
-      if (this.tasks.get(cacheKey) === task) {
-        this.tasks.delete(cacheKey);
+  private startBuild(
+    source: string,
+    ref: string | null | undefined,
+    entry: CacheEntry,
+    generationAtStart: number,
+  ): Promise<MiruIndex> {
+    return (async () => {
+      const index = await MiruIndex.fromSource(source, this.content, undefined, ref);
+      if (entry.generation !== generationAtStart) {
+        throw new StaleIndexError();
+      }
+      if (!isGitUrl(source)) {
+        await index.saveToDefaultCache(resolve(source));
+      }
+      return index;
+    })();
+  }
+
+  async get(source: string, ref?: string | null): Promise<MiruIndex> {
+    const cacheKey = computeSourceCacheKey(source, ref);
+
+    for (;;) {
+      const entry = this.ensureEntry(cacheKey);
+      const generationAtStart = entry.generation;
+
+      if (!entry.task) {
+        entry.task = this.startBuild(source, ref, entry, generationAtStart);
+      }
+
+      const task = entry.task;
+      try {
+        const index = await task;
+        if (entry.generation !== generationAtStart) {
+          continue;
+        }
+        return index;
+      } catch (err) {
+        if (entry.task === task) {
+          entry.task = null;
+        }
+        if (err instanceof StaleIndexError) {
+          continue;
+        }
+        if (this.entries.get(cacheKey) === entry) {
+          this.entries.delete(cacheKey);
+        }
+        throw err;
       }
-      throw err;
     }
   }
 
+  private scheduleReindex(source: string, ref?: string | null): void {
+    const cacheKey = computeSourceCacheKey(source, ref);
+    const existing = this.reindexTimers.get(cacheKey);
+    if (existing) {
+      clearTimeout(existing);
+    }
+
+    const debounceMs = resolveReindexDebounceMs();
+    const timer = setTimeout(() => {
+      this.reindexTimers.delete(cacheKey);
+      this.invalidate(cacheKey);
+      void this.get(source, ref).catch(() => undefined);
+    }, debounceMs);
+
+    this.reindexTimers.set(cacheKey, timer);
+  }
+
   startWatcher(path: string): void {
     const resolved = resolve(path);
     if (this.watcher) {
       this.watcher.close();
     }
 
-    this.watcher = watch(resolved, { recursive: true }, () => {
-      this.evict(resolved);
-      void this.get(resolved).catch(() => undefined);
+    this.watcher = watch(resolved, { recursive: true }, (_event, filename) => {
+      if (shouldIgnoreWatchPath(filename)) {
+        return;
+      }
+      this.scheduleReindex(resolved);
     });
   }
 
   close(): void {
+    for (const timer of this.reindexTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.reindexTimers.clear();
     this.watcher?.close();
     this.watcher = null;
   }

package/src/mcp/serve.ts

@@ -2,7 +2,7 @@ import { resolve } from "node:path";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import type { ContentType } from "../types.ts";
 import { isGitUrl } from "../utils.ts";
-import { IndexCache } from "./index-cache.ts";
+import { IndexCache, mcpWatchEnabled } from "./index-cache.ts";
 import { createMcpServer } from "./server.ts";
 
 export async function serveMcp(options: {
@@ -14,7 +14,7 @@ export async function serveMcp(options: {
   const defaultSource = options.path ?? resolve(process.cwd());
 
   void cache.get(defaultSource, options.ref).catch(() => undefined);
-  if (!isGitUrl(defaultSource)) {
+  if (!isGitUrl(defaultSource) && mcpWatchEnabled()) {
     cache.startWatcher(defaultSource);
   }
 

package/bin/miru.cjs

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const { spawnSync } = require("node:child_process");
-const fs = require("node:fs");
-const path = require("node:path");
-
-const packageRoot = path.join(__dirname, "..");
-
-function resolveBunExecutable() {
-  const binName = process.platform === "win32" ? "bun.cmd" : "bun";
-  const candidates = [
-    path.join(packageRoot, "node_modules", ".bin", binName),
-    path.join(packageRoot, "node_modules", "bun", "bin", process.platform === "win32" ? "bun.exe" : "bun"),
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return binName;
-}
-
-const cli = path.join(packageRoot, "src", "cli.ts");
-const bun = resolveBunExecutable();
-const result = spawnSync(bun, [cli, ...process.argv.slice(2)], {
-  stdio: "inherit",
-  cwd: process.cwd(),
-  env: process.env,
-  shell: process.platform === "win32",
-});
-
-if (result.error) {
-  console.error(
-    "miru: failed to run Bun. Reinstall with lifecycle scripts enabled (do not use --ignore-scripts).",
-  );
-  console.error(result.error.message);
-  process.exit(1);
-}
-
-process.exit(result.status ?? 1);