@takara-ai/miru-code 0.1.4 → 0.2.0

package/README.md

@@ -93,14 +93,14 @@ Run `miru init --agent <id> --force` to overwrite an existing sub-agent file.
 
 ### MCP server
 
-Run with **no arguments** to start the stdio MCP server. It indexes the **current working directory** (most IDEs set this to your workspace). Optional path/ref flags pre-index a different repo.
+Run with **no arguments** to start the stdio MCP server. Indexing begins on the first `search` or `find_related` call, using the `repo` path you pass. Optional `--ref` sets the default git ref for remote repos.
 
 ```bash
 bunx @takara-ai/miru-code
 # or after bun add -g @takara-ai/miru-code:  miru
 ```
 
-**Tools:** `search`, `find_related` — pass `repo` only when querying a different path or git URL.
+**Tools:** `search`, `find_related` — `repo` is required (project root or https:// git URL).
 
 For MCP configs, use `bunx` as the command (`bun` with `x` in `args` works too — they're equivalent).
 
@@ -352,12 +352,14 @@ bun run typecheck
 
 Releases use **Bun** for install, test, and `bun pm pack`. The registry upload uses **`npm publish`** on that tarball because [Bun does not yet support npm OIDC trusted publishing](https://github.com/oven-sh/bun/issues/22423) — no long-lived npm tokens in GitHub secrets.
 
-**Local first publish** (creates the package on npm):
+**Local publish** (logged in to npm; `publishConfig.access` is already `public`):
 
 ```bash
-bun publish --access public
+bun publish
 ```
 
+Runs `prepublishOnly` (typecheck + tests), then a single registry upload. Do not add a `publish` script that calls `npm publish` — Bun runs lifecycle scripts after its own upload and would publish twice.
+
 **CI** (after Trusted Publisher is configured on npm):
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",
@@ -50,7 +50,6 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "prepublishOnly": "bun run typecheck && bun test",
-    "publish": "npm publish --access public",
     "benchmark:quality": "bun run scripts/benchmark-quality.ts",
     "benchmark:quantization": "bun run scripts/benchmark-quantization.ts"
   },

package/src/cli.ts

@@ -8,7 +8,7 @@ import { serveMcp } from "./mcp/serve.ts";
 import { MiruIndex } from "./miru-index.ts";
 import { ensureCredentials, runClearCredentials, runSetup } from "./setup.ts";
 import type { ContentType } from "./types.ts";
-import { formatResults, isGitUrl, resolveChunk, resolveContent } from "./utils.ts";
+import { formatResults, resolveChunk, resolveContent } from "./utils.ts";
 
 loadEnvFiles();
 await loadStoredCredentials();
@@ -121,10 +121,9 @@ CLI:
   miru clear [path]
 
 MCP server (default when no CLI subcommand):
-  miru
-  miru [path] [--ref BRANCH] [--content code ...]
+  miru [--ref BRANCH] [--content code ...]
 
-  With no path, indexes the process working directory (Cursor sets this to your workspace).
+  Indexes a repo on the first search/find_related call via the tool repo argument.
 
 Examples:
   miru search "auth middleware" ./src
@@ -226,7 +225,6 @@ async function runCli(argv: string[]): Promise<void> {
 }
 
 async function runMcp(argv: string[]): Promise<void> {
-  let path: string | null = null;
   let ref: string | null = null;
   const contentTokens: string[] = [];
 
@@ -247,15 +245,10 @@ async function runMcp(argv: string[]): Promise<void> {
         contentTokens.push(value);
         i++;
       }
-      continue;
-    }
-    if (arg && !arg.startsWith("-") && path === null) {
-      path = isGitUrl(arg) ? arg : resolve(arg);
     }
   }
 
   await serveMcp({
-    path,
     ref,
     content: resolveContent(contentTokens.length > 0 ? contentTokens : ["code"]),
   });

package/src/mcp/index-cache.ts

@@ -57,11 +57,14 @@ export function shouldIgnoreWatchPath(relativePath: string | null | undefined):
 
 export class IndexCache {
   private readonly content: ContentType[];
+  private readonly defaultRef: string | null;
   private readonly entries = new Map<string, CacheEntry>();
   private watcher: ReturnType<typeof watch> | null = null;
+  private watchedSource: string | null = null;
 
-  constructor(content: ContentType[] = ["code"]) {
+  constructor(content: ContentType[] = ["code"], defaultRef: string | null = null) {
     this.content = content;
+    this.defaultRef = defaultRef;
   }
 
   private ensureEntry(cacheKey: string): CacheEntry {
@@ -107,6 +110,7 @@ export class IndexCache {
     void task
       .then((index) => {
         entry.index = index;
+        this.maybeStartWatcher(source);
         void this.flushFileUpdates(cacheKey, source);
         return index;
       })
@@ -120,11 +124,12 @@ export class IndexCache {
   }
 
   async get(source: string, ref?: string | null): Promise<MiruIndex> {
-    const cacheKey = computeSourceCacheKey(source, ref);
+    const resolvedRef = ref ?? this.defaultRef;
+    const cacheKey = computeSourceCacheKey(source, resolvedRef);
     const entry = this.ensureEntry(cacheKey);
 
     if (!entry.task) {
-      this.startBuild(source, ref, cacheKey);
+      this.startBuild(source, resolvedRef, cacheKey);
     }
 
     const index = await entry.task;
@@ -237,6 +242,18 @@ export class IndexCache {
     entry.updateChain = entry.updateChain.then(run, run);
   }
 
+  private maybeStartWatcher(source: string): void {
+    if (!mcpWatchEnabled() || isGitUrl(source)) {
+      return;
+    }
+    const resolved = resolve(source);
+    if (this.watchedSource === resolved) {
+      return;
+    }
+    this.watchedSource = resolved;
+    this.startWatcher(resolved);
+  }
+
   startWatcher(path: string): void {
     const resolved = resolve(path);
     if (this.watcher) {
@@ -251,34 +268,33 @@ export class IndexCache {
   close(): void {
     this.watcher?.close();
     this.watcher = null;
+    this.watchedSource = null;
     this.entries.clear();
   }
 }
 
 export async function getIndexForRepo(
   repo: string | null | undefined,
-  defaultSource: string | null,
   cache: IndexCache,
   ref?: string | null,
 ): Promise<MiruIndex> {
-  if (repo && isGitUrl(repo) && !repo.startsWith("https://") && !repo.startsWith("http://")) {
+  if (!repo) {
     throw new Error(
-      `Only https://, http://, or local directory paths are accepted as \`repo\`. Got: ${repo}`,
+      "Pass an https:// or http:// git URL or local directory path as `repo` (project root for local workspaces).",
     );
   }
 
-  const source = repo ?? defaultSource;
-  if (!source) {
+  if (isGitUrl(repo) && !repo.startsWith("https://") && !repo.startsWith("http://")) {
     throw new Error(
-      "No repo specified and no default index. Pass an https:// or http:// git URL or local directory path as `repo`.",
+      `Only https://, http://, or local directory paths are accepted as \`repo\`. Got: ${repo}`,
     );
   }
 
   try {
-    return await cache.get(source, ref);
+    return await cache.get(repo, ref);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to index ${source}: ${message}`);
+    throw new Error(`Failed to index ${repo}: ${message}`);
   }
 }
 

package/src/mcp/serve.ts

@@ -1,24 +1,14 @@
-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, mcpWatchEnabled } from "./index-cache.ts";
+import { IndexCache } from "./index-cache.ts";
 import { createMcpServer } from "./server.ts";
 
 export async function serveMcp(options: {
-  path?: string | null;
   ref?: string | null;
   content?: ContentType[];
 }): Promise<void> {
-  const cache = new IndexCache(options.content ?? ["code"]);
-  const defaultSource = options.path ?? resolve(process.cwd());
-
-  void cache.get(defaultSource, options.ref).catch(() => undefined);
-  if (!isGitUrl(defaultSource) && mcpWatchEnabled()) {
-    cache.startWatcher(defaultSource);
-  }
-
-  const server = createMcpServer(cache, defaultSource);
+  const cache = new IndexCache(options.content ?? ["code"], options.ref ?? null);
+  const server = createMcpServer(cache);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }

package/src/mcp/server.ts

@@ -6,17 +6,17 @@ import { getIndexForRepo, type IndexCache, toolText } from "./index-cache.ts";
 
 const REPO_DESCRIPTION =
   "https:// or http:// git URL (e.g. https://github.com/org/repo) or local directory path to index and search. " +
-  "Required when no default index was configured at startup. " +
-  "The index is cached after the first call, so repeat queries are fast.";
+  "Pass the project root for local workspaces. " +
+  "The index is built on the first tool call and cached for the session.";
 
 const SERVER_INSTRUCTIONS =
   "Instant code search for any local or remote git repository. " +
   "Call `search` to find relevant code; call `find_related` on a result to discover similar code elsewhere. " +
-  "When working in a local project, pass the project root as `repo`. " +
-  "For remote repos, pass an explicit https:// URL. Never guess or infer URLs. " +
+  "Always pass the project root as `repo` on the first call (local path or https:// git URL). " +
+  "Never guess or infer URLs. " +
   "Prefer these tools over Grep, Glob, or Read for any question about how code works.";
 
-export function createMcpServer(cache: IndexCache, defaultSource: string | null = null): McpServer {
+export function createMcpServer(cache: IndexCache): McpServer {
   const server = new McpServer(
     {
       name: "miru",
@@ -32,16 +32,16 @@ export function createMcpServer(cache: IndexCache, defaultSource: string | null
     {
       description:
         "Search a codebase with a natural-language or code query. " +
-        "Pass a git URL or local path as `repo` to index it on demand; indexes are cached for the session.",
+        "Indexes `repo` on the first call; later calls reuse the session cache.",
       inputSchema: {
         query: z.string().describe("Natural language or code query."),
-        repo: z.string().nullable().optional().describe(REPO_DESCRIPTION),
+        repo: z.string().describe(REPO_DESCRIPTION),
         top_k: z.number().int().min(1).optional().describe("Number of results to return."),
       },
     },
     async ({ query, repo, top_k: topK }) => {
       try {
-        const index = await getIndexForRepo(repo ?? null, defaultSource, cache);
+        const index = await getIndexForRepo(repo, cache);
         const results = await index.search({ query, topK: topK ?? 5 });
         if (results.length === 0) {
           return toolText(JSON.stringify({ error: "No results found." }));
@@ -66,13 +66,13 @@ export function createMcpServer(cache: IndexCache, defaultSource: string | null
             "Path to the file as stored in the index (use file_path from a search result).",
           ),
         line: z.number().int().describe("Line number (1-indexed)."),
-        repo: z.string().nullable().optional().describe(REPO_DESCRIPTION),
+        repo: z.string().describe(REPO_DESCRIPTION),
         top_k: z.number().int().min(1).optional().describe("Number of similar chunks to return."),
       },
     },
     async ({ file_path: filePath, line, repo, top_k: topK }) => {
       try {
-        const index = await getIndexForRepo(repo ?? null, defaultSource, cache);
+        const index = await getIndexForRepo(repo, cache);
         const chunk = resolveChunk(index.chunks, filePath, line);
         if (!chunk) {
           return toolText(