codebaseiq 0.1.0

package/dist/queries/affected.d.ts

@@ -0,0 +1,40 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface AffectedResult {
+    symbol: string;
+    shortName: string;
+    file: string;
+    depth: number;
+}
+interface PossibleImpactCoverage {
+    status: 'accounted' | 'bounded' | 'incomplete';
+    edgeBasis: 'reverse-static-call-or-reference-evidence';
+    maxDepth: number;
+    reachedDepth: number;
+    perSymbolEvidenceLimit: number | null;
+    remainingFrontierSymbols: number;
+    reasons: string[];
+    semanticEvidence: 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable';
+}
+interface PossibleImpactClosureResult {
+    rows: AffectedResult[];
+    coverage: PossibleImpactCoverage;
+}
+/**
+ * Bounded reverse closure of symbols that may consume a given symbol.
+ * BFS from the target through the mention graph: depth 1 = direct consumers,
+ * depth 2 = consumers of consumers, etc.
+ */
+declare function affected(db: ScipDatabase, symbolPattern: string, opts?: {
+    maxDepth?: number;
+    scope?: string;
+}): AffectedResult[];
+/** Conservative reverse reference/caller closure; rows are possible impacts, not predicted failures. */
+declare function possibleImpactClosure(db: ScipDatabase, symbolPattern: string, opts?: {
+    maxDepth?: number;
+    scope?: string;
+}): PossibleImpactClosureResult;
+
+export { type AffectedResult, type PossibleImpactClosureResult, type PossibleImpactCoverage, affected, possibleImpactClosure };

package/dist/queries/affected.js

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

package/dist/queries/anchors.d.ts

@@ -0,0 +1,123 @@
+import { F as FileKind } from '../file-kind-BKCVMNUf.js';
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { a as CalleeEvidenceSource } from '../call-graph-evidence-gNsxjCW8.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type AnchorDiscoveryMatchSource = 'symbol' | 'path' | 'documentation' | 'source';
+interface AnchorDiscoveryTermMatch {
+    term: string;
+    sources: AnchorDiscoveryMatchSource[];
+    locations: Array<{
+        file: string;
+        line: number;
+    }>;
+}
+interface AnchorDiscoveryCandidate {
+    symbol: string;
+    label: string;
+    leaf: string;
+    file: string;
+    line: number;
+    endLine: number;
+    kind: 'callable' | 'type' | 'symbol';
+    fileKind: FileKind;
+    matches: AnchorDiscoveryTermMatch[];
+    focusLocations: Array<{
+        file: string;
+        line: number;
+        matchedTerms: string[];
+    }>;
+    matchedTerms: string[];
+    symbolMatchedTerms: string[];
+    symbolPhraseLength: number;
+    identityMatchedTerms: string[];
+    rarity: number;
+    symbolRarity: number;
+    /** Exact slash-delimited query path fragments matched by this candidate's repository path. */
+    queryPathMatches?: string[];
+    /** Exact current source size for the compiler-owned range, when available. */
+    sourceCharacters?: number;
+}
+interface AnchorDiscoveryRelation {
+    kind: 'call' | 'runtime-boundary';
+    fromSymbol: string;
+    fromLabel: string;
+    fromFile: string;
+    toSymbol: string;
+    toLabel: string;
+    toFile: string;
+    depth: number;
+    strength: 'exact' | 'derived';
+    evidence: CalleeEvidenceSource | 'scip-occurrence-callsite' | 'ast-member-import-candidate' | `runtime-boundary:${string}`;
+    callsiteLine: number | null;
+    runtimeBoundaryKey?: string;
+}
+interface AnchorDiscoveryGroup {
+    id: string;
+    kind: 'cross-boundary-flow' | 'parallel-paths' | 'connected-flow' | 'shared-callee-owners';
+    roots: AnchorDiscoveryCandidate[];
+    keyAnchors: AnchorDiscoveryCandidate[];
+    candidateOwnerCount: number;
+    omittedCandidateOwners: AnchorDiscoveryCandidate[];
+    ownerRecoveryCommands: string[];
+    upstreamEntries: AnchorDiscoveryUpstreamEntry[];
+    matchedTerms: string[];
+    /** Exact slash-delimited query path fragments covered by the group's roots. */
+    queryPathMatches?: string[];
+    relations: AnchorDiscoveryRelation[];
+    relationCount: number;
+    /** Number of independently named sides that carry at least one causal edge. */
+    parallelConnectedSides?: number;
+    /** Number of independently named sides whose matched root has an outgoing causal edge. */
+    parallelOrchestrationSides?: number;
+    /** Query vocabulary that occurs in the repository path on every batched side. */
+    parallelSharedPathTerms?: string[];
+    /** Rarest repository frequency among the shared path terms; lower is more discriminative. */
+    parallelSharedPathFrequency?: number;
+    /** Matched roots that initiate at least one returned causal relationship. */
+    orchestrationRootCount?: number;
+    omittedRelations: number;
+    systemMapCommand: string;
+}
+interface AnchorDiscoveryUpstreamEntry {
+    name: string;
+    file: string;
+    line: number;
+    endLine: number;
+    callsiteLine: number;
+}
+interface AnchorDiscoveryResult {
+    query: string;
+    /** Slash-delimited repository path fragments preserved from the original query. */
+    queryPathFragments?: string[];
+    normalizedTerms: string[];
+    matchedTerms: string[];
+    unmatchedTerms: string[];
+    groups: AnchorDiscoveryGroup[];
+    candidateRoots: AnchorDiscoveryCandidate[];
+    candidateRootCount: number;
+    analyzedRootCount: number;
+    omittedRootCount: number;
+    omittedGroupCount: number;
+    scannedFiles: number;
+    scannedBytes: number;
+    recoveryCommand: string | null;
+}
+interface AnchorDiscoveryOptions {
+    scope?: string;
+    limit?: number;
+    full?: boolean;
+    semantic?: boolean;
+}
+/**
+ * Locate a small set of graph starting points from vocabulary that already
+ * exists in the repository. Query words are normalized mechanically; their
+ * meaning is not inferred. The highest-ranked owning definitions receive a
+ * bounded two-hop call expansion so connected candidates can be selected in
+ * one model-visible packet.
+ */
+declare function discoverAnchors(db: ScipDatabase, query: string, options?: AnchorDiscoveryOptions): AnchorDiscoveryResult;
+declare function normalizeAnchorQuery(query: string): string[];
+
+export { type AnchorDiscoveryCandidate, type AnchorDiscoveryGroup, type AnchorDiscoveryMatchSource, type AnchorDiscoveryOptions, type AnchorDiscoveryRelation, type AnchorDiscoveryResult, type AnchorDiscoveryTermMatch, type AnchorDiscoveryUpstreamEntry, discoverAnchors, normalizeAnchorQuery };

