@takara-ai/miru-code 1.0.4 → 1.1.0

package/src/concurrency.ts

@@ -1,15 +1,25 @@
-import { availableParallelism, cpus } from "node:os";
+/**
+ * Concurrency helpers for indexing and embedding pipelines.
+ *
+ * Caps parallel file parsing, BM25 scoring, and embed batching so Miru stays
+ * responsive on laptops and shared CI runners without starving the OS.
+ */
+import { availableParallelism } from "node:os";
 
-const DEFAULT_RESERVE_CORES = 2;
+/** Cores left for the event loop, MCP stdio, and other host processes during indexing. */
+export const DEFAULT_RESERVE_CORES = 2;
 
-export function resolveCpuCount(): number {
-  if (typeof availableParallelism === "function") {
-    return availableParallelism();
-  }
-  return cpus().length;
+function workerCount(concurrency: number, itemCount: number): number {
+  return Math.max(1, Math.min(concurrency, itemCount));
 }
 
-/** Worker pool size: logical CPUs minus 2, minimum 1. Override with MIRU_CONCURRENCY. */
+/**
+ * Worker pool size for file parsing and other CPU-bound index work.
+ *
+ * Default: `availableParallelism() - DEFAULT_RESERVE_CORES`, floored at 1.
+ * Override with `MIRU_CONCURRENCY` or legacy alias `MIRU_WORKERS`.
+ * Invalid env values are ignored so a typo does not crash indexing.
+ */
 export function resolveWorkerConcurrency(): number {
   const raw = process.env.MIRU_CONCURRENCY ?? process.env.MIRU_WORKERS;
   if (raw) {
@@ -18,37 +28,34 @@ export function resolveWorkerConcurrency(): number {
       return Math.floor(n);
     }
   }
-  return Math.max(1, resolveCpuCount() - DEFAULT_RESERVE_CORES);
+  return Math.max(1, availableParallelism() - DEFAULT_RESERVE_CORES);
 }
 
-/** Run async work over items with at most `concurrency` tasks in flight. Results keep input order. */
+/**
+ * Bounded parallel map: at most `concurrency` workers run `worker` at once.
+ *
+ * Unlike `Promise.all(items.map(worker))`, this limits in-flight tasks when
+ * `items` is large (e.g. thousands of source files). Output order matches
+ * input order because each result is stored at its original index.
+ *
+ * Workers share a single `items.entries()` iterator; each claims the next
+ * `[index, item]` pair until the input is exhausted.
+ */
 export async function mapPool<T, R>(
   items: readonly T[],
   concurrency: number,
   worker: (item: T, index: number) => Promise<R>,
 ): Promise<R[]> {
-  if (items.length === 0) {
-    return [];
-  }
-
-  const limit = Math.max(1, Math.min(concurrency, items.length));
   const results = new Array<R>(items.length);
-  let nextIndex = 0;
+  const pending = items.entries();
 
-  async function drain(): Promise<void> {
-    while (true) {
-      const i = nextIndex++;
-      if (i >= items.length) {
-        return;
+  await Promise.all(
+    Array.from({ length: workerCount(concurrency, items.length) }, async () => {
+      for (const [i, item] of pending) {
+        results[i] = await worker(item, i);
       }
-      const item = items[i];
-      if (item === undefined) {
-        continue;
-      }
-      results[i] = await worker(item, i);
-    }
-  }
+    }),
+  );
 
-  await Promise.all(Array.from({ length: limit }, () => drain()));
   return results;
 }

package/src/credentials.ts

@@ -1,4 +1,4 @@
-import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { hasTakaraApiKeyInEnv, normalizeTakaraApiKeyEnv } from "./env.ts";
 
@@ -37,7 +37,7 @@ export async function readStoredCredentials(): Promise<StoredCredentials | null>
     return null;
   }
   try {
-    const parsed = JSON.parse(await readFile(path, "utf-8")) as StoredCredentials;
+    const parsed = JSON.parse(await Bun.file(path).text()) as StoredCredentials;
     if (parsed.version !== CREDENTIALS_VERSION || !parsed.takara_api_key) {
       return null;
     }
@@ -69,10 +69,7 @@ export async function saveStoredCredentials(apiKey: string): Promise<string> {
     version: CREDENTIALS_VERSION,
     takara_api_key: apiKey,
   };
-  await writeFile(path, `${JSON.stringify(payload, null, 2)}\n`, {
-    encoding: "utf-8",
-    mode: 0o600,
-  });
+  await Bun.write(path, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
   try {
     await chmod(path, 0o600);
   } catch {
@@ -88,7 +85,7 @@ export async function clearStoredCredentials(): Promise<{ cleared: boolean; path
   }
 
   const stored = await readStoredCredentials();
-  await rm(path, { force: true });
+  await Bun.file(path).delete();
 
   if (stored && process.env.TAKARA_API_KEY === stored.takara_api_key) {
     delete process.env.TAKARA_API_KEY;

package/src/embeddings/openai.ts

@@ -1,8 +1,8 @@
 import { mapPool, resolveWorkerConcurrency } from "../concurrency.ts";
 import { envFirstString, envOptionalInt, resolveEmbeddingApiKey } from "../env.ts";
 
-const DEFAULT_MODEL = "ds1-miru-int8";
-const DEFAULT_BASE_URL = "https://infer.takara.ai/v1";
+export const DEFAULT_EMBEDDING_MODEL = "ds1-miru-int8";
+export const DEFAULT_EMBEDDING_BASE_URL = "https://infer.takara.ai/v1";
 const DEFAULT_BATCH_SIZE = 32;
 const DEFAULT_MAX_EMBED_CHARS = 1300;
 const WINDOW_OVERLAP_CHARS = 120;
@@ -32,7 +32,10 @@ export interface EmbeddingBackend {
 }
 
 export function resolveEmbeddingModel(): string {
-  return envFirstString(["MIRU_OPENAI_EMBEDDING_MODEL", "OPENAI_EMBEDDING_MODEL"], DEFAULT_MODEL);
+  return envFirstString(
+    ["MIRU_OPENAI_EMBEDDING_MODEL", "OPENAI_EMBEDDING_MODEL"],
+    DEFAULT_EMBEDDING_MODEL,
+  );
 }
 
 export function resolveMaxEmbedChars(): number {
@@ -118,10 +121,10 @@ export function resolveEmbeddingBatchSize(): number {
 }
 
 export function resolveEmbeddingBaseUrl(): string {
-  return envFirstString(["MIRU_OPENAI_BASE_URL", "OPENAI_BASE_URL"], DEFAULT_BASE_URL).replace(
-    /\/$/,
-    "",
-  );
+  return envFirstString(
+    ["MIRU_OPENAI_BASE_URL", "OPENAI_BASE_URL"],
+    DEFAULT_EMBEDDING_BASE_URL,
+  ).replace(/\/$/, "");
 }
 
 interface Int8Embedding {

package/src/env-files.ts

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
 function applyEnvLine(line: string): void {
@@ -24,21 +23,25 @@ function applyEnvLine(line: string): void {
   process.env[key] = value;
 }
 
-function loadEnvFile(path: string): void {
-  if (!existsSync(path)) {
+async function loadEnvFile(path: string): Promise<void> {
+  const file = Bun.file(path);
+  if (!(await file.exists())) {
     return;
   }
-  for (const line of readFileSync(path, "utf-8").split("\n")) {
+  for (const line of (await file.text()).split("\n")) {
     applyEnvLine(line);
   }
 }
 
 /** Load .env.local / .env without overriding vars already set (e.g. MCP config env). */
-export function loadEnvFiles(options?: { packageRoot?: string; cwd?: string }): void {
+export async function loadEnvFiles(options?: {
+  packageRoot?: string;
+  cwd?: string;
+}): Promise<void> {
   const cwd = options?.cwd ?? process.cwd();
   const packageRoot = options?.packageRoot ?? join(import.meta.dir, "..");
   for (const dir of [packageRoot, cwd]) {
-    loadEnvFile(join(dir, ".env.local"));
-    loadEnvFile(join(dir, ".env"));
+    await loadEnvFile(join(dir, ".env.local"));
+    await loadEnvFile(join(dir, ".env"));
   }
 }

package/src/help.ts

@@ -1,6 +1,6 @@
 import type { AgentId } from "./agents.ts";
 import {
-  brandTitle,
+  commandHeader,
   commandRow,
   divider,
   fail,
@@ -9,6 +9,9 @@ import {
   section,
   writeStdout,
 } from "./cli-ui.ts";
+import { DEFAULT_RESERVE_CORES } from "./concurrency.ts";
+import { DEFAULT_EMBEDDING_BASE_URL, DEFAULT_EMBEDDING_MODEL } from "./embeddings/openai.ts";
+import { TAKARA_API_KEY_ENV } from "./env.ts";
 
 export const AGENT_IDS: readonly AgentId[] = [
   "claude",
@@ -22,7 +25,7 @@ export const AGENT_IDS: readonly AgentId[] = [
 const AGENT_LIST = AGENT_IDS.join(", ");
 
 export function printMainHelp(): void {
-  header("hybrid code search for agents");
+  header();
 
   section("Usage");
   writeStdout("  miru                         Start MCP server (stdio)");
@@ -51,14 +54,14 @@ export function printMainHelp(): void {
 
 export function printEnvHelp(): void {
   section("Environment");
-  writeStdout("  TAKARA_API_KEY");
+  writeStdout(`  ${TAKARA_API_KEY_ENV}`);
   writeStdout("      Takara bearer token for embeddings");
   writeStdout("  MIRU_OPENAI_BASE_URL");
-  writeStdout("      Default: https://infer.takara.ai/v1");
+  writeStdout(`      Default: ${DEFAULT_EMBEDDING_BASE_URL}`);
   writeStdout("  MIRU_OPENAI_EMBEDDING_MODEL");
-  writeStdout("      Default: ds1-miru-int8");
+  writeStdout(`      Default: ${DEFAULT_EMBEDDING_MODEL}`);
   writeStdout("  MIRU_CONCURRENCY");
-  writeStdout("      Parallel workers (default: CPUs − 2)");
+  writeStdout(`      Parallel workers (default: CPUs − ${DEFAULT_RESERVE_CORES})`);
   writeStdout("");
 }
 
@@ -67,17 +70,10 @@ export function printFullHelp(): void {
   printEnvHelp();
 }
 
-function printCommandHeader(name: string, summary: string): void {
-  writeStdout("");
-  writeStdout(`${brandTitle()} ${name}`);
-  writeStdout(summary);
-  divider();
-}
-
 export function printCommandHelp(command: string): void {
   switch (command) {
     case "search":
-      printCommandHeader("search", "Hybrid semantic + keyword search.");
+      commandHeader("search", "Hybrid semantic + keyword search.");
       section("Usage");
       writeStdout("  miru search <query> [path] [options]");
       section("Options");
@@ -89,7 +85,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "expand":
-      printCommandHeader("expand", "More context in the same file as a search hit.");
+      commandHeader("expand", "More context in the same file as a search hit.");
       section("Usage");
       writeStdout("  miru expand <file> <line> [path] [--before N] [--after N]");
       section("Example");
@@ -97,7 +93,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "find-related":
-      printCommandHeader("find-related", "Semantic neighbors of a file location.");
+      commandHeader("find-related", "Semantic neighbors of a file location.");
       section("Usage");
       writeStdout("  miru find-related <file> <line> [path] [options]");
       section("Example");
@@ -105,7 +101,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "setup":
-      printCommandHeader("setup", "Store and validate your Takara API key.");
+      commandHeader("setup", "Store and validate your Takara API key.");
       section("Usage");
       writeStdout("  miru setup [--key TOKEN] [--force] [--clear]");
       section("Options");
@@ -115,7 +111,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "install":
-      printCommandHeader("install", "Interactive global agent setup.");
+      commandHeader("install", "Interactive global agent setup.");
       writeStdout("Configures MCP server, instructions, and sub-agent files under");
       writeStdout("your user config (~/.claude, ~/.cursor, etc.).");
       writeStdout("");
@@ -123,12 +119,12 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "uninstall":
-      printCommandHeader("uninstall", "Remove miru configuration from agents.");
+      commandHeader("uninstall", "Remove miru configuration from agents.");
       writeStdout("Removes MCP entries, marked instruction blocks, and global sub-agents.");
       writeStdout("");
       return;
     case "init":
-      printCommandHeader("init", "Project-local sub-agent file.");
+      commandHeader("init", "Project-local sub-agent file.");
       writeStdout("Prefer miru install for global setup. Use init to commit into a repo.");
       section("Usage");
       writeStdout("  miru init --agent AGENT [--force]");
@@ -139,7 +135,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "clear":
-      printCommandHeader("clear", "Drop the on-disk index cache.");
+      commandHeader("clear", "Drop the on-disk index cache.");
       section("Usage");
       writeStdout("  miru clear [path]");
       section("Example");
@@ -147,7 +143,7 @@ export function printCommandHelp(command: string): void {
       writeStdout("");
       return;
     case "mcp":
-      printCommandHeader("mcp", "Stdio MCP server (default with no subcommand).");
+      commandHeader("mcp", "Stdio MCP server (default with no subcommand).");
       section("Usage");
       writeStdout("  miru [--ref BRANCH] [--content TYPE ...]");
       writeStdout("");

package/src/index/chunk-selector.ts

@@ -0,0 +1,57 @@
+export type ChunkIndexMappings = {
+  fileMapping: ReadonlyMap<string, readonly number[]>;
+  languageMapping: ReadonlyMap<string, readonly number[]>;
+};
+
+/**
+ * Union of chunk indices matching language and/or path filters.
+ *
+ * Filters combine with OR semantics: a chunk is included if it matches any
+ * requested language or path. Returns `undefined` when no filters are given
+ * (search all chunks) or when no chunks match.
+ *
+ * Single-filter queries return the prebuilt map array directly (read-only for
+ * callers). Multi-filter queries allocate a deduped index list.
+ */
+export function buildChunkSelector(
+  mappings: ChunkIndexMappings,
+  filterLanguages?: readonly string[],
+  filterPaths?: readonly string[],
+): readonly number[] | undefined {
+  const langCount = filterLanguages?.length ?? 0;
+  const pathCount = filterPaths?.length ?? 0;
+
+  if (langCount === 0 && pathCount === 0) {
+    return undefined;
+  }
+
+  if (langCount === 1 && pathCount === 0) {
+    const lang = filterLanguages?.[0];
+    if (!lang) {
+      return undefined;
+    }
+    const indices = mappings.languageMapping.get(lang);
+    return indices && indices.length > 0 ? indices : undefined;
+  }
+
+  if (pathCount === 1 && langCount === 0) {
+    const fp = filterPaths?.[0];
+    if (!fp) {
+      return undefined;
+    }
+    const indices = mappings.fileMapping.get(fp);
+    return indices && indices.length > 0 ? indices : undefined;
+  }
+
+  const selector: number[] = [];
+  for (const lang of filterLanguages ?? []) {
+    selector.push(...(mappings.languageMapping.get(lang) ?? []));
+  }
+  for (const fp of filterPaths ?? []) {
+    selector.push(...(mappings.fileMapping.get(fp) ?? []));
+  }
+  if (selector.length === 0) {
+    return undefined;
+  }
+  return [...new Set(selector)];
+}

package/src/index/dense.ts

@@ -1,70 +1,114 @@
-/** Cosine-distance vector index with optional chunk selector. */
-import { mkdir } from "node:fs/promises";
+/** Uncompressed float32 semantic index. Debug/precision baseline only; production uses int8. */
 import type { SemanticIndex } from "./semantic-index.ts";
-import { selectTopKByDistance } from "./topk.ts";
+import { TopKDistanceCollector } from "./topk.ts";
+
+function cosineDistanceFlat(
+  data: Float32Array,
+  dim: number,
+  docIndex: number,
+  query: Float32Array,
+): number {
+  const offset = docIndex * dim;
+  let dot = 0;
+  for (let i = 0; i < dim; i++) {
+    dot += (query[i] ?? 0) * (data[offset + i] ?? 0);
+  }
+  return 1 - dot;
+}
 
 export class VectorIndex implements SemanticIndex {
-  private vectors: Float32Array[];
+  private readonly data: Float32Array;
+  private readonly count: number;
+  private readonly dim: number;
+  private vectorsCache: Float32Array[] | null = null;
 
   constructor(vectors: Float32Array[]) {
-    this.vectors = vectors;
+    if (vectors.length === 0) {
+      this.count = 0;
+      this.dim = 0;
+      this.data = new Float32Array(0);
+      return;
+    }
+    this.count = vectors.length;
+    this.dim = vectors[0]?.length ?? 0;
+    this.data = new Float32Array(this.count * this.dim);
+    for (let i = 0; i < this.count; i++) {
+      const vec = vectors[i];
+      if (vec) {
+        this.data.set(vec, i * this.dim);
+      }
+    }
+  }
+
+  static fromFlatBuffer(data: Float32Array, count: number, dim: number): VectorIndex {
+    const index = Object.create(VectorIndex.prototype) as VectorIndex;
+    Object.assign(index, { data, count, dim });
+    return index;
   }
 
   get size(): number {
-    return this.vectors.length;
+    return this.count;
   }
 
   get dimensions(): number {
-    return this.vectors[0]?.length ?? 0;
+    return this.dim;
   }
 
   getVectors(): readonly Float32Array[] {
-    return this.vectors;
+    if (this.vectorsCache) {
+      return this.vectorsCache;
+    }
+    const vectors: Float32Array[] = [];
+    for (let i = 0; i < this.count; i++) {
+      vectors.push(this.data.subarray(i * this.dim, (i + 1) * this.dim));
+    }
+    this.vectorsCache = vectors;
+    return vectors;
   }
 
   vectorAt(docIndex: number): Float32Array {
-    const vec = this.vectors[docIndex];
-    if (!vec) {
+    if (docIndex < 0 || docIndex >= this.count) {
       throw new Error(`Missing vector at index ${docIndex}`);
     }
-    return vec;
+    return this.data.subarray(docIndex * this.dim, (docIndex + 1) * this.dim);
   }
 
   memoryBytes(): number {
-    return this.vectors.length * this.dimensions * 4;
+    return this.count * this.dim * 4;
   }
 
   query(
     queryVector: Float32Array,
     k: number,
-    selector?: number[],
+    selector?: readonly number[],
   ): { indices: number[]; distances: number[] } {
     if (k < 1) {
       throw new Error(`k should be >= 1, is now ${k}`);
     }
-
-    const numVectors = this.vectors.length;
-    if (numVectors === 0) {
+    if (this.count === 0) {
       return { indices: [], distances: [] };
     }
 
-    const indices = selector ?? Array.from({ length: numVectors }, (_, i) => i);
-    const effectiveK = Math.min(k, indices.length);
+    const effectiveK = Math.min(k, selector?.length ?? this.count);
     if (effectiveK === 0) {
       return { indices: [], distances: [] };
     }
 
-    const top = selectTopKByDistance(
-      indices.flatMap((idx) => {
-        const vec = this.vectors[idx];
-        if (!vec) {
-          return [];
+    const collector = new TopKDistanceCollector(effectiveK);
+    if (selector) {
+      for (const idx of selector) {
+        if (idx < 0 || idx >= this.count) {
+          continue;
         }
-        return [{ index: idx, distance: cosineDistance(queryVector, vec) }];
-      }),
-      effectiveK,
-    );
+        collector.offer(idx, cosineDistanceFlat(this.data, this.dim, idx, queryVector));
+      }
+    } else {
+      for (let i = 0; i < this.count; i++) {
+        collector.offer(i, cosineDistanceFlat(this.data, this.dim, i, queryVector));
+      }
+    }
 
+    const top = collector.finish();
     return {
       indices: top.map((t) => t.index),
       distances: top.map((t) => t.distance),
@@ -72,21 +116,10 @@ export class VectorIndex implements SemanticIndex {
   }
 
   async save(dir: string): Promise<void> {
-    await mkdir(dir, { recursive: true });
-
-    const dim = this.dimensions;
-    const count = this.size;
-    const buffer = new Float32Array(count * dim);
-    for (let i = 0; i < count; i++) {
-      const vec = this.vectors[i];
-      if (vec) {
-        buffer.set(vec, i * dim);
-      }
-    }
-    await Bun.write(`${dir}/vectors.bin`, buffer);
+    await Bun.write(`${dir}/vectors.bin`, this.data);
     await Bun.write(
       `${dir}/meta.json`,
-      JSON.stringify({ count, dimensions: dim, storage: "float32" }),
+      JSON.stringify({ count: this.count, dimensions: this.dim, storage: "float32" }),
     );
   }
 
@@ -95,19 +128,7 @@ export class VectorIndex implements SemanticIndex {
       count: number;
       dimensions: number;
     };
-    const raw = new Float32Array(await Bun.file(`${dir}/vectors.bin`).arrayBuffer());
-    const vectors: Float32Array[] = [];
-    for (let i = 0; i < meta.count; i++) {
-      vectors.push(raw.subarray(i * meta.dimensions, (i + 1) * meta.dimensions));
-    }
-    return new VectorIndex(vectors);
+    const data = new Float32Array(await Bun.file(`${dir}/vectors.bin`).arrayBuffer());
+    return VectorIndex.fromFlatBuffer(data, meta.count, meta.dimensions);
   }
 }
-
-function cosineDistance(a: Float32Array, b: Float32Array): number {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += (a[i] ?? 0) * (b[i] ?? 0);
-  }
-  return 1 - dot;
-}

package/src/index/entry-chunks.ts

@@ -1,7 +1,7 @@
 import { join, relative } from "node:path";
 import type { Chunk } from "../types.ts";
 
-function indexedPath(absPath: string, repoRoot: string, displayRoot?: string): string {
+function indexedPath(absPath: string, _repoRoot: string, displayRoot?: string): string {
   if (displayRoot) {
     return relative(displayRoot, absPath).replace(/\\/g, "/");
   }

package/src/index/int8-dot.ts

@@ -0,0 +1,55 @@
+type QuantizedVector = {
+  codes: Int8Array;
+  scale: number;
+};
+
+/** Reference scalar int8 dot product (A/B regression baseline). */
+export function quantizedDotFlatScalar(
+  query: QuantizedVector,
+  codes: Int8Array,
+  offset: number,
+  dim: number,
+  docScale: number,
+): number {
+  let sum = 0;
+  const q = query.codes;
+  for (let i = 0; i < dim; i++) {
+    sum += q[i] * codes[offset + i];
+  }
+  return sum * query.scale * docScale;
+}
+
+/** Production int8 dot product with 8-wide unrolling for JSC auto-vectorization. */
+export function quantizedDotFlat(
+  query: QuantizedVector,
+  codes: Int8Array,
+  offset: number,
+  dim: number,
+  docScale: number,
+): number {
+  const q = query.codes;
+  let s0 = 0;
+  let s1 = 0;
+  let s2 = 0;
+  let s3 = 0;
+  let s4 = 0;
+  let s5 = 0;
+  let s6 = 0;
+  let s7 = 0;
+  let i = 0;
+  for (; i + 7 < dim; i += 8) {
+    s0 += q[i] * codes[offset + i];
+    s1 += q[i + 1] * codes[offset + i + 1];
+    s2 += q[i + 2] * codes[offset + i + 2];
+    s3 += q[i + 3] * codes[offset + i + 3];
+    s4 += q[i + 4] * codes[offset + i + 4];
+    s5 += q[i + 5] * codes[offset + i + 5];
+    s6 += q[i + 6] * codes[offset + i + 6];
+    s7 += q[i + 7] * codes[offset + i + 7];
+  }
+  let sum = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7;
+  for (; i < dim; i++) {
+    sum += q[i] * codes[offset + i];
+  }
+  return sum * query.scale * docScale;
+}

package/src/index/persistence.ts

@@ -1,4 +1,3 @@
-import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { BM25Index } from "./bm25.ts";
 import { VectorIndex } from "./dense.ts";
@@ -78,7 +77,6 @@ export async function saveIndexBundle(options: {
   metadata: Record<string, unknown>;
 }): Promise<void> {
   const { paths, bm25, semantic, chunks, metadata } = options;
-  await mkdir(paths.root, { recursive: true });
   await saveBm25(bm25, paths.bm25Index);
   await saveSemantic(semantic, paths.semanticIndex);
   await Bun.write(