codebaseiq 0.1.0

package/dist/queries/co-change.d.ts

@@ -0,0 +1,90 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { C as CoChangeCommitScope, a as CoChangeRecency, b as CoChangeSubjectContext, G as GitHistoryMode } from '../git-history-ChNHbfZQ.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type CoChangePartnerClass = 'doc-code' | 'config-code' | 'schema-script' | 'model-view' | 'test-code' | 'same-feature' | 'unknown';
+interface CoChangePartnerClassification {
+    partnerClass: CoChangePartnerClass;
+    reasons: string[];
+}
+interface DeclaredCouplingSuggestion {
+    name: string;
+    files: string[];
+    reason: string;
+}
+interface CoChangePairEvidence {
+    fileA: string;
+    fileB: string;
+    together: number;
+    confidence: number;
+    commitScope?: CoChangeCommitScope;
+    recency?: CoChangeRecency;
+    subjectContext?: CoChangeSubjectContext;
+}
+interface CoChangeFinding {
+    fileA: string;
+    fileB: string;
+    /** Commits in the analyzed window where both files changed. */
+    together: number;
+    /** max(P(B|A), P(A|B)) over the analyzed window. */
+    confidence: number;
+    changesA: number;
+    changesB: number;
+    focusedTogether: number;
+    broadTogether: number;
+    broadCommitRatio: number;
+    lastTogetherAt: number;
+    recentTogether: number;
+    commitScope: CoChangeCommitScope;
+    recency: CoChangeRecency;
+    subjectContext: CoChangeSubjectContext;
+    /** True when a dependency edge or declared coupling already explains the pair. */
+    structurallyLinked: boolean;
+    partnerClass: CoChangePartnerClass;
+    partnerClassReasons: string[];
+    declaredCouplingSuggestion?: DeclaredCouplingSuggestion;
+}
+interface CoChangeResult {
+    /** False when git history is unavailable (not a repo, git missing). */
+    available: boolean;
+    commitsAnalyzed: number;
+    findings: CoChangeFinding[];
+}
+declare function isCoChangeNoiseFile(file: string): boolean;
+/**
+ * Hidden coupling from the change graph: file pairs that repeatedly change
+ * in the same commits but have no structural link between them.
+ *
+ * The reference graph cannot see that two mechanisms implement one concept —
+ * a config list and the test that checks it share no symbols. The commit
+ * history can: if editing one reliably means editing the other, a maintainer
+ * who edits only one is probably introducing drift. With a `file` argument,
+ * reports that file's co-change partners instead (including structurally
+ * linked ones — exploration mode).
+ */
+declare function coChange(db: ScipDatabase, file?: string, opts?: {
+    minTogether?: number;
+    minConfidence?: number;
+    limit?: number;
+    includeLinked?: boolean;
+    maxFilesPerCommit?: number;
+    historyMode?: GitHistoryMode;
+    /** Already-resolved invocation HEAD for snapshot-consistent Git evidence without another subprocess. */
+    head?: string;
+    /**
+     * Caps how many of the (already together-count-sorted) candidate pairs
+     * get classified — the per-pair loop below does filesystem/graph lookups
+     * so its cost scales with candidate count on a large repo history. Set
+     * by the CLI's analysis-budget disclosure on large indexes; honoring it
+     * for real (rather than only disclosing it) keeps the disclosed budget
+     * truthful. Highest-`together` pairs are kept first since `coChangePairs`
+     * returns them pre-sorted by priority.
+     */
+    scanLimit?: number;
+}): CoChangeResult;
+declare function classifyCoChangePartner(fileA: string, fileB: string): CoChangePartnerClassification;
+declare function declaredCouplingSuggestionForPair(pair: CoChangePairEvidence, classification: CoChangePartnerClassification, structurallyLinked: boolean): DeclaredCouplingSuggestion | undefined;
+declare function coChangeStructuralLinkChecker(db: ScipDatabase, graph?: Map<string, Set<string>>, declaredCouplings?: ReadonlySet<string>[]): (fileA: string, fileB: string) => boolean;
+
+export { type CoChangeFinding, type CoChangePairEvidence, type CoChangePartnerClass, type CoChangePartnerClassification, type CoChangeResult, type DeclaredCouplingSuggestion, classifyCoChangePartner, coChange, coChangeStructuralLinkChecker, declaredCouplingSuggestionForPair, isCoChangeNoiseFile };

package/dist/queries/co-change.js

