codebaseiq 0.1.0

package/dist/queries/react-large-component-pressure.d.ts

@@ -0,0 +1,34 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type ReactLargeComponentPressureAxis = 'component' | 'file' | 'jsx-structure' | 'hook-behavior';
+type ReactLargeComponentContextKind = 'component' | 'route-page';
+type ReactLargeComponentRecommendationKind = 'behavior-extraction' | 'component-decomposition' | 'file-decomposition' | 'jsx-decomposition' | 'route-page-decomposition';
+interface ReactLargeComponentPressureResult {
+    file: string;
+    component: string;
+    componentLines: number;
+    fileLines: number;
+    jsxTokens: number;
+    behaviorTokens: number;
+    dominantPressure: ReactLargeComponentPressureAxis;
+    pressureKinds: ReactLargeComponentPressureAxis[];
+    contextKind: ReactLargeComponentContextKind;
+    recommendationKind: ReactLargeComponentRecommendationKind;
+    recommendation: string;
+    reasons: string[];
+    loc: number;
+}
+declare function reactLargeComponentPressure(db: ScipDatabase, opts?: {
+    minComponentLines?: number;
+    minFileLines?: number;
+    minJsxTokens?: number;
+    minBehaviorTokens?: number;
+    limit?: number;
+    scope?: string;
+    scanLimit?: number;
+    filePattern?: string;
+}): ReactLargeComponentPressureResult[];
+
+export { type ReactLargeComponentContextKind, type ReactLargeComponentPressureAxis, type ReactLargeComponentPressureResult, type ReactLargeComponentRecommendationKind, reactLargeComponentPressure };

package/dist/queries/react-large-component-pressure.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-7NVGT435.js";import"../chunk-OTOKVOJ3.js";import"../chunk-NMTSZXCL.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as reactLargeComponentPressure};
+//# sourceMappingURL=react-large-component-pressure.js.map

package/dist/queries/recent-duplicates.d.ts

@@ -0,0 +1,79 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { G as GitHistoryMode } from '../git-history-ChNHbfZQ.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type RecentDuplicateDomain = 'callable' | 'react-component' | 'react-hook' | 'vue-component' | 'vue-composable';
+type RecentDuplicateBasis = 'callees' | 'source-tokens' | 'jsx-structure' | 'react-behavior' | 'vue-template' | 'vue-behavior';
+interface RecentDuplicateFinding {
+    /** 'echo': recent code duplicating established code. 'twin': both sides are new. */
+    kind: 'echo' | 'twin';
+    domain: RecentDuplicateDomain;
+    basis: RecentDuplicateBasis;
+    /** Stable grouping key for repeated pairwise rows behind one review item. */
+    groupKey?: string;
+    /** Stable root-cause identity without the analyzer prefix. */
+    rootCauseKey?: string;
+    echoSymbol: string;
+    echoFile: string;
+    /** Commits ago the echo's file was added. */
+    echoAgeCommits: number;
+    establishedSymbol: string;
+    establishedFile: string;
+    /** Commits ago the established file was added; null = older than the window. */
+    establishedAgeCommits: number | null;
+    similarity: number;
+    /** Domain-specific shared evidence. For callables this mirrors sharedCallees. */
+    sharedEvidence: string[];
+    /** Backwards-compatible callable evidence field. Empty for non-callable frontend domains. */
+    sharedCallees: string[];
+}
+interface RecentDuplicateRootCauseGroup {
+    groupKey: string;
+    rootCauseKey: string;
+    kind: 'echo' | 'twin';
+    domain: RecentDuplicateDomain;
+    basis: RecentDuplicateBasis;
+    count: number;
+    maxSimilarity: number;
+    findingIndexes: number[];
+    echoFiles: string[];
+    establishedFile?: string;
+    establishedSymbol?: string;
+    relatedFiles: string[];
+    sharedEvidence: string[];
+    recommendation: string;
+}
+interface RecentDuplicatesResult {
+    /** False when git history is unavailable. */
+    available: boolean;
+    windowCommits: number;
+    findings: RecentDuplicateFinding[];
+    /** Root-cause review items derived from the pairwise findings above. */
+    rootCauseGroups?: RecentDuplicateRootCauseGroup[];
+}
+/**
+ * Recent re-implementations: AI agents (and humans in a hurry) write new
+ * helpers that duplicate code they didn't know existed. Generic similarity
+ * finds the pairs; this makes them DIRECTIONAL using git file ages — which
+ * side is the established original, which is the recent echo.
+ *
+ * 'echo'  → the new code should probably use or extend the established code;
+ *           delete the echo.
+ * 'twin'  → both sides landed recently (often one agent session duplicating
+ *           itself); pick one and consolidate before they diverge.
+ *
+ * Pairs where both sides are established are ordinary `similar` territory
+ * and are skipped here.
+ */
+declare function recentDuplicates(db: ScipDatabase, opts?: {
+    windowCommits?: number;
+    minSimilarity?: number;
+    limit?: number;
+    scope?: string;
+    scanLimit?: number;
+    semantic?: boolean;
+    historyMode?: GitHistoryMode;
+}): RecentDuplicatesResult;
+
+export { type RecentDuplicateBasis, type RecentDuplicateDomain, type RecentDuplicateFinding, type RecentDuplicateRootCauseGroup, type RecentDuplicatesResult, recentDuplicates };

