scip-query 0.3.5 → 0.4.0

package/README.md

@@ -19,6 +19,7 @@ For goal-oriented usage guides (not just command reference), see **[Agent Guide]
 ```bash
 # Install
 npm install -g scip-query
+scip-query install-skills            # installs built-in Codex/Claude skills, including scip-language-playbook
 
 # Index your project (auto-detects language)
 scip-query reindex

package/dist/{chunk-6FKIA6EI.js → chunk-2F2WH5WQ.js}

@@ -3,37 +3,37 @@ import {
 } from "./chunk-74RFWB5T.js";
 import {
   wrapperCandidates
-} from "./chunk-4JCSOF2O.js";
+} from "./chunk-AS7N27JK.js";
 import {
   similarAll
-} from "./chunk-OIDHN6GD.js";
+} from "./chunk-I2JM34UV.js";
 import {
   staleAbstractions
-} from "./chunk-YGGFLMTM.js";
+} from "./chunk-5RKYZSQ6.js";
 import {
   isolated
-} from "./chunk-UQEQ6AHX.js";
+} from "./chunk-VISMEWYP.js";
 import {
   passthroughCandidates
-} from "./chunk-ZEUCXQBN.js";
+} from "./chunk-5AJJGPZE.js";
 import {
   drift
-} from "./chunk-7KIMF5PV.js";
+} from "./chunk-HRDPUTIQ.js";
 import {
   extractCandidates
-} from "./chunk-EPWLXXBL.js";
+} from "./chunk-IV6NZ426.js";
 import {
   complexityHotspots
-} from "./chunk-VIYSWZCO.js";
+} from "./chunk-SL674KAW.js";
 import {
   cycles
-} from "./chunk-LFJQVJYJ.js";
+} from "./chunk-VU7FDTWV.js";
 import {
   dead
-} from "./chunk-LQJUPXQY.js";
+} from "./chunk-SRELHCMG.js";
 import {
   isEntrySurface
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-X3J4VPWM.js";
 
 // src/queries/health.ts
 function health(db, opts = {}) {
@@ -218,4 +218,4 @@ function health(db, opts = {}) {
 export {
   health
 };
-//# sourceMappingURL=chunk-6FKIA6EI.js.map
+//# sourceMappingURL=chunk-2F2WH5WQ.js.map

package/dist/{chunk-C7H5WBTJ.js → chunk-2UISVZGQ.js}

@@ -2,7 +2,7 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getCallerRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -43,4 +43,4 @@ function uniqueRows(rows) {
 export {
   callGraph
 };
-//# sourceMappingURL=chunk-C7H5WBTJ.js.map
+//# sourceMappingURL=chunk-2UISVZGQ.js.map

package/dist/{chunk-EN2Z2CLO.js → chunk-4ZT7UGWW.js}

@@ -1,3 +1,6 @@
+import {
+  getAllDefinitions
+} from "./chunk-QGCEAVJD.js";
 import {
   leafSuffix,
   parseSymbol,
@@ -143,24 +146,18 @@ function kindCounts(db, opts = {}) {
   }));
 }
 function loadKindRows(db, scope) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT
-      gs.symbol,
-      gs.kind,
-      gs.documentation,
-      gs.enclosing_symbol,
-      d.relative_path,
-      der.start_line,
-      der.end_line
-    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")}
-      ${scopeFilter}
-    ORDER BY d.relative_path, der.start_line`
-  ).filter((row) => !db.isIgnored(row.relative_path));
+  return getAllDefinitions(db, { scope }).map(mapDefinitionToKindRow);
+}
+function mapDefinitionToKindRow(definition) {
+  return {
+    symbol: definition.symbol,
+    kind: definition.kind,
+    documentation: definition.documentation,
+    enclosing_symbol: definition.enclosingSymbol,
+    relative_path: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine
+  };
 }
 function resolveKindNumber(row) {
   if (row.kind !== null && row.kind !== 0) {
@@ -216,4 +213,4 @@ export {
   byKind,
   kindCounts
 };
-//# sourceMappingURL=chunk-EN2Z2CLO.js.map
+//# sourceMappingURL=chunk-4ZT7UGWW.js.map

package/dist/chunk-5AJJGPZE.js

@@ -0,0 +1,60 @@
+import {
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.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 getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+
+export {
+  passthroughCandidates
+};
+//# sourceMappingURL=chunk-5AJJGPZE.js.map

package/dist/chunk-5RKYZSQ6.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/stale-abstractions.ts
+function staleAbstractions(db, opts) {
+  const { scope, minLoc = 3, limit = 30 } = opts ?? {};
+  const rows = getScopedDefinitions(db, scope).filter((definition) => definition.isTypeLike && definitionLoc(definition) >= minLoc).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine,
+    loc: definitionLoc(definition),
+    consumers: countCrossFileConsumers(db, definition)
+  })).filter((row) => row.consumers <= 1).sort((left, right) => right.loc - left.loc || left.file.localeCompare(right.file) || left.start_line - right.start_line);
+  const filesWithFunctions = getFilesWithFunctions(db, scope);
+  return rows.filter((r) => !db.isIgnored(r.file)).filter((r) => isTrueStaleAbstraction(r, filesWithFunctions)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    file: r.file,
+    startLine: r.start_line,
+    endLine: r.end_line,
+    loc: r.loc,
+    consumers: r.consumers
+  })).slice(0, limit);
+}
+function getFilesWithFunctions(db, scope) {
+  return new Set(getScopedDefinitions(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
+}
+function isTrueStaleAbstraction(row, filesWithFunctions) {
+  const basename = row.file.split("/").pop() ?? "";
+  const isTypeFile = basename.includes("types") || row.file.includes("/types/");
+  if (isTypeFile && row.consumers > 0) {
+    return false;
+  }
+  if (row.consumers === 0 && filesWithFunctions.has(row.file)) {
+    return false;
+  }
+  return true;
+}
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function countCrossFileConsumers(db, definition) {
+  const callers = db.all(
+    `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
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("d")}`,
+    definition.symbolId
+  ).map((row) => row.relative_path).filter((relativePath) => relativePath !== definition.relativePath && !db.isIgnored(relativePath));
+  return new Set(callers).size;
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+
+export {
+  staleAbstractions
+};
+//# sourceMappingURL=chunk-5RKYZSQ6.js.map

package/dist/chunk-7YBLWIXY.js

@@ -0,0 +1,115 @@
+import {
+  findFirstSymbolMatch,
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/refs.ts
+function refs(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (match) {
+    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
+    const definitionRows = includeDefinitionSite ? [{
+      relativePath: match.relativePath,
+      line: match.startLine
+    }] : [];
+    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
+      relativePath: site.file,
+      line: site.line
+    }));
+    if (sourceSites.length > 0) {
+      const seen2 = /* @__PURE__ */ new Set();
+      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
+        const key = `${site.relativePath}:${site.line}`;
+        if (seen2.has(key)) return false;
+        seen2.add(key);
+        return true;
+      });
+      return rows2;
+    }
+  }
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line
+    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 m.symbol_id = ?
+      AND ${db.localSymbolPredicate}
+      AND m.role != 1
+    ORDER BY d.relative_path, c.start_line`,
+    match?.symbolId ?? -1
+  );
+  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.start_line
+  }));
+  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
+    return referenceRows;
+  }
+  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
+  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
+    referenceRows.unshift({
+      relativePath: match.relativePath,
+      line: match.startLine
+    });
+  }
+  for (const row of getRubySemanticRefs(db, match)) {
+    const key = `${row.relativePath}:${row.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    referenceRows.push(row);
+  }
+  return referenceRows;
+}
+function getRubySemanticRefs(db, match) {
+  if (!match.relativePath.endsWith(".rb")) {
+    return [];
+  }
+  const tokens = rubyReferenceTokens(match.symbol);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE '%.rb'
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const results = [];
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const source = getSourceText(db, row.relative_path);
+    if (!source) continue;
+    const lines = source.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      if (tokens.some((token) => new RegExp(`@${token}\\b|\\b${token}:`).test(line))) {
+        results.push({
+          relativePath: row.relative_path,
+          line: index
+        });
+      }
+    }
+  }
+  return results;
+}
+function rubyReferenceTokens(rawSymbol) {
+  const leaf = rawSymbol.split(":").pop() ?? rawSymbol;
+  const snake = leaf.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+  const parts = snake.split("_").filter(Boolean);
+  const candidates = /* @__PURE__ */ new Set();
+  if (snake) candidates.add(snake);
+  if (parts.length >= 1) candidates.add(parts[parts.length - 1]);
+  if (parts.length >= 2) candidates.add(parts.slice(-2).join("_"));
+  return [...candidates];
+}
+
+export {
+  refs
+};
+//# sourceMappingURL=chunk-7YBLWIXY.js.map

