brain-cache 0.4.2 → 3.0.0

package/dist/{search-O4CFAH45.js → search-7ISZ7EXI.js}

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
 import {
   RETRIEVAL_STRATEGIES,
-  classifyQueryIntent,
+  classifyRetrievalMode,
   deduplicateChunks,
   searchChunks
-} from "./chunk-SBSMKI4B.js";
+} from "./chunk-DFFMV3RR.js";
+import {
+  openDatabase,
+  readIndexState
+} from "./chunk-3HQRTLBH.js";
 import {
   embedBatchWithRetry
-} from "./chunk-KQZSBRRH.js";
+} from "./chunk-RKPICQU7.js";
 import {
   isOllamaRunning
-} from "./chunk-FQL4HV4R.js";
-import {
-  openDatabase,
-  readIndexState
-} from "./chunk-Y7BU7IYX.js";
+} from "./chunk-HRJ3OT6Q.js";
 import {
   readProfile
-} from "./chunk-PJQNHMQH.js";
-import "./chunk-EEC7KYPY.js";
+} from "./chunk-DPH5X5HL.js";
+import "./chunk-TXLCXXKY.js";
 
 // src/workflows/search.ts
 import { resolve } from "path";
@@ -52,18 +52,19 @@ async function runSearch(query, opts) {
       `Index is empty at ${rootDir}. No source files were indexed.`
     );
   }
-  const intent = classifyQueryIntent(query);
+  const mode = classifyRetrievalMode(query);
   const strategy = {
-    limit: opts?.limit ?? RETRIEVAL_STRATEGIES[intent].limit,
-    distanceThreshold: RETRIEVAL_STRATEGIES[intent].distanceThreshold
+    limit: opts?.limit ?? RETRIEVAL_STRATEGIES[mode].limit,
+    distanceThreshold: RETRIEVAL_STRATEGIES[mode].distanceThreshold,
+    keywordBoostWeight: RETRIEVAL_STRATEGIES[mode].keywordBoostWeight
   };
   process.stderr.write(
-    `brain-cache: searching (intent=${intent}, limit=${strategy.limit})
+    `brain-cache: searching (mode=${mode}, limit=${strategy.limit})
 `
   );
   const { embeddings: vectors } = await embedBatchWithRetry(indexState.embeddingModel, [query]);
   const queryVector = vectors[0];
-  const results = await searchChunks(table, queryVector, strategy);
+  const results = await searchChunks(table, queryVector, strategy, query);
   const deduped = deduplicateChunks(results);
   process.stderr.write(
     `brain-cache: found ${deduped.length} chunks (${results.length} before dedup)

package/dist/{status-7MT4IROA.js → status-VKTSG2SN.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   readIndexState
-} from "./chunk-Y7BU7IYX.js";
+} from "./chunk-3HQRTLBH.js";
 import {
   readProfile
-} from "./chunk-PJQNHMQH.js";
-import "./chunk-EEC7KYPY.js";
+} from "./chunk-DPH5X5HL.js";
+import "./chunk-TXLCXXKY.js";
 
 // src/workflows/status.ts
 import { resolve } from "path";

