scip-query 0.1.0

package/src/queries/stats.ts

@@ -0,0 +1,22 @@
+import type { ScipDatabase } from '../db.js';
+import type { StatsResult } from '../types.js';
+
+export function stats(db: ScipDatabase): StatsResult {
+  const documents = db.get<{ c: number }>('SELECT COUNT(*) as c FROM documents')!.c;
+  const symbols = db.get<{ c: number }>('SELECT COUNT(*) as c FROM global_symbols')!.c;
+  const definitions = db.get<{ c: number }>(
+    'SELECT COUNT(*) as c FROM mentions WHERE role = 1',
+  )!.c;
+  const references = db.get<{ c: number }>(
+    'SELECT COUNT(*) as c FROM mentions WHERE role = 0',
+  )!.c;
+
+  return {
+    documents,
+    symbols,
+    definitions,
+    references,
+    indexSizeBytes: db.sizeBytes(),
+    lastBuilt: db.lastModified(),
+  };
+}

package/src/queries/surface.ts

@@ -0,0 +1,34 @@
+import type { ScipDatabase } from '../db.js';
+import type { SurfaceResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/** Public API surface: what symbols do external consumers actually use from this module? */
+export function surface(db: ScipDatabase, modulePattern: string): SurfaceResult[] {
+  const rows = db.all<{
+    relative_path: string;
+    symbol: string;
+  }>(
+    `SELECT DISTINCT d1.relative_path, gs.symbol
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d2 ON der.document_id = d2.id
+    WHERE d2.relative_path LIKE ?
+      AND d1.relative_path NOT LIKE ?
+      AND ${db.localSymbolPredicate}
+      AND m.role = 0
+    ORDER BY d1.relative_path`,
+    `%${modulePattern}%`,
+    `%${modulePattern}%`,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({
+      consumer: r.relative_path,
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+    }));
+}

package/src/queries/symbols.ts

@@ -0,0 +1,39 @@
+import type { ScipDatabase } from '../db.js';
+import type { SymbolResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+import { cleanSignature } from './clean-signature.js';
+
+export function symbols(db: ScipDatabase, filePattern: string): SymbolResult[] {
+  const rows = db.all<{
+    start_line: number;
+    end_line: number;
+    sig: string | null;
+    symbol: string;
+    relative_path: string;
+  }>(
+    `SELECT
+      der.start_line,
+      der.end_line,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig,
+      gs.symbol,
+      d.relative_path
+    FROM defn_enclosing_ranges der
+    JOIN global_symbols gs ON der.symbol_id = gs.id
+    JOIN documents d ON der.document_id = d.id
+    WHERE d.relative_path LIKE ?
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+    ORDER BY der.start_line`,
+    `%${filePattern}%`,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({
+      startLine: r.start_line,
+      endLine: r.end_line,
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      signature: cleanSignature(r.sig),
+    }));
+}

package/src/queries/system.ts

@@ -0,0 +1,86 @@
+import type { ScipDatabase } from '../db.js';
+import type { SystemResult, SymbolResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+import { cleanSignature } from './clean-signature.js';
+
+/** Full system map for a module path: files, symbols, deps in/out */
+export function system(db: ScipDatabase, modulePattern: string): SystemResult {
+  // Files in this module
+  const fileRows = db.all<{ relative_path: string }>(
+    `SELECT relative_path FROM documents
+     WHERE relative_path LIKE ?
+     ORDER BY relative_path`,
+    `%${modulePattern}%`,
+  );
+  const files = fileRows
+    .map((r) => r.relative_path)
+    .filter((p) => !db.isIgnored(p));
+
+  // Exported symbols
+  const symbolRows = db.all<{
+    start_line: number;
+    end_line: number;
+    symbol: string;
+    sig: string | null;
+  }>(
+    `SELECT der.start_line, der.end_line, gs.symbol,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
+    FROM defn_enclosing_ranges der
+    JOIN global_symbols gs ON der.symbol_id = gs.id
+    JOIN documents d ON der.document_id = d.id
+    WHERE d.relative_path LIKE ?
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+      AND gs.documentation IS NOT NULL
+    ORDER BY d.relative_path, der.start_line`,
+    `%${modulePattern}%`,
+  );
+  const symbols: SymbolResult[] = symbolRows.map((r) => ({
+    startLine: r.start_line,
+    endLine: r.end_line,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    signature: cleanSignature(r.sig),
+  }));
+
+  // Internal dependencies (what this module depends on)
+  const depRows = db.all<{ relative_path: string }>(
+    `SELECT DISTINCT d2.relative_path
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d2 ON der.document_id = d2.id
+    WHERE d1.relative_path LIKE ?
+      AND d2.relative_path NOT LIKE ?
+      AND ${db.localSymbolPredicate}
+    ORDER BY d2.relative_path`,
+    `%${modulePattern}%`,
+    `%${modulePattern}%`,
+  );
+  const dependsOn = depRows
+    .map((r) => r.relative_path)
+    .filter((p) => !db.isIgnored(p));
+
+  // Reverse dependencies (who depends on this module)
+  const rdepRows = db.all<{ relative_path: string }>(
+    `SELECT DISTINCT d1.relative_path
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d2 ON der.document_id = d2.id
+    WHERE d2.relative_path LIKE ?
+      AND d1.relative_path NOT LIKE ?
+    ORDER BY d1.relative_path`,
+    `%${modulePattern}%`,
+    `%${modulePattern}%`,
+  );
+  const dependedOnBy = rdepRows
+    .map((r) => r.relative_path)
+    .filter((p) => !db.isIgnored(p));
+
+  return { files, symbols, dependsOn, dependedOnBy };
+}

package/src/queries/test-coverage.ts

@@ -0,0 +1,106 @@
+import type { ScipDatabase } from '../db.js';
+import { TEST_FILE_PATTERNS, testFileExclusionSql, testFileMatchSql } from '../query-support.js';
+import type { TestCoverageResult } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Check if a symbol is referenced by any test file.
+ * Reports which test files cover (reference) each matching symbol.
+ */
+export function testCoverage(
+  db: ScipDatabase,
+  symbolPattern: string,
+): TestCoverageResult[] {
+  // Find matching symbols
+  const syms = db.all<{
+    id: number;
+    symbol: string;
+    relative_path: string;
+  }>(
+    `SELECT gs.id, gs.symbol, d.relative_path
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE gs.symbol LIKE ?
+      ${db.pathExclusionsFor('d')}
+      ${db.symbolNoiseFor('gs')}
+    ORDER BY d.relative_path`,
+    `%${symbolPattern}%`,
+  );
+
+  const testPatternSql = testFileMatchSql('ref_d', TEST_FILE_PATTERNS);
+
+  return syms
+    .filter((s) => !db.isIgnored(s.relative_path))
+    .map((s) => {
+      // Find test files that reference this symbol
+      const testFiles = db.all<{ relative_path: string }>(
+        `SELECT DISTINCT ref_d.relative_path
+        FROM mentions m
+        JOIN chunks c ON m.chunk_id = c.id
+        JOIN documents ref_d ON c.document_id = ref_d.id
+        WHERE m.symbol_id = ?
+          AND m.role = 0
+          AND (${testPatternSql})
+        ORDER BY ref_d.relative_path`,
+        s.id,
+      ).map((r) => r.relative_path);
+
+      return {
+        symbol: s.symbol,
+        shortName: shortenSymbol(s.symbol),
+        definedIn: s.relative_path,
+        testFiles,
+        covered: testFiles.length > 0,
+      };
+    });
+}
+
+/**
+ * Summary: what percentage of symbols in scope are referenced by test files?
+ */
+export function testCoverageSummary(
+  db: ScipDatabase,
+  opts: { scope?: string; minLoc?: number } = {},
+): { total: number; covered: number; uncovered: number; percent: number } {
+  const { scope, minLoc = 3 } = opts;
+  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : '';
+  const testPatternSql = testFileExclusionSql('d');
+
+  const symbols = db.all<{ id: number }>(
+    `SELECT gs.id
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE 1 = 1
+      ${db.pathExclusionsFor('d')}
+      AND ${testPatternSql}
+      ${db.symbolNoiseFor('gs')}
+      AND gs.symbol NOT LIKE '%#%'
+      AND (der.end_line - der.start_line + 1) >= ?
+      ${scopeFilter}`,
+    minLoc,
+  );
+
+  const testRefSql = testFileMatchSql('ref_d', TEST_FILE_PATTERNS);
+
+  let covered = 0;
+  for (const s of symbols) {
+    const hasTest = db.get<{ c: number }>(
+      `SELECT COUNT(*) AS c FROM mentions m
+       JOIN chunks c ON m.chunk_id = c.id
+       JOIN documents ref_d ON c.document_id = ref_d.id
+       WHERE m.symbol_id = ? AND m.role = 0 AND (${testRefSql})`,
+      s.id,
+    );
+    if (hasTest && hasTest.c > 0) covered++;
+  }
+
+  const total = symbols.length;
+  return {
+    total,
+    covered,
+    uncovered: total - covered,
+    percent: total > 0 ? Math.round((covered / total) * 100) : 0,
+  };
+}

package/src/queries/trace.ts

@@ -0,0 +1,55 @@
+import type { ScipDatabase } from '../db.js';
+import type { TraceResult } from '../types.js';
+import { cleanSignature } from './clean-signature.js';
+
+export function trace(db: ScipDatabase, symbolPattern: string): TraceResult {
+  // Definitions
+  const defRows = db.all<{
+    relative_path: string;
+    start_line: number;
+    end_line: number;
+    sig: string | null;
+  }>(
+    `SELECT d.relative_path, der.start_line, der.end_line,
+      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
+    FROM global_symbols gs
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d ON der.document_id = d.id
+    WHERE gs.symbol LIKE ?
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+    ORDER BY d.relative_path, der.start_line
+    LIMIT 10`,
+    `%${symbolPattern}%`,
+  );
+
+  const definitions = defRows
+    .filter((r) => !db.isIgnored(r.relative_path))
+    .map((r) => ({
+      relativePath: r.relative_path,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      signature: cleanSignature(r.sig),
+    }));
+
+  // References
+  const refRows = db.all<{ relative_path: string }>(
+    `SELECT DISTINCT d.relative_path
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE gs.symbol LIKE ?
+      AND ${db.localSymbolPredicate}
+      ${db.symbolNoise}
+      AND m.role = 0
+    ORDER BY d.relative_path`,
+    `%${symbolPattern}%`,
+  );
+
+  const referencedBy = refRows
+    .map((r) => r.relative_path)
+    .filter((p) => !db.isIgnored(p));
+
+  return { definitions, referencedBy };
+}

package/src/queries/wrapper-candidates.ts

@@ -0,0 +1,112 @@
+import type { ScipDatabase } from '../db.js';
+import { testFileExclusionSql } from '../query-support.js';
+import type { WrapperCandidate } from '../types.js';
+import { shortenSymbol } from '../symbol-parser.js';
+
+/**
+ * Find wrapper candidates: symbols called by only one other symbol.
+ *
+ * These are premature abstractions that add indirection without
+ * providing reuse. A function with fan-in = 1 whose sole caller
+ * is widely used is a strong signal of unnecessary wrapping.
+ */
+export function wrapperCandidates(
+  db: ScipDatabase,
+  opts?: { scope?: string; maxLoc?: number; limit?: number },
+): WrapperCandidate[] {
+  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
+  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : '';
+
+  // Find all symbols with exactly 1 cross-file consumer (fan-in = 1),
+  // along with who that single caller is and the caller's own fan-in.
+  const rows = db.all<{
+    symbol: string;
+    file: string;
+    start_line: number;
+    end_line: number;
+    loc: number;
+    caller_symbol: string;
+    caller_fan_in: number;
+  }>(
+    `SELECT * FROM (
+      SELECT
+        gs.symbol,
+        d.relative_path AS file,
+        der.start_line,
+        der.end_line,
+        (der.end_line - der.start_line + 1) AS loc,
+        -- The single caller: the symbol whose definition range contains
+        -- the chunk that references our target
+        (SELECT caller_gs.symbol
+         FROM mentions ref_m
+         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+         JOIN defn_enclosing_ranges caller_der
+           ON caller_der.document_id = ref_c.document_id
+           AND ref_c.start_line >= caller_der.start_line
+           AND ref_c.end_line <= caller_der.end_line
+         JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
+         WHERE ref_m.symbol_id = gs.id
+           AND ref_m.role = 0
+           AND ref_c.document_id != der.document_id
+         LIMIT 1
+        ) AS caller_symbol,
+        -- Fan-in of that single caller
+        (SELECT COUNT(DISTINCT caller_ref_c.document_id)
+         FROM mentions caller_ref_m
+         JOIN chunks caller_ref_c ON caller_ref_m.chunk_id = caller_ref_c.id
+         WHERE caller_ref_m.symbol_id = (
+           SELECT caller_der2.symbol_id
+           FROM mentions ref_m2
+           JOIN chunks ref_c2 ON ref_m2.chunk_id = ref_c2.id
+           JOIN defn_enclosing_ranges caller_der2
+             ON caller_der2.document_id = ref_c2.document_id
+             AND ref_c2.start_line >= caller_der2.start_line
+             AND ref_c2.end_line <= caller_der2.end_line
+           WHERE ref_m2.symbol_id = gs.id
+             AND ref_m2.role = 0
+             AND ref_c2.document_id != der.document_id
+           LIMIT 1
+         )
+         AND caller_ref_m.role = 0
+        ) AS caller_fan_in
+      FROM global_symbols gs
+      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+      JOIN documents d ON der.document_id = d.id
+      WHERE 1 = 1
+        ${db.pathExclusionsFor('d')}
+        AND ${testFileExclusionSql('d')}
+        ${db.symbolNoiseFor('gs')}
+        -- Only functions/terms, not type definitions (types with # are not wrappers)
+        AND gs.symbol NOT LIKE '%#'
+        AND (der.end_line - der.start_line + 1) <= ?
+        AND (der.end_line - der.start_line + 1) >= 2
+        ${scopeFilter}
+        -- Exactly 1 cross-file consumer
+        AND (
+          SELECT COUNT(DISTINCT ref_c.document_id)
+          FROM mentions ref_m
+          JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+          WHERE ref_m.symbol_id = gs.id
+            AND ref_m.role = 0
+            AND ref_c.document_id != der.document_id
+        ) = 1
+    ) WHERE caller_symbol IS NOT NULL AND caller_fan_in > 3
+    ORDER BY caller_fan_in DESC, loc DESC
+    LIMIT ?`,
+    maxLoc, limit,
+  );
+
+  return rows
+    .filter((r) => !db.isIgnored(r.file))
+    .map((r) => ({
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      file: r.file,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      loc: r.loc,
+      singleCaller: r.caller_symbol,
+      singleCallerShort: shortenSymbol(r.caller_symbol),
+      callerFanIn: r.caller_fan_in,
+    }));
+}

package/src/query-support.ts

@@ -0,0 +1,226 @@
+import type { ScipDatabase } from './db.js';
+
+export interface SymbolLocation {
+  documentId: number;
+  startLine: number;
+  endLine: number;
+  symbolId: number;
+}
+
+export interface SymbolMatch extends SymbolLocation {
+  symbol: string;
+  relativePath: string;
+}
+
+export interface CalleeRow {
+  symbol: string;
+  file: string;
+  chunkId: number;
+}
+
+export const TEST_FILE_PATTERNS = [
+  '%/__tests__/%',
+  '%.test.%',
+  '%.spec.%',
+  '%/test/%',
+  '%/tests/%',
+  '%_test.%',
+  '%_spec.%',
+  '%/test_%.%',
+  '%/spec_%.%',
+] as const;
+
+export const TEST_SUPPORT_PATH_PATTERNS = [
+  '%/test-utils/%',
+] as const;
+
+export function testFileMatchSql(
+  alias: string,
+  patterns: readonly string[] = TEST_FILE_PATTERNS,
+): string {
+  return `(${patterns.map((pattern) => `${alias}.relative_path LIKE '${pattern}'`).join(' OR ')})`;
+}
+
+export function testFileExclusionSql(
+  alias: string,
+  extraPatterns: readonly string[] = [],
+): string {
+  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
+  return patterns
+    .map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`)
+    .join('\n      AND ');
+}
+
+export function buildFileDepGraph(
+  db: ScipDatabase,
+  scope?: string,
+): Map<string, Set<string>> {
+  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : '';
+
+  const edges = db.all<{ from_file: string; to_file: string }>(
+    `SELECT DISTINCT
+      d1.relative_path AS from_file,
+      d2.relative_path AS to_file
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d2 ON der.document_id = d2.id
+    WHERE d1.id != d2.id
+      AND m.role = 0
+      ${db.pathExclusionsFor('d1', 'd2')}
+      ${scopeFilter}`,
+  );
+
+  const graph = new Map<string, Set<string>>();
+  for (const edge of edges) {
+    if (db.isIgnored(edge.from_file) || db.isIgnored(edge.to_file)) continue;
+    if (!graph.has(edge.from_file)) graph.set(edge.from_file, new Set());
+    graph.get(edge.from_file)!.add(edge.to_file);
+  }
+
+  return graph;
+}
+
+export function findFirstSymbolMatch(
+  db: ScipDatabase,
+  symbolPattern: string,
+): SymbolMatch | null {
+  // Handle file:line-line syntax (e.g., "src/foo.ts:10-50")
+  const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
+  if (fileLineMatch) {
+    const [, filePath, startStr, endStr] = fileLineMatch;
+    const row = db.get<{
+      id: number;
+      symbol: string;
+      document_id: number;
+      start_line: number;
+      end_line: number;
+      relative_path: string;
+    }>(
+      `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+      FROM global_symbols gs
+      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+      JOIN documents d ON der.document_id = d.id
+      WHERE d.relative_path LIKE ?
+        AND der.start_line <= ? AND der.end_line >= ?
+        ${db.pathExclusionsFor('d')}
+      ORDER BY (der.end_line - der.start_line) ASC
+      LIMIT 1`,
+      `%${filePath}%`, parseInt(startStr!, 10), parseInt(endStr!, 10),
+    );
+    if (row && !db.isIgnored(row.relative_path)) {
+      return {
+        symbolId: row.id,
+        symbol: row.symbol,
+        documentId: row.document_id,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        relativePath: row.relative_path,
+      };
+    }
+  }
+
+  // Strip parentheses from the pattern to avoid shell escaping issues.
+  // Agents often pass "functionName()" — strip the () for matching.
+  const cleaned = symbolPattern.replace(/\(\)$/, '').replace(/\(.*$/, '');
+
+  // Try exact-ish match first (with noise filter), then fallback without noise filter.
+  // The noise filter excludes %().(%  which can incorrectly match some symbols.
+  for (const useNoiseFilter of [true, false]) {
+    const noiseClause = useNoiseFilter ? db.symbolNoiseFor('gs') : '';
+    const row = db.get<{
+      id: number;
+      symbol: string;
+      document_id: number;
+      start_line: number;
+      end_line: number;
+      relative_path: string;
+    }>(
+      `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+      FROM global_symbols gs
+      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+      JOIN documents d ON der.document_id = d.id
+      WHERE gs.symbol LIKE ?
+        ${db.pathExclusionsFor('d')}
+        ${noiseClause}
+      ORDER BY (der.end_line - der.start_line) DESC
+      LIMIT 1`,
+      `%${cleaned}%`,
+    );
+
+    if (row && !db.isIgnored(row.relative_path)) {
+      return {
+        symbolId: row.id,
+        symbol: row.symbol,
+        documentId: row.document_id,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        relativePath: row.relative_path,
+      };
+    }
+  }
+
+  return null;
+}
+
+export function getCalleeRowsForSymbol(
+  db: ScipDatabase,
+  symbol: SymbolLocation,
+  opts: { limit?: number } = {},
+): CalleeRow[] {
+  const rows = db.all<{
+    symbol: string;
+    file: string;
+    chunk_id: number;
+  }>(
+    `SELECT DISTINCT
+      callee_gs.symbol AS symbol,
+      callee_d.relative_path AS file,
+      c.id AS chunk_id
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN global_symbols callee_gs ON m.symbol_id = callee_gs.id
+    JOIN defn_enclosing_ranges callee_der ON callee_gs.id = callee_der.symbol_id
+    JOIN documents callee_d ON callee_der.document_id = callee_d.id
+    WHERE c.document_id = ?
+      AND c.start_line >= ?
+      AND c.end_line <= ?
+      AND m.role = 0
+      AND callee_gs.id != ?
+      ${db.symbolNoiseFor('callee_gs')}
+      ${db.pathExclusionsFor('callee_d')}
+    ORDER BY callee_d.relative_path
+    ${opts.limit ? 'LIMIT ?' : ''}`,
+    ...calleeQueryParams(symbol, opts.limit),
+  );
+
+  return rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
+    symbol: row.symbol,
+    file: row.file,
+    chunkId: row.chunk_id,
+  }));
+}
+
+function calleeQueryParams(
+  symbol: SymbolLocation,
+  limit?: number,
+): number[] {
+  const params = [
+    symbol.documentId,
+    symbol.startLine,
+    symbol.endLine,
+    symbol.symbolId,
+  ];
+
+  if (typeof limit === 'number') {
+    params.push(limit);
+  }
+
+  return params;
+}
+
+function uniquePatterns(patterns: readonly string[]): string[] {
+  return [...new Set(patterns)];
+}