package/dist/{chunk-O7Q7FDUJ.js → chunk-A4GWYETB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -79,4 +79,4 @@ function system(db, modulePattern) {
 export {
   system
 };
-//# sourceMappingURL=chunk-O7Q7FDUJ.js.map
+//# sourceMappingURL=chunk-A4GWYETB.js.map

package/dist/{chunk-CHDJXYBG.js → chunk-A5BGEBM7.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -97,4 +97,4 @@ function forwardSlice(db, match) {
 export {
   slice
 };
-//# sourceMappingURL=chunk-CHDJXYBG.js.map
+//# sourceMappingURL=chunk-A5BGEBM7.js.map

package/dist/{chunk-KKCHYLVI.js → chunk-A7YY7IDA.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/coupling.ts
 function coupling(db, file1, file2) {
@@ -81,4 +81,4 @@ export {
   coupling,
   topCoupling
 };
-//# sourceMappingURL=chunk-KKCHYLVI.js.map
+//# sourceMappingURL=chunk-A7YY7IDA.js.map

package/dist/chunk-AS7N27JK.js

@@ -0,0 +1,115 @@
+import {
+  buildFileDepGraph,
+  getCallerRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/wrapper-candidates.ts
+import { basename, extname } from "path";
+function wrapperCandidates(db, opts) {
+  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
+  const reverseFanIn = buildReverseFileFanIn(buildFileDepGraph(db, scope));
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) <= maxLoc && definitionLoc(definition) >= 2);
+  const results = [];
+  for (const symbol of symbols) {
+    if (db.isIgnored(symbol.relativePath) || !isFunctionLikeSymbol(symbol.symbol)) continue;
+    const symbolStem = basename(symbol.relativePath, extname(symbol.relativePath));
+    const callerRows = dedupeRows(
+      getCallerRowsForSymbol(db, symbol, { limit: 200 }).filter((row) => row.file !== symbol.relativePath)
+    ).filter((row) => basename(row.file, extname(row.file)) !== symbolStem);
+    if (callerRows.length !== 1) continue;
+    const caller = callerRows[0];
+    const callerDefinition = getDefinitionsForFile(db, caller.file).find((definition) => definition.symbol === caller.symbol);
+    const useDefinitionFanIn = callerDefinition?.isFunctionLike ?? false;
+    let callerFanIn;
+    if (useDefinitionFanIn && callerDefinition) {
+      callerFanIn = new Set(
+        getCallerRowsForSymbol(db, callerDefinition, { limit: 500 }).filter((row) => row.file !== callerDefinition.relativePath).map((row) => row.file)
+      ).size;
+    } else {
+      callerFanIn = fallbackCallerFanIn(db, reverseFanIn, caller.file);
+    }
+    if (callerFanIn <= 3) continue;
+    results.push({
+      symbol: symbol.symbol,
+      shortName: shortenSymbol(symbol.symbol),
+      file: symbol.relativePath,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine,
+      loc: definitionLoc(symbol),
+      singleCaller: caller.symbol,
+      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename(caller.file),
+      callerFanIn
+    });
+  }
+  results.sort((left, right) => right.callerFanIn - left.callerFanIn || right.loc - left.loc);
+  return results.slice(0, limit);
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
+function buildReverseFileFanIn(graph) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [fromFile, deps] of graph) {
+    if (!reverse.has(fromFile)) {
+      reverse.set(fromFile, reverse.get(fromFile) ?? 0);
+    }
+    for (const dep of deps) {
+      reverse.set(dep, (reverse.get(dep) ?? 0) + 1);
+    }
+  }
+  return reverse;
+}
+function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
+  const functionLikeFanIn = getDefinitionsForFile(db, callerFile).filter((definition) => definition.isFunctionLike).map((definition) => new Set(
+    getCallerRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => row.file)
+  ).size).sort((left, right) => right - left)[0] ?? 0;
+  if (functionLikeFanIn > 0) {
+    return functionLikeFanIn;
+  }
+  const direct = reverseFanIn.get(callerFile) ?? 0;
+  if (direct > 0) {
+    return direct;
+  }
+  const stem = basename(callerFile, extname(callerFile));
+  let best = 0;
+  for (const [file, fanIn] of reverseFanIn) {
+    if (file === callerFile) continue;
+    if (basename(file, extname(file)) !== stem) continue;
+    if (fanIn > best) {
+      best = fanIn;
+    }
+  }
+  return best;
+}
+
+export {
+  wrapperCandidates
+};
+//# sourceMappingURL=chunk-AS7N27JK.js.map

package/dist/{chunk-F7XU27LU.js → chunk-CQRYLK33.js}

@@ -1,3 +1,8 @@
+import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -39,7 +44,7 @@ function bottlenecks(db, opts = {}) {
     minFanOut,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     fanIn: r.fan_in,
@@ -47,9 +52,28 @@ function bottlenecks(db, opts = {}) {
     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-F7XU27LU.js.map
+//# sourceMappingURL=chunk-CQRYLK33.js.map

package/dist/{chunk-NFS5W3PP.js → chunk-CQUNEJYM.js}

@@ -1,6 +1,6 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   isDirectChildSymbol,
   leafSuffix,
@@ -34,4 +34,4 @@ function members(db, symbolPattern) {
 export {
   members
 };
-//# sourceMappingURL=chunk-NFS5W3PP.js.map
+//# sourceMappingURL=chunk-CQUNEJYM.js.map

package/dist/chunk-D4I3ZMN5.js

@@ -0,0 +1,38 @@
+import {
+  cleanSignature
+} from "./chunk-4TYLS5XX.js";
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/symbols.ts
+function symbols(db, filePattern) {
+  const resolvedPaths = resolveIndexedPaths(db, filePattern);
+  if (resolvedPaths.length === 0) {
+    return [];
+  }
+  return resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((row) => !db.isIgnored(row.relativePath)).map((row) => {
+    const docRow = db.get(
+      `SELECT REPLACE(SUBSTR(documentation, INSTR(documentation, '|') + 1), char(10), ' ') AS sig
+         FROM global_symbols
+         WHERE id = ?`,
+      row.symbolId
+    );
+    return {
+      startLine: row.startLine,
+      endLine: row.endLine,
+      symbol: row.symbol,
+      shortName: shortenSymbol(row.symbol),
+      signature: cleanSignature(docRow?.sig ?? null)
+    };
+  });
+}
+
+export {
+  symbols
+};
+//# sourceMappingURL=chunk-D4I3ZMN5.js.map

package/dist/{chunk-J3JSOSUO.js → chunk-E7J7Q7UW.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -76,4 +76,4 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 export {
   code
 };
-//# sourceMappingURL=chunk-J3JSOSUO.js.map
+//# sourceMappingURL=chunk-E7J7Q7UW.js.map