scip-query 0.2.1 → 0.3.1

package/dist/chunk-34JPTNRN.js

@@ -1,601 +0,0 @@
-import {
-  findFirstSymbolMatch
-} from "./chunk-LLMPAG56.js";
-import {
-  isModuleLikeSymbol,
-  leafName,
-  shortenSymbol
-} from "./chunk-QIXNAB5K.js";
-
-// src/source-analysis.ts
-import {
-  existsSync,
-  readFileSync
-} from "fs";
-import {
-  dirname,
-  extname,
-  join,
-  relative,
-  resolve
-} from "path";
-var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
-var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
-var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
-function getSourceImports(db, relativePath) {
-  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
-  const normalized = normalizePath(relativePath);
-  const cached = cache.get(normalized);
-  if (cached) {
-    return cached;
-  }
-  const fullPath = join(db.config.projectRoot, normalized);
-  if (!existsSync(fullPath)) {
-    cache.set(normalized, []);
-    return [];
-  }
-  const source = readFileSync(fullPath, "utf-8");
-  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : parseJavaScriptImports(db, normalized, source);
-  cache.set(normalized, parsed);
-  return parsed;
-}
-function parseJavaScriptImports(db, importerPath, source) {
-  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
-    db,
-    importerPath,
-    statement.clause,
-    statement.specifier,
-    statement.start,
-    statement.end,
-    source
-  ));
-}
-function parseJavaScriptImportStatements(source) {
-  const statements = [];
-  const importFromRegex = /^[ \t]*import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
-  for (const match of source.matchAll(importFromRegex)) {
-    const full = match[0];
-    const clause = match[1];
-    const specifier = match[2];
-    if (!full || !specifier || typeof match.index !== "number") continue;
-    statements.push({
-      clause,
-      specifier,
-      start: match.index,
-      end: match.index + full.length
-    });
-  }
-  const sideEffectRegex = /^[ \t]*import\s+['"]([^'"]+)['"]\s*;?/gm;
-  for (const match of source.matchAll(sideEffectRegex)) {
-    const full = match[0];
-    const specifier = match[1];
-    if (!full || !specifier || typeof match.index !== "number") continue;
-    statements.push({
-      clause: null,
-      specifier,
-      start: match.index,
-      end: match.index + full.length
-    });
-  }
-  return statements.sort((a, b) => a.start - b.start);
-}
-function parseJavaScriptImportStatement(db, importerPath, clause, specifier, start, end, source) {
-  const resolvedSource = resolveImportPath(db, importerPath, specifier);
-  const body = buildUsageBody(source, start, end);
-  if (!clause) {
-    return [{
-      importedName: "*",
-      localName: null,
-      sourcePath: resolvedSource,
-      kind: "side-effect",
-      used: true,
-      usedMembers: []
-    }];
-  }
-  const bindings = parseImportClause(clause).map((binding) => ({
-    ...binding,
-    sourcePath: resolvedSource
-  }));
-  return bindings.map((binding) => {
-    if (binding.kind === "namespace") {
-      const usedMembers = collectNamespaceMembers(body, binding.localName);
-      return {
-        ...binding,
-        used: usedMembers.length > 0 || hasIdentifierUsage(body, binding.localName),
-        usedMembers
-      };
-    }
-    if (binding.kind === "side-effect") {
-      return { ...binding, used: true, usedMembers: [] };
-    }
-    return {
-      ...binding,
-      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
-      usedMembers: []
-    };
-  });
-}
-function parsePythonImports(db, importerPath, source) {
-  return collectPythonImportStatements(source).flatMap(
-    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
-  );
-}
-function collectPythonImportStatements(source) {
-  const lines = source.split("\n");
-  const statements = [];
-  let offset = 0;
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
-    const line = lines[lineIndex];
-    const trimmed = line.trimStart();
-    const lineStart = offset;
-    offset += line.length + 1;
-    if (!trimmed.startsWith("import ") && !trimmed.startsWith("from ")) {
-      continue;
-    }
-    let statement = line;
-    let statementEnd = lineStart + line.length;
-    let balance = pythonParenBalance(line);
-    while (lineIndex + 1 < lines.length && (balance > 0 || statement.trimEnd().endsWith("\\"))) {
-      lineIndex++;
-      const nextLine = lines[lineIndex];
-      statement += `
-${nextLine}`;
-      statementEnd += 1 + nextLine.length;
-      balance += pythonParenBalance(nextLine);
-      offset += nextLine.length + 1;
-    }
-    const parsed = parsePythonStatementHeader(statement);
-    if (parsed) {
-      statements.push({
-        ...parsed,
-        start: lineStart,
-        end: statementEnd
-      });
-    }
-  }
-  return statements;
-}
-function parsePythonStatementHeader(statement) {
-  const normalized = statement.replace(/\\\s*\n/g, " ").trim();
-  if (normalized.startsWith("import ")) {
-    return {
-      kind: "import",
-      module: null,
-      clause: normalized.slice("import ".length).trim()
-    };
-  }
-  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
-  if (!fromMatch) {
-    return null;
-  }
-  let clause = fromMatch[2].trim();
-  if (clause.startsWith("(") && clause.endsWith(")")) {
-    clause = clause.slice(1, -1).trim();
-  }
-  return {
-    kind: "from",
-    module: fromMatch[1],
-    clause
-  };
-}
-function parsePythonImportStatement(db, importerPath, statement, source) {
-  const body = buildUsageBody(source, statement.start, statement.end);
-  const normalizedClause = statement.clause.replace(/\n/g, " ").trim();
-  if (statement.kind === "import") {
-    return splitTopLevel(normalizedClause).flatMap((entry) => {
-      const cleaned = entry.trim().replace(/,$/, "");
-      if (!cleaned) return [];
-      const [moduleName, alias] = cleaned.split(/\s+as\s+/);
-      const importedName = moduleName.trim();
-      const localName = (alias ?? importedName.split(".")[0] ?? importedName).trim();
-      const sourcePath2 = resolvePythonImportPath(db, importerPath, importedName);
-      const usedMembers = collectNamespaceMembers(body, localName);
-      return [{
-        importedName,
-        localName,
-        sourcePath: sourcePath2,
-        kind: "namespace",
-        used: hasIdentifierUsage(body, localName) || usedMembers.length > 0,
-        usedMembers
-      }];
-    });
-  }
-  const sourcePath = statement.module ? resolvePythonImportPath(db, importerPath, statement.module) : null;
-  const results = [];
-  for (const entry of splitTopLevel(normalizedClause)) {
-    const cleaned = entry.trim().replace(/,$/, "");
-    if (!cleaned) continue;
-    if (cleaned === "*") {
-      results.push({
-        importedName: "*",
-        localName: null,
-        sourcePath,
-        kind: "side-effect",
-        used: true,
-        usedMembers: []
-      });
-      continue;
-    }
-    const [importedName, alias] = cleaned.split(/\s+as\s+/);
-    const localName = (alias ?? importedName).trim();
-    results.push({
-      importedName: importedName.trim(),
-      localName,
-      sourcePath,
-      kind: "named",
-      used: hasIdentifierUsage(body, localName),
-      usedMembers: []
-    });
-  }
-  return results;
-}
-function parseImportClause(clause) {
-  const trimmed = clause.trim().replace(/^type\s+/, "");
-  const [first, second] = splitImportClause(trimmed);
-  const entries = [];
-  if (first) {
-    entries.push(...parseImportBinding(first));
-  }
-  if (second) {
-    entries.push(...parseImportBinding(second));
-  }
-  return entries;
-}
-function parseImportBinding(binding) {
-  const trimmed = binding.trim();
-  if (!trimmed) return [];
-  if (trimmed.startsWith("{")) {
-    const inner = trimmed.slice(1, -1).trim();
-    if (!inner) return [];
-    return splitTopLevel(inner).map((entry) => {
-      const cleaned = entry.trim().replace(/^type\s+/, "");
-      const [importedName, alias] = cleaned.split(/\s+as\s+/);
-      return {
-        importedName: importedName.trim(),
-        localName: (alias ?? importedName).trim(),
-        kind: "named"
-      };
-    });
-  }
-  if (trimmed.startsWith("* as ")) {
-    return [{
-      importedName: "*",
-      localName: trimmed.slice(5).trim(),
-      kind: "namespace"
-    }];
-  }
-  return [{
-    importedName: "default",
-    localName: trimmed,
-    kind: "default"
-  }];
-}
-function splitImportClause(clause) {
-  let depth = 0;
-  for (let i = 0; i < clause.length; i++) {
-    const char = clause[i];
-    if (char === "{") depth++;
-    if (char === "}") depth--;
-    if (char === "," && depth === 0) {
-      return [clause.slice(0, i).trim(), clause.slice(i + 1).trim()];
-    }
-  }
-  return [clause.trim(), null];
-}
-function splitTopLevel(input) {
-  const parts = [];
-  let depth = 0;
-  let start = 0;
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    if (char === "{" || char === "[" || char === "(") depth++;
-    if (char === "}" || char === "]" || char === ")") depth--;
-    if (char === "," && depth === 0) {
-      parts.push(input.slice(start, i));
-      start = i + 1;
-    }
-  }
-  parts.push(input.slice(start));
-  return parts;
-}
-function buildUsageBody(source, start, end) {
-  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
-  return stripCommentsAndStrings(masked);
-}
-function stripCommentsAndStrings(source) {
-  return source.replace(/'''[\s\S]*?'''/g, " ").replace(/"""[\s\S]*?"""/g, " ").replace(/#.*$/gm, " ").replace(/\/\/.*$/gm, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/`(?:\\[\s\S]|[^`])*`/g, " ").replace(/'(?:\\.|[^'\\\r\n])*'/g, " ").replace(/"(?:\\.|[^"\\\r\n])*"/g, " ");
-}
-function hasIdentifierUsage(body, identifier) {
-  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
-}
-function collectNamespaceMembers(body, namespaceName) {
-  const members = /* @__PURE__ */ new Set();
-  const regex = new RegExp(`\\b${escapeRegex(namespaceName)}\\s*\\.\\s*([A-Za-z_$][\\w$]*)`, "g");
-  for (const match of body.matchAll(regex)) {
-    const member = match[1];
-    if (member) {
-      members.add(member);
-    }
-  }
-  return [...members];
-}
-function resolveImportPath(db, importerPath, specifier) {
-  if (isPythonSourcePath(importerPath)) {
-    return resolvePythonImportPath(db, importerPath, specifier);
-  }
-  return resolveJavaScriptImportPath(db, importerPath, specifier);
-}
-function resolveJavaScriptImportPath(db, importerPath, specifier) {
-  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-    return null;
-  }
-  const importerDir = dirname(join(db.config.projectRoot, importerPath));
-  const absolute = resolve(importerDir, specifier);
-  const indexedPaths = getIndexedPaths(db);
-  for (const candidate of candidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return normalizePath(relative(db.config.projectRoot, absolute));
-}
-function resolvePythonImportPath(db, importerPath, specifier) {
-  const indexedPaths = getIndexedPaths(db);
-  let basePath;
-  if (specifier.startsWith(".")) {
-    const match = specifier.match(/^(\.+)(.*)$/);
-    if (!match) return null;
-    const dots = match[1].length;
-    const remainder = match[2].replace(/^\./, "");
-    let baseDir = dirname(join(db.config.projectRoot, importerPath));
-    for (let i = 1; i < dots; i++) {
-      baseDir = dirname(baseDir);
-    }
-    basePath = remainder ? resolve(baseDir, remainder.replace(/\./g, "/")) : baseDir;
-  } else {
-    basePath = resolve(db.config.projectRoot, specifier.replace(/\./g, "/"));
-  }
-  for (const candidate of pythonCandidateImportPaths(basePath)) {
-    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
-    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
-      return relativeCandidate;
-    }
-  }
-  return null;
-}
-function pythonCandidateImportPaths(basePath) {
-  const ext = extname(basePath);
-  if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
-    return [basePath];
-  }
-  return [
-    `${basePath}.py`,
-    `${basePath}.pyi`,
-    join(basePath, "__init__.py"),
-    join(basePath, "__init__.pyi")
-  ];
-}
-function candidateImportPaths(absolute) {
-  const ext = extname(absolute);
-  const candidates = /* @__PURE__ */ new Set();
-  if (ext) {
-    candidates.add(absolute);
-    for (const sourceExt of SOURCE_EXTENSIONS) {
-      candidates.add(absolute.slice(0, -ext.length) + sourceExt);
-    }
-  } else {
-    for (const sourceExt of SOURCE_EXTENSIONS) {
-      candidates.add(`${absolute}${sourceExt}`);
-      candidates.add(join(absolute, `index${sourceExt}`));
-    }
-  }
-  return [...candidates];
-}
-function getIndexedPaths(db) {
-  const cached = INDEXED_PATH_CACHE.get(db);
-  if (cached) {
-    return cached;
-  }
-  const paths = new Set(
-    db.all(
-      `SELECT relative_path
-       FROM documents
-       WHERE 1 = 1
-         ${db.pathExclusionsFor("documents")}`
-    ).map((row) => normalizePath(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
-  );
-  INDEXED_PATH_CACHE.set(db, paths);
-  return paths;
-}
-function getCachedMap(cache, db) {
-  let map = cache.get(db);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    cache.set(db, map);
-  }
-  return map;
-}
-function normalizePath(path) {
-  return path.replace(/\\/g, "/");
-}
-function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
-}
-function pythonParenBalance(value) {
-  let balance = 0;
-  for (const char of value) {
-    if (char === "(") balance++;
-    if (char === ")") balance--;
-  }
-  return balance;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/queries/imports.ts
-function imports(db, filePattern) {
-  const rows = db.all(
-    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file, imp_d.relative_path AS importer
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents imp_d ON c.document_id = imp_d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    LEFT JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    LEFT JOIN documents def_d ON der.document_id = def_d.id
-    WHERE imp_d.relative_path LIKE ?
-      AND m.role = 2
-    ORDER BY def_d.relative_path, gs.symbol`,
-    `%${filePattern}%`
-  );
-  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    fromFile: r.from_file ?? "(external)"
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  const importer = findIndexedFile(db, filePattern);
-  if (!importer) return [];
-  return getSourceImports(db, importer).map((entry) => ({
-    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    fromFile: entry.sourcePath ?? "(external)"
-  }));
-}
-function importedBy(db, symbolPattern) {
-  const rows = db.all(
-    `SELECT DISTINCT gs.symbol, d.relative_path AS importer
-    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 m.role = 2
-    ORDER BY d.relative_path`,
-    `%${symbolPattern}%`
-  );
-  const indexedResults = rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    fromFile: r.importer
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  const target = findFirstSymbolMatch(db, symbolPattern);
-  const targetFile = target?.relativePath ?? null;
-  const targetLeaf = target ? leafName(target.symbol) : symbolPattern.replace(/\(\)$/, "");
-  const targetIsModule = target ? isModuleLikeSymbol(target.symbol) : false;
-  const files = db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-     ORDER BY relative_path`
-  );
-  const importers = /* @__PURE__ */ new Set();
-  for (const row of files) {
-    if (db.isIgnored(row.relative_path)) continue;
-    for (const entry of getSourceImports(db, row.relative_path)) {
-      if (!entry.sourcePath) continue;
-      if (targetFile && normalizePath2(entry.sourcePath) !== normalizePath2(targetFile)) {
-        continue;
-      }
-      if (targetIsModule) {
-        importers.add(row.relative_path);
-        continue;
-      }
-      if (entry.kind === "named" && entry.importedName === targetLeaf) {
-        importers.add(row.relative_path);
-        continue;
-      }
-      if (entry.kind === "namespace" && entry.usedMembers.includes(targetLeaf)) {
-        importers.add(row.relative_path);
-      }
-    }
-  }
-  return [...importers].sort().map((importer) => ({
-    symbol: target?.symbol ?? targetLeaf,
-    shortName: target ? shortenSymbol(target.symbol) : targetLeaf,
-    fromFile: importer
-  }));
-}
-function unusedImports(db, filePattern) {
-  const rows = db.all(
-    `SELECT gs.symbol, d.relative_path AS imported_in, d.relative_path AS importer
-    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 d.relative_path LIKE ?
-      AND m.role = 2
-      AND NOT EXISTS (
-        SELECT 1
-        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 != 1
-          AND ref_c.document_id = d.id
-      )
-    ORDER BY d.relative_path, gs.symbol`,
-    `%${filePattern}%`
-  );
-  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    importedIn: r.imported_in
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  const importer = findIndexedFile(db, filePattern);
-  if (!importer) return [];
-  return getSourceImports(db, importer).filter((entry) => entry.kind !== "side-effect" && !entry.used).map((entry) => ({
-    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    importedIn: importer
-  }));
-}
-function findIndexedFile(db, filePattern) {
-  const doc = db.get(
-    `SELECT relative_path
-     FROM documents
-     WHERE relative_path LIKE ?
-       ${db.pathExclusionsFor("documents")}
-     LIMIT 1`,
-    `%${filePattern}%`
-  );
-  if (!doc || db.isIgnored(doc.relative_path)) {
-    return null;
-  }
-  return doc.relative_path;
-}
-function renderImportSymbol(importedName, localName, kind) {
-  if (kind === "namespace" && importedName === "*" && localName) {
-    return `* as ${localName}`;
-  }
-  if (kind === "default" && localName) {
-    return `default as ${localName}`;
-  }
-  if (kind === "side-effect") {
-    return "(side effect import)";
-  }
-  if (localName && localName !== importedName) {
-    return `${importedName} as ${localName}`;
-  }
-  return importedName;
-}
-function normalizePath2(path) {
-  return path.replace(/\\/g, "/");
-}
-
-export {
-  imports,
-  importedBy,
-  unusedImports
-};
-//# sourceMappingURL=chunk-34JPTNRN.js.map

package/dist/chunk-7JFZSOJ7.js

@@ -1,103 +0,0 @@
-import {
-  findFirstSymbolMatch
-} from "./chunk-LLMPAG56.js";
-import {
-  shortenSymbol
-} from "./chunk-QIXNAB5K.js";
-
-// src/queries/dataflow.ts
-function dataflow(db, symbolPattern) {
-  const match = findFirstSymbolMatch(db, symbolPattern);
-  if (!match) return null;
-  const defSites = db.all(
-    `SELECT d.relative_path AS file, c.start_line AS line
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    WHERE m.symbol_id = ? AND m.role = 1
-    ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const usageSites = db.all(
-    `SELECT d.relative_path AS file, c.start_line AS line,
-      (SELECT enc_gs.symbol
-       FROM defn_enclosing_ranges enc_der
-       JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-       WHERE enc_der.document_id = d.id
-         AND enc_der.start_line <= c.start_line
-         AND enc_der.end_line >= c.end_line
-       ORDER BY (enc_der.end_line - enc_der.start_line) ASC
-       LIMIT 1
-      ) AS enclosing_symbol
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    WHERE m.symbol_id = ? AND m.role != 1
-      ${db.pathExclusionsFor("d")}
-    ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const producers = db.all(
-    `SELECT DISTINCT other_gs.symbol, other_d.relative_path AS file
-    FROM mentions other_m
-    JOIN chunks other_c ON other_m.chunk_id = other_c.id
-    JOIN global_symbols other_gs ON other_m.symbol_id = other_gs.id
-    JOIN defn_enclosing_ranges other_der ON other_gs.id = other_der.symbol_id
-    JOIN documents other_d ON other_der.document_id = other_d.id
-    WHERE other_c.document_id = ?
-      AND other_c.start_line >= ? AND other_c.end_line <= ?
-      AND other_m.role != 1
-      AND other_gs.id != ?
-      ${db.symbolNoiseFor("other_gs")}
-      ${db.pathExclusionsFor("other_d")}
-    ORDER BY other_d.relative_path
-    LIMIT 30`,
-    match.documentId,
-    match.startLine,
-    match.endLine,
-    match.symbolId
-  );
-  const consumers = db.all(
-    `SELECT DISTINCT consumer_gs.symbol, consumer_d.relative_path AS file
-    FROM mentions ref_m
-    JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-    JOIN documents ref_d ON ref_c.document_id = ref_d.id
-    -- Find the enclosing function at each usage site
-    JOIN defn_enclosing_ranges enc_der
-      ON enc_der.document_id = ref_d.id
-      AND enc_der.start_line <= ref_c.start_line
-      AND enc_der.end_line >= ref_c.end_line
-    JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-    -- Find other symbols defined by that enclosing function's file
-    JOIN mentions consumer_m ON consumer_m.symbol_id = enc_gs.id AND consumer_m.role != 1
-    JOIN chunks consumer_c ON consumer_m.chunk_id = consumer_c.id
-    JOIN documents consumer_d ON consumer_c.document_id = consumer_d.id
-    JOIN global_symbols consumer_gs ON consumer_m.symbol_id = consumer_gs.id
-    WHERE ref_m.symbol_id = ? AND ref_m.role != 1
-      AND consumer_d.id != ref_d.id
-      ${db.symbolNoiseFor("consumer_gs")}
-      ${db.pathExclusionsFor("consumer_d")}
-    ORDER BY consumer_d.relative_path
-    LIMIT 30`,
-    match.symbolId
-  );
-  return {
-    symbol: match.symbol,
-    shortName: shortenSymbol(match.symbol),
-    relativePath: match.relativePath,
-    definitionSites: defSites.filter((s) => !db.isIgnored(s.file)),
-    usageSites: usageSites.filter((s) => !db.isIgnored(s.file)).map((s) => ({
-      file: s.file,
-      line: s.line,
-      enclosingSymbol: s.enclosing_symbol ?? "(top-level)",
-      enclosingShort: s.enclosing_symbol ? shortenSymbol(s.enclosing_symbol) : "(top-level)"
-    })),
-    producers: producers.filter((p) => !db.isIgnored(p.file)).map((p) => ({ symbol: p.symbol, shortName: shortenSymbol(p.symbol), file: p.file })),
-    consumers: consumers.filter((c) => !db.isIgnored(c.file)).map((c) => ({ symbol: c.symbol, shortName: shortenSymbol(c.symbol), file: c.file }))
-  };
-}
-
-export {
-  dataflow
-};
-//# sourceMappingURL=chunk-7JFZSOJ7.js.map