package/dist/statusline-script-NFUDFOWK.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// src/lib/statusline-script.ts
+var STATUSLINE_SCRIPT_CONTENT = `#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const STATS_PATH = join(homedir(), '.brain-cache', 'session-stats.json');
+const STATS_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours \u2014 must match sessionStats.ts STATS_TTL_MS
+export const IDLE_OUTPUT = 'brain-cache  idle\\n';
+
+/**
+ * Formats a token count into a human-readable string.
+ * - < 1000: plain number (e.g. "500")
+ * - >= 1000 and < 1,000,000: rounded k suffix (e.g. "2k")
+ * - >= 1,000,000: M suffix with one decimal (e.g. "1.5M")
+ *
+ * @param {number} n
+ * @returns {string}
+ */
+export function formatTokenCount(n) {
+  if (n >= 1_000_000) return \`\${(n / 1_000_000).toFixed(1)}M\`;
+  if (n >= 1_000) return \`\${Math.round(n / 1_000)}k\`;
+  return String(n);
+}
+
+/**
+ * Reads and validates stats from a given file path.
+ * Returns null if the file does not exist, is malformed, has no lastUpdatedAt,
+ * is older than STATS_TTL_MS, or has estimatedWithoutBraincache <= 0.
+ *
+ * @param {string} filePath
+ * @returns {import('../services/sessionStats.js').SessionStats | null}
+ */
+export function _readStatsFromPath(filePath) {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const stats = JSON.parse(raw);
+    if (!stats.lastUpdatedAt) return null;
+    const age = Date.now() - Date.parse(stats.lastUpdatedAt);
+    if (age > STATS_TTL_MS) return null;
+    if (!stats.estimatedWithoutBraincache || stats.estimatedWithoutBraincache <= 0) return null;
+    return stats;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reads session stats from the default stats path (~/.brain-cache/session-stats.json).
+ * Returns null if the file does not exist, is invalid, or is expired.
+ *
+ * @returns {import('../services/sessionStats.js').SessionStats | null}
+ */
+export function readStats() {
+  return _readStatsFromPath(STATS_PATH);
+}
+
+/**
+ * Renders the status line output string.
+ * Returns IDLE_OUTPUT when stats is null, savings <= 0, or pct <= 0.
+ * Otherwise returns a formatted savings string.
+ *
+ * @param {import('../services/sessionStats.js').SessionStats | null} stats
+ * @returns {string}
+ */
+export function renderOutput(stats) {
+  if (!stats) return IDLE_OUTPUT;
+  const saved = stats.estimatedWithoutBraincache - stats.tokensSent;
+  const pct = Math.round((1 - stats.tokensSent / stats.estimatedWithoutBraincache) * 100);
+  if (pct <= 0 || saved <= 0) return IDLE_OUTPUT;
+  return \`brain-cache  \\u2193\${pct}%  \${formatTokenCount(saved)} saved\\n\`;
+}
+
+// Stdin/stdout protocol \u2014 only when executed directly (not imported for testing)
+if (import.meta.url === \`file://\${process.argv[1]}\`) {
+  const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+  let input = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    clearTimeout(stdinTimeout);
+    try {
+      const stats = readStats();
+      process.stdout.write(renderOutput(stats));
+    } catch {
+      process.stdout.write(IDLE_OUTPUT);
+    }
+  });
+}
+`;
+export {
+  STATUSLINE_SCRIPT_CONTENT
+};

