scip-query 0.1.0

package/dist/queries/index.js

@@ -0,0 +1,207 @@
+import "../chunk-JJP7KQND.js";
+import {
+  surface
+} from "../chunk-FFSWWE5O.js";
+import {
+  symbols
+} from "../chunk-KCBMVQL5.js";
+import {
+  system
+} from "../chunk-DCKMSTJ4.js";
+import {
+  trace
+} from "../chunk-TBP6BICL.js";
+import {
+  redundantReexports
+} from "../chunk-3E2X7RIE.js";
+import {
+  refs
+} from "../chunk-6NBLIDF4.js";
+import {
+  similarChains
+} from "../chunk-JKP5GH6T.js";
+import {
+  similarFiles
+} from "../chunk-Z73NYSBZ.js";
+import {
+  similarSignatures
+} from "../chunk-SEFSL2GF.js";
+import {
+  slice
+} from "../chunk-ZJRYBOEE.js";
+import {
+  hierarchy
+} from "../chunk-DEZKCZXD.js";
+import {
+  hotspots
+} from "../chunk-BFSCMC22.js";
+import {
+  importedBy,
+  imports,
+  unusedImports
+} from "../chunk-BEPIEVLR.js";
+import {
+  members
+} from "../chunk-3UOUTZQT.js";
+import {
+  methods
+} from "../chunk-NUZ4OMU3.js";
+import {
+  outline
+} from "../chunk-6SXADWLW.js";
+import {
+  deps,
+  rdeps
+} from "../chunk-N5KEREIA.js";
+import {
+  diffImpact
+} from "../chunk-YZAA4LYG.js";
+import {
+  docCoverage
+} from "../chunk-FGXRVW7G.js";
+import {
+  fanIn,
+  fanOut,
+  topFanIn,
+  topFanOut
+} from "../chunk-GTILYBH6.js";
+import {
+  files
+} from "../chunk-MGNMHKX3.js";
+import {
+  health
+} from "../chunk-7OZPA5OO.js";
+import {
+  staleAbstractions
+} from "../chunk-GJFURBEW.js";
+import {
+  stats
+} from "../chunk-XFXDXEUN.js";
+import {
+  testCoverage,
+  testCoverageSummary
+} from "../chunk-3ZZJVBIO.js";
+import {
+  wrapperCandidates
+} from "../chunk-TDNNOR6D.js";
+import {
+  passthroughCandidates
+} from "../chunk-NDSQYIWT.js";
+import {
+  similar,
+  similarAll
+} from "../chunk-TSPZOMHC.js";
+import {
+  isolated
+} from "../chunk-LUSIFBXO.js";
+import {
+  drift
+} from "../chunk-36OMT7ZJ.js";
+import {
+  extractCandidates
+} from "../chunk-CM454WL3.js";
+import {
+  complexityHotspots
+} from "../chunk-EMDQWNYR.js";
+import {
+  complexity
+} from "../chunk-BP2ATLK2.js";
+import {
+  convergence
+} from "../chunk-LB7OS35Q.js";
+import {
+  coupling,
+  topCoupling
+} from "../chunk-KVSW5KYP.js";
+import {
+  cycles
+} from "../chunk-5WTJAXY2.js";
+import {
+  dataflow
+} from "../chunk-T6ARFSBZ.js";
+import {
+  dead
+} from "../chunk-5FGUEU7N.js";
+import {
+  deepChains
+} from "../chunk-MBVNHJVN.js";
+import {
+  affected
+} from "../chunk-6VJ6Q7IE.js";
+import {
+  bottlenecks
+} from "../chunk-2QZ23IBN.js";
+import {
+  byKind,
+  kindCounts
+} from "../chunk-LAWMH22O.js";
+import {
+  callGraph
+} from "../chunk-UNTPVD36.js";
+import {
+  changeSurface
+} from "../chunk-VRUJH4BO.js";
+import "../chunk-4TYLS5XX.js";
+import {
+  code
+} from "../chunk-VZ7AMAFL.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  affected,
+  bottlenecks,
+  byKind,
+  callGraph,
+  changeSurface,
+  code,
+  complexity,
+  complexityHotspots,
+  convergence,
+  coupling,
+  cycles,
+  dataflow,
+  dead,
+  deepChains,
+  deps,
+  diffImpact,
+  docCoverage,
+  drift,
+  extractCandidates,
+  fanIn,
+  fanOut,
+  files,
+  health,
+  hierarchy,
+  hotspots,
+  importedBy,
+  imports,
+  isolated,
+  kindCounts,
+  members,
+  methods,
+  outline,
+  passthroughCandidates,
+  rdeps,
+  redundantReexports,
+  refs,
+  similar,
+  similarAll,
+  similarChains,
+  similarFiles,
+  similarSignatures,
+  slice,
+  staleAbstractions,
+  stats,
+  surface,
+  symbols,
+  system,
+  testCoverage,
+  testCoverageSummary,
+  topCoupling,
+  topFanIn,
+  topFanOut,
+  trace,
+  unusedImports,
+  wrapperCandidates
+};
+//# sourceMappingURL=index.js.map