@@ -0,0 +1,2 @@
+import{a,b,c,d,e}from"../chunk-SWHMHUKF.js";import"../chunk-4WKDMDEW.js";import"../chunk-P5XHIJHI.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.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{c as classifyCoChangePartner,b as coChange,e as coChangeStructuralLinkChecker,d as declaredCouplingSuggestionForPair,a as isCoChangeNoiseFile};
+//# sourceMappingURL=co-change.js.map

package/dist/queries/code.d.ts

@@ -0,0 +1,6 @@
+export { S as SourceObservationFreshness, a as SourceSemanticFreshnessState } from '../repository-text-C0Q8VYdN.js';
+import '../db-D7sauVFH.js';
+export { b as CodeBatchEntry, c as CodeBatchResult, d as CodeFileCoverage, e as CodeFileDefinitionLedgerEntry, f as CodeFileMemberMode, g as CodeRangeCoverage, h as CodeResolutionCandidate, C as CodeResult, i as CodeSelectorKind, j as CodeSelectorStatus, l as code, m as codeBatch } from '../code-DlqpBDd0.js';
+import './outline.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';

package/dist/queries/code.js

@@ -0,0 +1,2 @@
+import{d as a,e as b}from"../chunk-Y6KHROC3.js";import"../chunk-PTAWHLVJ.js";import"../chunk-ST7V3SKN.js";import"../chunk-YSNONTJ2.js";import"../chunk-QHRNXP3C.js";import"../chunk-GTXSJDCO.js";import"../chunk-XLQ3GLWZ.js";import"../chunk-JEJLSICM.js";import"../chunk-VE5AVNMP.js";import"../chunk-J77SU6VA.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.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 code,b as codeBatch};
+//# sourceMappingURL=code.js.map

package/dist/queries/complexity-hotspots.d.ts

@@ -0,0 +1,61 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { BranchEstimateBasis } from './complexity.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+import '../symbol-types-BIQwfoAx.js';
+
+interface ComplexityHotspot {
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    fanIn: number;
+    fanOut: number;
+    calleeCount: number;
+    branches: number;
+    estimateBasis: BranchEstimateBasis;
+    score: number;
+}
+type ComplexitySemanticEvidenceStatus = 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+interface ComplexityHotspotCoverage {
+    semanticEvidence: {
+        enabled: boolean;
+        status: ComplexitySemanticEvidenceStatus;
+        incompleteSymbolCount: number;
+        unavailableSymbolCount: number;
+        excludedSymbolCount: number;
+    };
+}
+interface ComplexityHotspotsEvidenceResult {
+    rows: ComplexityHotspot[];
+    coverage: ComplexityHotspotCoverage;
+}
+/**
+ * Find complexity hotspots: symbols with a composite score based on
+ * LOC, fan-in, fan-out, and callee count.
+ *
+ * Score = (loc / 50) * (fanIn / 5) * max(fanOut / 5, 1) * max(cyclomatic / 5, 1)
+ *
+ * Bulk fan-in/out via caller evidence + buildCalleeMap so we pay
+ * one SQL pass per kind regardless of how many definitions we score —
+ * replaces the previous per-symbol getCaller/CalleeRowsForSymbol calls
+ * that were O(symbols × files) on large indexes.
+ */
+declare function complexityHotspots(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    limit?: number;
+    scanLimit?: number;
+    semantic?: boolean;
+}): ComplexityHotspot[];
+declare function complexityHotspotsEvidence(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    limit?: number;
+    scanLimit?: number;
+    semantic?: boolean;
+}): ComplexityHotspotsEvidenceResult;
+
+export { type ComplexityHotspot, type ComplexityHotspotCoverage, type ComplexityHotspotsEvidenceResult, type ComplexitySemanticEvidenceStatus, complexityHotspots, complexityHotspotsEvidence };

package/dist/queries/complexity-hotspots.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-C6SBF2WH.js";import"../chunk-DGXRDLV5.js";import"../chunk-OL6KJP3N.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 complexityHotspots,b as complexityHotspotsEvidence};
+//# sourceMappingURL=complexity-hotspots.js.map

package/dist/queries/complexity.d.ts

