brain-cache 0.2.0 → 0.3.0

package/dist/{askCodebase-ECDSSTQ6.js → askCodebase-DTII3Y6P.js}

@@ -4,16 +4,16 @@ import {
 } from "./chunk-GGOUKACO.js";
 import {
   runBuildContext
-} from "./chunk-7JLSJNKU.js";
-import "./chunk-OKWMQNH6.js";
-import "./chunk-ZLB4VJQK.js";
-import "./chunk-WCNMLSL2.js";
-import "./chunk-P7WSTGLE.js";
-import "./chunk-XXWJ57QP.js";
-import "./chunk-PA4BZBWS.js";
+} from "./chunk-ABKGOJTC.js";
+import "./chunk-5FXXZBZV.js";
+import "./chunk-BF5UDEIF.js";
+import "./chunk-GR6QXZ4J.js";
+import "./chunk-V4ARVFRG.js";
+import "./chunk-6MACVOTO.js";
+import "./chunk-MSI4MDIM.js";
 import {
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/workflows/askCodebase.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/buildContext-JKYV7CCP.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  runBuildContext
+} from "./chunk-ABKGOJTC.js";
+import "./chunk-5FXXZBZV.js";
+import "./chunk-BF5UDEIF.js";
+import "./chunk-GR6QXZ4J.js";
+import "./chunk-V4ARVFRG.js";
+import "./chunk-6MACVOTO.js";
+import "./chunk-MSI4MDIM.js";
+import "./chunk-3SFDFUEX.js";
+export {
+  runBuildContext
+};

package/dist/{chunk-PDQXJSH4.js → chunk-3SFDFUEX.js}

@@ -64,6 +64,9 @@ var logger = pino(
 function childLogger(component) {
   return logger.child({ component });
 }
+function setLogLevel(level) {
+  logger.level = level;
+}
 
 export {
   GLOBAL_CONFIG_DIR,
@@ -83,5 +86,6 @@ export {
   DIAGNOSTIC_SEARCH_LIMIT,
   DEFAULT_TOKEN_BUDGET,
   FILE_HASHES_FILENAME,
-  childLogger
+  childLogger,
+  setLogLevel
 };

package/dist/{chunk-OKWMQNH6.js → chunk-5FXXZBZV.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/tokenCounter.ts
 import { countTokens } from "@anthropic-ai/tokenizer";

package/dist/{chunk-XXWJ57QP.js → chunk-6MACVOTO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   IndexStateSchema
-} from "./chunk-PA4BZBWS.js";
+} from "./chunk-MSI4MDIM.js";
 import {
   DEFAULT_EMBEDDING_DIMENSION,
   EMBEDDING_DIMENSIONS,
@@ -9,7 +9,7 @@ import {
   PROJECT_DATA_DIR,
   VECTOR_INDEX_THRESHOLD,
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/lancedb.ts
 import * as lancedb from "@lancedb/lancedb";

package/dist/{chunk-7JLSJNKU.js → chunk-ABKGOJTC.js}

@@ -2,29 +2,29 @@
 import {
   assembleContext,
   countChunkTokens
-} from "./chunk-OKWMQNH6.js";
+} from "./chunk-5FXXZBZV.js";
 import {
   RETRIEVAL_STRATEGIES,
   classifyQueryIntent,
   deduplicateChunks,
   searchChunks
-} from "./chunk-ZLB4VJQK.js";
+} from "./chunk-BF5UDEIF.js";
 import {
   embedBatchWithRetry
-} from "./chunk-WCNMLSL2.js";
+} from "./chunk-GR6QXZ4J.js";
 import {
   isOllamaRunning
-} from "./chunk-P7WSTGLE.js";
+} from "./chunk-V4ARVFRG.js";
 import {
   openDatabase,
   readIndexState
-} from "./chunk-XXWJ57QP.js";
+} from "./chunk-6MACVOTO.js";
 import {
   readProfile
-} from "./chunk-PA4BZBWS.js";
+} from "./chunk-MSI4MDIM.js";
 import {
   DEFAULT_TOKEN_BUDGET
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/workflows/buildContext.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-ZLB4VJQK.js → chunk-BF5UDEIF.js}

