brain-cache 0.1.0

package/dist/chunk-PA4BZBWS.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import {
+  GLOBAL_CONFIG_DIR,
+  PROFILE_PATH,
+  childLogger
+} from "./chunk-PDQXJSH4.js";
+
+// src/services/capability.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile, writeFile, mkdir } from "fs/promises";
+
+// src/lib/types.ts
+import { z } from "zod";
+var CapabilityProfileSchema = z.object({
+  version: z.literal(1),
+  detectedAt: z.string().datetime(),
+  vramTier: z.enum(["none", "standard", "large"]),
+  vramGiB: z.number().nullable(),
+  gpuVendor: z.enum(["nvidia", "apple", "none"]),
+  embeddingModel: z.string(),
+  ollamaVersion: z.string().nullable(),
+  platform: z.string()
+});
+var CodeChunkSchema = z.object({
+  id: z.string(),
+  filePath: z.string(),
+  chunkType: z.enum(["function", "class", "method", "file"]),
+  scope: z.string().nullable(),
+  name: z.string().nullable(),
+  content: z.string(),
+  startLine: z.number().int(),
+  endLine: z.number().int()
+});
+var IndexStateSchema = z.object({
+  version: z.literal(1),
+  embeddingModel: z.string(),
+  dimension: z.number().int(),
+  indexedAt: z.string().datetime(),
+  fileCount: z.number().int(),
+  chunkCount: z.number().int()
+});
+
+// src/services/capability.ts
+var execFileAsync = promisify(execFile);
+var log = childLogger("capability");
+async function detectNvidiaVRAM() {
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", [
+      "--query-gpu=memory.total",
+      "--format=csv,noheader,nounits"
+    ], { timeout: 3e3 });
+    const raw = stdout.trim().split("\n")[0];
+    const mib = parseInt(raw, 10);
+    if (isNaN(mib)) {
+      log.debug({ raw }, "nvidia-smi returned non-numeric output");
+      return null;
+    }
+    return Math.round(mib / 1024);
+  } catch (err) {
+    log.debug({ err }, "nvidia-smi not available or timed out");
+    return null;
+  }
+}
+async function detectAppleSiliconVRAM() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const { stdout } = await execFileAsync("system_profiler", [
+      "SPHardwareDataType",
+      "-json"
+    ], { timeout: 3e3 });
+    const data = JSON.parse(stdout);
+    const hwInfo = data.SPHardwareDataType?.[0];
+    if (!hwInfo) return null;
+    const chipType = hwInfo.chip_type ?? "";
+    if (!chipType.includes("Apple M")) {
+      log.debug({ chipType }, "Non-Apple-Silicon Mac detected, skipping VRAM detection");
+      return null;
+    }
+    const memoryStr = hwInfo.physical_memory ?? "";
+    const match = memoryStr.match(/^(\d+)\s*GB/i);
+    if (!match) {
+      log.debug({ memoryStr }, "Could not parse physical_memory from system_profiler");
+      return null;
+    }
+    return parseInt(match[1], 10);
+  } catch (err) {
+    log.debug({ err }, "system_profiler failed or returned invalid JSON");
+    return null;
+  }
+}
+function classifyVRAMTier(vramGiB) {
+  if (vramGiB === null || vramGiB < 2) return "none";
+  if (vramGiB < 8) return "standard";
+  return "large";
+}
+function selectEmbeddingModel(tier) {
+  switch (tier) {
+    case "none":
+    case "standard":
+      return "nomic-embed-text";
+    case "large":
+      return "mxbai-embed-large";
+  }
+}
+async function readProfile() {
+  try {
+    const raw = await readFile(PROFILE_PATH, "utf-8");
+    const json = JSON.parse(raw);
+    const result = CapabilityProfileSchema.safeParse(json);
+    if (!result.success) {
+      log.debug({ issues: result.error.issues }, "Profile failed schema validation");
+      return null;
+    }
+    return result.data;
+  } catch (err) {
+    log.debug({ err }, "Could not read profile");
+    return null;
+  }
+}
+async function writeProfile(profile) {
+  await mkdir(GLOBAL_CONFIG_DIR, { recursive: true });
+  await writeFile(PROFILE_PATH, JSON.stringify(profile, null, 2));
+  log.debug({ path: PROFILE_PATH }, "Profile written");
+}
+async function detectCapabilities() {
+  let vramGiB = null;
+  let gpuVendor = "none";
+  const nvidiaVram = await detectNvidiaVRAM();
+  if (nvidiaVram !== null) {
+    vramGiB = nvidiaVram;
+    gpuVendor = "nvidia";
+  } else {
+    const appleVram = await detectAppleSiliconVRAM();
+    if (appleVram !== null) {
+      vramGiB = appleVram;
+      gpuVendor = "apple";
+    }
+  }
+  const vramTier = classifyVRAMTier(vramGiB);
+  const embeddingModel = selectEmbeddingModel(vramTier);
+  log.info({ gpuVendor, vramGiB, vramTier, embeddingModel }, "Hardware capabilities detected");
+  return {
+    version: 1,
+    detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    vramTier,
+    vramGiB,
+    gpuVendor,
+    embeddingModel,
+    ollamaVersion: null,
+    platform: process.platform
+  };
+}
+
+export {
+  IndexStateSchema,
+  readProfile,
+  writeProfile,
+  detectCapabilities
+};