@@ -0,0 +1,74 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { S as SymbolMatch } from '../symbol-types-BIQwfoAx.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SyntaxNode {
+    type: string;
+    text: string;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    startIndex: number;
+    endIndex: number;
+    childCount: number;
+    namedChildCount: number;
+    children: SyntaxNode[];
+    namedChildren: SyntaxNode[];
+    parent: SyntaxNode | null;
+    child(index: number): SyntaxNode | null;
+    namedChild(index: number): SyntaxNode | null;
+    childForFieldName(name: string): SyntaxNode | null;
+    descendantsOfType(type: string | string[]): SyntaxNode[];
+}
+
+interface ComplexityResult {
+    symbol: string;
+    shortName: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    /** Branch count from AST when available, otherwise source-level regex fallback. */
+    branches: number;
+    estimateBasis: BranchEstimateBasis;
+    /** Cyclomatic complexity estimate: branches + 1 */
+    cyclomaticEstimate: number;
+    /** Number of distinct callees within the definition */
+    calleeCount: number | null;
+    fanIn: number;
+    fanOut: number | null;
+    coverage: {
+        semanticEvidence: 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+    };
+}
+type BranchEstimateBasis = 'ast' | 'regex-fallback';
+interface BranchEstimate {
+    branches: number;
+    estimateBasis: BranchEstimateBasis;
+}
+/**
+ * Per-symbol complexity analysis combining source-level branch counting
+ * with index-level metrics (fan-in, fan-out, callee count).
+ *
+ * Branch counting uses language-aware regex. The language is read from
+ * the SCIP documents table, so it works for any indexed language.
+ */
+declare function complexity(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): ComplexityResult | null;
+declare function branchEstimateForDefinition(db: ScipDatabase, definition: SymbolMatch): BranchEstimate;
+declare function branchEstimatesForDefinitions(db: ScipDatabase, definitions: ReadonlyArray<SymbolMatch>): Map<number, BranchEstimate>;
+/**
+ * Count branch points in a parsed AST. The count follows the same practical
+ * McCabe approximation as the command output: decision nodes plus boolean
+ * decision operators.
+ */
+declare function countBranchesFromAst(node: SyntaxNode): number;
+
+export { type BranchEstimate, type BranchEstimateBasis, type ComplexityResult, branchEstimateForDefinition, branchEstimatesForDefinitions, complexity, countBranchesFromAst };

package/dist/queries/complexity.js

@@ -0,0 +1,2 @@
+import{a,b,c,d}from"../chunk-OL6KJP3N.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{b as branchEstimateForDefinition,c as branchEstimatesForDefinitions,a as complexity,d as countBranchesFromAst};
+//# sourceMappingURL=complexity.js.map

package/dist/queries/context.d.ts