package/dist/queries/recent-duplicates.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-H3LGFZVK.js";import"../chunk-DQMDCD24.js";import"../chunk-RBAS5ZHI.js";import"../chunk-XWUOUWYI.js";import"../chunk-SYDJMPES.js";import"../chunk-IRQOAM5G.js";import"../chunk-OTOKVOJ3.js";import"../chunk-4WKDMDEW.js";import"../chunk-UDS562V4.js";import"../chunk-NMTSZXCL.js";import"../chunk-B75HZHUP.js";import"../chunk-7FND7D7N.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as recentDuplicates};
+//# sourceMappingURL=recent-duplicates.js.map

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

@@ -0,0 +1,37 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type RedundantReexportActionTier = 'direct' | 'signal';
+interface RedundantReexport {
+    barrelFile: string;
+    symbol: string;
+    shortName: string;
+    originalFile: string;
+    /** How many consumers import through the barrel */
+    barrelConsumers: number;
+    /** How many consumers import directly from the source */
+    directConsumers: number;
+    actionTier: RedundantReexportActionTier;
+    surfaceEvidence: string[];
+    recommendation: string;
+}
+/**
+ * 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 { type RedundantReexport, type RedundantReexportActionTier, redundantReexports };

package/dist/queries/redundant-reexports.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-UP3BUZR5.js";import"../chunk-7FND7D7N.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as redundantReexports};
+//# sourceMappingURL=redundant-reexports.js.map

package/dist/queries/reference-neighborhood.d.ts

@@ -0,0 +1,4 @@
+import '../db-D7sauVFH.js';
+export { DataflowResult, ReferenceNeighborhoodResult, dataflow, referenceNeighborhood } from './dataflow.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';

package/dist/queries/reference-neighborhood.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-LZYFLFEH.js";import"../chunk-B75HZHUP.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{b as dataflow,a as referenceNeighborhood};
+//# sourceMappingURL=reference-neighborhood.js.map

package/dist/queries/reference-reachability.d.ts

@@ -0,0 +1,48 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SliceResult {
+    symbol: string;
+    shortName: string;
+    direction: 'backward' | 'forward';
+    /** Backward: symbols referenced in the same function as the target's definition (inputs) */
+    /** Forward: symbols defined by functions that reference the target (outputs) */
+    connectedSymbols: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+        relationship: string;
+    }>;
+}
+/**
+ * Historical reference/call reachability projection.
+ *
+ * Backward slice: "What feeds into this?" — transitive closure of callees.
+ * Depth 1 = direct callees, depth 2 = their callees, etc.
+ *
+ * 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.
+ *
+ * This is not a program slice: call reachability does not establish data or
+ * control dependence. It remains available under an honest name so existing
+ * callers can migrate without losing behavior.
+ */
+declare function referenceReachability(db: ScipDatabase, symbolPattern: string, opts?: {
+    direction?: 'backward' | 'forward';
+    maxDepth?: number;
+    semantic?: boolean;
+}): SliceResult | null;
+/**
+ * @deprecated The historical implementation traverses calls and reference
+ * owners, not a program-dependence graph. Use `referenceReachability` for that
+ * legacy projection and `dependenceSlice` for data/control slicing.
+ */
+declare function slice(db: ScipDatabase, symbolPattern: string, opts?: {
+    direction?: 'backward' | 'forward';
+    maxDepth?: number;
+    semantic?: boolean;
+}): SliceResult | null;
+
+export { type SliceResult, referenceReachability, slice };