package/dist/chunk-PDQXJSH4.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// src/lib/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var GLOBAL_CONFIG_DIR = join(homedir(), ".brain-cache");
+var PROFILE_PATH = join(GLOBAL_CONFIG_DIR, "profile.json");
+var CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "config.json");
+var PROJECT_DATA_DIR = ".brain-cache";
+var EMBEDDING_DIMENSIONS = {
+  "nomic-embed-text": 768,
+  "mxbai-embed-large": 1024
+};
+var DEFAULT_EMBEDDING_DIMENSION = 768;
+var DEFAULT_BATCH_SIZE = 50;
+var FILE_READ_CONCURRENCY = 20;
+var VECTOR_INDEX_THRESHOLD = 256;
+var EMBED_TIMEOUT_MS = 3e4;
+var COLD_START_RETRY_DELAY_MS = 2e3;
+var EMBED_MAX_TOKENS = 8192;
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_DISTANCE_THRESHOLD = 0.4;
+var DIAGNOSTIC_DISTANCE_THRESHOLD = 0.45;
+var DIAGNOSTIC_SEARCH_LIMIT = 20;
+var DEFAULT_TOKEN_BUDGET = 4096;
+var FILE_HASHES_FILENAME = "file-hashes.json";
+
+// src/services/logger.ts
+import pino from "pino";
+var VALID_LEVELS = ["debug", "info", "warn", "error", "silent"];
+function resolveLevel() {
+  const env = process.env.BRAIN_CACHE_LOG?.toLowerCase();
+  if (VALID_LEVELS.includes(env)) return env;
+  return "warn";
+}
+var logger = pino(
+  {
+    level: resolveLevel(),
+    redact: {
+      paths: [
+        "apiKey",
+        "api_key",
+        "secret",
+        "password",
+        "token",
+        "authorization",
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "*.apiKey",
+        "*.api_key",
+        "*.secret",
+        "*.password",
+        "*.token",
+        "*.authorization",
+        "*.ANTHROPIC_API_KEY",
+        "*.OPENAI_API_KEY"
+      ],
+      censor: "[Redacted]"
+    }
+  },
+  pino.destination(2)
+  // stderr, always — per D-16
+);
+function childLogger(component) {
+  return logger.child({ component });
+}
+
+export {
+  GLOBAL_CONFIG_DIR,
+  PROFILE_PATH,
+  PROJECT_DATA_DIR,
+  EMBEDDING_DIMENSIONS,
+  DEFAULT_EMBEDDING_DIMENSION,
+  DEFAULT_BATCH_SIZE,
+  FILE_READ_CONCURRENCY,
+  VECTOR_INDEX_THRESHOLD,
+  EMBED_TIMEOUT_MS,
+  COLD_START_RETRY_DELAY_MS,
+  EMBED_MAX_TOKENS,
+  DEFAULT_SEARCH_LIMIT,
+  DEFAULT_DISTANCE_THRESHOLD,
+  DIAGNOSTIC_DISTANCE_THRESHOLD,
+  DIAGNOSTIC_SEARCH_LIMIT,
+  DEFAULT_TOKEN_BUDGET,
+  FILE_HASHES_FILENAME,
+  childLogger
+};