package/dist/queries/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/isolated.d.ts

@@ -0,0 +1,14 @@
+import { S as ScipDatabase, s as IsolatedResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find isolated symbols: defined locally, referenced by nothing,
+ * and referencing nothing external. These are truly orphaned code —
+ * not just unused exports, but completely disconnected from the graph.
+ */
+declare function isolated(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+}): IsolatedResult[];
+
+export { isolated };

package/dist/queries/isolated.js

@@ -0,0 +1,9 @@
+import {
+  isolated
+} from "../chunk-LUSIFBXO.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  isolated
+};
+//# sourceMappingURL=isolated.js.map

package/dist/queries/isolated.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/members.d.ts

@@ -0,0 +1,10 @@
+import { S as ScipDatabase, M as MemberResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find all direct children of a symbol (methods, fields, nested types).
+ * Uses the enclosing_symbol relationship in global_symbols.
+ */
+declare function members(db: ScipDatabase, symbolPattern: string): MemberResult[];
+
+export { members };

package/dist/queries/members.js

@@ -0,0 +1,8 @@
+import {
+  members
+} from "../chunk-3UOUTZQT.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  members
+};
+//# sourceMappingURL=members.js.map

package/dist/queries/members.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/methods.d.ts

@@ -0,0 +1,6 @@
+import { S as ScipDatabase, t as MethodResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+declare function methods(db: ScipDatabase, className: string): MethodResult[];
+
+export { methods };

package/dist/queries/methods.js

@@ -0,0 +1,8 @@
+import {
+  methods
+} from "../chunk-NUZ4OMU3.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  methods
+};
+//# sourceMappingURL=methods.js.map

package/dist/queries/methods.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/outline.d.ts

@@ -0,0 +1,10 @@
+import { S as ScipDatabase, O as OutlineNode } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Build a tree-structured outline of symbols in a file,
+ * using the enclosing_symbol field to establish parent-child relationships.
+ */
+declare function outline(db: ScipDatabase, filePattern: string): OutlineNode[];
+
+export { outline };

package/dist/queries/outline.js

@@ -0,0 +1,8 @@
+import {
+  outline
+} from "../chunk-6SXADWLW.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  outline
+};
+//# sourceMappingURL=outline.js.map

package/dist/queries/outline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/passthrough-candidates.d.ts

@@ -0,0 +1,18 @@
+import { S as ScipDatabase, P as PassthroughCandidate } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find passthrough candidates: functions that just forward to one
+ * other function.
+ *
+ * A function with exactly 1 callee and small LOC is likely a thin
+ * wrapper that adds no value — it just passes arguments through to
+ * the real implementation.
+ */
+declare function passthroughCandidates(db: ScipDatabase, opts?: {
+    scope?: string;
+    maxLoc?: number;
+    limit?: number;
+}): PassthroughCandidate[];
+
+export { passthroughCandidates };

package/dist/queries/passthrough-candidates.js

@@ -0,0 +1,9 @@
+import {
+  passthroughCandidates
+} from "../chunk-NDSQYIWT.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  passthroughCandidates
+};
+//# sourceMappingURL=passthrough-candidates.js.map

package/dist/queries/passthrough-candidates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/redundant-reexports.d.ts

@@ -0,0 +1,22 @@
+import { S as ScipDatabase, N as RedundantReexport } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find barrel re-exports that no consumer actually imports through.
+ *
+ * If `queries/index.ts` re-exports `byKind` from `by-kind.ts`, but every
+ * consumer of `byKind` imports it directly from `by-kind.ts` (not through
+ * `index.ts`), the re-export in the barrel is dead weight.
+ *
+ * Algorithm:
+ * 1. Find all barrel files (index.ts / index.js)
+ * 2. For each barrel, find symbols it re-exports (defined elsewhere, referenced in barrel with role=0)
+ * 3. For each re-exported symbol, count consumers through the barrel vs direct from the source
+ * 4. If zero consumers go through the barrel, the re-export is redundant
+ */
+declare function redundantReexports(db: ScipDatabase, opts?: {
+    scope?: string;
+    limit?: number;
+}): RedundantReexport[];
+
+export { redundantReexports };