@@ -0,0 +1,146 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { b as CoChangeSubjectContext } from '../git-history-ChNHbfZQ.js';
+import { AffectedResult, PossibleImpactCoverage } from './affected.js';
+import { CallGraphResult } from './call-graph.js';
+import { ChangeSurfaceResult } from './change-surface.js';
+import { SimilarSymbolResult } from './similar.js';
+import { ComplexityResult } from './complexity.js';
+import { DataflowResult } from './dataflow.js';
+import { DepResult } from './deps.js';
+import { SliceResult } from './reference-reachability.js';
+import { SurfaceResult } from './surface.js';
+import { SystemResult } from './system.js';
+import { TraceResult } from './trace.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+import '../symbol-types-BIQwfoAx.js';
+import './symbols.js';
+
+interface RepositoryContextOptions {
+    semantic?: boolean;
+    impactDepth?: number;
+    sliceDepth?: number;
+    scope?: string;
+    /** Already-resolved invocation HEAD for snapshot-consistent history evidence. */
+    gitHead?: string;
+}
+/** Decision-time history risk for the target's file, from the change graph. */
+interface RepositoryContextHistory {
+    /** False when git history is unavailable or no file could be resolved. */
+    available: boolean;
+    file: string | null;
+    churn: {
+        changes: number;
+        fixChanges: number;
+        lastChangedAt: number;
+    } | null;
+    /** Files that usually change together with this one — edit checklist. */
+    coChangePartners: Array<{
+        file: string;
+        together: number;
+        confidence: number;
+        subjectContext: CoChangeSubjectContext;
+    }>;
+    /** Detector suppressions present in the file — known accepted findings. */
+    suppressionsInFile: number;
+}
+interface RepositoryContextAffectedConsumer {
+    symbol: string;
+    shortName: string;
+    file: string;
+    referenceCount: number;
+}
+interface RepositoryContextConsumerReuseCandidate {
+    /** Similarity evidence between one affected consumer and this possible existing owner. */
+    candidate: SimilarSymbolResult;
+    /** Affected consumers whose bounded similarity scan produced this same possible owner. */
+    consumers: RepositoryContextAffectedConsumer[];
+}
+interface RepositoryContextConsumerReuseCoverage {
+    totalConsumers: number;
+    analyzedConsumers: number;
+    omittedConsumers: number;
+    perConsumerSearchLimit: number;
+    perConsumerCandidateLimit: number;
+    candidateLimit: number;
+    returnedCandidates: number;
+}
+interface RepositoryContextConsumerReuse {
+    candidates: RepositoryContextConsumerReuseCandidate[];
+    coverage: RepositoryContextConsumerReuseCoverage;
+}
+interface RepositoryContextPrimaryCallable {
+    symbol: string;
+    shortName: string;
+    file: string;
+}
+interface RepositoryContextSourceSlice extends RepositoryContextPrimaryCallable {
+    role: 'target' | 'consumer' | 'reuse-candidate';
+    startLine: number;
+    endLine: number;
+    source: string;
+    omittedLines: number;
+    /** Exact reference lines inside a consumer-centered source window. */
+    focusLines?: number[];
+}
+interface RepositoryContextSourcePacket {
+    slices: RepositoryContextSourceSlice[];
+    candidateSlices: number;
+    omittedSlices: number;
+    maxSlices: number;
+    maxLinesPerSlice: number;
+    maxTotalLines: number;
+    targetLineLimit?: number;
+    consumerContextLines?: number;
+    reuseLineLimit?: number;
+}
+interface RepositoryContextResult {
+    target: string;
+    /** One callable selected from a file target only when the choice is unambiguous. */
+    primaryCallable?: RepositoryContextPrimaryCallable;
+    matched: {
+        symbol: boolean;
+        file: boolean;
+        module: boolean;
+    };
+    history: RepositoryContextHistory;
+    trace: TraceResult;
+    callGraph: CallGraphResult | null;
+    complexity: ComplexityResult | null;
+    dataflow: DataflowResult | null;
+    backwardSlice: SliceResult | null;
+    forwardSlice: SliceResult | null;
+    affected: AffectedResult[];
+    affectedCoverage: PossibleImpactCoverage | null;
+    changeSurface: ChangeSurfaceResult | null;
+    deps: DepResult[];
+    rdeps: DepResult[];
+    system: SystemResult;
+    surface: SurfaceResult[];
+    /** Bounded existing symbols whose implementation evidence may support reuse. */
+    reuseCandidates?: SimilarSymbolResult[];
+    /**
+     * Bounded possible owners found by comparing functions that directly use
+     * the target. Kept separate because this is surrounding-behavior evidence,
+     * not evidence that the owner can replace the target itself.
+     */
+    affectedConsumerReuse?: RepositoryContextConsumerReuse;
+    /** Bounded source slices for the target, its direct consumers, and possible owners. */
+    sourcePacket?: RepositoryContextSourcePacket;
+    warnings: string[];
+}
+declare function repositoryContext(db: ScipDatabase, target: string, opts?: RepositoryContextOptions): RepositoryContextResult;
+interface AffectedConsumerReuseLimits {
+    consumerLimit?: number;
+    perConsumerSearchLimit?: number;
+    perConsumerCandidateLimit?: number;
+    candidateLimit?: number;
+}
+/**
+ * Turn compiler-resolved target references into a bounded search for existing
+ * owners of the surrounding consumer behavior. Exported for a pure contract
+ * test; production supplies `similar` as the evidence source.
+ */
+declare function discoverAffectedConsumerReuse(traceResult: Pick<TraceResult, 'referencedBy'>, targetSymbol: string | null, findSimilar: (consumerSymbol: string) => SimilarSymbolResult[], limits?: AffectedConsumerReuseLimits): RepositoryContextConsumerReuse;
+
+export { type RepositoryContextAffectedConsumer, type RepositoryContextConsumerReuse, type RepositoryContextConsumerReuseCandidate, type RepositoryContextConsumerReuseCoverage, type RepositoryContextHistory, type RepositoryContextOptions, type RepositoryContextPrimaryCallable, type RepositoryContextResult, type RepositoryContextSourcePacket, type RepositoryContextSourceSlice, discoverAffectedConsumerReuse, repositoryContext };

