@optave/codegraph 2.5.0 → 2.6.0

package/src/communities.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import Graph from 'graphology';
 import louvain from 'graphology-communities-louvain';
 import { openReadonlyOrFail } from './db.js';
+import { paginateResult, printNdjson } from './paginate.js';
 import { isTestFile } from './queries.js';
 
 // ─── Graph Construction ───────────────────────────────────────────────
@@ -201,7 +202,7 @@ export function communitiesData(customDbPath, opts = {}) {
 
   const driftScore = Math.round(((splitRatio + mergeRatio) / 2) * 100);
 
-  return {
+  const base = {
     communities: opts.drift ? [] : communities,
     modularity: +modularity.toFixed(4),
     drift: { splitCandidates, mergeCandidates },
@@ -212,6 +213,7 @@ export function communitiesData(customDbPath, opts = {}) {
       driftScore,
     },
   };
+  return paginateResult(base, 'communities', { limit: opts.limit, offset: opts.offset });
 }
 
 /**
@@ -238,6 +240,10 @@ export function communitySummaryForStats(customDbPath, opts = {}) {
 export function communities(customDbPath, opts = {}) {
   const data = communitiesData(customDbPath, opts);
 
+  if (opts.ndjson) {
+    printNdjson(data, 'communities');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;

package/src/complexity.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { loadConfig } from './config.js';
 import { openReadonlyOrFail } from './db.js';
 import { info } from './logger.js';
+import { paginateResult, printNdjson } from './paginate.js';
 import { LANGUAGE_REGISTRY } from './parser.js';
 import { isTestFile } from './queries.js';
 
@@ -1799,7 +1800,6 @@ export async function buildComplexityMetrics(db, fileSymbols, rootDir, _engineOp
  */
 export function complexityData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
-  const limit = opts.limit || 20;
   const sort = opts.sort || 'cognitive';
   const noTests = opts.noTests || false;
   const aboveThreshold = opts.aboveThreshold || false;
@@ -1887,13 +1887,19 @@ export function complexityData(customDbPath, opts = {}) {
        FROM function_complexity fc
        JOIN nodes n ON fc.node_id = n.id
        ${where} ${having}
-       ORDER BY ${orderBy}
-       LIMIT ?`,
+       ORDER BY ${orderBy}`,
       )
-      .all(...params, limit);
+      .all(...params);
   } catch {
+    // Check if graph has nodes even though complexity table is missing/empty
+    let hasGraph = false;
+    try {
+      hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+    } catch {
+      /* ignore */
+    }
     db.close();
-    return { functions: [], summary: null, thresholds };
+    return { functions: [], summary: null, thresholds, hasGraph };
   }
 
   // Post-filter test files if needed (belt-and-suspenders for isTestFile)
@@ -1979,8 +1985,99 @@ export function complexityData(customDbPath, opts = {}) {
     /* ignore */
   }
 
+  // When summary is null (no complexity rows), check if graph has nodes
+  let hasGraph = false;
+  if (summary === null) {
+    try {
+      hasGraph = db.prepare('SELECT COUNT(*) as c FROM nodes').get().c > 0;
+    } catch {
+      /* ignore */
+    }
+  }
+
   db.close();