package/dist/queries/reference-reachability.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-XME3HPXZ.js";import"../chunk-7FND7D7N.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as referenceReachability,b as slice};
+//# sourceMappingURL=reference-reachability.js.map

package/dist/queries/refs.d.ts

@@ -0,0 +1,13 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface RefResult {
+    relativePath: string;
+    line: number;
+}
+declare function refs(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): RefResult[];
+
+export { type RefResult, refs };

package/dist/queries/refs.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-IJ4HMYBE.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-NNOKTMZT.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as refs};
+//# sourceMappingURL=refs.js.map

package/dist/queries/self-audit.d.ts

@@ -0,0 +1,65 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type AuditQuestion = 'references' | 'callees';
+type AuditOracleKind = 'semantic' | 'source';
+interface AuditDisagreement {
+    symbol: string;
+    question: AuditQuestion;
+    /** Files only the cheap evidence path reported (potential false positives). */
+    cheapOnly: string[];
+    /** Files only the compiler oracle reported (potential misses). */
+    oracleOnly: string[];
+}
+interface AuditQuestionScore {
+    question: AuditQuestion;
+    /** Symbols where both paths produced a comparable (non-empty) answer. */
+    comparedSymbols: number;
+    /**
+     * Null when the oracle is partial for this question (it confirms positives
+     * but doesn't enumerate all of them), so "cheap-only" answers are
+     * unverified rather than wrong and no precision claim is valid.
+     */
+    precision: number | null;
+    recall: number;
+    /** Cheap-path answers the oracle could not confirm (only meaningful when precision is null). */
+    unverified: number;
+    /** Samples skipped because the oracle is partial and produced no comparable answer. */
+    skippedOraclePartial: number;
+    /** Samples skipped because compiler-backed oracle evidence was incomplete or unavailable. */
+    skippedOracleUnavailable: number;
+}
+interface SelfAuditResult {
+    /** False when no semantic or source-backed oracle is available. */
+    available: boolean;
+    sampleSize: number;
+    /** Fraction of sampled symbols the oracle could answer at all. */
+    oracleCoverage: number;
+    /** Semantic means compiler-backed; source means language source-fact-backed. */
+    oracleKind?: AuditOracleKind;
+    scores: AuditQuestionScore[];
+    /** Largest divergences — the actionable debugging targets. */
+    topDisagreements: AuditDisagreement[];
+}
+/**
+ * Accuracy oracle: score the cheap evidence paths (SCIP + source heuristics)
+ * against the embedded TypeScript compiler (ts-morph) on a deterministic
+ * sample of symbols.
+ *
+ * This measures *agreement with compiler semantics*, not absolute truth —
+ * the compiler misses dynamic dispatch too. Comparison is at file-set
+ * granularity ("which files reference/are called by this symbol") because
+ * symbol-identity schemes differ between providers while file attribution
+ * does not.
+ *
+ * The point: "make every command as accurate as possible" is only meaningful
+ * once accuracy is a number you can track. This is that number.
+ */
+declare function selfAudit(db: ScipDatabase, opts?: {
+    samples?: number;
+    scope?: string;
+    maxDisagreements?: number;
+}): SelfAuditResult;
+
+export { type AuditDisagreement, type AuditOracleKind, type AuditQuestion, type AuditQuestionScore, type SelfAuditResult, selfAudit };