package/dist/queries/anchors.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-ENCCHKM6.js";import"../chunk-L57ZKWVG.js";import"../chunk-SMRBZ6EC.js";import"../chunk-XLQ3GLWZ.js";import"../chunk-JEJLSICM.js";import"../chunk-FQKZWM4L.js";import"../chunk-VE5AVNMP.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 discoverAnchors,b as normalizeAnchorQuery};
+//# sourceMappingURL=anchors.js.map

package/dist/queries/architecture.d.ts

@@ -0,0 +1,166 @@
+import { G as ArchitectureConfig } from '../config-types-BNoC96J3.js';
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+
+interface TestBoundaryViolation {
+    testFile: string;
+    /** Boundary of the code this test covers, or null when no subject was found. */
+    ownerBoundary: string | null;
+    importedFile: string;
+    importedBoundary: string;
+    reason: 'outside-owner-policy' | 'unowned-test';
+}
+
+type ArchitecturePolicyStatus = 'allowed' | 'forbidden' | 'undeclared';
+interface ArchitectureFileEdge {
+    fromFile: string;
+    toFile: string;
+}
+interface ArchitectureBoundaryEdge {
+    from: string;
+    to: string;
+    policyStatus: ArchitecturePolicyStatus;
+    fileEdgeCount: number;
+    importerCount: number;
+    importedFileCount: number;
+    examples: ArchitectureFileEdge[];
+    /**
+     * True when the entire boundary dependency rests on a single import. Not a
+     * violation — a signal that the edge is incidental rather than load-bearing,
+     * and therefore cheap to remove if it was never intended.
+     */
+    fragile: boolean;
+}
+interface ArchitectureBoundarySummary {
+    name: string;
+    paths: string[];
+    fileCount: number;
+    dependencyPolicyDeclared: boolean;
+}
+interface ArchitectureAmbiguousFile {
+    file: string;
+    boundaries: string[];
+}
+interface ArchitectureReciprocalPair {
+    boundaries: [string, string];
+    forward: ArchitectureBoundaryEdge;
+    reverse: ArchitectureBoundaryEdge;
+}
+interface ArchitectureCycle {
+    boundaries: string[];
+    internalEdges: ArchitectureBoundaryEdge[];
+    /** Least-broad internal edge(s), useful as inspection points rather than automatic repairs. */
+    narrowestEdges: ArchitectureBoundaryEdge[];
+    violatesPolicy: boolean;
+}
+interface ArchitectureCoverage {
+    totalFiles: number;
+    mappedFiles: number;
+    unmappedFiles: string[];
+    ambiguousFiles: ArchitectureAmbiguousFile[];
+}
+interface ArchitecturePolicyCoverage {
+    declaredRows: number;
+    totalBoundaries: number;
+    missingRows: string[];
+    requiresCompletePolicy: boolean;
+    requiresCompleteCoverage?: boolean;
+    requiresMinimalPolicy: boolean;
+}
+/** A declared allowance that no observed edge uses. */
+interface ArchitectureStaleAllowance {
+    from: string;
+    to: string;
+}
+/** A boundary exceeding a configured size or connectivity limit. */
+interface ArchitectureBoundaryLimit {
+    boundary: string;
+    kind: 'fan-out' | 'files';
+    observed: number;
+    limit: number;
+}
+/** One directed dependency between two sub-units inside a single boundary. */
+interface ArchitectureSubUnitEdge {
+    from: string;
+    to: string;
+    fileEdgeCount: number;
+    examples: ArchitectureFileEdge[];
+}
+/**
+ * A boundary whose own members form a dependency cycle.
+ *
+ * `requireAcyclic` quotients the file graph by boundary and discards every
+ * intra-boundary edge, so a cycle wholly inside one boundary is reported as
+ * absent. Such a boundary is "too coarse to check": its clean status carries
+ * no information about the code it contains.
+ */
+interface ArchitectureCoarseBoundary {
+    boundary: string;
+    violatesPolicy: boolean;
+    subUnits: string[];
+    internalEdges: ArchitectureSubUnitEdge[];
+    /** Least-broad internal edge(s) — the cheapest inspection points. */
+    narrowestEdges: ArchitectureSubUnitEdge[];
+}
+interface ArchitectureReport {
+    configured: boolean;
+    boundaries: ArchitectureBoundarySummary[];
+    edges: ArchitectureBoundaryEdge[];
+    forbiddenEdges: ArchitectureBoundaryEdge[];
+    reciprocalPairs: ArchitectureReciprocalPair[];
+    cycles: ArchitectureCycle[];
+    /** Boundaries hiding an internal cycle that the boundary graph cannot express. */
+    coarseBoundaries: ArchitectureCoarseBoundary[];
+    /** Declared allowances with no observed edge — policy wider than reality. */
+    staleAllowances: ArchitectureStaleAllowance[];
+    /** Boundaries over a configured fan-out or file-count limit. */
+    boundaryLimits: ArchitectureBoundaryLimit[];
+    /** Report-only: boundary edges resting on exactly one import. */
+    fragileEdges: ArchitectureBoundaryEdge[];
+    /** Test files importing beyond what their subject's boundary may reach. */
+    testBoundaryViolations: TestBoundaryViolation[];
+    coverage: ArchitectureCoverage;
+    policyCoverage: ArchitecturePolicyCoverage;
+}
+declare const ARCHITECTURE_BASELINE_PREFIX = "architecture:";
+/**
+ * Evaluate a file dependency graph against project-owned architectural
+ * boundaries. This pure seam deliberately separates graph facts from the
+ * repository-specific judgment recorded in ArchitectureConfig.
+ */
+declare function analyzeArchitectureGraph(fileGraph: ReadonlyMap<string, ReadonlySet<string>>, indexedFiles: readonly string[], config?: ArchitectureConfig, opts?: {
+    isModuleHierarchyFile?: (file: string) => boolean;
+    testBoundaryViolations?: TestBoundaryViolation[];
+}): ArchitectureReport;
+/** Build and analyze the current project's import dependency graph. */
+declare function architecture(db: ScipDatabase, opts?: {
+    scope?: string;
+}): ArchitectureReport;
+/**
+ * Produce responsibility-level identities for explicit architecture failures.
+ * File examples are intentionally excluded so ordinary refactors do not churn
+ * the ratchet while the same boundary relationship remains.
+ */
+declare function architectureFindingIdentities(report: ArchitectureReport): string[];
+/** True when configuration contains at least one closed rule worth enforcing. */
+declare function hasEnforceableArchitecturePolicy(config?: ArchitectureConfig): boolean;
+/**
+ * Find boundaries whose members form a cycle the boundary graph cannot show.
+ *
+ * Works on the *quotient by sub-unit* (a file's containing directory), not the
+ * file graph: `cycles` reports no file-level loop in this repository's large
+ * boundaries even though several of them are internally cyclic, because a
+ * quotient can be cyclic while the graph it quotients is acyclic.
+ *
+ * `isModuleHierarchyFile` removes re-export bookkeeping (barrels, entries,
+ * tests) so normal parent/child module structure is not reported as debt.
+ * Rust `mod.rs` and `index.ts` module declarations fall out through that rule
+ * because a pure re-export file defines nothing of its own.
+ *
+ * Directory nesting alone is deliberately *not* a suppression signal: a
+ * boundary's root files and one of its sub-directories depending on each other
+ * is the most common real cycle, not module bookkeeping.
+ */
+declare function detectCoarseBoundaries(fileGraph: ReadonlyMap<string, ReadonlySet<string>>, filesByBoundary: ReadonlyMap<string, ReadonlySet<string>>, isModuleHierarchyFile?: (file: string) => boolean, violatesPolicy?: boolean, granularityFor?: (boundary: string) => 'directory' | 'file'): ArchitectureCoarseBoundary[];
+
+export { ARCHITECTURE_BASELINE_PREFIX, type ArchitectureAmbiguousFile, type ArchitectureBoundaryEdge, type ArchitectureBoundaryLimit, type ArchitectureBoundarySummary, type ArchitectureCoarseBoundary, type ArchitectureCoverage, type ArchitectureCycle, type ArchitectureFileEdge, type ArchitecturePolicyCoverage, type ArchitecturePolicyStatus, type ArchitectureReciprocalPair, type ArchitectureReport, type ArchitectureStaleAllowance, type ArchitectureSubUnitEdge, analyzeArchitectureGraph, architecture, architectureFindingIdentities, detectCoarseBoundaries, hasEnforceableArchitecturePolicy };