package/dist/chunk-WCNMLSL2.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import {
+  COLD_START_RETRY_DELAY_MS,
+  DEFAULT_EMBEDDING_DIMENSION,
+  EMBED_TIMEOUT_MS,
+  childLogger
+} from "./chunk-PDQXJSH4.js";
+
+// src/services/embedder.ts
+import ollama from "ollama";
+var log = childLogger("embedder");
+async function embedBatch(model, texts, timeoutMs = EMBED_TIMEOUT_MS) {
+  if (texts.length === 0) {
+    return [];
+  }
+  log.debug({ model, batchSize: texts.length }, "Embedding batch");
+  const embedCall = ollama.embed({ model, input: texts, truncate: true }).then((r) => r.embeddings);
+  let timerId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timerId = setTimeout(
+      () => reject(new Error(`Embed timeout after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+  });
+  timeoutPromise.catch(() => {
+  });
+  try {
+    return await Promise.race([embedCall, timeoutPromise]);
+  } finally {
+    clearTimeout(timerId);
+  }
+}
+function isConnectionError(err) {
+  const msg = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  return msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("fetch failed") || msg.includes("socket hang up");
+}
+function isContextLengthError(err) {
+  const msg = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  return msg.includes("input length exceeds the context length");
+}
+async function embedBatchWithRetry(model, texts, dimension = DEFAULT_EMBEDDING_DIMENSION, attempt = 0) {
+  try {
+    return await embedBatch(model, texts);
+  } catch (err) {
+    if (attempt === 0 && isConnectionError(err)) {
+      log.warn({ model }, "Ollama cold-start suspected, retrying in 5s");
+      await new Promise((r) => setTimeout(r, COLD_START_RETRY_DELAY_MS));
+      return embedBatchWithRetry(model, texts, dimension, 1);
+    }
+    if (isContextLengthError(err)) {
+      log.warn({ model, batchSize: texts.length }, "Batch exceeded context length, falling back to individual embedding");
+      const results = [];
+      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)
+`
+            );
+            results.push(new Array(dimension).fill(0));
+          } else {
+            throw innerErr;
+          }
+        }
+      }
+      return results;
+    }
+    throw err;
+  }
+}
+
+export {
+  embedBatch,
+  embedBatchWithRetry
+};

