march-cli 0.1.35 → 0.1.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/code-search/cache.mjs

@@ -0,0 +1,133 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { chunkFile } from "./chunker.mjs";
+import { Bm25Index } from "./retrieval/bm25.mjs";
+import { LocalVectorIndex, defaultVectorizer } from "./retrieval/vector.mjs";
+
+const DEFAULT_MAX_FILE_ENTRIES = 8_000;
+const DEFAULT_MAX_INDEX_ENTRIES = 24;
+
+export class CodeSearchIndexCache {
+  constructor({
+    maxFileEntries = DEFAULT_MAX_FILE_ENTRIES,
+    maxIndexEntries = DEFAULT_MAX_INDEX_ENTRIES,
+    storagePath = null,
+    vectorizer = defaultVectorizer,
+  } = {}) {
+    this.maxFileEntries = maxFileEntries;
+    this.maxIndexEntries = maxIndexEntries;
+    this.storagePath = storagePath;
+    this.vectorizer = vectorizer;
+    this.fileChunks = new Map();
+    this.indices = new Map();
+    this.loaded = false;
+    this.dirty = false;
+  }
+
+  async build(files) {
+    await this.load();
+    const chunks = [];
+    let reusedFiles = 0;
+    let indexedFiles = 0;
+    for (const file of files) {
+      const signature = fileSignature(file);
+      const key = fileCacheKey(file);
+      const cached = this.fileChunks.get(key);
+      if (cached?.signature === signature) {
+        chunks.push(...cached.chunks);
+        reusedFiles += 1;
+        continue;
+      }
+      const fileChunks = await chunkFile(file);
+      this.fileChunks.set(key, { signature, chunks: fileChunks });
+      this.dirty = true;
+      chunks.push(...fileChunks);
+      indexedFiles += 1;
+    }
+
+    this.pruneFileCache();
+    await this.persist();
+
+    const indexSignature = [this.vectorizer.id, ...files.map(fileSignature)].join("\n");
+    const cachedIndex = this.indices.get(indexSignature);
+    if (cachedIndex) {
+      this.indices.delete(indexSignature);
+      this.indices.set(indexSignature, cachedIndex);
+      return { chunks, index: cachedIndex, reusedFiles, indexedFiles, reusedIndex: true, vectorizer: this.vectorizer.id };
+    }
+
+    const index = {
+      lexical: new Bm25Index(chunks),
+      vector: await LocalVectorIndex.create(chunks, { vectorizer: this.vectorizer }),
+    };
+    this.indices.set(indexSignature, index);
+    this.pruneIndexCache();
+    return { chunks, index, reusedFiles, indexedFiles, reusedIndex: false, vectorizer: this.vectorizer.id };
+  }
+
+  clear() {
+    this.fileChunks.clear();
+    this.indices.clear();
+    this.loaded = true;
+    this.dirty = true;
+  }
+
+  async load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    if (!this.storagePath) return;
+    try {
+      const raw = await readFile(this.storagePath, "utf8");
+      const parsed = JSON.parse(raw);
+      for (const entry of parsed.files ?? []) {
+        if (!entry?.key || !entry.signature || !Array.isArray(entry.chunks)) continue;
+        this.fileChunks.set(entry.key, { signature: entry.signature, chunks: entry.chunks });
+      }
+      this.pruneFileCache();
+    } catch (err) {
+      if (err?.code !== "ENOENT") this.fileChunks.clear();
+    }
+  }
+
+  async persist() {
+    if (!this.storagePath || !this.dirty) return;
+    const payload = {
+      version: 1,
+      files: [...this.fileChunks.entries()].map(([key, value]) => ({
+        key,
+        signature: value.signature,
+        chunks: value.chunks,
+      })),
+    };
+    await mkdir(dirname(this.storagePath), { recursive: true });
+    const tmpPath = `${this.storagePath}.${process.pid}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(payload), "utf8");
+    await rename(tmpPath, this.storagePath);
+    this.dirty = false;
+  }
+
+  pruneFileCache() {
+    while (this.fileChunks.size > this.maxFileEntries) {
+      const oldestKey = this.fileChunks.keys().next().value;
+      this.fileChunks.delete(oldestKey);
+      this.dirty = true;
+    }
+  }
+
+  pruneIndexCache() {
+    while (this.indices.size > this.maxIndexEntries) {
+      const oldestKey = this.indices.keys().next().value;
+      this.indices.delete(oldestKey);
+    }
+  }
+}
+
+export const defaultCodeSearchIndexCache = new CodeSearchIndexCache();
+
+function fileSignature(file) {
+  return `${fileCacheKey(file)}:${file.size ?? 0}:${Math.trunc(file.mtimeMs ?? 0)}`;
+}
+
+function fileCacheKey(file) {
+  return file.absPath ?? file.relPath;
+}

package/src/agent/code-search/chunk-rules.mjs

@@ -0,0 +1,107 @@
+const FUNCTION_TYPES = new Set([
+  "function_declaration",
+  "function_definition",
+  "function_item",
+  "method_definition",
+  "method_declaration",
+]);
+const CLASS_TYPES = new Set([
+  "class_declaration",
+  "class_definition",
+  "enum_declaration",
+  "enum_item",
+  "interface_declaration",
+  "struct_item",
+  "type_alias_declaration",
+]);
+
+const LANGUAGE_RULES = {
+  javascript: jsTsRules(),
+  typescript: jsTsRules(),
+  tsx: jsTsRules(),
+  python: rules({
+    function: ["function_definition"],
+    class: ["class_definition"],
+  }),
+  rust: rules({
+    function: ["function_item"],
+    class: ["enum_item", "impl_item", "struct_item", "trait_item", "type_item"],
+  }),
+  go: rules({
+    function: ["function_declaration", "method_declaration"],
+    class: ["type_declaration"],
+  }),
+  java: rules({
+    function: ["constructor_declaration", "method_declaration"],
+    class: ["class_declaration", "enum_declaration", "interface_declaration", "record_declaration"],
+  }),
+};
+
+export function chunkRuleFor(language, node) {
+  const rule = LANGUAGE_RULES[language]?.get(node.type);
+  if (rule) return rule;
+  if (FUNCTION_TYPES.has(node.type) || /function|method/.test(node.type)) return { kind: "function" };
+  if (CLASS_TYPES.has(node.type) || /class|interface|struct|enum|type_alias/.test(node.type)) return { kind: "class" };
+  return null;
+}
+
+export function extractNodeSymbols(language, node) {
+  const byField = extractFieldSymbols(node);
+  if (byField.length > 0) return byField.slice(0, 5);
+  return extractSymbolsFromText(language, node.text).slice(0, 5);
+}
+
+function jsTsRules() {
+  return rules({
+    function: ["function_declaration", "generator_function_declaration", "method_definition"],
+    class: ["abstract_class_declaration", "class_declaration", "interface_declaration", "type_alias_declaration"],
+    block: ["lexical_declaration"],
+  });
+}
+
+function rules(groups) {
+  const map = new Map();
+  for (const [kind, nodeTypes] of Object.entries(groups)) {
+    for (const type of nodeTypes) map.set(type, { kind });
+  }
+  return map;
+}
+
+function extractFieldSymbols(node) {
+  const symbols = [];
+  const children = node.children ?? [];
+  for (let index = 0; index < children.length; index += 1) {
+    const field = node.fieldNameForChild(index) ?? "";
+    if (field === "name" && children[index].text && isIdentifier(children[index].text)) {
+      symbols.push(children[index].text);
+    }
+  }
+  return symbols;
+}
+
+function isIdentifier(text) {
+  return /^[A-Za-z_$][\w$]*$/.test(text);
+}
+
+function extractSymbolsFromText(language, text) {
+  const source = String(text ?? "");
+  const patterns = symbolPatterns(language);
+  const symbols = [];
+  for (const pattern of patterns) {
+    const match = source.match(pattern);
+    if (match?.[1]) symbols.push(match[1]);
+  }
+  return [...new Set(symbols)];
+}
+
+function symbolPatterns(language) {
+  if (language === "python") return [/^\s*(?:async\s+)?def\s+([A-Za-z_][\w]*)/m, /^\s*class\s+([A-Za-z_][\w]*)/m];
+  if (language === "rust") return [/^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_][\w]*)/m, /^\s*(?:pub\s+)?(?:struct|enum|trait|impl)\s+([A-Za-z_][\w]*)/m];
+  if (language === "go") return [/^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_][\w]*)/m, /^\s*type\s+([A-Za-z_][\w]*)/m];
+  if (language === "java") return [/\b(?:class|interface|enum|record)\s+([A-Za-z_][\w]*)/m, /\b([A-Za-z_][\w]*)\s*\([^)]*\)\s*\{/m];
+  return [
+    /\b(?:function|class|interface|type)\s+([A-Za-z_$][\w$]*)/m,
+    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/m,
+    /\b([A-Za-z_$][\w$]*)\s*[:=]\s*(?:async\s*)?\([^)]*\)\s*=>/m,
+  ];
+}

package/src/agent/code-search/chunker.mjs

@@ -0,0 +1,125 @@
+import { chunkRuleFor, extractNodeSymbols } from "./chunk-rules.mjs";
+import { getParser } from "./parser-pool.mjs";
+import { uniqueTokens } from "./tokenize.mjs";
+
+const MAX_CHUNK_LINES = 80;
+const FALLBACK_WINDOW = 60;
+
+
+export async function chunkFile(file) {
+  const lines = file.content.split("\n");
+  const parser = await getParser(file.language);
+  if (!parser) return fallbackChunks(file, lines);
+  try {
+    const tree = parser.parse(file.content);
+    const chunks = collectAstChunks(file, lines, tree.rootNode);
+    const completed = addUncoveredLineChunks(file, lines, chunks);
+    return completed.length > 0 ? completed : fallbackChunks(file, lines);
+  } catch {
+    return fallbackChunks(file, lines);
+  }
+}
+
+function collectAstChunks(file, lines, rootNode) {
+  const chunks = [];
+  walk(rootNode, (node) => {
+    const rule = chunkRuleFor(file.language, node);
+    if (!rule) return;
+    const start = node.startPosition.row + 1;
+    const end = Math.min(node.endPosition.row + 1, start + MAX_CHUNK_LINES - 1);
+    if (end < start) return;
+    const content = lines.slice(start - 1, end).join("\n");
+    if (!content.trim()) return;
+    chunks.push(toChunk(file, content, start, end, rule.kind, extractNodeSymbols(file.language, node)));
+  });
+  return dedupeContainedChunks(chunks);
+}
+
+function walk(node, visit) {
+  visit(node);
+  for (const child of node.namedChildren ?? node.children ?? []) walk(child, visit);
+}
+
+
+function dedupeContainedChunks(chunks) {
+  const sorted = chunks.sort((a, b) => a.start_line - b.start_line || a.end_line - b.end_line);
+  return sorted.filter((chunk, index) => !sorted.some((other, otherIndex) => (
+    otherIndex !== index
+      && other.file_path === chunk.file_path
+      && other.start_line <= chunk.start_line
+      && other.end_line >= chunk.end_line
+      && span(other) < span(chunk) + 10
+  )));
+}
+
+function span(chunk) {
+  return chunk.end_line - chunk.start_line;
+}
+
+function addUncoveredLineChunks(file, lines, chunks) {
+  const covered = new Set();
+  for (const chunk of chunks) {
+    for (let line = chunk.start_line; line <= chunk.end_line; line += 1) covered.add(line);
+  }
+  const completed = [...chunks];
+  let start = null;
+  for (let line = 1; line <= lines.length; line += 1) {
+    if (!covered.has(line) && lines[line - 1]?.trim()) {
+      start ??= line;
+    } else if (start !== null) {
+      completed.push(...fallbackRangeChunks(file, lines, start, line - 1));
+      start = null;
+    }
+  }
+  if (start !== null) completed.push(...fallbackRangeChunks(file, lines, start, lines.length));
+  return completed.sort((a, b) => a.start_line - b.start_line || a.end_line - b.end_line);
+}
+
+function fallbackRangeChunks(file, lines, start, end) {
+  const chunks = [];
+  for (let line = start; line <= end; line += FALLBACK_WINDOW) {
+    const chunkEnd = Math.min(end, line + FALLBACK_WINDOW - 1);
+    const content = lines.slice(line - 1, chunkEnd).join("\n");
+    if (content.trim()) chunks.push(toChunk(file, content, line, chunkEnd, docsOrConfigKind(file), []));
+  }
+  return chunks;
+}
+
+function fallbackChunks(file, lines) {
+  const kind = docsOrConfigKind(file);
+  const chunks = [];
+  for (let start = 1; start <= lines.length; start += FALLBACK_WINDOW) {
+    const end = Math.min(lines.length, start + FALLBACK_WINDOW - 1);
+    const content = lines.slice(start - 1, end).join("\n");
+    if (content.trim()) chunks.push(toChunk(file, content, start, end, kind, []));
+  }
+  return chunks;
+}
+
+function docsOrConfigKind(file) {
+  if (/\.(md|mdx|txt)$/i.test(file.relPath)) return "docs";
+  if (/\.(json|jsonc|ya?ml|toml)$/i.test(file.relPath)) return "config";
+  return "block";
+}
+
+function toChunk(file, content, start, end, kind, symbols) {
+  return {
+    id: `${file.relPath}:${start}-${end}`,
+    file_path: file.relPath,
+    abs_path: file.absPath,
+    start_line: start,
+    end_line: end,
+    language: file.language,
+    kind: refineKind(kind, content),
+    symbols,
+    identifiers: uniqueTokens(`${symbols.join(" ")} ${content}`).slice(0, 40),
+    content,
+  };
+}
+
+function refineKind(kind, content) {
+  if (kind !== "block") return kind;
+  if (/\b(class|interface|struct|enum|type)\b/.test(content)) return "class";
+  if (/\b(function|def|fn)\b|=>/.test(content)) return "function";
+  return kind;
+}

package/src/agent/code-search/engine.mjs

@@ -0,0 +1,109 @@
+import { defaultCodeSearchIndexCache } from "./cache.mjs";
+import { rrfFuse } from "./retrieval/fusion.mjs";
+import { rerankResults } from "./rerank.mjs";
+import { scanCodeFiles } from "./scanner.mjs";
+
+const DEFAULT_TOP_K = 5;
+const RETRIEVAL_LIMIT = 80;
+
+export async function searchCode(options = {}) {
+  const {
+    root,
+    query,
+    path = ".",
+    top_k = DEFAULT_TOP_K,
+    mode = "auto",
+    include_tests = false,
+    related_to,
+    cache = defaultCodeSearchIndexCache,
+  } = options;
+  const normalizedQuery = String(query ?? "").trim();
+  const activeCache = cache ?? defaultCodeSearchIndexCache;
+  if (!normalizedQuery && !related_to) return { results: [], stats: { files: 0, chunks: 0 } };
+
+  const files = await scanCodeFiles({ root, path });
+  const built = await activeCache.build(files);
+  const related = related_to ? relatedQuery(built.chunks, related_to, normalizedQuery) : null;
+  const queryText = related?.query ?? normalizedQuery;
+  const retrieved = await retrieveChunks(built.index, queryText, mode);
+  const filtered = related ? retrieved.filter((result) => result.chunk.id !== related.targetId) : retrieved;
+  const ranked = rerankResults(filtered, queryText, { includeTests: include_tests });
+  const limit = clampTopK(top_k);
+  return {
+    results: ranked.slice(0, limit).map(formatResult),
+    stats: formatStats(files, built, resultMode({ related_to, mode })),
+  };
+}
+
+async function retrieveChunks(index, queryText, mode) {
+  const lexical = index.lexical.search(queryText, { limit: RETRIEVAL_LIMIT });
+  if (mode === "lexical" || mode === "symbol") return lexical;
+  const semantic = await index.vector.search(queryText, { limit: RETRIEVAL_LIMIT });
+  if (mode === "semantic") return semantic;
+  return rrfFuse([
+    { results: lexical, weight: 1.2 },
+    { results: semantic, weight: 1 },
+  ], { limit: RETRIEVAL_LIMIT });
+}
+
+function resultMode({ related_to, mode }) {
+  if (related_to) return "related";
+  if (mode === "symbol") return "symbol";
+  if (mode === "semantic") return "semantic";
+  if (mode === "lexical") return "lexical";
+  return "hybrid";
+}
+
+function relatedQuery(chunks, relatedTo, query) {
+  const target = findRelatedTarget(chunks, relatedTo);
+  if (!target) throw new Error(`No indexed chunk found at ${relatedTo.file_path}:${relatedTo.line}`);
+  return {
+    targetId: target.id,
+    query: [query, target.symbols.join(" "), target.identifiers.join(" "), target.content].filter(Boolean).join("\n"),
+  };
+}
+
+function findRelatedTarget(chunks, relatedTo) {
+  const filePath = String(relatedTo?.file_path ?? "").replace(/\\/g, "/");
+  const line = Math.trunc(Number(relatedTo?.line));
+  if (!filePath || !Number.isFinite(line)) throw new Error("related_to requires file_path and line");
+  return chunks.find((chunk) => chunk.file_path === filePath && chunk.start_line <= line && chunk.end_line >= line);
+}
+
+function formatStats(files, built, mode) {
+  return {
+    files: files.length,
+    chunks: built.chunks.length,
+    mode,
+    reused_files: built.reusedFiles,
+    indexed_files: built.indexedFiles,
+    reused_index: built.reusedIndex,
+    vectorizer: built.vectorizer,
+  };
+}
+
+function formatResult({ chunk, score }) {
+  return {
+    file_path: chunk.file_path,
+    start_line: chunk.start_line,
+    end_line: chunk.end_line,
+    language: chunk.language,
+    kind: chunk.kind,
+    symbols: chunk.symbols,
+    score: Number(score.toFixed(3)),
+    snippet: trimSnippet(chunk.content),
+  };
+}
+
+function trimSnippet(content) {
+  const lines = String(content ?? "").split("\n");
+  const selected = lines.slice(0, 40);
+  const suffix = lines.length > selected.length ? "\n…" : "";
+  return selected.join("\n") + suffix;
+}
+
+function clampTopK(value) {
+  const parsed = Math.trunc(Number(value));
+  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_TOP_K;
+  return Math.min(parsed, 20);
+}

package/src/agent/code-search/languages.mjs

@@ -0,0 +1,25 @@
+import { extname } from "node:path";
+import { LANG_ALIASES, LANGUAGES } from "../../cli/tui/syntax/languages.mjs";
+
+export const SEARCHABLE_TEXT_EXTENSIONS = new Set([
+  ".md", ".mdx", ".txt", ".json", ".jsonc", ".yaml", ".yml", ".toml", ".xml", ".html", ".css",
+]);
+
+export function languageForPath(path) {
+  const ext = extname(path).slice(1).toLowerCase();
+  if (!ext) return "";
+  return LANG_ALIASES.get(ext) ?? "";
+}
+
+export function canParseLanguage(language) {
+  return Boolean(language && LANGUAGES[language]);
+}
+
+export function isSearchableTextPath(path) {
+  const ext = extname(path).toLowerCase();
+  return SEARCHABLE_TEXT_EXTENSIONS.has(ext) || canParseLanguage(languageForPath(path));
+}
+
+export function languageConfig(language) {
+  return LANGUAGES[language] ?? null;
+}

package/src/agent/code-search/parser-pool.mjs

@@ -0,0 +1,29 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Language, Parser } from "web-tree-sitter";
+import { canParseLanguage, languageConfig } from "./languages.mjs";
+
+const RESOURCE_DIR = join(dirname(fileURLToPath(import.meta.url)), "../../cli/tui/syntax/tree-sitter");
+
+let initPromise = null;
+const parsers = new Map();
+
+export async function getParser(language) {
+  if (!canParseLanguage(language)) return null;
+  if (!initPromise) initPromise = Parser.init().catch(() => false);
+  const ready = await initPromise;
+  if (ready === false) return null;
+  if (parsers.has(language)) return parsers.get(language);
+
+  try {
+    const config = languageConfig(language);
+    const grammar = await Language.load(join(RESOURCE_DIR, config.file));
+    const parser = new Parser();
+    parser.setLanguage(grammar);
+    parsers.set(language, parser);
+    return parser;
+  } catch {
+    parsers.set(language, null);
+    return null;
+  }
+}

package/src/agent/code-search/rerank.mjs

@@ -0,0 +1,43 @@
+import { tokenize } from "./tokenize.mjs";
+
+export function rerankResults(results, query, { includeTests = false } = {}) {
+  const queryTokens = new Set(tokenize(query));
+  return results
+    .map((result) => ({ ...result, score: applyBoosts(result.chunk, result.score, queryTokens, includeTests) }))
+    .filter((result) => includeTests || !isTestPath(result.chunk.file_path))
+    .sort((a, b) => b.score - a.score || a.chunk.file_path.localeCompare(b.chunk.file_path));
+}
+
+function applyBoosts(chunk, baseScore, queryTokens, includeTests) {
+  let score = baseScore;
+  const symbolTokens = new Set(tokenize(chunk.symbols.join(" ")));
+  const pathTokens = new Set(tokenize(chunk.file_path));
+  const identifierTokens = new Set(chunk.identifiers ?? []);
+
+  score += overlap(queryTokens, symbolTokens) * 3.0;
+  score += overlap(queryTokens, identifierTokens) * 1.5;
+  score += overlap(queryTokens, pathTokens) * 1.0;
+  if (chunk.kind === "function" || chunk.kind === "class") score += 0.75;
+  if (isImplementationPath(chunk.file_path)) score += 0.5;
+  if (!includeTests && isTestPath(chunk.file_path)) score -= 2.5;
+  if (isVendorPath(chunk.file_path)) score -= 5;
+  return score;
+}
+
+function overlap(a, b) {
+  let count = 0;
+  for (const token of a) if (b.has(token)) count += 1;
+  return count;
+}
+
+function isImplementationPath(path) {
+  return /(^|\/)src\//.test(path) || /(^|\/)lib\//.test(path);
+}
+
+function isTestPath(path) {
+  return /(^|\/)(__tests__|test|tests|spec)(\/|$)|\.(test|spec)\.[cm]?[jt]sx?$/.test(path);
+}
+
+function isVendorPath(path) {
+  return /(^|\/)(node_modules|vendor|dist|build|coverage)(\/|$)/.test(path);
+}

package/src/agent/code-search/retrieval/bm25.mjs

@@ -0,0 +1,47 @@
+import { tokenize } from "../tokenize.mjs";
+
+const K1 = 1.2;
+const B = 0.75;
+
+export class Bm25Index {
+  constructor(chunks) {
+    this.chunks = chunks;
+    this.documents = chunks.map((chunk) => buildDocument(chunk));
+    this.averageLength = this.documents.reduce((sum, doc) => sum + doc.length, 0) / Math.max(1, this.documents.length);
+    this.documentFrequency = new Map();
+    for (const doc of this.documents) {
+      for (const token of doc.uniqueTokens) this.documentFrequency.set(token, (this.documentFrequency.get(token) ?? 0) + 1);
+    }
+  }
+
+  search(query, { limit = 50 } = {}) {
+    const queryTokens = [...new Set(tokenize(query))];
+    if (queryTokens.length === 0) return [];
+    const scored = [];
+    for (let index = 0; index < this.documents.length; index += 1) {
+      const score = this.scoreDocument(this.documents[index], queryTokens);
+      if (score > 0) scored.push({ chunk: this.chunks[index], score });
+    }
+    scored.sort((a, b) => b.score - a.score || a.chunk.file_path.localeCompare(b.chunk.file_path));
+    return scored.slice(0, limit);
+  }
+
+  scoreDocument(doc, queryTokens) {
+    let score = 0;
+    for (const token of queryTokens) {
+      const frequency = doc.termFrequency.get(token) ?? 0;
+      if (frequency === 0) continue;
+      const idf = Math.log(1 + (this.documents.length - (this.documentFrequency.get(token) ?? 0) + 0.5) / ((this.documentFrequency.get(token) ?? 0) + 0.5));
+      const denominator = frequency + K1 * (1 - B + B * doc.length / Math.max(1, this.averageLength));
+      score += idf * (frequency * (K1 + 1)) / denominator;
+    }
+    return score;
+  }
+}
+
+function buildDocument(chunk) {
+  const tokens = tokenize(`${chunk.file_path} ${chunk.symbols.join(" ")} ${chunk.content}`);
+  const termFrequency = new Map();
+  for (const token of tokens) termFrequency.set(token, (termFrequency.get(token) ?? 0) + 1);
+  return { termFrequency, uniqueTokens: new Set(tokens), length: Math.max(1, tokens.length) };
+}

package/src/agent/code-search/retrieval/fusion.mjs

@@ -0,0 +1,18 @@
+const RRF_K = 60;
+
+export function rrfFuse(resultSets, { limit = 80 } = {}) {
+  const fused = new Map();
+  for (const { results, weight = 1 } of resultSets) {
+    for (let index = 0; index < results.length; index += 1) {
+      const result = results[index];
+      const id = result.chunk.id;
+      const current = fused.get(id) ?? { chunk: result.chunk, score: 0, sources: [] };
+      current.score += weight / (RRF_K + index + 1);
+      current.sources.push({ rank: index + 1, score: result.score });
+      fused.set(id, current);
+    }
+  }
+  return [...fused.values()]
+    .sort((a, b) => b.score - a.score || a.chunk.file_path.localeCompare(b.chunk.file_path))
+    .slice(0, limit);
+}