package/dist/queries/self-audit.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-VEXUL62T.js";import"../chunk-7FND7D7N.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as selfAudit};
+//# sourceMappingURL=self-audit.js.map

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

@@ -0,0 +1,48 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SimilarChainResult {
+    chainA: string[];
+    chainB: string[];
+    /** Fraction of nodes shared (0-1) */
+    similarity: number;
+    /** Edit distance between the two chains */
+    editDistance: number;
+    /** Indices where the chains diverge — the consolidation targets */
+    divergencePoints: Array<{
+        index: number;
+        nodeA: string;
+        nodeB: string;
+    }>;
+    /** Shared prefix */
+    commonPrefix: string[];
+    /** Shared suffix */
+    commonSuffix: string[];
+}
+/**
+ * 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 { type SimilarChainResult, similarChains };

package/dist/queries/similar-chains.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-CO5R3UNA.js";import"../chunk-NNOKTMZT.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as similarChains};
+//# sourceMappingURL=similar-chains.js.map

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

@@ -0,0 +1,35 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SimilarFileResult {
+    fileA: string;
+    fileB: string;
+    /** Jaccard similarity of dependency sets (0-1) */
+    similarity: number;
+    sharedDeps: string[];
+    uniqueToA: string[];
+    uniqueToB: string[];
+}
+/**
+ * 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.
+ *
+ * Evidence policy: a pair must share at least two *distinctive* deps —
+ * deps with low global fan-in. Files that overlap only on family
+ * infrastructure (the modules everyone in their directory imports) are
+ * not copy-paste variants; adapter families sharing an SDK scored 100%
+ * before this gate while differing in everything that matters.
+ */
+declare function similarFiles(db: ScipDatabase, opts?: {
+    minSimilarity?: number;
+    limit?: number;
+    scope?: string;
+    minDeps?: number;
+    filePattern?: string;
+}): SimilarFileResult[];
+
+export { type SimilarFileResult, similarFiles };

package/dist/queries/similar-files.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-Q65CQ4XL.js";import"../chunk-IRQOAM5G.js";import"../chunk-NMTSZXCL.js";import"../chunk-NNOKTMZT.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as similarFiles};
+//# sourceMappingURL=similar-files.js.map

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

@@ -0,0 +1,46 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type SignatureLocBand = '<=5' | '6-20' | '>20';
+type SimilarSignatureFunction = {
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+};
+interface SimilarSignatureGroup {
+    /** The normalized signature shared by all functions in the group */
+    signature: string;
+    /** Size band used to avoid mixing tiny helpers with larger implementations. */
+    locBand: SignatureLocBand;
+    /** True when an over-common shape was kept because the bodies match exactly. */
+    exactBody: boolean;
+    /** Functions that share this signature */
+    functions: SimilarSignatureFunction[];
+}
+/**
+ * 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. When that data is missing or too thin, we fall
+ * back to the declaration head from source. We normalize the result
+ * (strip the function name, normalize whitespace and case), then group
+ * by signature shape.
+ *
+ * Groups with 2+ functions = same-shape candidates.
+ */
+declare function similarSignatures(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    limit?: number;
+    scanLimit?: number;
+    semantic?: boolean;
+    maxShapeFrequency?: number;
+}): SimilarSignatureGroup[];
+
+export { type SimilarSignatureGroup, similarSignatures };

package/dist/queries/similar-signatures.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-7XAN6GKB.js";import"../chunk-T3DGWPXM.js";import"../chunk-4WKDMDEW.js";import"../chunk-B75HZHUP.js";import"../chunk-BGBBVSH4.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-UCD3H3UZ.js";import"../chunk-ELNRLMC5.js";import"../chunk-ZKX2FRS6.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as similarSignatures};
+//# sourceMappingURL=similar-signatures.js.map

package/dist/queries/similar.d.ts