package/dist/queries/context.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-6MUIJMVL.js";import"../chunk-N3IQCBCF.js";import"../chunk-GCHRX4YW.js";import"../chunk-XME3HPXZ.js";import"../chunk-BFFZDZQV.js";import"../chunk-ID63777H.js";import"../chunk-AKB7V7TV.js";import"../chunk-GW6Z3WGY.js";import"../chunk-LZYFLFEH.js";import"../chunk-T3DGWPXM.js";import"../chunk-KMITESMT.js";import"../chunk-ANFVSJWQ.js";import"../chunk-SWHMHUKF.js";import"../chunk-4WKDMDEW.js";import"../chunk-PTAWHLVJ.js";import"../chunk-YSNONTJ2.js";import"../chunk-GTXSJDCO.js";import"../chunk-OL6KJP3N.js";import"../chunk-UDS562V4.js";import"../chunk-NMTSZXCL.js";import"../chunk-LU3BMVH2.js";import"../chunk-JEJLSICM.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{b as discoverAffectedConsumerReuse,a as repositoryContext};
+//# sourceMappingURL=context.js.map

package/dist/queries/convergence.d.ts

@@ -0,0 +1,33 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface ConvergenceResult {
+    symbolA: {
+        symbol: string;
+        shortName: string;
+        file: string;
+        loc: number;
+    };
+    symbolB: {
+        symbol: string;
+        shortName: string;
+        file: string;
+        loc: number;
+    };
+    similarity: number;
+    sharedCallees: string[];
+    uniqueToA: string[];
+    uniqueToB: string[];
+    consolidationStrategy: string;
+}
+/**
+ * Given two similar symbols, show what a consolidated version would look like.
+ * The shared callee set becomes the common body. The unique callees become
+ * the parameterization points.
+ */
+declare function convergence(db: ScipDatabase, symbolPatternA: string, symbolPatternB: string, opts?: {
+    semantic?: boolean;
+}): ConvergenceResult | null;
+
+export { type ConvergenceResult, convergence };

package/dist/queries/convergence.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-BH5F2Q4O.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 convergence};
+//# sourceMappingURL=convergence.js.map

package/dist/queries/coupling.d.ts

@@ -0,0 +1,32 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface CouplingResult {
+    file1: string;
+    file2: string;
+    sharedSymbols: number;
+    actionTier: 'signal';
+    couplingKind: 'shared-symbol-coupling';
+    evidenceReasons: string[];
+    recommendation: string;
+}
+/**
+ * Measure coupling between two files: how many symbols do they share
+ * (symbols defined in one and referenced in the other, or vice versa).
+ */
+declare function coupling(db: ScipDatabase, file1: string, file2: string): CouplingResult;
+declare function sharedSymbolCoupling(db: ScipDatabase, file1: string, file2: string): CouplingResult;
+/**
+ * Find the most coupled file pairs in the codebase.
+ */
+declare function topCoupling(db: ScipDatabase, opts?: {
+    limit?: number;
+    scope?: string;
+}): CouplingResult[];
+declare function topSharedSymbolCoupling(db: ScipDatabase, opts?: {
+    limit?: number;
+    scope?: string;
+}): CouplingResult[];
+
+export { type CouplingResult, coupling, sharedSymbolCoupling, topCoupling, topSharedSymbolCoupling };

package/dist/queries/coupling.js

@@ -0,0 +1,2 @@
+import{a,b,c,d}from"../chunk-HRWGYWRJ.js";import"../chunk-GTXSJDCO.js";import"../chunk-UZGZB3VB.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 coupling,b as sharedSymbolCoupling,c as topCoupling,d as topSharedSymbolCoupling};
+//# sourceMappingURL=coupling.js.map

package/dist/queries/cycles.d.ts

