brain-cache 0.4.1 → 2.1.0

package/README.md

@@ -119,6 +119,19 @@ When using brain-cache build_context, include the token savings summary from the
 
 This keeps it transparent and under your control.
 
+## 🎛 Tuning how much Claude uses brain-cache
+
+`brain-cache init` adds a section to your project's `CLAUDE.md` with clear instructions to use brain-cache tools first. This works well for most users.
+
+If you want to go further, you can strengthen the language yourself. For example:
+
+```
+ALWAYS use brain-cache build_context before reading files or using Grep/Glob.
+Do not skip brain-cache tools — they return better results with fewer tokens.
+```
+
+Or soften it if you prefer Claude to decide on its own. It's your `CLAUDE.md` — edit it to match how you want to work.
+
 ---
 
 ## 🧩 Core capabilities

package/dist/{askCodebase-BZIXS3EV.js → askCodebase-EE32B7BP.js}

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import {
   runBuildContext
-} from "./chunk-JZQWPHAQ.js";
-import "./chunk-ZKVZTDND.js";
+} from "./chunk-KMRPAVMM.js";
+import "./chunk-DFFMV3RR.js";
+import "./chunk-4IOR54GU.js";
+import "./chunk-3HQRTLBH.js";
 import {
   formatTokenSavings
-} from "./chunk-ZGYLHFHJ.js";
-import "./chunk-SBSMKI4B.js";
-import "./chunk-KQZSBRRH.js";
-import "./chunk-FQL4HV4R.js";
-import "./chunk-Y7BU7IYX.js";
-import "./chunk-PJQNHMQH.js";
+} from "./chunk-6C2OYMKD.js";
+import "./chunk-RKPICQU7.js";
+import "./chunk-HRJ3OT6Q.js";
+import "./chunk-DPH5X5HL.js";
 import {
   childLogger
-} from "./chunk-EEC7KYPY.js";
+} from "./chunk-TXLCXXKY.js";
 
 // src/workflows/askCodebase.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/buildContext-GWVDAYH6.js

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

package/dist/{chunk-Y7BU7IYX.js → chunk-3HQRTLBH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   IndexStateSchema
-} from "./chunk-PJQNHMQH.js";
+} from "./chunk-DPH5X5HL.js";
 import {
   DEFAULT_EMBEDDING_DIMENSION,
   EMBEDDING_DIMENSIONS,
@@ -9,7 +9,7 @@ import {
   PROJECT_DATA_DIR,
   VECTOR_INDEX_THRESHOLD,
   childLogger
-} from "./chunk-EEC7KYPY.js";
+} from "./chunk-TXLCXXKY.js";
 
 // src/services/lancedb.ts
 import * as lancedb from "@lancedb/lancedb";
@@ -18,6 +18,12 @@ 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");
+var _writeMutex = Promise.resolve();
+function withWriteLock(fn) {
+  const next = _writeMutex.then(() => fn());
+  _writeMutex = next.then(() => void 0, () => void 0);
+  return next;
+}
 function chunkSchema(dim) {
   return new Schema([
     new Field("id", new Utf8(), false),
@@ -35,6 +41,16 @@ function chunkSchema(dim) {
     )
   ]);
 }