@@ -0,0 +1,187 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SimilarSymbolResult {
+    symbolA: string;
+    shortNameA: string;
+    fileA: string;
+    symbolB: string;
+    shortNameB: string;
+    fileB: string;
+    /** Similarity score (0-1). Basis says what evidence was compared. */
+    similarity: number;
+    /** Evidence used for similarity: call graph callees or lexical source tokens. */
+    similarityBasis?: 'callees' | 'source-tokens';
+    /** Shared callees or source tokens, depending on similarityBasis. */
+    sharedCallees: string[];
+    /** Callees or source tokens unique to A, depending on similarityBasis. */
+    uniqueToA: string[];
+    /** Callees or source tokens unique to B, depending on similarityBasis. */
+    uniqueToB: string[];
+    evidenceClass: SimilarEvidenceClass;
+    actionTier: SimilarActionTier;
+    evidenceClassReasons: string[];
+    recommendation: string;
+}
+interface SimilarConsolidationPlan {
+    symbolA: {
+        symbol: string;
+        shortName: string;
+        file: string;
+        loc: number;
+    };
+    symbolB: {
+        symbol: string;
+        shortName: string;
+        file: string;
+        loc: number;
+    };
+    similarity: number;
+    similarityBasis: NonNullable<SimilarSymbolResult['similarityBasis']>;
+    sharedEvidence: string[];
+    uniqueToA: string[];
+    uniqueToB: string[];
+    evidenceClass: SimilarEvidenceClass;
+    actionTier: SimilarActionTier;
+    recommendation: string;
+    consolidationStrategy: string;
+}
+type SimilarEvidenceClass = 'access-query-scaffolding' | 'domain-behavior' | 'framework-scaffolding' | 'mixed' | 'structural-overlap';
+type SimilarActionTier = 'direct' | 'signal';
+interface SimilarEvidenceClassification {
+    evidenceClass: SimilarEvidenceClass;
+    actionTier: SimilarActionTier;
+    evidenceClassReasons: string[];
+    recommendation: string;
+}
+/**
+ * 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;
+    scanLimit?: number;
+    semantic?: boolean;
+    sourceCandidateMode?: SourceCandidateMode;
+}): SimilarSymbolResult[];
+declare function similarConsolidationPlan(db: ScipDatabase, symbolPatternA: string, symbolPatternB: string, opts?: {
+    semantic?: boolean;
+    scanLimit?: number;
+}): SimilarConsolidationPlan | null;
+declare function targetSpecificIdfWeights(target: SymbolFingerprint, index: Pick<CalleeFingerprintIndex, 'corpus' | 'docFreq'>): Map<string, number>;
+interface ComparePairOptions {
+    minSimilarity: number;
+    /** Pair is dropped when significantShared.length < this AND sharedCount < requireSharedCount. */
+    requireSignificantShared: number;
+    requireSharedCount: number;
+    medianIdf?: number;
+    magnitudeA?: number;
+    magnitudeB?: number;
+}
+declare function comparePair(a: SymbolFingerprint, b: SymbolFingerprint, idfWeights: ReadonlyMap<string, number>, opts: ComparePairOptions): SimilarSymbolResult | null;
+/**
+ * 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;
+    crossFileOnly?: boolean;
+    scanLimit?: number;
+    semantic?: boolean;
+    focusFiles?: ReadonlySet<string>;
+}): SimilarSymbolResult[];
+declare function similarAllCount(db: ScipDatabase, opts?: {
+    minSimilarity?: number;
+    scope?: string;
+    minCallees?: number;
+    crossFileOnly?: boolean;
+    scanLimit?: number;
+    semantic?: boolean;
+    focusFiles?: ReadonlySet<string>;
+}): number;
+interface SymbolFingerprint {
+    symbol: string;
+    file: string;
+    callees: Set<string>;
+    paramCount: number;
+}
+type SourceCandidateMode = 'full' | 'target-pruned';
+interface CalleeFingerprintCorpusOptions {
+    minCallees: number;
+    scope?: string;
+    excludeSymbol?: string;
+    scanLimit?: number;
+    semantic?: boolean;
+}
+interface CalleeFingerprintIndexOptions {
+    minCallees: number;
+    scope?: string;
+    scanLimit?: number;
+    semantic?: boolean;
+}
+interface SourceFingerprintOptions {
+    scanLimit?: number;
+}
+interface SourceFingerprintCandidateOptions extends SourceFingerprintOptions {
+    minSimilarity: number;
+    candidateMode?: SourceCandidateMode;
+}
+interface SimilarityFingerprintProduct {
+    calleeCorpus(opts: CalleeFingerprintCorpusOptions): SymbolFingerprint[];
+    calleeIndex(opts: CalleeFingerprintIndexOptions): CalleeFingerprintIndex;
+    sourceCorpus(opts?: SourceFingerprintOptions): SourceFingerprint[];
+    sourceIndex(opts?: SourceFingerprintOptions): SourceFingerprintIndex;
+    sourceCandidates(target: SourceFingerprint, opts: SourceFingerprintCandidateOptions): SourceFingerprint[];
+}
+interface CalleeFingerprintIndex {
+    corpus: readonly SymbolFingerprint[];
+    candidateIndexesByCallee: ReadonlyMap<string, readonly number[]>;
+    docFreq: ReadonlyMap<string, number>;
+    idfWeights: ReadonlyMap<string, number>;
+    weightedMagnitudes: readonly number[];
+    medianIdf: number;
+    ubiquityThreshold: number;
+}
+interface SourceFingerprint {
+    symbol: string;
+    file: string;
+    tokens: Set<string>;
+}
+interface SourceFingerprintIndex {
+    corpus: readonly SourceFingerprint[];
+    candidateByToken: ReadonlyMap<string, readonly SourceFingerprint[]>;
+    docFreq: ReadonlyMap<string, number>;
+    ubiquityThreshold: number;
+}
+interface RankedSimilarResult {
+    result: SimilarSymbolResult;
+    order: number;
+}
+declare function insertTopSimilarResult(top: RankedSimilarResult[], result: SimilarSymbolResult, limit: number, order: number): void;
+declare function getAllCalleeFingerprints(db: ScipDatabase, opts: CalleeFingerprintCorpusOptions): SymbolFingerprint[];
+declare function getCalleeFingerprintIndex(db: ScipDatabase, opts: CalleeFingerprintIndexOptions): CalleeFingerprintIndex;
+declare function similarityFingerprintProduct(db: ScipDatabase): SimilarityFingerprintProduct;
+declare function buildCalleeFingerprintIndex(corpus: readonly SymbolFingerprint[]): CalleeFingerprintIndex;
+declare function candidateFingerprintsForTarget(target: SymbolFingerprint, index: CalleeFingerprintIndex): SymbolFingerprint[];
+declare const SAME_FILE_SIBLING_SATURATION_THRESHOLD = 5;
+declare function trimSameFileSiblingSaturatedCallees(fingerprints: readonly SymbolFingerprint[]): SymbolFingerprint[];
+declare function meaningfulCallees(callees: Iterable<string>): Set<string>;
+declare function classifySimilarityEvidence(sharedEvidence: readonly string[], basis: NonNullable<SimilarSymbolResult['similarityBasis']>): SimilarEvidenceClassification;
+
+export { type CalleeFingerprintCorpusOptions, type CalleeFingerprintIndex, type CalleeFingerprintIndexOptions, type RankedSimilarResult, SAME_FILE_SIBLING_SATURATION_THRESHOLD, type SimilarActionTier, type SimilarConsolidationPlan, type SimilarEvidenceClass, type SimilarEvidenceClassification, type SimilarSymbolResult, type SimilarityFingerprintProduct, type SourceCandidateMode, type SourceFingerprint, type SourceFingerprintCandidateOptions, type SourceFingerprintIndex, type SourceFingerprintOptions, type SymbolFingerprint, buildCalleeFingerprintIndex, candidateFingerprintsForTarget, classifySimilarityEvidence, comparePair, getAllCalleeFingerprints, getCalleeFingerprintIndex, insertTopSimilarResult, meaningfulCallees, similar, similarAll, similarAllCount, similarConsolidationPlan, similarityFingerprintProduct, targetSpecificIdfWeights, trimSameFileSiblingSaturatedCallees };