package/dist/queries/architecture.js

@@ -0,0 +1,2 @@
+import{a,b,c,d,e,f}from"../chunk-WMPRTGH2.js";import"../chunk-QDCCHMVZ.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{a as ARCHITECTURE_BASELINE_PREFIX,b as analyzeArchitectureGraph,c as architecture,d as architectureFindingIdentities,f as detectCoarseBoundaries,e as hasEnforceableArchitecturePolicy};
+//# sourceMappingURL=architecture.js.map

package/dist/queries/bottlenecks.d.ts

@@ -0,0 +1,68 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface CoordinationHubCalleeEvidence {
+    symbol: string;
+    shortName: string;
+    file: string;
+    evidenceStrength: 'exact' | 'candidate';
+    evidenceSource: string;
+}
+interface BottleneckResult {
+    symbol: string;
+    shortName: string;
+    fanIn: number;
+    fanOut: number;
+    callerFiles: string[];
+    candidateCallerFiles?: string[];
+    externalCallees: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+    externalCalleeEvidence?: CoordinationHubCalleeEvidence[];
+    candidateExternalCallees?: string[];
+    inputBasis?: 'mixed-static-call-or-reference-evidence';
+    /** fanIn * fanOut — higher = more central coupling hub */
+    score: number;
+    definedIn: string;
+    actionTier: 'signal';
+    riskKind: 'coordination-hotspot';
+    evidenceReasons: string[];
+    recommendation: string;
+}
+type BottleneckSemanticEvidenceStatus = 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+interface BottleneckCoverage {
+    semanticEvidence: {
+        enabled: boolean;
+        status: BottleneckSemanticEvidenceStatus;
+        incompleteSymbolCount: number;
+        unavailableSymbolCount: number;
+        excludedSymbolCount: number;
+    };
+}
+interface BottlenecksEvidenceResult {
+    rows: BottleneckResult[];
+    coverage: BottleneckCoverage;
+}
+interface BottlenecksOptions {
+    limit?: number;
+    scope?: string;
+    minFanIn?: number;
+    minFanOut?: number;
+    scanLimit?: number;
+    semantic?: boolean;
+}
+/**
+ * Find coordination hubs: symbols with both many incoming caller/reference
+ * evidence files and many outgoing cross-file callable targets.
+ *
+ * This is a coordination-hub heuristic, not a graph-theoretic articulation
+ * point or proof that a change is dangerous. Score = fanIn * fanOut.
+ */
+declare function bottlenecks(db: ScipDatabase, opts?: BottlenecksOptions): BottleneckResult[];
+declare function bottlenecksEvidence(db: ScipDatabase, opts?: BottlenecksOptions): BottlenecksEvidenceResult;
+declare function coordinationHubs(db: ScipDatabase, opts?: BottlenecksOptions): BottleneckResult[];
+
+export { type BottleneckCoverage, type BottleneckResult, type BottleneckSemanticEvidenceStatus, type BottlenecksEvidenceResult, type BottlenecksOptions, type CoordinationHubCalleeEvidence, bottlenecks, bottlenecksEvidence, coordinationHubs };