-  return { functions, summary, thresholds };
+  const base = { functions, summary, thresholds, hasGraph };
+  return paginateResult(base, 'functions', { limit: opts.limit, offset: opts.offset });
+}
+
+/**
+ * Generator: stream complexity rows one-by-one using .iterate() for memory efficiency.
+ * @param {string} [customDbPath]
+ * @param {object} [opts]
+ * @param {boolean} [opts.noTests]
+ * @param {string} [opts.file]
+ * @param {string} [opts.target]
+ * @param {string} [opts.kind]
+ * @param {string} [opts.sort]
+ * @yields {{ name: string, kind: string, file: string, line: number, cognitive: number, cyclomatic: number, maxNesting: number, loc: number, sloc: number }}
+ */
+export function* iterComplexity(customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const sort = opts.sort || 'cognitive';
+
+    let where = "WHERE n.kind IN ('function','method')";
+    const params = [];
+
+    if (noTests) {
+      where += ` AND n.file NOT LIKE '%.test.%'
+         AND n.file NOT LIKE '%.spec.%'
+         AND n.file NOT LIKE '%__test__%'
+         AND n.file NOT LIKE '%__tests__%'
+         AND n.file NOT LIKE '%.stories.%'`;
+    }
+    if (opts.target) {
+      where += ' AND n.name LIKE ?';
+      params.push(`%${opts.target}%`);
+    }
+    if (opts.file) {
+      where += ' AND n.file LIKE ?';
+      params.push(`%${opts.file}%`);
+    }
+    if (opts.kind) {
+      where += ' AND n.kind = ?';
+      params.push(opts.kind);
+    }
+
+    const orderMap = {
+      cognitive: 'fc.cognitive DESC',
+      cyclomatic: 'fc.cyclomatic DESC',
+      nesting: 'fc.max_nesting DESC',
+      mi: 'fc.maintainability_index ASC',
+      volume: 'fc.halstead_volume DESC',
+      effort: 'fc.halstead_effort DESC',
+      bugs: 'fc.halstead_bugs DESC',
+      loc: 'fc.loc DESC',
+    };
+    const orderBy = orderMap[sort] || 'fc.cognitive DESC';
+
+    const stmt = db.prepare(
+      `SELECT n.name, n.kind, n.file, n.line, n.end_line,
+              fc.cognitive, fc.cyclomatic, fc.max_nesting, fc.loc, fc.sloc
+       FROM function_complexity fc
+       JOIN nodes n ON fc.node_id = n.id
+       ${where}
+       ORDER BY ${orderBy}`,
+    );
+    for (const r of stmt.iterate(...params)) {
+      if (noTests && isTestFile(r.file)) continue;
+      yield {
+        name: r.name,
+        kind: r.kind,
+        file: r.file,
+        line: r.line,
+        endLine: r.end_line || null,
+        cognitive: r.cognitive,
+        cyclomatic: r.cyclomatic,
+        maxNesting: r.max_nesting,
+        loc: r.loc || 0,
+        sloc: r.sloc || 0,
+      };
+    }
+  } finally {
+    db.close();
+  }
 }
 
 /**
@@ -1989,6 +2086,10 @@ export function complexityData(customDbPath, opts = {}) {
 export function complexity(customDbPath, opts = {}) {
   const data = complexityData(customDbPath, opts);
 
+  if (opts.ndjson) {
+    printNdjson(data, 'functions');
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify(data, null, 2));
     return;
@@ -1996,9 +2097,15 @@ export function complexity(customDbPath, opts = {}) {
 
   if (data.functions.length === 0) {
     if (data.summary === null) {
-      console.log(
-        '\nNo complexity data found. Run "codegraph build" first to analyze your codebase.\n',
-      );
+      if (data.hasGraph) {
+        console.log(
+          '\nNo complexity data found, but a graph exists. Run "codegraph build --no-incremental" to populate complexity metrics.\n',
+        );
+      } else {
+        console.log(
+          '\nNo complexity data found. Run "codegraph build" first to analyze your codebase.\n',
+        );
+      }
     } else {
       console.log('\nNo functions match the given filters.\n');
     }

package/src/config.js

@@ -14,6 +14,7 @@ export const DEFAULTS = {
   build: {
     incremental: true,
     dbPath: '.codegraph/graph.db',
+    driftThreshold: 0.2,
   },
   query: {
     defaultDepth: 3,
@@ -36,7 +37,16 @@ export const DEFAULTS = {
       fanIn: { warn: null, fail: null },
       fanOut: { warn: null, fail: null },
       noCycles: { warn: null, fail: null },
+      boundaries: { warn: null, fail: null },
     },
+    boundaries: null,
+  },
+  check: {
+    cycles: true,
+    blastRadius: null,
+    signatures: true,
+    boundaries: true,
+    depth: 3,
   },
   coChange: {
     since: '1 year ago',

package/src/embedder.js

@@ -384,6 +384,22 @@ function initEmbeddingsSchema(db) {
       value TEXT
     );
   `);
+
+  // Add full_text column (idempotent — ignore if already exists)
+  try {
+    db.exec('ALTER TABLE embeddings ADD COLUMN full_text TEXT');
+  } catch {
+    /* column already exists */
+  }
+
+  // FTS5 virtual table for BM25 keyword search
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS fts_index USING fts5(
+      name,
+      content,
+      tokenize='unicode61'
+    );
+  `);
 }
 
 /**
@@ -411,6 +427,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
 
   db.exec('DELETE FROM embeddings');
   db.exec('DELETE FROM embedding_meta');
+  db.exec('DELETE FROM fts_index');
 
   const nodes = db
     .prepare(
@@ -445,6 +462,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
 
   const texts = [];
   const nodeIds = [];
+  const nodeNames = [];
   const previews = [];
   const config = getModelConfig(modelKey);
   const contextWindow = config.contextWindow;
@@ -476,6 +494,7 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
 
       texts.push(text);
       nodeIds.push(node.id);
+      nodeNames.push(node.name);
       previews.push(`${node.name} (${node.kind}) -- ${file}:${node.line}`);
     }
   }
@@ -490,16 +509,19 @@ export async function buildEmbeddings(rootDir, modelKey, customDbPath, options =
   const { vectors, dim } = await embed(texts, modelKey);
 
   const insert = db.prepare(
-    'INSERT OR REPLACE INTO embeddings (node_id, vector, text_preview) VALUES (?, ?, ?)',
+    'INSERT OR REPLACE INTO embeddings (node_id, vector, text_preview, full_text) VALUES (?, ?, ?, ?)',
   );
+  const insertFts = db.prepare('INSERT INTO fts_index(rowid, name, content) VALUES (?, ?, ?)');
   const insertMeta = db.prepare('INSERT OR REPLACE INTO embedding_meta (key, value) VALUES (?, ?)');
   const insertAll = db.transaction(() => {
     for (let i = 0; i < vectors.length; i++) {
-      insert.run(nodeIds[i], Buffer.from(vectors[i].buffer), previews[i]);
+      insert.run(nodeIds[i], Buffer.from(vectors[i].buffer), previews[i], texts[i]);
+      insertFts.run(nodeIds[i], nodeNames[i], texts[i]);
     }
     insertMeta.run('model', config.name);
     insertMeta.run('dim', String(dim));
     insertMeta.run('count', String(vectors.length));
+    insertMeta.run('fts_count', String(vectors.length));
     insertMeta.run('strategy', strategy);
     insertMeta.run('built_at', new Date().toISOString());
     if (overflowCount > 0) {
@@ -731,71 +753,361 @@ export async function multiSearchData(queries, customDbPath, opts = {}) {
 }
 
 /**
- * Semantic search with pre-filter support — CLI wrapper with multi-query detection.
+ * Sanitize a user query for FTS5 MATCH syntax.
+ * Wraps each token as an implicit OR and escapes special FTS5 characters.
+ */
+function sanitizeFtsQuery(query) {
+  // Remove FTS5 special chars that could cause syntax errors
+  const cleaned = query.replace(/[*"():^{}~<>]/g, ' ').trim();
+  if (!cleaned) return null;
+  // Split into tokens, wrap with OR for multi-token queries
+  const tokens = cleaned.split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0) return null;
+  if (tokens.length === 1) return `"${tokens[0]}"`;
+  return tokens.map((t) => `"${t}"`).join(' OR ');
+}
+
+/**
+ * Check if the FTS5 index exists in the database.
+ * Returns true if fts_index table exists and has rows, false otherwise.
+ */
+function hasFtsIndex(db) {
+  try {
+    const row = db.prepare('SELECT COUNT(*) as c FROM fts_index').get();
+    return row.c > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * BM25 keyword search via FTS5.
+ * Returns { results: [{ name, kind, file, line, bm25Score }] } or null if no FTS5 index.
+ */
+export function ftsSearchData(query, customDbPath, opts = {}) {
+  const limit = opts.limit || 15;
+  const noTests = opts.noTests || false;
+  const TEST_PATTERN = /\.(test|spec)\.|__test__|__tests__|\.stories\./;
+
+  const db = openReadonlyOrFail(customDbPath);
+
+  if (!hasFtsIndex(db)) {
+    db.close();
+    return null;
+  }
+
+  const ftsQuery = sanitizeFtsQuery(query);
+  if (!ftsQuery) {
+    db.close();
+    return { results: [] };
+  }
+
+  let sql = `
+    SELECT f.rowid AS node_id, rank AS bm25_score,
+           n.name, n.kind, n.file, n.line
+    FROM fts_index f
+    JOIN nodes n ON f.rowid = n.id
+    WHERE fts_index MATCH ?
+  `;
+  const params = [ftsQuery];
+
+  if (opts.kind) {
+    sql += ' AND n.kind = ?';
+    params.push(opts.kind);
+  }
+
+  const isGlob = opts.filePattern && /[*?[\]]/.test(opts.filePattern);
+  if (opts.filePattern && !isGlob) {
+    sql += ' AND n.file LIKE ?';
+    params.push(`%${opts.filePattern}%`);
+  }
+
+  sql += ' ORDER BY rank LIMIT ?';
+  params.push(limit * 5); // fetch generous set for post-filtering
+
+  let rows;
+  try {
+    rows = db.prepare(sql).all(...params);
+  } catch {
+    // Invalid FTS5 query syntax — return empty
+    db.close();
+    return { results: [] };
+  }
+
+  if (isGlob) {
+    rows = rows.filter((row) => globMatch(row.file, opts.filePattern));
+  }
+  if (noTests) {
+    rows = rows.filter((row) => !TEST_PATTERN.test(row.file));
+  }
+
+  db.close();
+
+  const results = rows.slice(0, limit).map((row) => ({
+    name: row.name,
+    kind: row.kind,
+    file: row.file,
+    line: row.line,
+    bm25Score: -row.bm25_score, // FTS5 rank is negative; negate for display
+  }));
+
+  return { results };
+}
+
+/**
+ * Hybrid BM25 + semantic search with RRF fusion.
+ * Returns { results: [{ name, kind, file, line, rrf, bm25Score, bm25Rank, similarity, semanticRank }] }
+ * or null if no FTS5 index (caller should fall back to semantic-only).
+ */
+export async function hybridSearchData(query, customDbPath, opts = {}) {
+  const limit = opts.limit || 15;
+  const k = opts.rrfK || 60;
+  const topK = (opts.limit || 15) * 5;
+
+  // Split semicolons for multi-query support
+  const queries =
+    typeof query === 'string'
+      ? query
+          .split(';')
+          .map((q) => q.trim())
+          .filter((q) => q.length > 0)
+      : [query];
+
+  // Check FTS5 availability first (sync, cheap)
+  const checkDb = openReadonlyOrFail(customDbPath);
+  const ftsAvailable = hasFtsIndex(checkDb);
+  checkDb.close();
+  if (!ftsAvailable) return null;
+
+  // Collect ranked lists: for each query, one BM25 list + one semantic list
+  const rankedLists = [];
+
+  for (const q of queries) {
+    // BM25 ranked list (sync)
+    const bm25Data = ftsSearchData(q, customDbPath, { ...opts, limit: topK });
+    if (bm25Data?.results) {
+      rankedLists.push(
+        bm25Data.results.map((r, idx) => ({
+          key: `${r.name}:${r.file}:${r.line}`,
+          rank: idx + 1,
+          source: 'bm25',
+          ...r,
+        })),
+      );
+    }
+
+    // Semantic ranked list (async)
+    const semData = await searchData(q, customDbPath, {
+      ...opts,
+      limit: topK,
+      minScore: opts.minScore || 0.2,
+    });
+    if (semData?.results) {
+      rankedLists.push(
+        semData.results.map((r, idx) => ({
+          key: `${r.name}:${r.file}:${r.line}`,
+          rank: idx + 1,
+          source: 'semantic',
+          ...r,
+        })),
+      );
+    }
+  }
+
+  // RRF fusion across all ranked lists
+  const fusionMap = new Map();
+  for (const list of rankedLists) {
+    for (const item of list) {
+      if (!fusionMap.has(item.key)) {
+        fusionMap.set(item.key, {
+          name: item.name,
+          kind: item.kind,
+          file: item.file,
+          line: item.line,
+          rrfScore: 0,
+          bm25Score: null,
+          bm25Rank: null,
+          similarity: null,
+          semanticRank: null,
+        });
+      }
+      const entry = fusionMap.get(item.key);
+      entry.rrfScore += 1 / (k + item.rank);
+      if (item.source === 'bm25') {
+        if (entry.bm25Rank === null || item.rank < entry.bm25Rank) {
+          entry.bm25Score = item.bm25Score;
+          entry.bm25Rank = item.rank;
+        }
+      } else {
+        if (entry.semanticRank === null || item.rank < entry.semanticRank) {
+          entry.similarity = item.similarity;
+          entry.semanticRank = item.rank;
+        }
+      }
+    }
+  }
+
+  const results = [...fusionMap.values()]
+    .sort((a, b) => b.rrfScore - a.rrfScore)
+    .slice(0, limit)
+    .map((e) => ({
+      name: e.name,
+      kind: e.kind,
+      file: e.file,
+      line: e.line,
+      rrf: e.rrfScore,
+      bm25Score: e.bm25Score,
+      bm25Rank: e.bm25Rank,
+      similarity: e.similarity,
+      semanticRank: e.semanticRank,
+    }));
+
+  return { results };
+}
+
+/**
+ * Search with mode support — CLI wrapper with multi-query detection.
+ * Modes: 'hybrid' (default), 'semantic', 'keyword'
  */
 export async function search(query, customDbPath, opts = {}) {
+  const mode = opts.mode || 'hybrid';
+
   // Split by semicolons, trim, filter empties
   const queries = query
     .split(';')
     .map((q) => q.trim())
     .filter((q) => q.length > 0);
 
-  if (queries.length <= 1) {
-    // Single-query path — preserve original output format
-    const singleQuery = queries[0] || query;
-    const data = await searchData(singleQuery, customDbPath, opts);
-    if (!data) return;
+  const kindIcon = (kind) => (kind === 'function' ? 'f' : kind === 'class' ? '*' : 'o');
+
+  // ─── Keyword-only mode ──────────────────────────────────────────────
+  if (mode === 'keyword') {
+    const singleQuery = queries.length === 1 ? queries[0] : query;
+    const data = ftsSearchData(singleQuery, customDbPath, opts);
+    if (!data) {
+      console.log('No FTS5 index found. Run `codegraph embed` to build the keyword index.');
+      return;
+    }
 
     if (opts.json) {
       console.log(JSON.stringify(data, null, 2));
       return;
     }
 
-    console.log(`\nSemantic search: "${singleQuery}"\n`);
-
+    console.log(`\nKeyword search: "${singleQuery}" (BM25)\n`);
     if (data.results.length === 0) {
-      console.log('  No results above threshold.');
+      console.log('  No results found.');
     } else {
       for (const r of data.results) {
-        const bar = '#'.repeat(Math.round(r.similarity * 20));
-        const kindIcon = r.kind === 'function' ? 'f' : r.kind === 'class' ? '*' : 'o';
-        console.log(`  ${(r.similarity * 100).toFixed(1)}% ${bar}`);
-        console.log(`    ${kindIcon} ${r.name} -- ${r.file}:${r.line}`);
+        console.log(
+          `  BM25 ${r.bm25Score.toFixed(2)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
+        );
       }
     }