+function edgeSchema() {
+  return new Schema([
+    new Field("from_chunk_id", new Utf8(), false),
+    new Field("from_file", new Utf8(), false),
+    new Field("from_symbol", new Utf8(), true),
+    new Field("to_symbol", new Utf8(), false),
+    new Field("to_file", new Utf8(), true),
+    new Field("edge_type", new Utf8(), false)
+  ]);
+}
 async function openDatabase(projectRoot) {
   const dataDir = join(projectRoot, PROJECT_DATA_DIR);
   await mkdir(dataDir, { recursive: true });
@@ -52,6 +68,10 @@ async function openOrCreateChunkTable(db, projectRoot, model, dim) {
         "Embedding model or dimension changed \u2014 dropping and recreating chunks table"
       );
       await db.dropTable("chunks");
+      if (tableNames.includes("edges")) {
+        await db.dropTable("edges");
+        log.warn("Also dropped edges table (stale chunk IDs)");
+      }
     } else {
       log.info({ model, dim }, "Opened existing chunks table");
       return db.openTable("chunks");
@@ -67,8 +87,10 @@ async function insertChunks(table, rows) {
   if (rows.length === 0) {
     return;
   }
-  await table.add(rows);
-  log.debug({ count: rows.length }, "Inserted chunk rows");
+  await withWriteLock(async () => {
+    await table.add(rows);
+    log.debug({ count: rows.length }, "Inserted chunk rows");
+  });
 }
 async function createVectorIndexIfNeeded(table, embeddingModel) {
   const rowCount = await table.countRows();
@@ -135,10 +157,49 @@ async function writeFileHashes(projectRoot, hashes) {
 }
 async function deleteChunksByFilePath(table, filePath) {
   const escaped = filePath.replace(/'/g, "''");
-  await table.delete(`file_path = '${escaped}'`);
+  await withWriteLock(async () => {
+    await table.delete(`file_path = '${escaped}'`);
+  });
+}
+async function openOrCreateEdgesTable(db, opts) {
+  const tableNames = await db.tableNames();
+  if (tableNames.includes("edges")) {
+    if (opts?.shouldReset) {
+      log.warn("Resetting edges table (chunks table was recreated)");
+      await db.dropTable("edges");
+    } else {
+      log.info("Opened existing edges table");
+      return db.openTable("edges");
+    }
+  }
+  const schema = edgeSchema();
+  const emptyData = lancedb.makeArrowTable([], { schema });
+  const table = await db.createTable("edges", emptyData, { mode: "overwrite" });
+  log.info("Created new edges table");
+  return table;
+}
+async function insertEdges(table, edges) {
+  if (edges.length === 0) return;
+  const rows = edges.map((e) => ({
+    from_chunk_id: e.fromChunkId,
+    from_file: e.fromFile,
+    from_symbol: e.fromSymbol,
+    to_symbol: e.toSymbol,
+    to_file: e.toFile,
+    edge_type: e.edgeType
+  }));
+  await withWriteLock(async () => {
+    await table.add(rows);
+    log.debug({ count: rows.length }, "Inserted edge rows");
+  });
+}
+async function queryEdgesFrom(edgesTable, fromChunkId) {
+  const escaped = fromChunkId.replace(/'/g, "''");
+  return edgesTable.query().where(`from_chunk_id = '${escaped}'`).toArray();
 }
 
 export {
+  withWriteLock,
   openDatabase,
   openOrCreateChunkTable,
   insertChunks,
@@ -147,5 +208,8 @@ export {
   writeIndexState,
   readFileHashes,
   writeFileHashes,
-  deleteChunksByFilePath
+  deleteChunksByFilePath,
+  openOrCreateEdgesTable,
+  insertEdges,
+  queryEdgesFrom
 };

package/dist/{chunk-ZKVZTDND.js → chunk-4IOR54GU.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   childLogger
-} from "./chunk-EEC7KYPY.js";
+} from "./chunk-TXLCXXKY.js";
 
 // src/services/tokenCounter.ts
 import { countTokens } from "@anthropic-ai/tokenizer";
@@ -36,5 +36,6 @@ function assembleContext(chunks, opts) {
 
 export {
   countChunkTokens,
+  formatChunk,
   assembleContext
 };

package/dist/chunk-6C2OYMKD.js

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

package/dist/{workflows-KYCBR7TC.js → chunk-CY34XQ2O.js}

@@ -1,29 +1,32 @@
 #!/usr/bin/env node
 import {
   countChunkTokens
-} from "./chunk-ZKVZTDND.js";
-import {
-  formatTokenSavings
-} from "./chunk-ZGYLHFHJ.js";
-import {
-  embedBatchWithRetry
-} from "./chunk-KQZSBRRH.js";
-import {
-  isOllamaRunning
-} from "./chunk-FQL4HV4R.js";
+} from "./chunk-4IOR54GU.js";
 import {
   createVectorIndexIfNeeded,
   deleteChunksByFilePath,
   insertChunks,
+  insertEdges,
   openDatabase,
   openOrCreateChunkTable,
+  openOrCreateEdgesTable,
   readFileHashes,
+  withWriteLock,
   writeFileHashes,
   writeIndexState
-} from "./chunk-Y7BU7IYX.js";
+} from "./chunk-3HQRTLBH.js";
+import {
+  formatTokenSavings
+} from "./chunk-6C2OYMKD.js";
+import {
+  embedBatchWithRetry
+} from "./chunk-RKPICQU7.js";
+import {
+  isOllamaRunning
+} from "./chunk-HRJ3OT6Q.js";
 import {
   readProfile
-} from "./chunk-PJQNHMQH.js";
+} from "./chunk-DPH5X5HL.js";
 import {
   DEFAULT_BATCH_SIZE,
   DEFAULT_EMBEDDING_DIMENSION,
@@ -32,11 +35,11 @@ import {
   FILE_READ_CONCURRENCY,
   childLogger,
   setLogLevel
-} from "./chunk-EEC7KYPY.js";
+} from "./chunk-TXLCXXKY.js";
 
 // src/workflows/index.ts
-import { resolve } from "path";
-import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { readFile as readFile3 } from "fs/promises";
 import { createHash } from "crypto";
 
 // src/services/crawler.ts
@@ -73,13 +76,16 @@ var ALWAYS_EXCLUDE_GLOBS = [
   "**/Cargo.lock",
   "**/*.min.js"
 ];
-async function crawlSourceFiles(rootDir) {
+async function crawlSourceFiles(rootDir, opts) {
   const ig = ignore();
   try {
     const gitignoreContent = await readFile(`${rootDir}/.gitignore`, "utf-8");
     ig.add(gitignoreContent);
   } catch {
   }
+  if (opts?.extraIgnorePatterns?.length) {
+    ig.add(opts.extraIgnorePatterns);
+  }
   const files = await fg("**/*", {
     cwd: rootDir,
     absolute: true,
@@ -98,7 +104,7 @@ async function crawlSourceFiles(rootDir) {
 
 // src/services/chunker.ts
 import { createRequire } from "module";
-import { extname as extname2 } from "path";
+import { extname as extname2, resolve, dirname } from "path";
 var _require = createRequire(import.meta.url);
 var Parser = _require("tree-sitter");
 var { typescript: tsLang, tsx: tsxLang } = _require("tree-sitter-typescript");
@@ -203,7 +209,7 @@ function chunkFile(filePath, content) {
   const ext = extname2(filePath);
   const lang = LANGUAGE_MAP[ext];
   if (!lang) {
-    return [];
+    return { chunks: [], edges: [] };
   }
   const category = getLanguageCategory(ext);
   const nodeTypes = CHUNK_NODE_TYPES[category];
@@ -211,7 +217,50 @@ function chunkFile(filePath, content) {
   parser.setLanguage(lang);
   const tree = parser.parse(content);
   const chunks = [];
+  const edges = [];
+  let currentChunkId = null;
+  let currentSymbol = null;
   for (const node of walkNodes(tree.rootNode)) {
+    if (node.type === "call_expression") {
+      const funcNode = node.childForFieldName("function");
+      if (funcNode) {
+        let toSymbol = null;
+        if (funcNode.type === "identifier") {
+          toSymbol = funcNode.text;
+        } else if (funcNode.type === "member_expression" || funcNode.type === "optional_member_expression") {
+          toSymbol = funcNode.childForFieldName("property")?.text ?? null;
+        }
+        if (toSymbol) {
+          const chunkId = currentChunkId ?? `${filePath}:0`;
+          const symbol = currentSymbol;
+          edges.push({
+            fromChunkId: chunkId,
+            fromFile: filePath,
+            fromSymbol: symbol,
+            toSymbol,
+            toFile: null,
+            // Resolved at query time, not index time
+            edgeType: "call"
+          });
+        }
+      }
+    }
+    if (node.type === "import_statement") {
+      const source = node.childForFieldName("source");
+      if (source) {
+        const raw = source.text.replace(/['"]/g, "");
+        const isRelative = raw.startsWith("./") || raw.startsWith("../");
+        const toFile = isRelative ? resolve(dirname(filePath), raw) : null;
+        edges.push({
+          fromChunkId: `${filePath}:0`,
+          fromFile: filePath,
+          fromSymbol: null,
+          toSymbol: raw,
+          toFile,
+          edgeType: "import"
+        });
+      }
+    }
     if (!nodeTypes.has(node.type)) {
       continue;
     }
@@ -237,6 +286,8 @@ function chunkFile(filePath, content) {
       startLine: node.startPosition.row + 1,
       endLine: node.endPosition.row + 1
     });
+    currentChunkId = `${filePath}:${node.startPosition.row}`;
+    currentSymbol = extractName(node);
   }
   if (chunks.length === 0) {
     chunks.push({
@@ -250,8 +301,20 @@ function chunkFile(filePath, content) {
       endLine: content.split("\n").length
     });
   }
-  log2.debug({ filePath, chunkCount: chunks.length }, "File chunked");
-  return chunks;
+  log2.debug({ filePath, chunkCount: chunks.length, edgeCount: edges.length }, "File chunked");
+  return { chunks, edges };
+}
+
+// src/services/ignorePatterns.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+async function loadIgnorePatterns(rootDir) {
+  try {
+    const content = await readFile2(join(rootDir, ".braincacheignore"), "utf-8");
+    return content.split("\n").filter((line) => line.trim() !== "" && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
 }
 
 // src/workflows/index.ts
@@ -271,7 +334,12 @@ async function runIndex(targetPath, opts) {
     return originalStderrWrite(chunk, ...args);
   });
   try {
-    const rootDir = resolve(targetPath ?? ".");
+    const rootDir = resolve2(targetPath ?? ".");
+    const ignorePatterns = await loadIgnorePatterns(rootDir);
+    if (ignorePatterns.length > 0) {
+      process.stderr.write(`brain-cache: loaded ${ignorePatterns.length} patterns from .braincacheignore
+`);
+    }
     const profile = await readProfile();
     if (profile === null) {
       throw new Error("No profile found. Run 'brain-cache init' first.");
@@ -289,7 +357,10 @@ async function runIndex(targetPath, opts) {
     }
     const db = await openDatabase(rootDir);
     const table = await openOrCreateChunkTable(db, rootDir, profile.embeddingModel, dim);
-    const files = await crawlSourceFiles(rootDir);
+    const edgesTable = await openOrCreateEdgesTable(db);
+    const files = await crawlSourceFiles(rootDir, {
+      extraIgnorePatterns: ignorePatterns.length > 0 ? ignorePatterns : void 0
+    });
     process.stderr.write(`brain-cache: found ${files.length} source files
 `);
     if (files.length === 0) {
@@ -303,7 +374,7 @@ async function runIndex(targetPath, opts) {
       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");
+          const content = await readFile3(filePath, "utf-8");
           return { filePath, content, hash: hashContent(content) };
         })
       );
@@ -339,6 +410,10 @@ async function runIndex(targetPath, opts) {
     );
     for (const filePath of [...removedFiles, ...changedFiles]) {
       await deleteChunksByFilePath(table, filePath);
+      await withWriteLock(async () => {
+        const escaped = filePath.replace(/'/g, "''");
+        await edgesTable.delete(`from_file = '${escaped}'`);
+      });
     }
     const updatedHashes = { ...storedHashes };
     for (const filePath of removedFiles) {
@@ -386,11 +461,13 @@ async function runIndex(targetPath, opts) {
     for (let groupStart = 0; groupStart < filesToProcess.length; groupStart += FILE_READ_CONCURRENCY) {
       const group = filesToProcess.slice(groupStart, groupStart + FILE_READ_CONCURRENCY);
       const groupChunks = [];
+      const groupEdges = [];
       for (const filePath of group) {
         const content = contentMap.get(filePath);
         totalRawTokens += countChunkTokens(content);
-        const chunks = chunkFile(filePath, content);
+        const { chunks, edges } = chunkFile(filePath, content);
         groupChunks.push(...chunks);
+        groupEdges.push(...edges);
       }
       processedFiles += group.length;
       totalChunks += groupChunks.length;
@@ -431,6 +508,9 @@ async function runIndex(targetPath, opts) {
 `
         );
       }
+      if (groupEdges.length > 0) {
+        await insertEdges(edgesTable, groupEdges);
+      }
     }
     if (skippedChunks > 0) {
       process.stderr.write(`brain-cache: ${skippedChunks} chunks skipped (too large for model context)
@@ -440,6 +520,14 @@ async function runIndex(targetPath, opts) {
       `brain-cache: ${totalChunks} chunks from ${filesToProcess.length} files
 `
     );
+    const edgeCount = await edgesTable.countRows();
+    if (edgeCount === 0) {
+      process.stderr.write(`brain-cache: no call edges extracted \u2014 check source files
+`);
+    } else {
+      process.stderr.write(`brain-cache: ${edgeCount} call/import edges stored
+`);
+    }
     await createVectorIndexIfNeeded(table, profile.embeddingModel);
     for (const filePath of filesToProcess) {
       updatedHashes[filePath] = currentHashes[filePath];
@@ -480,6 +568,9 @@ ${savingsBlock}
     process.stderr.write = originalStderrWrite;
   }
 }
+
 export {
+  ALWAYS_EXCLUDE_GLOBS,
+  loadIgnorePatterns,
   runIndex
 };

package/dist/chunk-DFFMV3RR.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+import {
+  HIGH_RELEVANCE_SIMILARITY_THRESHOLD,
+  childLogger
+} from "./chunk-TXLCXXKY.js";
+
+// src/services/retriever.ts
+var log = childLogger("retriever");
+var TRACE_KEYWORDS = [
+  "trace the",
+  "trace flow",
+  "call path",
+  "flow of",
+  "follows from",
+  "calls into",
+  "invokes",
+  "trace from"
+];
+var TRACE_REGEX = /how does\b.*\bflow\b/i;
+var LOOKUP_BIGRAMS = [
+  "stack trace",
+  "null pointer",
+  "not defined",
+  "type error",
+  "reference error",
+  "syntax error",
+  "runtime error",
+  "segmentation fault",
+  "not working",
+  "throws exception"
+];
+var LOOKUP_KEYWORDS = [
+  "where is",
+  "find the",
+  "definition of",
+  "signature of",
+  "show me the",
+  "what does",
+  "what is the type"
+];
+var EXPLORE_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 classifyRetrievalMode(query) {
+  const lower = query.toLowerCase();
+  if (TRACE_KEYWORDS.some((kw) => lower.includes(kw)) || TRACE_REGEX.test(lower)) {
+    const broadTerms = ["architecture", "overview", "structure", "system", "design", "pipeline", "codebase"];
+    const isBroad = broadTerms.some((t) => lower.includes(t));
+    if (!isBroad) {
+      return "trace";
+    }
+  }
+  if (LOOKUP_BIGRAMS.some((bg) => lower.includes(bg))) {
+    return "lookup";
+  }
+  const hasLookupKeyword = LOOKUP_KEYWORDS.some((kw) => lower.includes(kw));
+  if (hasLookupKeyword) {
+    const isExcluded = EXPLORE_EXCLUSIONS.some((ex) => lower.includes(ex));
+    if (!isExcluded) {
+      return "lookup";
+    }
+  }
+  return "explore";
+}
+var RETRIEVAL_STRATEGIES = {
+  lookup: { limit: 5, distanceThreshold: 0.4, keywordBoostWeight: 0.4 },
+  trace: { limit: 3, distanceThreshold: 0.5, keywordBoostWeight: 0.2 },
+  explore: { limit: 20, distanceThreshold: 0.6, keywordBoostWeight: 0.1 }
+};
+function extractQueryTokens(query) {
+  return query.toLowerCase().split(/[\s.,;:!?'"()\[\]{}/\\]+/).filter((t) => t.length >= 3);
+}
+function splitCamelCase(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((t) => t.length >= 2);
+}
+function computeKeywordBoost(chunk, queryTokens) {
+  if (queryTokens.length === 0) return 0;
+  const fileName = chunk.filePath.split("/").pop()?.toLowerCase() ?? "";
+  const fileNameStem = fileName.replace(/\.[^.]+$/, "");
+  const chunkName = (chunk.name ?? "").toLowerCase();
+  if (chunkName.length > 0 && queryTokens.some((t) => t === chunkName)) {
+    return 1;
+  }
+  const subTokens = chunkName.length > 0 ? splitCamelCase(chunkName) : [];
+  if (subTokens.length > 1 && subTokens.every((sub) => queryTokens.some((t) => t.includes(sub) || sub.includes(t)))) {
+    return 1;
+  }
+  if (fileNameStem.length > 0 && queryTokens.some((t) => t === fileNameStem)) {
+    return 0.6;
+  }
+  const target = `${fileName} ${chunkName}`;
+  const matchCount = queryTokens.filter((t) => target.includes(t)).length;
+  return matchCount / queryTokens.length;
+}
+var CONFIG_NOISE_PATTERNS = [
+  { pattern: /^vitest\.config\./, toolName: "vitest" },
+  { pattern: /^tsup\.config\./, toolName: "tsup" },
+  { pattern: /^tsconfig.*\.json$/, toolName: "tsconfig" },
+  { pattern: /^jest\.config\./, toolName: "jest" },
+  { pattern: /^eslint\.config\./, toolName: "eslint" },
+  { pattern: /^\.eslintrc/, toolName: "eslint" }
+];
+var CONFIG_FILE_NOISE_PENALTY = 0.15;
+function computeNoisePenalty(chunk, query) {
+  const fileName = chunk.filePath.split("/").pop() ?? "";
+  const lowerQuery = query.toLowerCase();
+  for (const { pattern, toolName } of CONFIG_NOISE_PATTERNS) {
+    if (pattern.test(fileName)) {
+      if (lowerQuery.includes(toolName)) return 0;
+      return CONFIG_FILE_NOISE_PENALTY;
+    }
+  }
+  return 0;
+}
+async function searchChunks(table, queryVector, opts, query) {
+  log.debug({ limit: opts.limit, distanceThreshold: opts.distanceThreshold }, "Searching chunks");
+  const rows = await table.query().nearestTo(queryVector).distanceType("cosine").limit(opts.limit).toArray();
+  const queryTokens = query ? extractQueryTokens(query) : [];
+  const chunks = 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
+  }));
+  if (queryTokens.length > 0) {
+    const boostWeight = opts.keywordBoostWeight ?? 0.1;
+    const scored = chunks.map((chunk) => {
+      const boost = computeKeywordBoost(chunk, queryTokens);
+      const score = chunk.similarity * (1 - boostWeight) + boost * boostWeight - computeNoisePenalty(chunk, query);
+      const promotedSimilarity = boost > 0 ? Math.max(chunk.similarity, HIGH_RELEVANCE_SIMILARITY_THRESHOLD) : chunk.similarity;
+      return { chunk: { ...chunk, similarity: promotedSimilarity }, score };
+    });
+    return scored.sort((a, b) => b.score - a.score).map(({ chunk }) => chunk);
+  }
+  return chunks.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 {
+  classifyRetrievalMode,
+  RETRIEVAL_STRATEGIES,
+  searchChunks,
+  deduplicateChunks
+};

package/dist/{chunk-PJQNHMQH.js → chunk-DPH5X5HL.js}

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

package/dist/{chunk-FQL4HV4R.js → chunk-HRJ3OT6Q.js}

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