package/dist/queries/bottlenecks.js

@@ -0,0 +1,2 @@
+import{a,b,c}from"../chunk-PBI2LFKH.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 bottlenecks,b as bottlenecksEvidence,c as coordinationHubs};
+//# sourceMappingURL=bottlenecks.js.map

package/dist/queries/by-kind.d.ts

@@ -0,0 +1,27 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface ByKindResult {
+    symbol: string;
+    shortName: string;
+    kind: number;
+    kindName: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+}
+declare function byKind(db: ScipDatabase, kindQuery: string, opts?: {
+    scope?: string;
+    limit?: number;
+}): ByKindResult[];
+/** List all symbol kinds present in the index with counts */
+declare function kindCounts(db: ScipDatabase, opts?: {
+    scope?: string;
+}): Array<{
+    kind: number;
+    kindName: string;
+    count: number;
+}>;
+
+export { type ByKindResult, byKind, kindCounts };

package/dist/queries/by-kind.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-VXYS3FZD.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 byKind,b as kindCounts};
+//# sourceMappingURL=by-kind.js.map

package/dist/queries/call-graph.d.ts

@@ -0,0 +1,52 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface CallGraphEvidenceRow {
+    symbol: string;
+    shortName: string;
+    file: string;
+    relationship: 'resolved-call' | 'reference-candidate' | 'chunk-candidate';
+    evidenceStrength: 'exact' | 'candidate';
+    evidenceSource: string;
+}
+interface CallGraphResult {
+    symbol: string;
+    shortName: string;
+    /** Symbols that call this one (incoming) */
+    callers: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+    /** Symbols called by this one (outgoing) */
+    callees: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+    }>;
+    callerEvidence?: CallGraphEvidenceRow[];
+    calleeEvidence?: CallGraphEvidenceRow[];
+    coverage?: {
+        scope: 'indexed-static-call-graph';
+        blindSpots: string[];
+        semanticEvidence: {
+            enabled: boolean;
+            incoming: SemanticEvidenceCoverageStatus;
+            outgoing: SemanticEvidenceCoverageStatus;
+        };
+    };
+}
+/**
+ * Build a call graph for a symbol: who calls it (incoming) and
+ * what it calls (outgoing).
+ *
+ * Incoming: other symbols whose definition ranges contain a reference to this symbol.
+ * Outgoing: symbols referenced within this symbol's definition range.
+ */
+declare function callGraph(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): CallGraphResult | null;
+type SemanticEvidenceCoverageStatus = 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+
+export { type CallGraphEvidenceRow, type CallGraphResult, callGraph };

