scip-query 0.5.0 → 0.6.0

package/dist/chunk-QJI7EECA.js

@@ -1,327 +0,0 @@
-import {
-  findFirstSymbolMatch,
-  getAllDefinitions,
-  getCalleeRowsForSymbol,
-  getSourceText
-} from "./chunk-OMCRXXDX.js";
-import {
-  isFunctionLikeSymbol,
-  leafName,
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/similar.ts
-function similar(db, symbolPattern, opts = {}) {
-  const { minSimilarity = 0.4, limit = 20 } = opts;
-  const target = findCallees(db, symbolPattern);
-  if (!target) return [];
-  if (!isFunctionLikeSymbol(target.symbol)) return [];
-  const candidates = getAllCalleeFingerprints(db, {
-    minCallees: 3,
-    excludeSymbol: target.symbol
-  });
-  const allFingerprints = [target, ...candidates];
-  const idfWeights = computeIdf(allFingerprints);
-  const results = [];
-  for (const candidate of candidates) {
-    if (candidate.callees.size < 3) continue;
-    const { similarity, significantShared } = weightedSimilarity(
-      target.callees,
-      candidate.callees,
-      idfWeights
-    );
-    if (similarity < minSimilarity) continue;
-    if (significantShared.length < 1) continue;
-    results.push({
-      symbolA: target.symbol,
-      shortNameA: shortenSymbol(target.symbol),
-      fileA: target.file,
-      symbolB: candidate.symbol,
-      shortNameB: shortenSymbol(candidate.symbol),
-      fileB: candidate.file,
-      similarity,
-      sharedCallees: significantShared.map(shortenSymbol),
-      uniqueToA: [...difference(target.callees, candidate.callees)].map(shortenSymbol),
-      uniqueToB: [...difference(candidate.callees, target.callees)].map(shortenSymbol)
-    });
-  }
-  results.sort((a, b) => b.similarity - a.similarity);
-  if (results.length > 0) {
-    return results.slice(0, limit);
-  }
-  return similarBySourceShape(db, symbolPattern, { minSimilarity, limit });
-}
-function similarAll(db, opts = {}) {
-  const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4, crossFileOnly = false } = opts;
-  const all = getAllCalleeFingerprints(db, { minCallees, scope });
-  const idfWeights = computeIdf(all);
-  const results = [];
-  for (let i = 0; i < all.length; i++) {
-    for (let j = i + 1; j < all.length; j++) {
-      const a = all[i];
-      const b = all[j];
-      if (crossFileOnly && a.file === b.file) continue;
-      const { similarity, significantShared } = weightedSimilarity(
-        a.callees,
-        b.callees,
-        idfWeights
-      );
-      if (similarity < minSimilarity) continue;
-      const sharedCount = intersection(a.callees, b.callees).size;
-      if (significantShared.length < 2 && sharedCount < 4) continue;
-      const displayShared = significantShared.length > 0 ? significantShared : [...intersection(a.callees, b.callees)];
-      results.push({
-        symbolA: a.symbol,
-        shortNameA: shortenSymbol(a.symbol),
-        fileA: a.file,
-        symbolB: b.symbol,
-        shortNameB: shortenSymbol(b.symbol),
-        fileB: b.file,
-        similarity,
-        sharedCallees: displayShared.map(shortenSymbol),
-        uniqueToA: [...difference(a.callees, b.callees)].map(shortenSymbol),
-        uniqueToB: [...difference(b.callees, a.callees)].map(shortenSymbol)
-      });
-    }
-    if (results.length > limit * 5) break;
-  }
-  results.sort((a, b) => b.similarity - a.similarity);
-  return results.slice(0, limit);
-}
-function computeIdf(fingerprints) {
-  const n = fingerprints.length;
-  if (n === 0) return /* @__PURE__ */ new Map();
-  const docFreq = /* @__PURE__ */ new Map();
-  for (const fp of fingerprints) {
-    for (const callee of fp.callees) {
-      docFreq.set(callee, (docFreq.get(callee) ?? 0) + 1);
-    }
-  }
-  const idf = /* @__PURE__ */ new Map();
-  for (const [callee, df] of docFreq) {
-    idf.set(callee, Math.log(n / df));
-  }
-  return idf;
-}
-function weightedSimilarity(a, b, idf) {
-  const shared = intersection(a, b);
-  if (shared.size === 0) return { similarity: 0, significantShared: [], trivialShared: [] };
-  let dotProduct = 0;
-  let magA = 0;
-  let magB = 0;
-  const allCallees = /* @__PURE__ */ new Set([...a, ...b]);
-  for (const callee of allCallees) {
-    const weight = idf.get(callee) ?? 0;
-    const inA = a.has(callee) ? weight : 0;
-    const inB = b.has(callee) ? weight : 0;
-    dotProduct += inA * inB;
-    magA += inA * inA;
-    magB += inB * inB;
-  }
-  const magnitude = Math.sqrt(magA) * Math.sqrt(magB);
-  const similarity = magnitude > 0 ? dotProduct / magnitude : 0;
-  const medianIdf = getMedianIdf(idf);
-  const significantShared = [];
-  const trivialShared = [];
-  for (const callee of shared) {
-    const weight = idf.get(callee) ?? 0;
-    if (weight >= medianIdf) {
-      significantShared.push(callee);
-    } else {
-      trivialShared.push(callee);
-    }
-  }
-  significantShared.sort((x, y) => (idf.get(y) ?? 0) - (idf.get(x) ?? 0));
-  return { similarity, significantShared, trivialShared };
-}
-function getMedianIdf(idf) {
-  const values = [...idf.values()].sort((a, b) => a - b);
-  if (values.length === 0) return 0;
-  const mid = Math.floor(values.length / 2);
-  return values.length % 2 === 0 ? (values[mid - 1] + values[mid]) / 2 : values[mid];
-}
-function findCallees(db, symbolPattern) {
-  const target = findFirstSymbolMatch(db, symbolPattern);
-  if (!target) return null;
-  const calleeRows = getCalleeRowsForSymbol(db, target);
-  return {
-    symbol: target.symbol,
-    file: target.relativePath,
-    callees: new Set(calleeRows.map((r) => r.symbol))
-  };
-}
-function getAllCalleeFingerprints(db, opts) {
-  const { minCallees, scope, excludeSymbol } = opts;
-  const fingerprints = [];
-  for (const definition of getAllDefinitions(db, { scope })) {
-    if (db.isIgnored(definition.relativePath)) continue;
-    if (!definition.isFunctionLike) continue;
-    if (excludeSymbol && definition.symbol === excludeSymbol) continue;
-    if (definition.endLine - definition.startLine + 1 < 5) continue;
-    const callees = new Set(
-      getCalleeRowsForSymbol(db, definition).map((row) => row.symbol)
-    );
-    if (callees.size < minCallees) continue;
-    fingerprints.push({
-      symbol: definition.symbol,
-      file: definition.relativePath,
-      callees
-    });
-  }
-  return fingerprints;
-}
-function intersection(a, b) {
-  const result = /* @__PURE__ */ new Set();
-  for (const item of a) {
-    if (b.has(item)) result.add(item);
-  }
-  return result;
-}
-function difference(a, b) {
-  const result = /* @__PURE__ */ new Set();
-  for (const item of a) {
-    if (!b.has(item)) result.add(item);
-  }
-  return result;
-}
-function similarBySourceShape(db, symbolPattern, opts) {
-  const target = findSourceFingerprint(db, symbolPattern);
-  if (!target || target.tokens.size < 3) {
-    return [];
-  }
-  const minSimilarity = opts.minSimilarity >= 0.5 ? opts.minSimilarity : 0.3;
-  const results = [];
-  for (const candidate of getAllSourceFingerprints(db)) {
-    if (candidate.symbol === target.symbol || candidate.tokens.size < 3) continue;
-    const shared = intersection(target.tokens, candidate.tokens);
-    if (shared.size < 2) continue;
-    const union = /* @__PURE__ */ new Set([...target.tokens, ...candidate.tokens]);
-    const similarity = union.size > 0 ? shared.size / union.size : 0;
-    if (similarity < minSimilarity) continue;
-    results.push({
-      symbolA: target.symbol,
-      shortNameA: shortenSymbol(target.symbol),
-      fileA: target.file,
-      symbolB: candidate.symbol,
-      shortNameB: shortenSymbol(candidate.symbol),
-      fileB: candidate.file,
-      similarity,
-      sharedCallees: [...shared].sort(),
-      uniqueToA: [...difference(target.tokens, candidate.tokens)].sort(),
-      uniqueToB: [...difference(candidate.tokens, target.tokens)].sort()
-    });
-  }
-  results.sort((a, b) => b.similarity - a.similarity || a.shortNameB.localeCompare(b.shortNameB));
-  return results.slice(0, opts.limit);
-}
-function findSourceFingerprint(db, symbolPattern) {
-  const match = findFirstSymbolMatch(db, symbolPattern);
-  if (!match || !isFunctionLikeSymbol(match.symbol)) {
-    return null;
-  }
-  const snippet = definitionSnippet(db, match.relativePath, match.startLine, match.endLine, leafName(match.symbol));
-  const tokens = sourceTokens(snippet, leafName(match.symbol));
-  if (tokens.size === 0) {
-    return null;
-  }
-  return {
-    symbol: match.symbol,
-    file: match.relativePath,
-    tokens
-  };
-}
-function getAllSourceFingerprints(db) {
-  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike).map((definition) => ({
-    symbol: definition.symbol,
-    file: definition.relativePath,
-    tokens: sourceTokens(
-      definitionSnippet(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
-      definition.leaf
-    )
-  })).filter((fingerprint) => fingerprint.tokens.size > 0);
-}
-function definitionSnippet(db, relativePath, startLine, endLine, leaf) {
-  const source = getSourceText(db, relativePath);
-  if (!source) {
-    return "";
-  }
-  const lines = source.split("\n");
-  if (endLine >= startLine && endLine - startLine <= 12) {
-    return lines.slice(startLine, endLine + 1).join("\n");
-  }
-  const markerPatterns = [
-    new RegExp(`\\bdef\\s+${escapeRegex(leaf)}\\b`),
-    new RegExp(`\\bfun\\s+${escapeRegex(leaf)}\\b`),
-    new RegExp(`\\bfn\\s+${escapeRegex(leaf)}\\b`),
-    new RegExp(`\\bfunction\\s+${escapeRegex(leaf)}\\b`),
-    new RegExp(`\\b${escapeRegex(leaf)}\\s*\\(`)
-  ];
-  const definitionStart = lines.findIndex((line) => markerPatterns.some((pattern) => pattern.test(line)));
-  if (definitionStart >= 0) {
-    let definitionEnd = definitionStart;
-    for (let index = definitionStart + 1; index < lines.length && index <= definitionStart + 8; index++) {
-      const line = lines[index] ?? "";
-      if (index > definitionStart && looksLikeDefinitionBoundary(line)) {
-        break;
-      }
-      definitionEnd = index;
-      if (line.trim() === "" && index > definitionStart + 1) {
-        break;
-      }
-    }
-    return lines.slice(definitionStart, definitionEnd + 1).join("\n");
-  }
-  return lines.slice(startLine, Math.min(lines.length, startLine + 8)).join("\n");
-}
-function sourceTokens(snippet, leaf) {
-  if (!snippet) {
-    return /* @__PURE__ */ new Set();
-  }
-  const stopWords = /* @__PURE__ */ new Set([
-    "public",
-    "private",
-    "protected",
-    "final",
-    "static",
-    "class",
-    "def",
-    "fun",
-    "fn",
-    "function",
-    "return",
-    "string",
-    "bool",
-    "boolean",
-    "void",
-    "unit",
-    "self",
-    "this",
-    "new",
-    "const",
-    "let",
-    "var",
-    "end",
-    "pub"
-  ]);
-  const normalizedLeafParts = splitIdentifier(leaf);
-  const normalized = snippet.replace(/["'`]/g, " ").replace(/\b\d+\b/g, " NUM ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9_]+/g, " ").replace(/_/g, " ").toLowerCase();
-  const tokens = normalized.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 1).filter((token) => !stopWords.has(token)).filter((token) => !normalizedLeafParts.has(token));
-  return new Set(tokens);
-}
-function splitIdentifier(value) {
-  return new Set(
-    value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9_]+|_/).map((part) => part.toLowerCase()).filter((part) => part.length > 1)
-  );
-}
-function looksLikeDefinitionBoundary(line) {
-  return /^\s*(?:def|fun|fn|function|class|trait|module|object|enum|interface|public|private|protected)\b/.test(line);
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export {
-  similar,
-  similarAll
-};
-//# sourceMappingURL=chunk-QJI7EECA.js.map

package/dist/chunk-R5HICGMB.js

@@ -1,110 +0,0 @@
-import {
-  getInactiveBarrelPaths,
-  isEntrySurface
-} from "./chunk-UGS7HJI4.js";
-import {
-  TEST_FILE_PATTERNS,
-  TEST_SUPPORT_PATH_PATTERNS,
-  getAllDefinitions
-} from "./chunk-OMCRXXDX.js";
-import {
-  isFunctionLikeSymbol,
-  isModuleLikeSymbol,
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/dead.ts
-function dead(db, opts = {}) {
-  const {
-    scope,
-    minLoc = 1,
-    includeTests = false,
-    skipBarrels = false,
-    includeMembers = false
-  } = opts;
-  const inactiveBarrelPaths = skipBarrels ? new Set(getInactiveBarrelPaths(db)) : /* @__PURE__ */ new Set();
-  const referenceRows = db.all(
-    `SELECT
-      m.symbol_id,
-      d.relative_path,
-      COUNT(*) AS ref_count
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE m.role != 1
-       ${db.pathExclusionsFor("d")}
-     GROUP BY m.symbol_id, d.relative_path`
-  );
-  const referencesBySymbol = /* @__PURE__ */ new Map();
-  for (const row of referenceRows) {
-    if (db.isIgnored(row.relative_path)) continue;
-    if (inactiveBarrelPaths.has(row.relative_path)) continue;
-    let refsForSymbol = referencesBySymbol.get(row.symbol_id);
-    if (!refsForSymbol) {
-      refsForSymbol = /* @__PURE__ */ new Map();
-      referencesBySymbol.set(row.symbol_id, refsForSymbol);
-    }
-    refsForSymbol.set(row.relative_path, row.ref_count);
-  }
-  const definitions = getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isModuleLikeSymbol(definition.symbol)).filter((definition) => looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.isFunctionLike || !definition.enclosingSymbol || !looksValueLikeDefinition(definition.enclosingSymbol)).filter((definition) => includeTests || passesTestFileFilter(definition.relativePath)).filter((definition) => includeMembers || looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.endLine - definition.startLine + 1 >= minLoc);
-  const rows = definitions.map((definition) => {
-    const refMap = referencesBySymbol.get(definition.symbolId) ?? /* @__PURE__ */ new Map();
-    const sameFileRefs = refMap.get(definition.relativePath) ?? 0;
-    let crossFileRefs = 0;
-    for (const [relativePath, count] of refMap) {
-      if (relativePath === definition.relativePath) continue;
-      crossFileRefs += count;
-    }
-    return {
-      relative_path: definition.relativePath,
-      start_line: definition.startLine,
-      end_line: definition.endLine,
-      loc: definition.endLine - definition.startLine + 1,
-      symbol: definition.symbol,
-      same_file_refs: sameFileRefs,
-      cross_file_refs: crossFileRefs
-    };
-  }).filter((row) => row.cross_file_refs === 0).sort((a, b) => b.loc - a.loc || a.relative_path.localeCompare(b.relative_path) || a.start_line - b.start_line);
-  let deadCodeCount = 0;
-  let fileInternalCount = 0;
-  let totalLoc = 0;
-  const symbols = rows.filter((r) => !db.isIgnored(r.relative_path)).filter((r) => !isEntrySurface(db, r.relative_path)).map((r) => {
-    const kind = r.same_file_refs === 0 ? "dead-code" : "file-internal";
-    if (kind === "dead-code") deadCodeCount++;
-    else fileInternalCount++;
-    totalLoc += r.loc;
-    return {
-      relativePath: r.relative_path,
-      startLine: r.start_line,
-      endLine: r.end_line,
-      loc: r.loc,
-      symbol: r.symbol,
-      shortName: shortenSymbol(r.symbol),
-      sameFileRefs: r.same_file_refs,
-      kind
-    };
-  });
-  return {
-    symbols,
-    totalCount: symbols.length,
-    deadCodeCount,
-    fileInternalCount,
-    totalLoc
-  };
-}
-function passesTestFileFilter(relativePath) {
-  const patterns = [.../* @__PURE__ */ new Set([...TEST_FILE_PATTERNS, ...TEST_SUPPORT_PATH_PATTERNS])];
-  return patterns.every((pattern) => !likeMatches(relativePath, pattern));
-}
-function likeMatches(value, pattern) {
-  const regex = new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`);
-  return regex.test(value);
-}
-function looksValueLikeDefinition(rawSymbol) {
-  return isFunctionLikeSymbol(rawSymbol) || rawSymbol.endsWith("().") || rawSymbol.endsWith(".");
-}
-
-export {
-  dead
-};
-//# sourceMappingURL=chunk-R5HICGMB.js.map

package/dist/chunk-RJ2D6YWQ.js

@@ -1,49 +0,0 @@
-import {
-  getCalleeRowsForSymbol,
-  getScopedDefinitions
-} from "./chunk-OMCRXXDX.js";
-import {
-  isFunctionLikeSymbol,
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/passthrough-candidates.ts
-function passthroughCandidates(db, opts) {
-  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
-  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) >= 3 && definitionLoc(definition) <= maxLoc);
-  const results = [];
-  for (const sym of symbols) {
-    if (db.isIgnored(sym.relativePath) || !isFunctionLikeSymbol(sym.symbol)) continue;
-    const rawCallees = getCalleeRowsForSymbol(db, sym);
-    const callees = rawCallees.some((callee2) => isFunctionLikeSymbol(callee2.symbol)) ? rawCallees.filter((callee2) => isFunctionLikeSymbol(callee2.symbol)) : rawCallees;
-    const uniqueCallees = /* @__PURE__ */ new Map();
-    for (const c of callees) {
-      if (!uniqueCallees.has(c.symbol)) {
-        uniqueCallees.set(c.symbol, { symbol: c.symbol, file: c.file });
-      }
-    }
-    if (uniqueCallees.size !== 1) continue;
-    const [, callee] = [...uniqueCallees.entries()][0];
-    results.push({
-      symbol: sym.symbol,
-      shortName: shortenSymbol(sym.symbol),
-      file: sym.relativePath,
-      startLine: sym.startLine,
-      endLine: sym.endLine,
-      loc: definitionLoc(sym),
-      forwardsTo: callee.symbol,
-      forwardsToShort: shortenSymbol(callee.symbol),
-      forwardsToFile: callee.file
-    });
-  }
-  results.sort((a, b) => a.loc - b.loc || a.file.localeCompare(b.file));
-  return results.slice(0, limit);
-}
-function definitionLoc(definition) {
-  return definition.endLine - definition.startLine + 1;
-}
-
-export {
-  passthroughCandidates
-};
-//# sourceMappingURL=chunk-RJ2D6YWQ.js.map

package/dist/chunk-RZ5GYPBP.js

@@ -1,79 +0,0 @@
-import {
-  getAllDefinitions,
-  getCalleeRowsForSymbol,
-  getCallerRowsForSymbol
-} from "./chunk-OMCRXXDX.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/bottlenecks.ts
-function bottlenecks(db, opts = {}) {
-  const { limit = 20, scope, minFanIn = 2, minFanOut = 2 } = opts;
-  const scopeFilter = scope ? `AND def_d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT * FROM (
-      SELECT
-        gs.symbol,
-        def_d.relative_path AS defined_in,
-        (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 != 1
-        ) AS fan_in,
-        (SELECT COUNT(DISTINCT ref_gs.id)
-         FROM mentions ref_m
-         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-         JOIN global_symbols ref_gs ON ref_m.symbol_id = ref_gs.id
-         JOIN defn_enclosing_ranges ref_der ON ref_gs.id = ref_der.symbol_id
-         WHERE ref_c.document_id = def_d.id
-           AND ref_m.role != 1
-           AND ref_der.document_id != def_d.id
-        ) AS fan_out
-      FROM global_symbols gs
-      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-      JOIN documents def_d ON der.document_id = def_d.id
-      WHERE 1 = 1
-        ${db.pathExclusionsFor("def_d")}
-        ${db.symbolNoiseFor("gs")}
-        ${scopeFilter}
-    ) WHERE fan_in >= ? AND fan_out >= ?
-    ORDER BY (fan_in * fan_out) DESC
-    LIMIT ?`,
-    minFanIn,
-    minFanOut,
-    limit
-  );
-  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    score: r.fan_in * r.fan_out,
-    definedIn: r.defined_in
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
-    const fanIn = new Set(
-      getCallerRowsForSymbol(db, definition, { limit: 500 }).map((row) => row.file)
-    ).size;
-    const fanOut = new Set(
-      getCalleeRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
-    ).size;
-    return {
-      symbol: definition.symbol,
-      shortName: shortenSymbol(definition.symbol),
-      fanIn,
-      fanOut,
-      score: fanIn * fanOut,
-      definedIn: definition.relativePath
-    };
-  }).filter((row) => row.fanIn >= minFanIn && row.fanOut >= minFanOut).sort((left, right) => right.score - left.score || right.fanIn - left.fanIn).slice(0, limit);
-}
-
-export {
-  bottlenecks
-};
-//# sourceMappingURL=chunk-RZ5GYPBP.js.map

package/dist/chunk-SRLQNO6O.js

@@ -1,101 +0,0 @@
-import {
-  findEnclosingDefinition,
-  findExactSymbolMatch,
-  findFirstSymbolMatch,
-  getCalleeRowsForSymbol,
-  getDefinitionsForFile,
-  getResolvedReferenceSites,
-  getSourceReferenceSites
-} from "./chunk-OMCRXXDX.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/slice.ts
-function slice(db, symbolPattern, opts = {}) {
-  const { direction = "backward", maxDepth = 3 } = opts;
-  const match = findFirstSymbolMatch(db, symbolPattern);
-  if (!match) return null;
-  if (direction === "backward") {
-    return backwardSlice(db, match, maxDepth);
-  } else {
-    return forwardSlice(db, match);
-  }
-}
-function backwardSlice(db, match, maxDepth) {
-  const connected = [];
-  const visited = /* @__PURE__ */ new Set([match.symbol]);
-  let frontier = [match];
-  for (let depth = 1; depth <= maxDepth; depth++) {
-    if (frontier.length === 0) break;
-    const nextFrontier = [];
-    for (const current of frontier) {
-      const callees = getCalleeRowsForSymbol(db, current);
-      for (const c of callees) {
-        if (visited.has(c.symbol)) continue;
-        visited.add(c.symbol);
-        connected.push({
-          symbol: c.symbol,
-          shortName: shortenSymbol(c.symbol),
-          file: c.file,
-          relationship: depth === 1 ? "referenced within definition (callee)" : `depth ${depth} callee`
-        });
-        const calleeMatch = findExactSymbolMatch(db, c.symbol);
-        if (calleeMatch && !db.isIgnored(calleeMatch.relativePath)) {
-          nextFrontier.push(calleeMatch);
-        }
-      }
-    }
-    frontier = nextFrontier;
-  }
-  return {
-    symbol: match.symbol,
-    shortName: shortenSymbol(match.symbol),
-    direction: "backward",
-    connectedSymbols: connected
-  };
-}
-function forwardSlice(db, match) {
-  const sourceRefs = getSourceReferenceSites(db, match);
-  const refs = sourceRefs.length > 0 ? sourceRefs : getResolvedReferenceSites(db, match);
-  const seenOutputs = /* @__PURE__ */ new Set();
-  const connected = [];
-  for (const ref of refs) {
-    if (connected.length >= 30) break;
-    if (db.isIgnored(ref.file)) continue;
-    const enclosingSymbol = ref.enclosingSymbol ?? findEnclosingDefinition(
-      getDefinitionsForFile(db, ref.file),
-      ref.line
-    )?.symbol ?? null;
-    if (!enclosingSymbol || enclosingSymbol === match.symbol) continue;
-    const enclosingMatch = findExactSymbolMatch(db, enclosingSymbol);
-    if (!enclosingMatch) continue;
-    for (const callee of getCalleeRowsForSymbol(db, enclosingMatch)) {
-      if (callee.symbol === match.symbol) continue;
-      if (callee.symbol === enclosingSymbol) continue;
-      if (callee.file === ref.file) continue;
-      if (db.isIgnored(callee.file)) continue;
-      if (seenOutputs.has(callee.symbol)) continue;
-      seenOutputs.add(callee.symbol);
-      connected.push({
-        symbol: callee.symbol,
-        shortName: shortenSymbol(callee.symbol),
-        file: callee.file,
-        relationship: `used alongside target in ${shortenSymbol(enclosingSymbol)}`
-      });
-      if (connected.length >= 30) break;
-    }
-  }
-  connected.sort((a, b) => a.file.localeCompare(b.file));
-  return {
-    symbol: match.symbol,
-    shortName: shortenSymbol(match.symbol),
-    direction: "forward",
-    connectedSymbols: connected
-  };
-}
-
-export {
-  slice
-};
-//# sourceMappingURL=chunk-SRLQNO6O.js.map