-
     console.log(`\n  ${data.results.length} results shown\n`);
-  } else {
-    // Multi-query path — RRF ranking
-    const data = await multiSearchData(queries, customDbPath, opts);
-    if (!data) return;
+    return;
+  }
 
-    if (opts.json) {
-      console.log(JSON.stringify(data, null, 2));
-      return;
-    }
+  // ─── Semantic-only mode ─────────────────────────────────────────────
+  if (mode === 'semantic') {
+    if (queries.length <= 1) {
+      const singleQuery = queries[0] || query;
+      const data = await searchData(singleQuery, customDbPath, opts);
+      if (!data) return;
 
-    console.log(`\nMulti-query semantic search (RRF, k=${opts.rrfK || 60}):`);
-    queries.forEach((q, i) => {
-      console.log(`  [${i + 1}] "${q}"`);
-    });
-    console.log();
+      if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
 
-    if (data.results.length === 0) {
-      console.log('  No results above threshold.');
+      console.log(`\nSemantic search: "${singleQuery}"\n`);
+      if (data.results.length === 0) {
+        console.log('  No results above threshold.');
+      } else {
+        for (const r of data.results) {
+          const bar = '#'.repeat(Math.round(r.similarity * 20));
+          console.log(`  ${(r.similarity * 100).toFixed(1)}% ${bar}`);
+          console.log(`    ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`);
+        }
+      }
+      console.log(`\n  ${data.results.length} results shown\n`);
     } else {
-      for (const r of data.results) {
-        const kindIcon = r.kind === 'function' ? 'f' : r.kind === 'class' ? '*' : 'o';
-        console.log(`  RRF ${r.rrf.toFixed(4)}  ${kindIcon} ${r.name} -- ${r.file}:${r.line}`);
-        for (const qs of r.queryScores) {
-          const bar = '#'.repeat(Math.round(qs.similarity * 20));
+      const data = await multiSearchData(queries, customDbPath, opts);
+      if (!data) return;
+
+      if (opts.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+
+      console.log(`\nMulti-query semantic search (RRF, k=${opts.rrfK || 60}):`);
+      for (let i = 0; i < queries.length; i++) console.log(`  [${i + 1}] "${queries[i]}"`);
+      console.log();
+      if (data.results.length === 0) {
+        console.log('  No results above threshold.');
+      } else {
+        for (const r of data.results) {
           console.log(
-            `    [${queries.indexOf(qs.query) + 1}] ${(qs.similarity * 100).toFixed(1)}% ${bar} (rank ${qs.rank})`,
+            `  RRF ${r.rrf.toFixed(4)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
           );
+          for (const qs of r.queryScores) {
+            const bar = '#'.repeat(Math.round(qs.similarity * 20));
+            console.log(
+              `    [${queries.indexOf(qs.query) + 1}] ${(qs.similarity * 100).toFixed(1)}% ${bar} (rank ${qs.rank})`,
+            );
+          }
         }
       }
+      console.log(`\n  ${data.results.length} results shown\n`);
     }
+    return;
+  }
 
-    console.log(`\n  ${data.results.length} results shown\n`);
+  // ─── Hybrid mode (default) ──────────────────────────────────────────
+  const data = await hybridSearchData(query, customDbPath, opts);
+
+  if (!data) {
+    // No FTS5 index — fall back to semantic-only
+    warn(
+      'FTS5 index not found — using semantic search only. Re-run `codegraph embed` to enable hybrid mode.',
+    );
+    return search(query, customDbPath, { ...opts, mode: 'semantic' });
   }
+
+  if (opts.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  const rrfK = opts.rrfK || 60;
+  if (queries.length <= 1) {
+    const singleQuery = queries[0] || query;
+    console.log(`\nHybrid search: "${singleQuery}" (BM25 + semantic, RRF k=${rrfK})\n`);
+  } else {
+    console.log(`\nHybrid multi-query search (BM25 + semantic, RRF k=${rrfK}):`);
+    for (let i = 0; i < queries.length; i++) console.log(`  [${i + 1}] "${queries[i]}"`);
+    console.log();
+  }
+
+  if (data.results.length === 0) {
+    console.log('  No results found.');
+  } else {
+    for (const r of data.results) {
+      console.log(
+        `  RRF ${r.rrf.toFixed(4)}  ${kindIcon(r.kind)} ${r.name} -- ${r.file}:${r.line}`,
+      );
+      const parts = [];
+      if (r.bm25Rank != null) {
+        parts.push(`BM25: rank ${r.bm25Rank} (score ${r.bm25Score.toFixed(2)})`);
+      }
+      if (r.semanticRank != null) {
+        parts.push(`Semantic: rank ${r.semanticRank} (${(r.similarity * 100).toFixed(1)}%)`);
+      }
+      if (parts.length > 0) {
+        console.log(`    ${parts.join('  |  ')}`);
+      }
+    }
+  }
+
+  console.log(`\n  ${data.results.length} results shown\n`);
 }