package/dist/queries/call-graph.js

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

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

@@ -0,0 +1,55 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type ChangeRiskReasonKind = 'operational-root' | 'published-api' | 'metadata-unavailable';
+interface ChangeRiskReason {
+    kind: ChangeRiskReasonKind;
+    detail: string;
+}
+interface FileChangeRiskMetadata {
+    operationalRoot: boolean;
+    publishedApi: boolean;
+    coverage: 'complete' | 'partial';
+    reasons: ChangeRiskReason[];
+}
+
+type ChangeSurfaceRiskReason = ChangeRiskReason | {
+    kind: 'external-consumers';
+    detail: string;
+} | {
+    kind: 'semantic-consumer-coverage';
+    detail: string;
+};
+type ChangeSurfaceConsumerCoverage = 'complete' | 'incomplete' | 'unavailable' | 'incomplete-and-unavailable' | 'disabled';
+interface ChangeSurfaceEntry {
+    symbol: string;
+    shortName: string;
+    startLine: number;
+    endLine: number;
+    externalConsumers: number | null;
+    knownExternalConsumers: number;
+    consumerCoverage: ChangeSurfaceConsumerCoverage;
+    externalConsumerRiskLevel?: 'low' | 'medium' | 'high';
+    riskLevel: 'low' | 'medium' | 'high';
+    riskReasons?: ChangeSurfaceRiskReason[];
+}
+interface ChangeSurfaceResult {
+    file: string;
+    symbols: ChangeSurfaceEntry[];
+    totalExternalConsumers: number | null;
+    knownTotalExternalConsumers: number;
+    fileRisk?: FileChangeRiskMetadata;
+}
+/**
+ * Pre-change briefing for a file. For each symbol defined in the file,
+ * reports external consumer count and blast-radius risk.
+ *
+ * Symbol ranges come from getDefinitionsForFile so they are source-corrected
+ * and match `scip symbols` output.
+ */
+declare function changeSurface(db: ScipDatabase, filePattern: string, opts?: {
+    semantic?: boolean;
+}): ChangeSurfaceResult | null;
+
+export { type ChangeSurfaceEntry, type ChangeSurfaceResult, type ChangeSurfaceRiskReason, changeSurface };