@@ -0,0 +1,66 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { F as FileDependencyEdgeBasis } from '../file-dep-graph-Bqg3t3Px.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface CycleResult {
+    /** One deterministic directed witness path; the first file is repeated at the end. */
+    path: string[];
+    /** Every file in the cyclic strongly connected component represented by the witness. */
+    component?: string[];
+    /** The file edge relation on which cyclic reachability was computed. */
+    edgeBasis?: FileDependencyEdgeBasis;
+    /** Distinguishes a witness from an enumeration of every simple cycle. */
+    witness?: true;
+    classification?: 'dependency-cycle' | 'module-structure-candidate';
+    /**
+     * @deprecated Compatibility field. Prefer `classification`: “real” was too
+     * strong for a static dependency observation.
+     *
+     * Historical classification of the cycle:
+     *   - 'real':            architectural cycle worth fixing
+     *   - 'module-hierarchy': barrel-file pattern (mod.rs / index.ts /
+     *                        __init__.py declaring children that re-import
+     *                        parent re-exports). Standard module structure,
+     *                        not actionable.
+     */
+    kind: 'real' | 'module-hierarchy';
+}
+interface CycleSummary {
+    cycles: CycleResult[];
+    truncated: boolean;
+    edgeBasis?: FileDependencyEdgeBasis;
+    maxDepth: number;
+}
+interface DependencyCycleOptions {
+    scope?: string;
+    /** @deprecated Cycle enumeration is SCC-complete; this value is reported only for legacy callers. */
+    maxDepth?: number;
+    edgeBasis?: FileDependencyEdgeBasis;
+}
+/**
+ * Detect circular dependency chains between files.
+ * A cycle exists when file A depends on B, B depends on C, and C depends on A.
+ *
+ * By default this uses the same symbol-reference plus source-import dependency
+ * edges as `deps`. `edgeBasis: 'imports'` selects the narrower import graph.
+ * Every cyclic strongly connected component is returned exactly once with one
+ * deterministic witness path; this is not an enumeration of every simple cycle.
+ */
+declare function cycles(db: ScipDatabase, opts?: {
+    scope?: string;
+    maxDepth?: number;
+}): CycleResult[];
+declare function cycleSummary(db: ScipDatabase, opts?: {
+    scope?: string;
+    maxDepth?: number;
+}): CycleSummary;
+/**
+ * Enumerate cyclic strongly connected components in a named file-dependency
+ * relation. This is the explicit replacement for selecting a different graph
+ * through the legacy `cycles` API.
+ */
+declare function dependencyCycles(db: ScipDatabase, opts?: DependencyCycleOptions): CycleResult[];
+declare function dependencyCycleSummary(db: ScipDatabase, opts?: DependencyCycleOptions): CycleSummary;
+
+export { type CycleResult, type CycleSummary, type DependencyCycleOptions, FileDependencyEdgeBasis, cycleSummary, cycles, dependencyCycleSummary, dependencyCycles };

package/dist/queries/cycles.js

@@ -0,0 +1,2 @@
+import{a,b,c,d}from"../chunk-PX4RYAAK.js";import"../chunk-35NLDRZC.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.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{b as cycleSummary,a as cycles,d as dependencyCycleSummary,c as dependencyCycles};
+//# sourceMappingURL=cycles.js.map

package/dist/queries/dataflow.d.ts

@@ -0,0 +1,77 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface DataflowResult {
+    symbol: string;
+    shortName: string;
+    relativePath: string;
+    /** Where the symbol is defined (role=1) */
+    definitionSites: Array<{
+        file: string;
+        line: number;
+    }>;
+    /** Where the symbol is referenced (role!=1) */
+    usageSites: Array<{
+        file: string;
+        line: number;
+        enclosingSymbol: string;
+        enclosingShort: string;
+    }>;
+    /** Symbols that appear in the same function that defines this symbol (producers/inputs) */
+    producers: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+    /** Symbols defined by functions that reference this symbol (consumers/outputs) */
+    consumers: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+}
+interface ReferenceNeighborhoodResult {
+    symbol: string;
+    shortName: string;
+    relativePath: string;
+    definitionSites: Array<{
+        file: string;
+        line: number;
+    }>;
+    referenceSites: Array<{
+        file: string;
+        line: number;
+        enclosingSymbol: string;
+        enclosingShort: string;
+    }>;
+    outgoingCalls: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+    incomingCalls: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+}
+/**
+ * Compiler-identified definition/reference sites plus the static call
+ * neighborhood of one symbol. This projection deliberately makes no value-flow
+ * claim: an outgoing callee is not necessarily a producer and an incoming
+ * caller is not necessarily a consumer of a returned value.
+ */
+declare function referenceNeighborhood(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): ReferenceNeighborhoodResult | null;
+/**
+ * @deprecated This historical command returns a reference/call neighborhood,
+ * not value-level data flow. Use `referenceNeighborhood` for that projection
+ * and `valueFlow` for proved data-dependence edges.
+ */
+declare function dataflow(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): DataflowResult | null;
+
+export { type DataflowResult, type ReferenceNeighborhoodResult, dataflow, referenceNeighborhood };

package/dist/queries/dataflow.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=dataflow.js.map