@takara-ai/miru-code 0.1.3 → 0.2.0

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(

package/src/miru-index.ts

@@ -10,6 +10,7 @@ import {
 import { cloneGitRepository } from "./git.ts";
 import type { BM25Index } from "./index/bm25.ts";
 import { createIndexFromPath } from "./index/create.ts";
+import { applyIncrementalFileChanges } from "./index/incremental.ts";
 import { persistencePaths, saveIndexBundle } from "./index/persistence.ts";
 import type { SemanticIndex } from "./index/semantic-index.ts";
 import { hybridSearch, searchSemanticOnly } from "./search.ts";
@@ -19,16 +20,24 @@ import { computeSourceCacheKey, isGitUrl } from "./utils.ts";
 
 export class MiruIndex {
   readonly embeddings: EmbeddingBackend;
-  readonly chunks: Chunk[];
-  readonly loadedFromDisk: boolean;
+  private chunksInternal: Chunk[];
+  private bm25Index: BM25Index;
+  private semanticIndex: SemanticIndex;
+  private loadedFromDiskFlag: boolean;
 
-  private readonly bm25Index: BM25Index;
-  private readonly semanticIndex: SemanticIndex;
-  private readonly embeddingModel: string;
+  readonly embeddingModel: string;
   private readonly root: string | null;
   private readonly content: ContentType[];
-  private readonly fileMapping: Map<string, number[]>;
-  private readonly languageMapping: Map<string, number[]>;
+  private fileMapping: Map<string, number[]>;
+  private languageMapping: Map<string, number[]>;
+
+  get chunks(): Chunk[] {
+    return this.chunksInternal;
+  }
+
+  get loadedFromDisk(): boolean {
+    return this.loadedFromDiskFlag;
+  }
 
   constructor(options: {
     embeddings: EmbeddingBackend;
@@ -43,16 +52,21 @@ export class MiruIndex {
     this.embeddings = options.embeddings;
     this.bm25Index = options.bm25Index;
     this.semanticIndex = options.semanticIndex;
-    this.chunks = options.chunks;
+    this.chunksInternal = options.chunks;
     this.embeddingModel = options.embeddingModel;
     this.root = options.root ?? null;
     this.content = options.content ?? ["code"];
-    this.loadedFromDisk = options.loadedFromDisk ?? false;
+    this.loadedFromDiskFlag = options.loadedFromDisk ?? false;
+    this.fileMapping = new Map();
+    this.languageMapping = new Map();
+    this.rebuildMappings();
+  }
 
+  private rebuildMappings(): void {
     this.fileMapping = new Map();
     this.languageMapping = new Map();
-    for (let i = 0; i < this.chunks.length; i++) {
-      const chunk = this.chunks[i];
+    for (let i = 0; i < this.chunksInternal.length; i++) {
+      const chunk = this.chunksInternal[i];
       if (!chunk) {
         continue;
       }
@@ -203,11 +217,40 @@ export class MiruIndex {
   }
 
   async saveToDefaultCache(sourcePath: string): Promise<void> {
-    if (!this.loadedFromDisk) {
+    if (!this.loadedFromDiskFlag) {
       await this.save(findIndexCachePath(sourcePath));
     }
   }
 
+  async persistToCache(sourcePath: string): Promise<void> {
+    await this.save(findIndexCachePath(sourcePath));
+  }
+
+  /** Re-chunk and re-embed only the given repo-relative paths; drop their old chunks. */
+  async applyFileChanges(relativePaths: readonly string[]): Promise<void> {
+    if (!this.root) {
+      throw new Error("Incremental update requires a local index with root_path set.");
+    }
+    if (relativePaths.length === 0) {
+      return;
+    }
+
+    const updated = await applyIncrementalFileChanges({
+      root: this.root,
+      content: this.content,
+      embeddings: this.embeddings,
+      chunks: this.chunksInternal,
+      semanticIndex: this.semanticIndex,
+      relativePaths,
+    });
+
+    this.chunksInternal = updated.chunks;
+    this.bm25Index = updated.bm25;
+    this.semanticIndex = updated.semantic;
+    this.loadedFromDiskFlag = false;
+    this.rebuildMappings();
+  }
+
   private getSelector(filterLanguages?: string[], filterPaths?: string[]): number[] | undefined {
     const selector: number[] = [];
     for (const lang of filterLanguages ?? []) {

package/src/setup.ts

@@ -0,0 +1,168 @@
+import { stdin as input, stdout as output } from "node:process";
+import {
+  clearStoredCredentials,
+  hasEmbeddingApiKeyInEnv,
+  loadStoredCredentials,
+  readStoredCredentials,
+  resolveCredentialsPath,
+  saveStoredCredentials,
+} from "./credentials.ts";
+import { validateEmbeddingApiKey } from "./embeddings/validate.ts";
+import { resolveEmbeddingApiKey } from "./env.ts";
+import { Spinner } from "./spinner.ts";
+
+async function promptHidden(message: string): Promise<string> {
+  if (!input.isTTY) {
+    throw new Error(
+      "Cannot prompt for API key: stdin is not a TTY. Run `miru setup --key YOUR_KEY` or set TAKARA_API_KEY.",
+    );
+  }
+
+  return new Promise((resolve, reject) => {
+    output.write(message);
+    input.setRawMode?.(true);
+    input.resume();
+    input.setEncoding("utf8");
+
+    let value = "";
+    const onData = (chunk: string) => {
+      const char = chunk[0];
+      if (char === "\n" || char === "\r" || char === "\u0004") {
+        cleanup();
+        output.write("\n");
+        resolve(value.trim());
+        return;
+      }
+      if (char === "\u0003") {
+        cleanup();
+        output.write("\n");
+        reject(new Error("Setup cancelled."));
+        process.exit(130);
+      }
+      if (char === "\u007f" || char === "\b") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          output.write("\b \b");
+        }
+        return;
+      }
+      value += chunk;
+      output.write("*");
+    };
+
+    const cleanup = () => {
+      input.setRawMode?.(false);
+      input.pause();
+      input.removeListener("data", onData);
+    };
+
+    input.on("data", onData);
+  });
+}
+
+async function promptApiKey(): Promise<string> {
+  let key = "";
+  while (!key) {
+    key = await promptHidden("Takara API key (input hidden): ");
+    if (!key) {
+      output.write("API key cannot be empty.\n");
+    }
+  }
+  return key;
+}
+
+export interface RunSetupOptions {
+  apiKey?: string;
+  force?: boolean;
+  skipValidation?: boolean;
+}
+
+export async function runSetup(options: RunSetupOptions = {}): Promise<string> {
+  if (!options.force && hasEmbeddingApiKeyInEnv()) {
+    const path = resolveCredentialsPath();
+    const stored = await readStoredCredentials();
+    if (stored) {
+      process.stderr.write(
+        `API key already configured (env var and ${path}). Use --force to replace the stored key.\n`,
+      );
+      return path;
+    }
+    process.stderr.write(
+      "API key already set via environment variable. Stored credentials were not changed.\n",
+    );
+    return resolveCredentialsPath();
+  }
+
+  if (!options.force) {
+    const stored = await readStoredCredentials();
+    if (stored && !options.apiKey) {
+      process.stderr.write(
+        `API key already stored at ${resolveCredentialsPath()}. Use --force to replace it.\n`,
+      );
+      process.env.TAKARA_API_KEY = stored.takara_api_key;
+      return resolveCredentialsPath();
+    }
+  }
+
+  process.stderr.write("\nMiru (見る) — first-time setup\n\n");
+  process.stderr.write(
+    "Miru needs a Takara API key for code embeddings.\n" +
+      "Get a bearer token from Takara, then enter it below.\n\n",
+  );
+
+  const apiKey = options.apiKey ?? (await promptApiKey());
+
+  if (!options.skipValidation) {
+    const spinner = new Spinner("Validating API key");
+    spinner.start();
+    const result = await validateEmbeddingApiKey({ apiKey });
+    if (!result.valid) {
+      spinner.fail(result.message);
+      throw new Error(result.message);
+    }
+    spinner.succeed("API key validated");
+  }
+
+  const path = await saveStoredCredentials(apiKey);
+  process.env.TAKARA_API_KEY = apiKey;
+  process.stderr.write(`\nSaved credentials to ${path} (readable only by your user account).\n`);
+  process.stderr.write("You can also set TAKARA_API_KEY in MCP config for IDE integrations.\n\n");
+  return path;
+}
+
+export async function runClearCredentials(): Promise<void> {
+  const { cleared, path } = await clearStoredCredentials();
+  if (cleared) {
+    process.stderr.write(`Removed stored API key from ${path}.\n`);
+    return;
+  }
+  process.stderr.write(`No stored API key at ${path}.\n`);
+}
+
+export async function ensureCredentials(options?: { interactive?: boolean }): Promise<void> {
+  try {
+    resolveEmbeddingApiKey();
+    return;
+  } catch {
+    await loadStoredCredentials();
+  }
+
+  try {
+    resolveEmbeddingApiKey();
+    return;
+  } catch {
+    // still missing
+  }
+
+  const interactive = options?.interactive ?? process.stdin.isTTY;
+  if (interactive) {
+    await runSetup();
+    resolveEmbeddingApiKey();
+    return;
+  }
+
+  throw new Error(
+    "Embedding API key required. Run `miru setup` in a terminal, or set TAKARA_API_KEY " +
+      "in your MCP server env (Cursor mcp.json) or .env.local.",
+  );
+}

package/src/spinner.ts

@@ -0,0 +1,57 @@
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export class Spinner {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private frame = 0;
+
+  constructor(private readonly message: string) {}
+
+  start(): void {
+    if (!process.stderr.isTTY) {
+      process.stderr.write(`${this.message}...\n`);
+      return;
+    }
+    this.timer = setInterval(() => {
+      const glyph = FRAMES[this.frame++ % FRAMES.length];
+      process.stderr.write(`\r${glyph} ${this.message}`);
+    }, 80);
+  }
+
+  stop(finalMessage?: string): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (process.stderr.isTTY) {
+      process.stderr.write("\r\x1b[K");
+    }
+    if (finalMessage) {
+      process.stderr.write(`${finalMessage}\n`);
+    }
+  }
+
+  succeed(message?: string): void {
+    this.stop(message ?? `${this.message} — ok`);
+  }
+
+  fail(message?: string): void {
+    this.stop(message ?? `${this.message} — failed`);
+  }
+}
+
+export async function withSpinner<T>(
+  message: string,
+  fn: () => Promise<T>,
+  options?: { successMessage?: string; failMessage?: string },
+): Promise<T> {
+  const spinner = new Spinner(message);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed(options?.successMessage);
+    return result;
+  } catch (err) {
+    spinner.fail(options?.failMessage);
+    throw err;
+  }
+}