package/dist/queries/redundant-reexports.js

@@ -0,0 +1,8 @@
+import {
+  redundantReexports
+} from "../chunk-3E2X7RIE.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  redundantReexports
+};
+//# sourceMappingURL=redundant-reexports.js.map

package/dist/queries/redundant-reexports.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/refs.d.ts

@@ -0,0 +1,6 @@
+import { S as ScipDatabase, R as RefResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+declare function refs(db: ScipDatabase, symbolPattern: string): RefResult[];
+
+export { refs };

package/dist/queries/refs.js

@@ -0,0 +1,7 @@
+import {
+  refs
+} from "../chunk-6NBLIDF4.js";
+export {
+  refs
+};
+//# sourceMappingURL=refs.js.map

package/dist/queries/refs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/similar-chains.d.ts

@@ -0,0 +1,29 @@
+import { S as ScipDatabase, J as SimilarChainResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find end-to-end dependency flows that are structurally similar
+ * but diverge at a few points — indicating duplicated pipelines
+ * that could be consolidated.
+ *
+ * Uses infrastructure-filtered chain comparison:
+ *
+ * 1. Build all dependency chains via DFS
+ * 2. Compute node frequency across all chains
+ * 3. Filter out infrastructure nodes (appearing in >50% of chains)
+ * 4. Compare the filtered chains — what's left is the unique pipeline
+ * 5. Edit distance on filtered chains finds real structural duplicates
+ *
+ * Two chains that both pass through db.ts → types.ts is meaningless.
+ * Two chains that both pass through userValidation → userRepo → emailService
+ * after filtering is a strong consolidation signal.
+ */
+declare function similarChains(db: ScipDatabase, opts?: {
+    minSimilarity?: number;
+    limit?: number;
+    scope?: string;
+    minChainLength?: number;
+    maxChainLength?: number;
+}): SimilarChainResult[];
+
+export { similarChains };

package/dist/queries/similar-chains.js

@@ -0,0 +1,8 @@
+import {
+  similarChains
+} from "../chunk-JKP5GH6T.js";
+import "../chunk-FUHJCHS4.js";
+export {
+  similarChains
+};
+//# sourceMappingURL=similar-chains.js.map

package/dist/queries/similar-chains.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/similar-files.d.ts

@@ -0,0 +1,19 @@
+import { S as ScipDatabase, G as SimilarFileResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find files with similar dependency profiles.
+ *
+ * Two files that depend on (import from) the same set of other files
+ * are structurally doing similar work. High Jaccard similarity between
+ * their dependency sets = likely copy-paste variants or consolidation candidates.
+ */
+declare function similarFiles(db: ScipDatabase, opts?: {
+    minSimilarity?: number;
+    limit?: number;
+    scope?: string;
+    minDeps?: number;
+    filePattern?: string;
+}): SimilarFileResult[];
+
+export { similarFiles };

package/dist/queries/similar-files.js

@@ -0,0 +1,8 @@
+import {
+  similarFiles
+} from "../chunk-Z73NYSBZ.js";
+import "../chunk-FUHJCHS4.js";
+export {
+  similarFiles
+};
+//# sourceMappingURL=similar-files.js.map

package/dist/queries/similar-files.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/similar-signatures.d.ts

@@ -0,0 +1,21 @@
+import { S as ScipDatabase, Q as SimilarSignatureGroup } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find functions with near-identical type signatures (same parameter types
+ * and return type) but different names. These are "same shape" functions
+ * that may be doing similar work even if their internal implementation differs.
+ *
+ * The SCIP `documentation` field often contains the full type signature
+ * after a `|` delimiter. We parse it, normalize it (strip the function name,
+ * whitespace, and case), then group by normalized signature.
+ *
+ * Groups with 2+ functions = same-shape candidates.
+ */
+declare function similarSignatures(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    limit?: number;
+}): SimilarSignatureGroup[];
+
+export { similarSignatures };

package/dist/queries/similar-signatures.js

@@ -0,0 +1,8 @@
+import {
+  similarSignatures
+} from "../chunk-SEFSL2GF.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  similarSignatures
+};
+//# sourceMappingURL=similar-signatures.js.map

package/dist/queries/similar-signatures.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/similar.d.ts

@@ -0,0 +1,34 @@
+import { S as ScipDatabase, z as SimilarSymbolResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find functions with similar callee fingerprints using TF-IDF weighted
+ * cosine similarity.
+ *
+ * Plain Jaccard similarity inflates scores when functions share ubiquitous
+ * infrastructure imports (db, types, shortenSymbol). TF-IDF fixes this by
+ * weighting each shared callee by how rare it is:
+ *
+ *   - A callee used by 2 functions (rare) gets high weight → strong signal
+ *   - A callee used by 30 functions (common) gets low weight → noise
+ *
+ * This means two functions sharing `sendWelcomeEmail()` (rare) score
+ * much higher than two functions sharing `db.all()` (ubiquitous), even
+ * though both are "shared callees."
+ */
+declare function similar(db: ScipDatabase, symbolPattern: string, opts?: {
+    minSimilarity?: number;
+    limit?: number;
+}): SimilarSymbolResult[];
+/**
+ * Find similar symbols across the entire codebase.
+ * Uses TF-IDF weighted similarity to filter out infrastructure noise.
+ */
+declare function similarAll(db: ScipDatabase, opts?: {
+    minSimilarity?: number;
+    limit?: number;
+    scope?: string;
+    minCallees?: number;
+}): SimilarSymbolResult[];
+
+export { similar, similarAll };

package/dist/queries/similar.js

@@ -0,0 +1,11 @@
+import {
+  similar,
+  similarAll
+} from "../chunk-TSPZOMHC.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  similar,
+  similarAll
+};
+//# sourceMappingURL=similar.js.map

package/dist/queries/similar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/slice.d.ts

@@ -0,0 +1,21 @@
+import { S as ScipDatabase, L as SliceResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Reference-level program slicing: track what affects a symbol (backward)
+ * or what a symbol affects (forward).
+ *
+ * Backward slice: "What feeds into this?" — symbols referenced in the same
+ * function that defines the target. These are the inputs/dependencies.
+ *
+ * Forward slice: "What does this feed into?" — at each site where the target
+ * is referenced, find the enclosing function, then find what that function
+ * exports/defines. These are the outputs/consumers.
+ *
+ * Language-agnostic: works with any SCIP index.
+ */
+declare function slice(db: ScipDatabase, symbolPattern: string, opts?: {
+    direction?: 'backward' | 'forward';
+}): SliceResult | null;
+
+export { slice };

package/dist/queries/slice.js

@@ -0,0 +1,9 @@
+import {
+  slice
+} from "../chunk-ZJRYBOEE.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  slice
+};
+//# sourceMappingURL=slice.js.map

package/dist/queries/slice.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/stale-abstractions.d.ts

@@ -0,0 +1,18 @@
+import { S as ScipDatabase, K as StaleAbstraction } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/**
+ * Find stale abstractions: type-level symbols (classes, interfaces, type
+ * aliases) that have 0 or 1 cross-file consumers.
+ *
+ * A type that only one file uses is over-abstracted — it was designed
+ * for reuse that never materialized. Large single-consumer types are
+ * the strongest signal of wasted abstraction.
+ */
+declare function staleAbstractions(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    limit?: number;
+}): StaleAbstraction[];
+
+export { staleAbstractions };

package/dist/queries/stale-abstractions.js

@@ -0,0 +1,9 @@
+import {
+  staleAbstractions
+} from "../chunk-GJFURBEW.js";
+import "../chunk-FUHJCHS4.js";
+import "../chunk-QOV2R2WT.js";
+export {
+  staleAbstractions
+};
+//# sourceMappingURL=stale-abstractions.js.map

package/dist/queries/stale-abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/stats.d.ts

@@ -0,0 +1,6 @@
+import { S as ScipDatabase, u as StatsResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+declare function stats(db: ScipDatabase): StatsResult;
+
+export { stats };

package/dist/queries/stats.js

@@ -0,0 +1,7 @@
+import {
+  stats
+} from "../chunk-XFXDXEUN.js";
+export {
+  stats
+};
+//# sourceMappingURL=stats.js.map

package/dist/queries/stats.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/queries/surface.d.ts

@@ -0,0 +1,7 @@
+import { S as ScipDatabase, x as SurfaceResult } from '../db-BxaevAyc.js';
+import 'better-sqlite3';
+
+/** Public API surface: what symbols do external consumers actually use from this module? */
+declare function surface(db: ScipDatabase, modulePattern: string): SurfaceResult[];
+
+export { surface };