package/dist/queries/change-surface.js

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

package/dist/queries/cleanup-plan.d.ts

@@ -0,0 +1,66 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface CleanupPlanEntry {
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    /**
+     * 'graph-fact': zero references anywhere — deletable today.
+     * 'cascade':    becomes dead once earlier batches are deleted.
+     */
+    evidence: 'graph-fact' | 'cascade';
+}
+interface CleanupBatch {
+    /** 0 = deletable now; n = deletable after batch n-1 is applied. */
+    depth: number;
+    entries: CleanupPlanEntry[];
+    loc: number;
+    /** Files whose every definition is removed once this batch lands. */
+    filesEmptied: string[];
+}
+interface CleanupPlanResult {
+    batches: CleanupBatch[];
+    totalSymbols: number;
+    totalLoc: number;
+    /** Cascade candidates blocked by references outside the removal set. */
+    blocked: Array<{
+        shortName: string;
+        file: string;
+        blockingFiles: string[];
+    }>;
+}
+/**
+ * Cascade cleanup plan: dead-code analysis is single-pass, but deletion
+ * cascades — once batch 0 is gone, symbols referenced only from batch 0
+ * become dead too. This runs the fixpoint and emits an ordered plan.
+ *
+ * Cascade rule (conservative): a symbol joins batch n+1 only when every
+ * resolved reference site lies inside an already-removed definition's range.
+ * Any reference that can't be placed inside the removal set — including
+ * unattributable file-level references — blocks the cascade for that symbol.
+ *
+ * Apply batch by batch, re-running the project's typecheck between batches.
+ */
+declare function cleanupPlan(db: ScipDatabase, opts?: {
+    scope?: string;
+    minLoc?: number;
+    maxDepth?: number;
+    scanLimit?: number;
+}): CleanupPlanResult;
+/** Line-range membership for the removal set, per file. */
+declare class RemovedRangeIndex {
+    private readonly ranges;
+    add(entry: {
+        file: string;
+        startLine: number;
+        endLine: number;
+    }): void;
+    contains(file: string, line: number): boolean;
+}
+
+export { type CleanupBatch, type CleanupPlanEntry, type CleanupPlanResult, RemovedRangeIndex, cleanupPlan };

package/dist/queries/cleanup-plan.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-BVAJLC5A.js";import"../chunk-OZYRSMSH.js";import"../chunk-OVTS4DKB.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 RemovedRangeIndex,a as cleanupPlan};
+//# sourceMappingURL=cleanup-plan.js.map