@takara-ai/miru-code 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takara-ai/miru-code",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Miru (見る) — hybrid code search for agents. Bun, TypeScript, Takara embeddings.",
   "type": "module",
   "license": "MIT",

package/src/installer/prompt.ts

@@ -91,23 +91,52 @@ function readKey(): Promise<Buffer> {
   });
 }
 
-function parseKey(chunk: Buffer): string {
-  const text = chunk.toString("utf8");
-  if (chunk.length >= 3 && chunk[0] === 0x1b && chunk[1] === 0x5b) {
-    const code = chunk[2];
-    if (code === 0x41) {
+function parseArrowKey(chunk: Buffer, text: string): string | null {
+  if (chunk.length >= 2 && (chunk[0] === 0x00 || chunk[0] === 0xe0)) {
+    const scanCode = chunk[1];
+    if (scanCode === 0x48) {
       return "up";
     }
-    if (code === 0x42) {
+    if (scanCode === 0x50) {
       return "down";
     }
-    if (code === 0x43) {
+    if (scanCode === 0x4d) {
       return "right";
     }
-    if (code === 0x44) {
+    if (scanCode === 0x4b) {
       return "left";
     }
   }
+
+  // Support both ANSI CSI (ESC [ A) and SS3 (ESC O A) arrow sequences.
+  if (text.startsWith(ESC) && text.length >= 3) {
+    const introducer = text.charAt(1);
+    if (introducer === "[" || introducer === "O") {
+      const arrow = text.charAt(text.length - 1);
+      if (arrow === "A") {
+        return "up";
+      }
+      if (arrow === "B") {
+        return "down";
+      }
+      if (arrow === "C") {
+        return "right";
+      }
+      if (arrow === "D") {
+        return "left";
+      }
+    }
+  }
+
+  return null;
+}
+
+function parseKey(chunk: Buffer): string {
+  const text = chunk.toString("utf8");
+  const arrowKey = parseArrowKey(chunk, text);
+  if (arrowKey) {
+    return arrowKey;
+  }
   if (text === "\r" || text === "\n") {
     return "enter";
   }
@@ -129,6 +158,11 @@ function parseKey(chunk: Buffer): string {
   return text;
 }
 
+/** Test hook for validating raw key sequence parsing without a TTY. */
+export function parseInstallerKeyForTest(chunk: Buffer): string {
+  return parseKey(chunk);
+}
+
 async function withRawMode<T>(fn: () => Promise<T>): Promise<T> {
   input.setRawMode(true);
   input.resume();

package/src/mcp/index-cache.ts

@@ -1,5 +1,7 @@
 import { watch } from "node:fs";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import { walkFiles } from "../index/file-walker.ts";
+import { getExtensions } from "../index/files.ts";
 import { normalizeRelativePath, relativePathFromRoot } from "../index/incremental.ts";
 import { MiruIndex } from "../miru-index.ts";
 import type { ContentType } from "../types.ts";
@@ -120,6 +122,11 @@ export class IndexCache {
       if (!isGitUrl(source)) {
         await index.saveToCache(resolve(source));
       }
+      if (index.loadedFromDisk) {
+        // Await reconciliation here (not fire-and-forget) so callers of `get()`
+        // never observe an index that's stale relative to what's on disk.
+        await this.checkAndQueueStaleFiles(source, index, cacheKey);
+      }
       return index;
     })();
 
@@ -129,7 +136,6 @@ export class IndexCache {
       .then((index) => {
         entry.index = index;
         this.maybeStartWatcher(source);
-        void this.flushFileUpdates(cacheKey, source);
         return index;
       })
       .catch(() => {
@@ -162,7 +168,7 @@ export class IndexCache {
     if (!entry.flushQueued) {
       entry.flushQueued = true;
       queueMicrotask(() => {
-        this.flushFileUpdates(cacheKey, source);
+        void this.flushFileUpdates(cacheKey, source);
       });
     }
   }
@@ -219,10 +225,10 @@ export class IndexCache {
     this.scheduleFlush(cacheKey, source, entry);
   }
 
-  private flushFileUpdates(cacheKey: string, source: string): void {
+  private flushFileUpdates(cacheKey: string, source: string): Promise<void> {
     const entry = this.entries.get(cacheKey);
     if (!entry) {
-      return;
+      return Promise.resolve();
     }
     entry.flushQueued = false;
 
@@ -264,6 +270,57 @@ export class IndexCache {
     };
 
     entry.updateChain = entry.updateChain.then(run, run);
+    return entry.updateChain;
+  }
+
+  private async checkAndQueueStaleFiles(
+    source: string,
+    index: MiruIndex,
+    cacheKey: string,
+  ): Promise<void> {
+    if (isGitUrl(source)) {
+      return;
+    }
+
+    const root = index.root;
+    if (!root) {
+      return;
+    }
+
+    const storedMtimes = index.getStoredFileMtimes();
+    const entry = this.ensureEntry(cacheKey, source);
+
+    try {
+      await Promise.all(
+        [...storedMtimes].map(async ([filePath, storedMtime]) => {
+          try {
+            const currentStat = await Bun.file(resolve(root, filePath)).stat();
+            const currentMtime = Math.floor(currentStat.mtime?.getTime() ?? 0);
+
+            if (currentMtime !== storedMtime) {
+              entry.pendingPaths.add(normalizeRelativePath(filePath));
+            }
+          } catch {
+            entry.pendingPaths.add(normalizeRelativePath(filePath));
+          }
+        }),
+      );
+
+      // Files created on disk while this index wasn't loaded (or never indexed
+      // before) have no entry in `storedMtimes` and are otherwise invisible to
+      // the mtime comparison above; a directory walk is the only way to find them.
+      const extensions = getExtensions(index.contentTypes);
+      for await (const absolutePath of walkFiles(root, extensions)) {
+        const relativePath = normalizeRelativePath(relative(root, absolutePath));
+        if (!storedMtimes.has(relativePath)) {
+          entry.pendingPaths.add(relativePath);
+        }
+      }
+
+      if (entry.pendingPaths.size > 0) {
+        await this.flushFileUpdates(cacheKey, source);
+      }
+    } catch {}
   }
 
   private maybeStartWatcher(source: string): void {

package/src/miru-index.ts

@@ -60,7 +60,7 @@ export class MiruIndex {
    * Absolute path to the indexed tree on disk, or `null` for git-only indexes
    * (clone is deleted after indexing; incremental updates need a local root).
    */
-  private readonly root: string | null;
+  private readonly _root: string | null;
 
   /** Content kinds indexed at build time (e.g. `code`, `markdown`). */
   private readonly content: ContentType[];
@@ -71,6 +71,9 @@ export class MiruIndex {
   /** Language tag → chunk indices, for `filterLanguages` in search. */
   private languageMapping: Map<string, number[]>;
 
+  /** Stored file mtimes (file path → mtime_ms) for cache freshness checking. */
+  private storedFileMtimes: Map<string, number>;
+
   /** Read-only view of indexed chunks. */
   get chunks(): Chunk[] {
     return this.chunksInternal;
@@ -81,6 +84,21 @@ export class MiruIndex {
     return this.loadedFromDiskFlag;
   }
 
+  /** Get stored file mtimes for cache validation. */
+  getStoredFileMtimes(): Map<string, number> {
+    return this.storedFileMtimes;
+  }
+
+  /** Get the root path for local indexes (null for git indexes). */
+  get root(): string | null {
+    return this._root;
+  }
+
+  /** Content kinds indexed at build time, for re-walking the tree during freshness checks. */
+  get contentTypes(): ContentType[] {
+    return this.content;
+  }
+
   /**
    * Prefer static factories (`fromPath`, `fromGit`, `loadFromDisk`) over calling
    * directly; the constructor is public for tests and advanced composition.
@@ -94,15 +112,17 @@ export class MiruIndex {
     root?: string | null;
     content?: ContentType[];
     loadedFromDisk?: boolean;
+    storedFileMtimes?: Record<string, number>;
   }) {
     this.embeddings = options.embeddings;
     this.bm25Index = options.bm25Index;
     this.semanticIndex = options.semanticIndex;
     this.chunksInternal = options.chunks;
     this.embeddingModel = options.embeddingModel;
-    this.root = options.root ?? null;
+    this._root = options.root ?? null;
     this.content = options.content ?? ["code"];
     this.loadedFromDiskFlag = options.loadedFromDisk ?? false;
+    this.storedFileMtimes = new Map(Object.entries(options.storedFileMtimes ?? {}));
     this.fileMapping = new Map();
     this.languageMapping = new Map();
     this.rebuildMappings();
@@ -253,6 +273,7 @@ export class MiruIndex {
     const { bm25, semantic, chunks, metadata } = await loadCachedIndex(path);
     const content = (metadata.content_type as ContentType[]) ?? ["code"];
     const root = metadata.root_path ? String(metadata.root_path) : null;
+    const storedFileMtimes = (metadata.file_mtimes as Record<string, number>) ?? {};
 
     return new MiruIndex({
       embeddings: getEmbeddingBackend(model),
@@ -263,6 +284,7 @@ export class MiruIndex {
       root,
       content,
       loadedFromDisk: true,
+      storedFileMtimes,
     });
   }
 
@@ -275,6 +297,19 @@ export class MiruIndex {
   async save(path: string): Promise<void> {
     const paths = persistencePaths(path);
     await mkdir(paths.root, { recursive: true });
+
+    const fileMtimes: Record<string, number> = {};
+    if (this._root) {
+      for (const filePath of this.fileMapping.keys()) {
+        try {
+          const stat = await Bun.file(resolve(this._root, filePath)).stat();
+          fileMtimes[filePath] = Math.floor(stat.mtime?.getTime() ?? 0);
+        } catch {
+          fileMtimes[filePath] = 0;
+        }
+      }
+    }
+
     await saveIndexBundle({
       paths,
       bm25: this.bm25Index,
@@ -282,7 +317,7 @@ export class MiruIndex {
       chunks: this.chunks.map(chunkToDict),
       metadata: {
         index_epoch: indexCacheEpoch(),
-        root_path: this.root,
+        root_path: this._root,
         time: Date.now() / 1000,
         embedding_model: this.embeddingModel,
         embedding_dimensions:
@@ -290,6 +325,7 @@ export class MiruIndex {
         embedding_provider: "openai",
         content_type: this.content,
         file_paths: [...this.fileMapping.keys()].sort(),
+        file_mtimes: fileMtimes,
       },
     });
   }
@@ -313,7 +349,7 @@ export class MiruIndex {
    * index, and mappings in place; clears `loadedFromDisk` since data changed.
    */
   async applyFileChanges(relativePaths: readonly string[]): Promise<void> {
-    if (!this.root) {
+    if (!this._root) {
       throw new Error("Incremental update requires a local index with root_path set.");
     }
     if (relativePaths.length === 0) {
@@ -321,7 +357,7 @@ export class MiruIndex {
     }
 
     const updated = await applyIncrementalFileChanges({
-      root: this.root,
+      root: this._root,
       content: this.content,
       embeddings: this.embeddings,
       chunks: this.chunksInternal,