@@ -5,7 +5,7 @@ import {
   DIAGNOSTIC_DISTANCE_THRESHOLD,
   DIAGNOSTIC_SEARCH_LIMIT,
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/retriever.ts
 var log = childLogger("retriever");

package/dist/{chunk-WCNMLSL2.js → chunk-GR6QXZ4J.js}

@@ -4,7 +4,7 @@ import {
   DEFAULT_EMBEDDING_DIMENSION,
   EMBED_TIMEOUT_MS,
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/embedder.ts
 import ollama from "ollama";
@@ -40,7 +40,8 @@ function isContextLengthError(err) {
 }
 async function embedBatchWithRetry(model, texts, dimension = DEFAULT_EMBEDDING_DIMENSION, attempt = 0) {
   try {
-    return await embedBatch(model, texts);
+    const embeddings = await embedBatch(model, texts);
+    return { embeddings, skipped: 0 };
   } catch (err) {
     if (attempt === 0 && isConnectionError(err)) {
       log.warn({ model }, "Ollama cold-start suspected, retrying in 5s");
@@ -50,24 +51,21 @@ async function embedBatchWithRetry(model, texts, dimension = DEFAULT_EMBEDDING_D
     if (isContextLengthError(err)) {
       log.warn({ model, batchSize: texts.length }, "Batch exceeded context length, falling back to individual embedding");
       const results = [];
+      let skipped = 0;
       for (const text of texts) {
         try {
           const [vec] = await embedBatch(model, [text]);
           results.push(vec);
         } catch (innerErr) {
           if (isContextLengthError(innerErr)) {
-            process.stderr.write(
-              `
-brain-cache: chunk too large for embedding model, skipping (${text.length} chars)
-`
-            );
+            skipped++;
             results.push(new Array(dimension).fill(0));
           } else {
             throw innerErr;
           }
         }
       }
-      return results;
+      return { embeddings: results, skipped };
     }
     throw err;
   }

package/dist/{chunk-PA4BZBWS.js → chunk-MSI4MDIM.js}

@@ -3,7 +3,7 @@ import {
   GLOBAL_CONFIG_DIR,
   PROFILE_PATH,
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/capability.ts
 import { execFile } from "child_process";

package/dist/{chunk-P7WSTGLE.js → chunk-V4ARVFRG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   childLogger
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/services/ollama.ts
 import { execFile, spawn } from "child_process";

package/dist/cli.js

@@ -5,23 +5,23 @@ import {
 
 // src/cli/index.ts
 import { Command } from "commander";
-var version = "0.1.0";
+var version = "0.3.0";
 var program = new Command();
 program.name("brain-cache").description("Local AI runtime \u2014 GPU cache layer for Claude").version(version);
 program.command("init").description("Detect hardware, pull embedding model, create config directory").action(async () => {
-  const { runInit } = await import("./init-TRPFEOHF.js");
+  const { runInit } = await import("./init-SXC4MWOR.js");
   await runInit();
 });
 program.command("doctor").description("Report system health: GPU, VRAM tier, Ollama status").action(async () => {
-  const { runDoctor } = await import("./doctor-5775VUMA.js");
+  const { runDoctor } = await import("./doctor-3RIVSSNB.js");
   await runDoctor();
 });
 program.command("index").description("Index a codebase: parse, chunk, embed, and store in LanceDB").argument("[path]", "Directory to index (defaults to current directory)").option("-f, --force", "Force full reindex, ignoring cached file hashes").action(async (path, opts) => {
-  const { runIndex } = await import("./workflows-MJLEPCZY.js");
+  const { runIndex } = await import("./workflows-TWA2GDHJ.js");
   await runIndex(path, { force: opts.force });
 });
 program.command("search").description("Search indexed codebase with a natural language query").argument("<query>", "Natural language query string").option("-n, --limit <n>", "Maximum number of results", "10").option("-p, --path <path>", "Project root directory").action(async (query, opts) => {
-  const { runSearch } = await import("./search-WKKGPNLV.js");
+  const { runSearch } = await import("./search-BF7QY64J.js");
   await runSearch(query, {
     limit: parseInt(opts.limit, 10),
     path: opts.path
@@ -30,12 +30,12 @@ program.command("search").description("Search indexed codebase with a natural la
 program.command("status").description(
   "Show index stats: files indexed, chunks stored, last indexed time"
 ).argument("[path]", "Project root directory (defaults to current directory)").action(async (path) => {
-  const { runStatus } = await import("./status-2SOIQ3LX.js");
+  const { runStatus } = await import("./status-JYNMLSXZ.js");
   await runStatus(path);
 });
 program.command("context").description("Build token-budgeted context from codebase for a query").argument("<query>", "Natural language query string").option("-n, --limit <n>", "Maximum number of search results", "10").option("-b, --budget <tokens>", "Token budget for assembled context", "4096").option("-p, --path <path>", "Project root directory").option("--raw", "Output raw JSON (MCP transport compatible)").action(
   async (query, opts) => {
-    const { runBuildContext } = await import("./buildContext-6755TRND.js");
+    const { runBuildContext } = await import("./buildContext-JKYV7CCP.js");
     const result = await runBuildContext(query, {
       limit: parseInt(opts.limit, 10),
       maxTokens: parseInt(opts.budget, 10),
@@ -61,7 +61,7 @@ ${formatTokenSavings({ tokensSent: result.metadata.tokensSent, estimatedWithout,
 program.command("ask").description(
   "Ask a natural language question about the codebase \u2014 retrieves context locally, reasons via Claude"
 ).argument("<question>", "Natural language question about the codebase").option("-b, --budget <tokens>", "Token budget for context retrieval", "4096").option("-p, --path <path>", "Project root directory").action(async (question, opts) => {
-  const { runAskCodebase } = await import("./askCodebase-ECDSSTQ6.js");
+  const { runAskCodebase } = await import("./askCodebase-DTII3Y6P.js");
   const result = await runAskCodebase(question, {
     path: opts.path,
     maxContextTokens: parseInt(opts.budget, 10)

package/dist/{doctor-5775VUMA.js → doctor-3RIVSSNB.js}

@@ -4,14 +4,14 @@ import {
   isOllamaInstalled,
   isOllamaRunning,
   modelMatches
-} from "./chunk-P7WSTGLE.js";
+} from "./chunk-V4ARVFRG.js";
 import {
   detectCapabilities,
   readProfile
-} from "./chunk-PA4BZBWS.js";
+} from "./chunk-MSI4MDIM.js";
 import {
   PROFILE_PATH
-} from "./chunk-PDQXJSH4.js";
+} from "./chunk-3SFDFUEX.js";
 
 // src/workflows/doctor.ts
 import ollama from "ollama";

package/dist/{embedder-KRANITVN.js → embedder-2UG2GDQO.js}

@@ -2,8 +2,8 @@
 import {
   embedBatch,
   embedBatchWithRetry
-} from "./chunk-WCNMLSL2.js";
-import "./chunk-PDQXJSH4.js";
+} from "./chunk-GR6QXZ4J.js";
+import "./chunk-3SFDFUEX.js";
 export {
   embedBatch,
   embedBatchWithRetry

package/dist/{init-TRPFEOHF.js → init-SXC4MWOR.js}

@@ -5,12 +5,12 @@ import {
   isOllamaRunning,
   pullModelIfMissing,
   startOllama
-} from "./chunk-P7WSTGLE.js";
+} from "./chunk-V4ARVFRG.js";
 import {
   detectCapabilities,
   writeProfile
-} from "./chunk-PA4BZBWS.js";
-import "./chunk-PDQXJSH4.js";
+} from "./chunk-MSI4MDIM.js";
+import "./chunk-3SFDFUEX.js";
 
 // src/workflows/init.ts
 import { existsSync, readFileSync, writeFileSync, appendFileSync } from "fs";
@@ -52,7 +52,7 @@ async function runInit() {
     `brain-cache: warming model ${profileWithVersion.embeddingModel} into VRAM...
 `
   );
-  const { embedBatchWithRetry } = await import("./embedder-KRANITVN.js");
+  const { embedBatchWithRetry } = await import("./embedder-2UG2GDQO.js");
   await embedBatchWithRetry(profileWithVersion.embeddingModel, ["warmup"]);
   process.stderr.write("brain-cache: model warm.\n");
   await writeProfile(profileWithVersion);
@@ -63,6 +63,28 @@ async function runInit() {
   VRAM tier: ${profileWithVersion.vramTier}
 `
   );
+  const brainCacheMcpEntry = {
+    command: "node",
+    args: ["node_modules/brain-cache/dist/mcp.js"]
+  };
+  const mcpJsonPath = ".mcp.json";
+  if (existsSync(mcpJsonPath)) {
+    const mcpContent = readFileSync(mcpJsonPath, "utf-8");
+    const parsed = JSON.parse(mcpContent);
+    const existing = parsed.mcpServers?.["brain-cache"];
+    if (existing && JSON.stringify(existing) === JSON.stringify(brainCacheMcpEntry)) {
+      process.stderr.write("brain-cache: .mcp.json already contains brain-cache MCP server, skipping.\n");
+    } else {
+      parsed.mcpServers = parsed.mcpServers ?? {};
+      parsed.mcpServers["brain-cache"] = brainCacheMcpEntry;
+      writeFileSync(mcpJsonPath, JSON.stringify(parsed, null, 2) + "\n");
+      process.stderr.write("brain-cache: added brain-cache MCP server to .mcp.json.\n");
+    }
+  } else {
+    const mcpConfig = { mcpServers: { "brain-cache": brainCacheMcpEntry } };
+    writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+    process.stderr.write("brain-cache: created .mcp.json with brain-cache MCP server.\n");
+  }
   const claudeMdPath = "CLAUDE.md";
   const brainCacheSection = `
 ## Brain-Cache MCP Tools

package/dist/mcp.js

@@ -43,6 +43,9 @@ var logger = pino(
 function childLogger(component) {
   return logger.child({ component });
 }
+function setLogLevel(level) {
+  logger.level = level;
+}
 
 // src/lib/format.ts
 function formatTokenSavings(input) {
@@ -640,7 +643,8 @@ function isContextLengthError(err) {
 }
 async function embedBatchWithRetry(model, texts, dimension = DEFAULT_EMBEDDING_DIMENSION, attempt = 0) {
   try {
-    return await embedBatch(model, texts);
+    const embeddings = await embedBatch(model, texts);
+    return { embeddings, skipped: 0 };
   } catch (err) {
     if (attempt === 0 && isConnectionError(err)) {
       log6.warn({ model }, "Ollama cold-start suspected, retrying in 5s");
@@ -650,24 +654,21 @@ async function embedBatchWithRetry(model, texts, dimension = DEFAULT_EMBEDDING_D
     if (isContextLengthError(err)) {
       log6.warn({ model, batchSize: texts.length }, "Batch exceeded context length, falling back to individual embedding");
       const results = [];
+      let skipped = 0;
       for (const text of texts) {
         try {
           const [vec] = await embedBatch(model, [text]);
           results.push(vec);
         } catch (innerErr) {
           if (isContextLengthError(innerErr)) {
-            process.stderr.write(
-              `
-brain-cache: chunk too large for embedding model, skipping (${text.length} chars)
-`
-            );
+            skipped++;
             results.push(new Array(dimension).fill(0));
           } else {
             throw innerErr;
           }
         }
       }
-      return results;
+      return { embeddings: results, skipped };
     }
     throw err;
   }
@@ -710,201 +711,218 @@ function hashContent(content) {
 }
 async function runIndex(targetPath, opts) {
   const force = opts?.force ?? false;
-  const rootDir = resolve(targetPath ?? ".");
-  const profile = await readProfile();
-  if (profile === null) {
-    throw new Error("No profile found. Run 'brain-cache init' first.");
-  }
-  const running = await isOllamaRunning();
-  if (!running) {
-    throw new Error("Ollama is not running. Start it with 'ollama serve' or run 'brain-cache init'.");
-  }
-  const dim = EMBEDDING_DIMENSIONS[profile.embeddingModel] ?? DEFAULT_EMBEDDING_DIMENSION;
-  if (!(profile.embeddingModel in EMBEDDING_DIMENSIONS)) {
-    process.stderr.write(
-      `Warning: Unknown embedding model '${profile.embeddingModel}', defaulting to ${DEFAULT_EMBEDDING_DIMENSION} dimensions.
+  const previousLogLevel = process.env.BRAIN_CACHE_LOG ?? "warn";
+  setLogLevel("silent");
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk, ...args) => {
+    const str = typeof chunk === "string" ? chunk : chunk.toString();
+    if (/^\[[\d\-T:Z]+ WARN lance/.test(str) || /^\[[\d\-T:Z]+ INFO lance/.test(str)) {
+      return true;
+    }
+    return originalStderrWrite(chunk, ...args);
+  });
+  try {
+    const rootDir = resolve(targetPath ?? ".");
+    const profile = await readProfile();
+    if (profile === null) {
+      throw new Error("No profile found. Run 'brain-cache init' first.");
+    }
+    const running = await isOllamaRunning();
+    if (!running) {
+      throw new Error("Ollama is not running. Start it with 'ollama serve' or run 'brain-cache init'.");
+    }
+    const dim = EMBEDDING_DIMENSIONS[profile.embeddingModel] ?? DEFAULT_EMBEDDING_DIMENSION;
+    if (!(profile.embeddingModel in EMBEDDING_DIMENSIONS)) {
+      process.stderr.write(
+        `Warning: Unknown embedding model '${profile.embeddingModel}', defaulting to ${DEFAULT_EMBEDDING_DIMENSION} dimensions.
 `
-    );
-  }
-  const db = await openDatabase(rootDir);
-  const table = await openOrCreateChunkTable(db, rootDir, profile.embeddingModel, dim);
-  const files = await crawlSourceFiles(rootDir);
-  process.stderr.write(`brain-cache: found ${files.length} source files
+      );
+    }
+    const db = await openDatabase(rootDir);
+    const table = await openOrCreateChunkTable(db, rootDir, profile.embeddingModel, dim);
+    const files = await crawlSourceFiles(rootDir);
+    process.stderr.write(`brain-cache: found ${files.length} source files
 `);
-  if (files.length === 0) {
-    process.stderr.write(`No source files found in ${rootDir}
+    if (files.length === 0) {
+      process.stderr.write(`No source files found in ${rootDir}
 `);
-    return;
-  }
-  const contentMap = /* @__PURE__ */ new Map();
-  const currentHashes = {};
-  for (let groupStart = 0; groupStart < files.length; groupStart += FILE_READ_CONCURRENCY) {
-    const group = files.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
-    const results = await Promise.all(
-      group.map(async (filePath) => {
-        const content = await readFile4(filePath, "utf-8");
-        return { filePath, content, hash: hashContent(content) };
-      })
+      return;
+    }
+    const contentMap = /* @__PURE__ */ new Map();
+    const currentHashes = {};
+    for (let groupStart = 0; groupStart < files.length; groupStart += FILE_READ_CONCURRENCY) {
+      const group = files.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
+      const results = await Promise.all(
+        group.map(async (filePath) => {
+          const content = await readFile4(filePath, "utf-8");
+          return { filePath, content, hash: hashContent(content) };
+        })
+      );
+      for (const { filePath, content, hash } of results) {
+        contentMap.set(filePath, content);
+        currentHashes[filePath] = hash;
+      }
+    }
+    const storedHashes = force ? {} : await readFileHashes(rootDir);
+    const crawledSet = new Set(files);
+    const newFiles = [];
+    const changedFiles = [];
+    const removedFiles = [];
+    const unchangedFiles = [];
+    for (const filePath of files) {
+      const currentHash = currentHashes[filePath];
+      if (!(filePath in storedHashes)) {
+        newFiles.push(filePath);
+      } else if (storedHashes[filePath] !== currentHash) {
+        changedFiles.push(filePath);
+      } else {
+        unchangedFiles.push(filePath);
+      }
+    }
+    for (const filePath of Object.keys(storedHashes)) {
+      if (!crawledSet.has(filePath)) {
+        removedFiles.push(filePath);
+      }
+    }
+    process.stderr.write(
+      `brain-cache: incremental index -- ${newFiles.length} new, ${changedFiles.length} changed, ${removedFiles.length} removed (${unchangedFiles.length} unchanged)
+`
     );
-    for (const { filePath, content, hash } of results) {
-      contentMap.set(filePath, content);
-      currentHashes[filePath] = hash;
+    for (const filePath of [...removedFiles, ...changedFiles]) {
+      await deleteChunksByFilePath(table, filePath);
     }
-  }
-  const storedHashes = force ? {} : await readFileHashes(rootDir);
-  const crawledSet = new Set(files);
-  const newFiles = [];
-  const changedFiles = [];
-  const removedFiles = [];
-  const unchangedFiles = [];
-  for (const filePath of files) {
-    const currentHash = currentHashes[filePath];
-    if (!(filePath in storedHashes)) {
-      newFiles.push(filePath);
-    } else if (storedHashes[filePath] !== currentHash) {
-      changedFiles.push(filePath);
-    } else {
-      unchangedFiles.push(filePath);
+    const updatedHashes = { ...storedHashes };
+    for (const filePath of removedFiles) {
+      delete updatedHashes[filePath];
     }
-  }
-  for (const filePath of Object.keys(storedHashes)) {
-    if (!crawledSet.has(filePath)) {
-      removedFiles.push(filePath);
+    const filesToProcess = [...newFiles, ...changedFiles];
+    if (filesToProcess.length === 0) {
+      process.stderr.write(`brain-cache: nothing to re-index
+`);
+      for (const filePath of files) {
+        updatedHashes[filePath] = currentHashes[filePath];
+      }
+      await writeFileHashes(rootDir, updatedHashes);
+      const totalFiles2 = unchangedFiles.length;
+      const chunkCount2 = await table.countRows();
+      await writeIndexState(rootDir, {
+        version: 1,
+        embeddingModel: profile.embeddingModel,
+        dimension: dim,
+        indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        fileCount: totalFiles2,
+        chunkCount: chunkCount2
+      });
+      process.stderr.write(
+        `brain-cache: indexing complete
+  Files:        ${totalFiles2}
+  Chunks:       ${chunkCount2}
+  Model:        ${profile.embeddingModel}
+  Stored in:    ${rootDir}/.brain-cache/
+`
+      );
+      return;
     }
-  }
-  process.stderr.write(
-    `brain-cache: incremental index -- ${newFiles.length} new, ${changedFiles.length} changed, ${removedFiles.length} removed (${unchangedFiles.length} unchanged)
+    let totalRawTokens = 0;
+    let totalChunkTokens = 0;
+    let totalChunks = 0;
+    let processedFiles = 0;
+    let processedChunks = 0;
+    let skippedChunks = 0;
+    for (let groupStart = 0; groupStart < filesToProcess.length; groupStart += FILE_READ_CONCURRENCY) {
+      const group = filesToProcess.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
+      const groupChunks = [];
+      for (const filePath of group) {
+        const content = contentMap.get(filePath);
+        totalRawTokens += countChunkTokens(content);
+        const chunks = chunkFile(filePath, content);
+        groupChunks.push(...chunks);
+      }
+      processedFiles += group.length;
+      totalChunks += groupChunks.length;
+      if (processedFiles % 10 === 0 || groupStart + FILE_READ_CONCURRENCY >= filesToProcess.length) {
+        process.stderr.write(`brain-cache: chunked ${processedFiles}/${filesToProcess.length} files
+`);
+      }
+      for (let offset = 0; offset < groupChunks.length; offset += DEFAULT_BATCH_SIZE) {
+        const batch = groupChunks.slice(offset, offset + DEFAULT_BATCH_SIZE);
+        const embeddableBatch = batch.filter((chunk) => {
+          const tokens = countChunkTokens(chunk.content);
+          if (tokens > EMBED_MAX_TOKENS) {
+            skippedChunks++;
+            return false;
+          }
+          return true;
+        });
+        if (embeddableBatch.length === 0) continue;
+        const texts = embeddableBatch.map((chunk) => chunk.content);
+        totalChunkTokens += texts.reduce((sum, t) => sum + countChunkTokens(t), 0);
+        const { embeddings: vectors, skipped } = await embedBatchWithRetry(profile.embeddingModel, texts, dim);
+        skippedChunks += skipped;
+        const rows = embeddableBatch.map((chunk, i) => ({
+          id: chunk.id,
+          file_path: chunk.filePath,
+          chunk_type: chunk.chunkType,
+          scope: chunk.scope,
+          name: chunk.name,
+          content: chunk.content,
+          start_line: chunk.startLine,
+          end_line: chunk.endLine,
+          vector: vectors[i]
+        }));
+        await insertChunks(table, rows);
+        processedChunks += batch.length;
+        process.stderr.write(
+          `brain-cache: embedding ${processedChunks}/${totalChunks} chunks (${Math.round(processedChunks / totalChunks * 100)}%)
 `
-  );
-  for (const filePath of [...removedFiles, ...changedFiles]) {
-    await deleteChunksByFilePath(table, filePath);
-  }
-  const updatedHashes = { ...storedHashes };
-  for (const filePath of removedFiles) {
-    delete updatedHashes[filePath];
-  }
-  const filesToProcess = [...newFiles, ...changedFiles];
-  if (filesToProcess.length === 0) {
-    process.stderr.write(`brain-cache: nothing to re-index
+        );
+      }
+    }
+    if (skippedChunks > 0) {
+      process.stderr.write(`brain-cache: ${skippedChunks} chunks skipped (too large for model context)
 `);
-    for (const filePath of files) {
+    }
+    process.stderr.write(
+      `brain-cache: ${totalChunks} chunks from ${filesToProcess.length} files
+`
+    );
+    await createVectorIndexIfNeeded(table, profile.embeddingModel);
+    for (const filePath of filesToProcess) {
+      updatedHashes[filePath] = currentHashes[filePath];
+    }
+    for (const filePath of unchangedFiles) {
       updatedHashes[filePath] = currentHashes[filePath];
     }
     await writeFileHashes(rootDir, updatedHashes);
-    const totalFiles2 = unchangedFiles.length;
-    const chunkCount2 = await table.countRows();
+    const totalFiles = files.length;
+    const chunkCount = await table.countRows();
     await writeIndexState(rootDir, {
       version: 1,
       embeddingModel: profile.embeddingModel,
       dimension: dim,
       indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fileCount: totalFiles2,
-      chunkCount: chunkCount2
+      fileCount: totalFiles,
+      chunkCount
     });
+    const reductionPct = totalRawTokens > 0 ? Math.round((1 - totalChunkTokens / totalRawTokens) * 100) : 0;
+    const savingsBlock = formatTokenSavings({
+      tokensSent: totalChunkTokens,
+      estimatedWithout: totalRawTokens,
+      reductionPct
+    }).split("\n").map((line) => `  ${line}`).join("\n");
     process.stderr.write(
       `brain-cache: indexing complete
-  Files:        ${totalFiles2}
-  Chunks:       ${chunkCount2}
-  Model:        ${profile.embeddingModel}
-  Stored in:    ${rootDir}/.brain-cache/
-`
-    );
-    return;
-  }
-  let totalRawTokens = 0;
-  let totalChunkTokens = 0;
-  let totalChunks = 0;
-  let processedFiles = 0;
-  let processedChunks = 0;
-  for (let groupStart = 0; groupStart < filesToProcess.length; groupStart += FILE_READ_CONCURRENCY) {
-    const group = filesToProcess.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
-    const groupChunks = [];
-    for (const filePath of group) {
-      const content = contentMap.get(filePath);
-      totalRawTokens += countChunkTokens(content);
-      const chunks = chunkFile(filePath, content);
-      groupChunks.push(...chunks);
-    }
-    processedFiles += group.length;
-    totalChunks += groupChunks.length;
-    if (processedFiles % 10 === 0 || groupStart + FILE_READ_CONCURRENCY >= filesToProcess.length) {
-      process.stderr.write(`brain-cache: chunked ${processedFiles}/${filesToProcess.length} files
-`);
-    }
-    for (let offset = 0; offset < groupChunks.length; offset += DEFAULT_BATCH_SIZE) {
-      const batch = groupChunks.slice(offset, offset + DEFAULT_BATCH_SIZE);
-      const embeddableBatch = batch.filter((chunk) => {
-        const tokens = countChunkTokens(chunk.content);
-        if (tokens > EMBED_MAX_TOKENS) {
-          process.stderr.write(
-            `
-brain-cache: skipping oversized chunk (${tokens} tokens > ${EMBED_MAX_TOKENS} limit): ${chunk.filePath} lines ${chunk.startLine}-${chunk.endLine}
-`
-          );
-          return false;
-        }
-        return true;
-      });
-      if (embeddableBatch.length === 0) continue;
-      const texts = embeddableBatch.map((chunk) => chunk.content);
-      totalChunkTokens += texts.reduce((sum, t) => sum + countChunkTokens(t), 0);
-      const vectors = await embedBatchWithRetry(profile.embeddingModel, texts, dim);
-      const rows = embeddableBatch.map((chunk, i) => ({
-        id: chunk.id,
-        file_path: chunk.filePath,
-        chunk_type: chunk.chunkType,
-        scope: chunk.scope,
-        name: chunk.name,
-        content: chunk.content,
-        start_line: chunk.startLine,
-        end_line: chunk.endLine,
-        vector: vectors[i]
-      }));
-      await insertChunks(table, rows);
-      processedChunks += batch.length;
-      process.stderr.write(
-        `\rbrain-cache: embedding ${processedChunks}/${totalChunks} chunks (${Math.round(processedChunks / totalChunks * 100)}%)`
-      );
-    }
-  }
-  process.stderr.write("\n");
-  process.stderr.write(
-    `brain-cache: ${totalChunks} chunks from ${filesToProcess.length} files
-`
-  );
-  await createVectorIndexIfNeeded(table, profile.embeddingModel);
-  for (const filePath of filesToProcess) {
-    updatedHashes[filePath] = currentHashes[filePath];
-  }
-  for (const filePath of unchangedFiles) {
-    updatedHashes[filePath] = currentHashes[filePath];
-  }
-  await writeFileHashes(rootDir, updatedHashes);
-  const totalFiles = files.length;
-  const chunkCount = await table.countRows();
-  await writeIndexState(rootDir, {
-    version: 1,
-    embeddingModel: profile.embeddingModel,
-    dimension: dim,
-    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    fileCount: totalFiles,
-    chunkCount
-  });
-  const reductionPct = totalRawTokens > 0 ? Math.round((1 - totalChunkTokens / totalRawTokens) * 100) : 0;
-  const savingsBlock = formatTokenSavings({
-    tokensSent: totalChunkTokens,
-    estimatedWithout: totalRawTokens,
-    reductionPct
-  }).split("\n").map((line) => `  ${line}`).join("\n");
-  process.stderr.write(
-    `brain-cache: indexing complete
   Files:                     ${totalFiles}
   Chunks:                    ${totalChunks}
   Model:                     ${profile.embeddingModel}
 ${savingsBlock}
   Stored in:                 ${rootDir}/.brain-cache/
 `
-  );
+    );
+  } finally {
+    setLogLevel(previousLogLevel);
+    process.stderr.write = originalStderrWrite;
+  }
 }
 
 // src/workflows/search.ts
@@ -1128,7 +1146,7 @@ async function runBuildContext(query, opts) {
 }
 
 // src/mcp/index.ts
-var version = "0.1.0";
+var version = "0.3.0";
 var log9 = childLogger("mcp");
 var server = new McpServer({ name: "brain-cache", version });
 server.registerTool(

package/dist/{search-WKKGPNLV.js → search-BF7QY64J.js}

@@ -4,21 +4,21 @@ import {
   classifyQueryIntent,
   deduplicateChunks,
   searchChunks
-} from "./chunk-ZLB4VJQK.js";
+} from "./chunk-BF5UDEIF.js";
 import {
   embedBatchWithRetry
-} from "./chunk-WCNMLSL2.js";
+} from "./chunk-GR6QXZ4J.js";
 import {
   isOllamaRunning
-} from "./chunk-P7WSTGLE.js";
+} from "./chunk-V4ARVFRG.js";
 import {
   openDatabase,
   readIndexState
-} from "./chunk-XXWJ57QP.js";
+} from "./chunk-6MACVOTO.js";
 import {
   readProfile
-} from "./chunk-PA4BZBWS.js";
-import "./chunk-PDQXJSH4.js";
+} from "./chunk-MSI4MDIM.js";
+import "./chunk-3SFDFUEX.js";
 
 // src/workflows/search.ts
 import { resolve } from "path";

package/dist/{status-2SOIQ3LX.js → status-JYNMLSXZ.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   readIndexState
-} from "./chunk-XXWJ57QP.js";
+} from "./chunk-6MACVOTO.js";
 import {
   readProfile
-} from "./chunk-PA4BZBWS.js";
-import "./chunk-PDQXJSH4.js";
+} from "./chunk-MSI4MDIM.js";
+import "./chunk-3SFDFUEX.js";
 
 // src/workflows/status.ts
 import { resolve } from "path";

package/dist/{workflows-MJLEPCZY.js → workflows-TWA2GDHJ.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-GGOUKACO.js";
 import {
   countChunkTokens
-} from "./chunk-OKWMQNH6.js";
+} from "./chunk-5FXXZBZV.js";
 import {
   embedBatchWithRetry
-} from "./chunk-WCNMLSL2.js";
+} from "./chunk-GR6QXZ4J.js";
 import {
   isOllamaRunning
-} from "./chunk-P7WSTGLE.js";
+} from "./chunk-V4ARVFRG.js";
 import {
   createVectorIndexIfNeeded,
   deleteChunksByFilePath,
@@ -20,18 +20,19 @@ import {
   readFileHashes,
   writeFileHashes,
   writeIndexState
-} from "./chunk-XXWJ57QP.js";
+} from "./chunk-6MACVOTO.js";
 import {
   readProfile
-} from "./chunk-PA4BZBWS.js";
+} from "./chunk-MSI4MDIM.js";
 import {
   DEFAULT_BATCH_SIZE,
   DEFAULT_EMBEDDING_DIMENSION,
   EMBEDDING_DIMENSIONS,
   EMBED_MAX_TOKENS,
   FILE_READ_CONCURRENCY,
-  childLogger
-} from "./chunk-PDQXJSH4.js";
+  childLogger,
+  setLogLevel
+} from "./chunk-3SFDFUEX.js";
 
 // src/workflows/index.ts
 import { resolve } from "path";
@@ -259,201 +260,218 @@ function hashContent(content) {
 }
 async function runIndex(targetPath, opts) {
   const force = opts?.force ?? false;
-  const rootDir = resolve(targetPath ?? ".");
-  const profile = await readProfile();
-  if (profile === null) {
-    throw new Error("No profile found. Run 'brain-cache init' first.");
-  }
-  const running = await isOllamaRunning();
-  if (!running) {
-    throw new Error("Ollama is not running. Start it with 'ollama serve' or run 'brain-cache init'.");
-  }
-  const dim = EMBEDDING_DIMENSIONS[profile.embeddingModel] ?? DEFAULT_EMBEDDING_DIMENSION;
-  if (!(profile.embeddingModel in EMBEDDING_DIMENSIONS)) {
-    process.stderr.write(
-      `Warning: Unknown embedding model '${profile.embeddingModel}', defaulting to ${DEFAULT_EMBEDDING_DIMENSION} dimensions.
+  const previousLogLevel = process.env.BRAIN_CACHE_LOG ?? "warn";
+  setLogLevel("silent");
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk, ...args) => {
+    const str = typeof chunk === "string" ? chunk : chunk.toString();
+    if (/^\[[\d\-T:Z]+ WARN lance/.test(str) || /^\[[\d\-T:Z]+ INFO lance/.test(str)) {
+      return true;
+    }
+    return originalStderrWrite(chunk, ...args);
+  });
+  try {
+    const rootDir = resolve(targetPath ?? ".");
+    const profile = await readProfile();
+    if (profile === null) {
+      throw new Error("No profile found. Run 'brain-cache init' first.");
+    }
+    const running = await isOllamaRunning();
+    if (!running) {
+      throw new Error("Ollama is not running. Start it with 'ollama serve' or run 'brain-cache init'.");
+    }
+    const dim = EMBEDDING_DIMENSIONS[profile.embeddingModel] ?? DEFAULT_EMBEDDING_DIMENSION;
+    if (!(profile.embeddingModel in EMBEDDING_DIMENSIONS)) {
+      process.stderr.write(
+        `Warning: Unknown embedding model '${profile.embeddingModel}', defaulting to ${DEFAULT_EMBEDDING_DIMENSION} dimensions.
 `
-    );
-  }
-  const db = await openDatabase(rootDir);
-  const table = await openOrCreateChunkTable(db, rootDir, profile.embeddingModel, dim);
-  const files = await crawlSourceFiles(rootDir);
-  process.stderr.write(`brain-cache: found ${files.length} source files
+      );
+    }
+    const db = await openDatabase(rootDir);
+    const table = await openOrCreateChunkTable(db, rootDir, profile.embeddingModel, dim);
+    const files = await crawlSourceFiles(rootDir);
+    process.stderr.write(`brain-cache: found ${files.length} source files
 `);
-  if (files.length === 0) {
-    process.stderr.write(`No source files found in ${rootDir}
+    if (files.length === 0) {
+      process.stderr.write(`No source files found in ${rootDir}
 `);
-    return;
-  }
-  const contentMap = /* @__PURE__ */ new Map();
-  const currentHashes = {};
-  for (let groupStart = 0; groupStart < files.length; groupStart += FILE_READ_CONCURRENCY) {
-    const group = files.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
-    const results = await Promise.all(
-      group.map(async (filePath) => {
-        const content = await readFile2(filePath, "utf-8");
-        return { filePath, content, hash: hashContent(content) };
-      })
+      return;
+    }
+    const contentMap = /* @__PURE__ */ new Map();
+    const currentHashes = {};
+    for (let groupStart = 0; groupStart < files.length; groupStart += FILE_READ_CONCURRENCY) {
+      const group = files.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
+      const results = await Promise.all(
+        group.map(async (filePath) => {
+          const content = await readFile2(filePath, "utf-8");
+          return { filePath, content, hash: hashContent(content) };
+        })
+      );
+      for (const { filePath, content, hash } of results) {
+        contentMap.set(filePath, content);
+        currentHashes[filePath] = hash;
+      }
+    }
+    const storedHashes = force ? {} : await readFileHashes(rootDir);
+    const crawledSet = new Set(files);
+    const newFiles = [];
+    const changedFiles = [];
+    const removedFiles = [];
+    const unchangedFiles = [];
+    for (const filePath of files) {
+      const currentHash = currentHashes[filePath];
+      if (!(filePath in storedHashes)) {
+        newFiles.push(filePath);
+      } else if (storedHashes[filePath] !== currentHash) {
+        changedFiles.push(filePath);
+      } else {
+        unchangedFiles.push(filePath);
+      }
+    }
+    for (const filePath of Object.keys(storedHashes)) {
+      if (!crawledSet.has(filePath)) {
+        removedFiles.push(filePath);
+      }
+    }
+    process.stderr.write(
+      `brain-cache: incremental index -- ${newFiles.length} new, ${changedFiles.length} changed, ${removedFiles.length} removed (${unchangedFiles.length} unchanged)
+`
     );
-    for (const { filePath, content, hash } of results) {
-      contentMap.set(filePath, content);
-      currentHashes[filePath] = hash;
+    for (const filePath of [...removedFiles, ...changedFiles]) {
+      await deleteChunksByFilePath(table, filePath);
     }
-  }
-  const storedHashes = force ? {} : await readFileHashes(rootDir);
-  const crawledSet = new Set(files);
-  const newFiles = [];
-  const changedFiles = [];
-  const removedFiles = [];
-  const unchangedFiles = [];
-  for (const filePath of files) {
-    const currentHash = currentHashes[filePath];
-    if (!(filePath in storedHashes)) {
-      newFiles.push(filePath);
-    } else if (storedHashes[filePath] !== currentHash) {
-      changedFiles.push(filePath);
-    } else {
-      unchangedFiles.push(filePath);
+    const updatedHashes = { ...storedHashes };
+    for (const filePath of removedFiles) {
+      delete updatedHashes[filePath];
     }
-  }
-  for (const filePath of Object.keys(storedHashes)) {
-    if (!crawledSet.has(filePath)) {
-      removedFiles.push(filePath);
+    const filesToProcess = [...newFiles, ...changedFiles];
+    if (filesToProcess.length === 0) {
+      process.stderr.write(`brain-cache: nothing to re-index
+`);
+      for (const filePath of files) {
+        updatedHashes[filePath] = currentHashes[filePath];
+      }
+      await writeFileHashes(rootDir, updatedHashes);
+      const totalFiles2 = unchangedFiles.length;
+      const chunkCount2 = await table.countRows();
+      await writeIndexState(rootDir, {
+        version: 1,
+        embeddingModel: profile.embeddingModel,
+        dimension: dim,
+        indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        fileCount: totalFiles2,
+        chunkCount: chunkCount2
+      });
+      process.stderr.write(
+        `brain-cache: indexing complete
+  Files:        ${totalFiles2}
+  Chunks:       ${chunkCount2}
+  Model:        ${profile.embeddingModel}
+  Stored in:    ${rootDir}/.brain-cache/
+`
+      );
+      return;
     }
-  }
-  process.stderr.write(
-    `brain-cache: incremental index -- ${newFiles.length} new, ${changedFiles.length} changed, ${removedFiles.length} removed (${unchangedFiles.length} unchanged)
+    let totalRawTokens = 0;
+    let totalChunkTokens = 0;
+    let totalChunks = 0;
+    let processedFiles = 0;
+    let processedChunks = 0;
+    let skippedChunks = 0;
+    for (let groupStart = 0; groupStart < filesToProcess.length; groupStart += FILE_READ_CONCURRENCY) {
+      const group = filesToProcess.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
+      const groupChunks = [];
+      for (const filePath of group) {
+        const content = contentMap.get(filePath);
+        totalRawTokens += countChunkTokens(content);
+        const chunks = chunkFile(filePath, content);
+        groupChunks.push(...chunks);
+      }
+      processedFiles += group.length;
+      totalChunks += groupChunks.length;
+      if (processedFiles % 10 === 0 || groupStart + FILE_READ_CONCURRENCY >= filesToProcess.length) {
+        process.stderr.write(`brain-cache: chunked ${processedFiles}/${filesToProcess.length} files
+`);
+      }
+      for (let offset = 0; offset < groupChunks.length; offset += DEFAULT_BATCH_SIZE) {
+        const batch = groupChunks.slice(offset, offset + DEFAULT_BATCH_SIZE);
+        const embeddableBatch = batch.filter((chunk) => {
+          const tokens = countChunkTokens(chunk.content);
+          if (tokens > EMBED_MAX_TOKENS) {
+            skippedChunks++;
+            return false;
+          }
+          return true;
+        });
+        if (embeddableBatch.length === 0) continue;
+        const texts = embeddableBatch.map((chunk) => chunk.content);
+        totalChunkTokens += texts.reduce((sum, t) => sum + countChunkTokens(t), 0);
+        const { embeddings: vectors, skipped } = await embedBatchWithRetry(profile.embeddingModel, texts, dim);
+        skippedChunks += skipped;
+        const rows = embeddableBatch.map((chunk, i) => ({
+          id: chunk.id,
+          file_path: chunk.filePath,
+          chunk_type: chunk.chunkType,
+          scope: chunk.scope,
+          name: chunk.name,
+          content: chunk.content,
+          start_line: chunk.startLine,
+          end_line: chunk.endLine,
+          vector: vectors[i]
+        }));
+        await insertChunks(table, rows);
+        processedChunks += batch.length;
+        process.stderr.write(
+          `brain-cache: embedding ${processedChunks}/${totalChunks} chunks (${Math.round(processedChunks / totalChunks * 100)}%)
 `
-  );
-  for (const filePath of [...removedFiles, ...changedFiles]) {
-    await deleteChunksByFilePath(table, filePath);
-  }
-  const updatedHashes = { ...storedHashes };
-  for (const filePath of removedFiles) {
-    delete updatedHashes[filePath];
-  }
-  const filesToProcess = [...newFiles, ...changedFiles];
-  if (filesToProcess.length === 0) {
-    process.stderr.write(`brain-cache: nothing to re-index
+        );
+      }
+    }
+    if (skippedChunks > 0) {
+      process.stderr.write(`brain-cache: ${skippedChunks} chunks skipped (too large for model context)
 `);
-    for (const filePath of files) {
+    }
+    process.stderr.write(
+      `brain-cache: ${totalChunks} chunks from ${filesToProcess.length} files
+`
+    );
+    await createVectorIndexIfNeeded(table, profile.embeddingModel);
+    for (const filePath of filesToProcess) {
+      updatedHashes[filePath] = currentHashes[filePath];
+    }
+    for (const filePath of unchangedFiles) {
       updatedHashes[filePath] = currentHashes[filePath];
     }
     await writeFileHashes(rootDir, updatedHashes);
-    const totalFiles2 = unchangedFiles.length;
-    const chunkCount2 = await table.countRows();
+    const totalFiles = files.length;
+    const chunkCount = await table.countRows();
     await writeIndexState(rootDir, {
       version: 1,
       embeddingModel: profile.embeddingModel,
       dimension: dim,
       indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      fileCount: totalFiles2,
-      chunkCount: chunkCount2
+      fileCount: totalFiles,
+      chunkCount
     });
+    const reductionPct = totalRawTokens > 0 ? Math.round((1 - totalChunkTokens / totalRawTokens) * 100) : 0;
+    const savingsBlock = formatTokenSavings({
+      tokensSent: totalChunkTokens,
+      estimatedWithout: totalRawTokens,
+      reductionPct
+    }).split("\n").map((line) => `  ${line}`).join("\n");
     process.stderr.write(
       `brain-cache: indexing complete
-  Files:        ${totalFiles2}
-  Chunks:       ${chunkCount2}
-  Model:        ${profile.embeddingModel}
-  Stored in:    ${rootDir}/.brain-cache/
-`
-    );
-    return;
-  }
-  let totalRawTokens = 0;
-  let totalChunkTokens = 0;
-  let totalChunks = 0;
-  let processedFiles = 0;
-  let processedChunks = 0;
-  for (let groupStart = 0; groupStart < filesToProcess.length; groupStart += FILE_READ_CONCURRENCY) {
-    const group = filesToProcess.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
-    const groupChunks = [];
-    for (const filePath of group) {
-      const content = contentMap.get(filePath);
-      totalRawTokens += countChunkTokens(content);
-      const chunks = chunkFile(filePath, content);
-      groupChunks.push(...chunks);
-    }
-    processedFiles += group.length;
-    totalChunks += groupChunks.length;
-    if (processedFiles % 10 === 0 || groupStart + FILE_READ_CONCURRENCY >= filesToProcess.length) {
-      process.stderr.write(`brain-cache: chunked ${processedFiles}/${filesToProcess.length} files
-`);
-    }
-    for (let offset = 0; offset < groupChunks.length; offset += DEFAULT_BATCH_SIZE) {
-      const batch = groupChunks.slice(offset, offset + DEFAULT_BATCH_SIZE);
-      const embeddableBatch = batch.filter((chunk) => {
-        const tokens = countChunkTokens(chunk.content);
-        if (tokens > EMBED_MAX_TOKENS) {
-          process.stderr.write(
-            `
-brain-cache: skipping oversized chunk (${tokens} tokens > ${EMBED_MAX_TOKENS} limit): ${chunk.filePath} lines ${chunk.startLine}-${chunk.endLine}
-`
-          );
-          return false;
-        }
-        return true;
-      });
-      if (embeddableBatch.length === 0) continue;
-      const texts = embeddableBatch.map((chunk) => chunk.content);
-      totalChunkTokens += texts.reduce((sum, t) => sum + countChunkTokens(t), 0);
-      const vectors = await embedBatchWithRetry(profile.embeddingModel, texts, dim);
-      const rows = embeddableBatch.map((chunk, i) => ({
-        id: chunk.id,
-        file_path: chunk.filePath,
-        chunk_type: chunk.chunkType,
-        scope: chunk.scope,
-        name: chunk.name,
-        content: chunk.content,
-        start_line: chunk.startLine,
-        end_line: chunk.endLine,
-        vector: vectors[i]
-      }));
-      await insertChunks(table, rows);
-      processedChunks += batch.length;
-      process.stderr.write(
-        `\rbrain-cache: embedding ${processedChunks}/${totalChunks} chunks (${Math.round(processedChunks / totalChunks * 100)}%)`
-      );
-    }
-  }
-  process.stderr.write("\n");
-  process.stderr.write(
-    `brain-cache: ${totalChunks} chunks from ${filesToProcess.length} files
-`
-  );
-  await createVectorIndexIfNeeded(table, profile.embeddingModel);
-  for (const filePath of filesToProcess) {
-    updatedHashes[filePath] = currentHashes[filePath];
-  }
-  for (const filePath of unchangedFiles) {
-    updatedHashes[filePath] = currentHashes[filePath];
-  }
-  await writeFileHashes(rootDir, updatedHashes);
-  const totalFiles = files.length;
-  const chunkCount = await table.countRows();
-  await writeIndexState(rootDir, {
-    version: 1,
-    embeddingModel: profile.embeddingModel,
-    dimension: dim,
-    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    fileCount: totalFiles,
-    chunkCount
-  });
-  const reductionPct = totalRawTokens > 0 ? Math.round((1 - totalChunkTokens / totalRawTokens) * 100) : 0;
-  const savingsBlock = formatTokenSavings({
-    tokensSent: totalChunkTokens,
-    estimatedWithout: totalRawTokens,
-    reductionPct
-  }).split("\n").map((line) => `  ${line}`).join("\n");
-  process.stderr.write(
-    `brain-cache: indexing complete
   Files:                     ${totalFiles}
   Chunks:                    ${totalChunks}
   Model:                     ${profile.embeddingModel}
 ${savingsBlock}
   Stored in:                 ${rootDir}/.brain-cache/
 `
-  );
+    );
+  } finally {
+    setLogLevel(previousLogLevel);
+    process.stderr.write = originalStderrWrite;
+  }
 }
 export {
   runIndex

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brain-cache",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Local MCP-first context engine for Claude. Index your codebase, retrieve only what matters, and cut token usage.",
   "license": "MIT",
   "type": "module",

package/dist/buildContext-6755TRND.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-import {
-  runBuildContext
-} from "./chunk-7JLSJNKU.js";
-import "./chunk-OKWMQNH6.js";
-import "./chunk-ZLB4VJQK.js";
-import "./chunk-WCNMLSL2.js";
-import "./chunk-P7WSTGLE.js";
-import "./chunk-XXWJ57QP.js";
-import "./chunk-PA4BZBWS.js";
-import "./chunk-PDQXJSH4.js";
-export {
-  runBuildContext
-};