package/dist/chunk-XXWJ57QP.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import {
+  IndexStateSchema
+} from "./chunk-PA4BZBWS.js";
+import {
+  DEFAULT_EMBEDDING_DIMENSION,
+  EMBEDDING_DIMENSIONS,
+  FILE_HASHES_FILENAME,
+  PROJECT_DATA_DIR,
+  VECTOR_INDEX_THRESHOLD,
+  childLogger
+} from "./chunk-PDQXJSH4.js";
+
+// src/services/lancedb.ts
+import * as lancedb from "@lancedb/lancedb";
+import { Index } from "@lancedb/lancedb";
+import { Schema, Field, Utf8, Int32, Float32, FixedSizeList } from "apache-arrow";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+var log = childLogger("lancedb");
+function chunkSchema(dim) {
+  return new Schema([
+    new Field("id", new Utf8(), false),
+    new Field("file_path", new Utf8(), false),
+    new Field("chunk_type", new Utf8(), false),
+    new Field("scope", new Utf8(), true),
+    new Field("name", new Utf8(), true),
+    new Field("content", new Utf8(), false),
+    new Field("start_line", new Int32(), false),
+    new Field("end_line", new Int32(), false),
+    new Field(
+      "vector",
+      new FixedSizeList(dim, new Field("item", new Float32(), true)),
+      false
+    )
+  ]);
+}
+async function openDatabase(projectRoot) {
+  const dataDir = join(projectRoot, PROJECT_DATA_DIR);
+  await mkdir(dataDir, { recursive: true });
+  const dbPath = join(dataDir, "index");
+  return lancedb.connect(dbPath);
+}
+async function openOrCreateChunkTable(db, projectRoot, model, dim) {
+  const tableNames = await db.tableNames();
+  if (tableNames.includes("chunks")) {
+    const state = await readIndexState(projectRoot);
+    const mismatch = state === null || state.embeddingModel !== model || state.dimension !== dim;
+    if (mismatch) {
+      log.warn(
+        { storedModel: state?.embeddingModel, storedDim: state?.dimension, model, dim },
+        "Embedding model or dimension changed \u2014 dropping and recreating chunks table"
+      );
+      await db.dropTable("chunks");
+    } else {
+      log.info({ model, dim }, "Opened existing chunks table");
+      return db.openTable("chunks");
+    }
+  }
+  const schema = chunkSchema(dim);
+  const emptyData = lancedb.makeArrowTable([], { schema });
+  const table = await db.createTable("chunks", emptyData, { mode: "overwrite" });
+  log.info({ model, dim }, "Created new chunks table");
+  return table;
+}
+async function insertChunks(table, rows) {
+  if (rows.length === 0) {
+    return;
+  }
+  await table.add(rows);
+  log.debug({ count: rows.length }, "Inserted chunk rows");
+}
+async function createVectorIndexIfNeeded(table, embeddingModel) {
+  const rowCount = await table.countRows();
+  if (rowCount < VECTOR_INDEX_THRESHOLD) {
+    log.debug(
+      { rowCount, threshold: VECTOR_INDEX_THRESHOLD },
+      "Row count below threshold \u2014 skipping IVF-PQ index creation"
+    );
+    return;
+  }
+  const indices = await table.listIndices();
+  const hasVectorIndex = indices.some(
+    (idx) => idx.columns.includes("vector")
+  );
+  if (hasVectorIndex) {
+    log.debug("IVF-PQ index already exists \u2014 skipping creation");
+    return;
+  }
+  const dim = EMBEDDING_DIMENSIONS[embeddingModel] ?? DEFAULT_EMBEDDING_DIMENSION;
+  const numSubVectors = Math.floor(dim / 8);
+  log.info(
+    { rowCount, numPartitions: 256, numSubVectors },
+    "Creating IVF-PQ vector index"
+  );
+  await table.createIndex("vector", {
+    config: Index.ivfPq({ numPartitions: 256, numSubVectors })
+  });
+  log.info("IVF-PQ vector index created successfully");
+}
+async function readIndexState(projectRoot) {
+  const statePath = join(projectRoot, PROJECT_DATA_DIR, "index_state.json");
+  try {
+    const raw = await readFile(statePath, "utf-8");
+    const parsed = IndexStateSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function writeIndexState(projectRoot, state) {
+  const dataDir = join(projectRoot, PROJECT_DATA_DIR);
+  await mkdir(dataDir, { recursive: true });
+  const statePath = join(dataDir, "index_state.json");
+  await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+async function readFileHashes(projectRoot) {
+  const hashPath = join(projectRoot, PROJECT_DATA_DIR, FILE_HASHES_FILENAME);
+  try {
+    const raw = await readFile(hashPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+async function writeFileHashes(projectRoot, hashes) {
+  const dataDir = join(projectRoot, PROJECT_DATA_DIR);
+  await mkdir(dataDir, { recursive: true });
+  const hashPath = join(dataDir, FILE_HASHES_FILENAME);
+  await writeFile(hashPath, JSON.stringify(hashes, null, 2), "utf-8");
+}
+async function deleteChunksByFilePath(table, filePath) {
+  const escaped = filePath.replace(/'/g, "''");
+  await table.delete(`file_path = '${escaped}'`);
+}
+
+export {
+  openDatabase,
+  openOrCreateChunkTable,
+  insertChunks,
+  createVectorIndexIfNeeded,
+  readIndexState,
+  writeIndexState,
+  readFileHashes,
+  writeFileHashes,
+  deleteChunksByFilePath
+};

package/dist/chunk-ZLB4VJQK.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_DISTANCE_THRESHOLD,
+  DEFAULT_SEARCH_LIMIT,
+  DIAGNOSTIC_DISTANCE_THRESHOLD,
+  DIAGNOSTIC_SEARCH_LIMIT,
+  childLogger
+} from "./chunk-PDQXJSH4.js";
+
+// src/services/retriever.ts
+var log = childLogger("retriever");
+var DIAGNOSTIC_KEYWORDS = [
+  "why",
+  "broken",
+  "error",
+  "bug",
+  "fail",
+  "crash",
+  "exception",
+  "undefined",
+  "null",
+  "wrong",
+  "issue",
+  "problem",
+  "causes",
+  "caused",
+  "debug",
+  "fix",
+  "incorrect",
+  "unexpected"
+];
+var DIAGNOSTIC_BIGRAMS = [
+  "stack trace",
+  "null pointer",
+  "not defined",
+  "type error",
+  "reference error",
+  "syntax error",
+  "runtime error",
+  "segmentation fault",
+  "not working",
+  "throws exception"
+];
+var DIAGNOSTIC_EXCLUSIONS = [
+  "error handler",
+  "error handling",
+  "error boundary",
+  "error type",
+  "error message",
+  "error code",
+  "error class",
+  "null object",
+  "null check",
+  "null pattern",
+  "undefined behavior",
+  "fix the style",
+  "fix the format",
+  "fix the lint",
+  "fix the config",
+  "fix the setup"
+];
+function classifyQueryIntent(query) {
+  const lower = query.toLowerCase();
+  if (DIAGNOSTIC_BIGRAMS.some((bg) => lower.includes(bg))) {
+    return "diagnostic";
+  }
+  const hasKeyword = DIAGNOSTIC_KEYWORDS.some((kw) => lower.includes(kw));
+  if (hasKeyword) {
+    const isExcluded = DIAGNOSTIC_EXCLUSIONS.some((ex) => lower.includes(ex));
+    if (!isExcluded) {
+      return "diagnostic";
+    }
+  }
+  return "knowledge";
+}
+var RETRIEVAL_STRATEGIES = {
+  diagnostic: { limit: DIAGNOSTIC_SEARCH_LIMIT, distanceThreshold: DIAGNOSTIC_DISTANCE_THRESHOLD },
+  knowledge: { limit: DEFAULT_SEARCH_LIMIT, distanceThreshold: DEFAULT_DISTANCE_THRESHOLD }
+};
+async function searchChunks(table, queryVector, opts) {
+  log.debug({ limit: opts.limit, distanceThreshold: opts.distanceThreshold }, "Searching chunks");
+  const rows = await table.query().nearestTo(queryVector).distanceType("cosine").limit(opts.limit).toArray();
+  return rows.filter((r) => r._distance <= opts.distanceThreshold).map((r) => ({
+    id: r.id,
+    filePath: r.file_path,
+    chunkType: r.chunk_type,
+    scope: r.scope,
+    name: r.name,
+    content: r.content,
+    startLine: r.start_line,
+    endLine: r.end_line,
+    similarity: 1 - r._distance
+  })).sort((a, b) => b.similarity - a.similarity);
+}
+function deduplicateChunks(chunks) {
+  const seen = /* @__PURE__ */ new Set();
+  return chunks.filter((c) => {
+    if (seen.has(c.id)) return false;
+    seen.add(c.id);
+    return true;
+  });
+}
+
+export {
+  classifyQueryIntent,
+  RETRIEVAL_STRATEGIES,
+  searchChunks,
+  deduplicateChunks
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import {
+  formatTokenSavings
+} from "./chunk-GGOUKACO.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+var version = "0.1.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");
+  await runInit();
+});
+program.command("doctor").description("Report system health: GPU, VRAM tier, Ollama status").action(async () => {
+  const { runDoctor } = await import("./doctor-5775VUMA.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");
+  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");
+  await runSearch(query, {
+    limit: parseInt(opts.limit, 10),
+    path: opts.path
+  });
+});
+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");
+  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 result = await runBuildContext(query, {
+      limit: parseInt(opts.limit, 10),
+      maxTokens: parseInt(opts.budget, 10),
+      path: opts.path
+    });
+    if (opts.raw) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    } else {
+      process.stdout.write(result.content);
+      if (!result.content.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
+      const estimatedWithout = result.metadata.reductionPct > 0 ? Math.round(result.metadata.tokensSent / (1 - result.metadata.reductionPct / 100)) : result.metadata.tokensSent;
+      process.stderr.write(
+        `
+\u{1F9E0} brain-cache
+${formatTokenSavings({ tokensSent: result.metadata.tokensSent, estimatedWithout, reductionPct: result.metadata.reductionPct })}
+`
+      );
+    }
+  }
+);
+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 result = await runAskCodebase(question, {
+    path: opts.path,
+    maxContextTokens: parseInt(opts.budget, 10)
+  });
+  process.stderr.write(`
+${result.answer}
+`);
+  process.stderr.write(
+    `
+\u{1F9E0} brain-cache
+${formatTokenSavings({ tokensSent: result.contextMetadata.tokensSent, estimatedWithout: result.contextMetadata.estimatedWithoutBraincache, reductionPct: result.contextMetadata.reductionPct })}
+`
+  );
+});
+(async () => {
+  await program.parseAsync();
+})().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+});