package/dist/watch-QPMAB62P.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import {
+  ALWAYS_EXCLUDE_GLOBS,
+  loadIgnorePatterns,
+  runIndex
+} from "./chunk-CY34XQ2O.js";
+import "./chunk-4IOR54GU.js";
+import "./chunk-3HQRTLBH.js";
+import "./chunk-6C2OYMKD.js";
+import "./chunk-RKPICQU7.js";
+import "./chunk-HRJ3OT6Q.js";
+import "./chunk-DPH5X5HL.js";
+import "./chunk-TXLCXXKY.js";
+
+// src/workflows/watch.ts
+import { resolve, join } from "path";
+import { open, unlink, mkdir } from "fs/promises";
+
+// src/services/fileWatcher.ts
+import { watch } from "chokidar";
+import { relative } from "path";
+import ignore from "ignore";
+async function createWatcher(projectRoot) {
+  const userPatterns = await loadIgnorePatterns(projectRoot);
+  const ig = ignore();
+  ig.add(userPatterns);
+  ig.add(ALWAYS_EXCLUDE_GLOBS);
+  const ignored = (filePath) => {
+    if (filePath.includes("/.brain-cache/") || filePath.endsWith("/.brain-cache")) {
+      return true;
+    }
+    const rel = relative(projectRoot, filePath);
+    if (!rel || rel.startsWith("..")) {
+      return false;
+    }
+    return ig.ignores(rel);
+  };
+  return watch(projectRoot, {
+    persistent: true,
+    ignoreInitial: true,
+    ignored
+  });
+}
+
+// src/workflows/watch.ts
+var debounceTimer = null;
+var pendingFiles = /* @__PURE__ */ new Set();
+function resetState() {
+  if (debounceTimer !== null) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+  pendingFiles.clear();
+}
+async function acquireIndexLock(projectRoot) {
+  const lockPath = join(projectRoot, ".brain-cache", ".indexing");
+  await mkdir(join(projectRoot, ".brain-cache"), { recursive: true });
+  try {
+    const handle = await open(lockPath, "wx");
+    await handle.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function releaseIndexLock(projectRoot) {
+  await unlink(join(projectRoot, ".brain-cache", ".indexing")).catch(() => void 0);
+}
+function scheduleReindex(filePath, eventType, projectRoot) {
+  process.stderr.write(`brain-cache: ${eventType} ${filePath}
+`);
+  pendingFiles.add(filePath);
+  if (debounceTimer !== null) {
+    clearTimeout(debounceTimer);
+  }
+  debounceTimer = setTimeout(async () => {
+    debounceTimer = null;
+    pendingFiles.clear();
+    const locked = await acquireIndexLock(projectRoot);
+    if (!locked) {
+      process.stderr.write("brain-cache: skipping reindex \u2014 another index process is running\n");
+      return;
+    }
+    try {
+      await runIndex(projectRoot);
+    } finally {
+      await releaseIndexLock(projectRoot);
+    }
+  }, 500);
+}
+async function runWatch(targetPath) {
+  const rootDir = resolve(targetPath ?? ".");
+  process.stderr.write(`brain-cache: watching ${rootDir}
+`);
+  const watcher = await createWatcher(rootDir);
+  watcher.on("add", (fp) => scheduleReindex(fp, "add", rootDir));
+  watcher.on("change", (fp) => scheduleReindex(fp, "change", rootDir));
+  watcher.on("unlink", (fp) => scheduleReindex(fp, "unlink", rootDir));
+  watcher.on("addDir", (fp) => scheduleReindex(fp, "addDir", rootDir));
+  watcher.on("unlinkDir", (fp) => scheduleReindex(fp, "unlinkDir", rootDir));
+  watcher.on("error", (err) => {
+    process.stderr.write(`brain-cache: watcher error: ${String(err)}
+`);
+  });
+  watcher.on("ready", () => {
+    process.stderr.write("brain-cache: watcher ready\n");
+  });
+  const cleanup = async () => {
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    pendingFiles.clear();
+    await watcher.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+export {
+  acquireIndexLock,
+  releaseIndexLock,
+  resetState,
+  runWatch,
+  scheduleReindex
+};

package/dist/workflows-MWEY7OAI.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import {
+  runIndex
+} from "./chunk-CY34XQ2O.js";
+import "./chunk-4IOR54GU.js";
+import "./chunk-3HQRTLBH.js";
+import "./chunk-6C2OYMKD.js";
+import "./chunk-RKPICQU7.js";
+import "./chunk-HRJ3OT6Q.js";
+import "./chunk-DPH5X5HL.js";
+import "./chunk-TXLCXXKY.js";
+export {
+  runIndex
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brain-cache",
-  "version": "0.4.2",
+  "version": "3.0.0",
   "description": "Local MCP-first context engine for Claude. Index your codebase, retrieve only what matters, and cut token usage.",
   "license": "MIT",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/",
+    ".claude/skills/",
     "README.md",
     "LICENSE"
   ],
@@ -37,7 +38,9 @@
     "@lancedb/lancedb": "^0.27.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "apache-arrow": "^18.1.0",
+    "chokidar": "^5.0.0",
     "commander": "14.0.3",
+    "dedent": "^1.7.2",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
     "ollama": "^0.6.3",
@@ -50,6 +53,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@types/dedent": "^0.7.2",
     "@types/node": "^22.0.0",
     "pino-pretty": "^11.0.0",
     "tsup": "^8.0.0",

package/dist/buildContext-APWOPZMJ.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-import {
-  runBuildContext
-} from "./chunk-JZQWPHAQ.js";
-import "./chunk-ZKVZTDND.js";
-import "./chunk-SBSMKI4B.js";
-import "./chunk-KQZSBRRH.js";
-import "./chunk-FQL4HV4R.js";
-import "./chunk-Y7BU7IYX.js";
-import "./chunk-PJQNHMQH.js";
-import "./chunk-EEC7KYPY.js";
-export {
-  runBuildContext
-};

package/dist/chunk-JZQWPHAQ.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-import {
-  assembleContext,
-  countChunkTokens
-} from "./chunk-ZKVZTDND.js";
-import {
-  RETRIEVAL_STRATEGIES,
-  classifyQueryIntent,
-  deduplicateChunks,
-  searchChunks
-} from "./chunk-SBSMKI4B.js";
-import {
-  embedBatchWithRetry
-} from "./chunk-KQZSBRRH.js";
-import {
-  isOllamaRunning
-} from "./chunk-FQL4HV4R.js";
-import {
-  openDatabase,
-  readIndexState
-} from "./chunk-Y7BU7IYX.js";
-import {
-  readProfile
-} from "./chunk-PJQNHMQH.js";
-import {
-  DEFAULT_TOKEN_BUDGET,
-  TOOL_CALL_OVERHEAD_TOKENS
-} from "./chunk-EEC7KYPY.js";
-
-// src/workflows/buildContext.ts
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-async function runBuildContext(query, opts) {
-  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 rootDir = resolve(opts?.path ?? ".");
-  const indexState = await readIndexState(rootDir);
-  if (indexState === null) {
-    throw new Error(`No index found at ${rootDir}. Run 'brain-cache index' first.`);
-  }
-  const db = await openDatabase(rootDir);
-  const tableNames = await db.tableNames();
-  if (!tableNames.includes("chunks")) {
-    throw new Error("No chunks table found. Run 'brain-cache index' first.");
-  }
-  const table = await db.openTable("chunks");
-  const intent = classifyQueryIntent(query);
-  const strategy = {
-    limit: opts?.limit ?? RETRIEVAL_STRATEGIES[intent].limit,
-    distanceThreshold: RETRIEVAL_STRATEGIES[intent].distanceThreshold
-  };
-  const maxTokens = opts?.maxTokens ?? DEFAULT_TOKEN_BUDGET;
-  process.stderr.write(
-    `brain-cache: building context (intent=${intent}, budget=${maxTokens} tokens)
-`
-  );
-  const { embeddings: vectors } = await embedBatchWithRetry(indexState.embeddingModel, [query]);
-  const queryVector = vectors[0];
-  const results = await searchChunks(table, queryVector, strategy);
-  const deduped = deduplicateChunks(results);
-  const assembled = assembleContext(deduped, { maxTokens });
-  const uniqueFiles = [...new Set(assembled.chunks.map((c) => c.filePath))];
-  const numFiles = uniqueFiles.length;
-  let fileContentTokens = 0;
-  for (const filePath of uniqueFiles) {
-    try {
-      const fileContent = await readFile(filePath, "utf-8");
-      fileContentTokens += countChunkTokens(fileContent);
-    } catch {
-    }
-  }
-  const toolCalls = 1 + numFiles;
-  const toolCallOverhead = toolCalls * TOOL_CALL_OVERHEAD_TOKENS;
-  const estimatedWithoutBraincache = fileContentTokens + toolCallOverhead;
-  const reductionPct = estimatedWithoutBraincache > 0 ? Math.max(0, Math.round((1 - assembled.tokenCount / estimatedWithoutBraincache) * 100)) : 0;
-  const result = {
-    content: assembled.content,
-    chunks: assembled.chunks,
-    metadata: {
-      tokensSent: assembled.tokenCount,
-      estimatedWithoutBraincache,
-      reductionPct,
-      filesInContext: numFiles,
-      localTasksPerformed: ["embed_query", "vector_search", "dedup", "token_budget"],
-      cloudCallsMade: 0
-    }
-  };
-  process.stderr.write(
-    `brain-cache: context assembled (${assembled.tokenCount} tokens, ${reductionPct}% reduction, ${assembled.chunks.length} chunks)
-`
-  );
-  return result;
-}
-
-export {
-  runBuildContext
-};

package/dist/chunk-SBSMKI4B.js

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-import {
-  DEFAULT_DISTANCE_THRESHOLD,
-  DEFAULT_SEARCH_LIMIT,
-  DIAGNOSTIC_DISTANCE_THRESHOLD,
-  DIAGNOSTIC_SEARCH_LIMIT,
-  childLogger
-} from "./chunk-EEC7KYPY.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/chunk-ZGYLHFHJ.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/format.ts
-function formatTokenSavings(input) {
-  const PAD = 27;
-  const fileSuffix = input.filesInContext !== 1 ? "s" : "";
-  const lines = [
-    ["Tokens sent to Claude:", input.tokensSent.toLocaleString()],
-    ["Estimated without:", `~${input.estimatedWithout.toLocaleString()}  (${input.filesInContext} file${fileSuffix} + overhead)`],
-    ["Reduction:", `${input.reductionPct}%`]
-  ];
-  return lines.map(([label, value]) => `${label.padEnd(PAD)}${value}`).join("\n");
-}
-
-export {
-  formatTokenSavings
-};

package/dist/claude-md-section-6ZJ3TMO4.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/claude-md-section.ts
-var CLAUDE_MD_SECTION = `
-## Brain-Cache MCP Tools
-
-Use brain-cache tools before reading files or using Grep/Glob for codebase questions.
-
-### build_context (use for understanding)
-
-Call \`mcp__brain-cache__build_context\` with the user's question before reading individual files. It retrieves semantically relevant code from across the repo, deduplicates results, and fits them to a token budget.
-
-Use for questions like:
-- "How does X work?" / "Explain X end to end"
-- "Walk me through the flow of X"
-- "What does this page/feature/component do?"
-- "Explain the architecture" / "How is the project structured?"
-- "What happens when Y is called?"
-- Any question that requires understanding code across multiple files
-- Debugging unfamiliar code paths or understanding error flows
-
-This returns better results with fewer tokens than reading files individually.
-
-### search_codebase (use for locating)
-
-Call \`mcp__brain-cache__search_codebase\` to find functions, types, definitions, or implementations by meaning rather than keyword match.
-
-### doctor (use for diagnosing)
-
-Call \`mcp__brain-cache__doctor\` when any brain-cache tool fails or returns unexpected results.
-`;
-export {
-  CLAUDE_MD_SECTION
-};