codebaseiq 0.1.0

package/dist/queries/dead.d.ts

@@ -0,0 +1,58 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface DeadOptions {
+    scope?: string;
+    minLoc?: number;
+    includeTests?: boolean;
+    skipBarrels?: boolean;
+    includeMembers?: boolean;
+    deadCodeOnly?: boolean;
+    scanLimit?: number;
+    semantic?: boolean;
+}
+
+interface DeadSymbolResult {
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    symbol: string;
+    shortName: string;
+    sameFileRefs: number;
+    kind: 'dead-code' | 'file-internal' | 'implicit-usage';
+    implicitUsageReason?: string;
+}
+interface DeadCounts {
+    total: number;
+    deadCode: number;
+    fileInternal: number;
+    implicitUsage: number;
+    loc: number;
+}
+interface DeadSummary {
+    symbols: DeadSymbolResult[];
+    counts: DeadCounts;
+    applicability: {
+        entrySurfaceExcluded: number;
+        externalRootExcluded: number;
+        implicitUsageSignals: number;
+    };
+    totalCount: number;
+    /** Symbols with zero references anywhere; verify before deleting */
+    deadCodeCount: number;
+    /** Symbols referenced only within their own file — no cross-file consumers.
+     *  May be private helpers (fine) or forgotten exports (needs review). */
+    fileInternalCount: number;
+    /** Symbols reached through traits, attributes, generated code, or reflection. */
+    implicitUsageCount: number;
+    totalLoc: number;
+}
+/**
+ * Find dead exports: symbols defined locally with no cross-file references.
+ * Language-agnostic — works with any SCIP index.
+ */
+declare function dead(db: ScipDatabase, opts?: DeadOptions): DeadSummary;
+
+export { type DeadCounts, type DeadSummary, type DeadSymbolResult, dead };

package/dist/queries/dead.js

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

package/dist/queries/decorative-checkers.d.ts

@@ -0,0 +1,34 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+/**
+ * decorative-checkers (D2): mechanizes the cleanup integrity scenario for a
+ * checker-naming family (`validate*`/`verify*`/`check*`/`assert*`,
+ * `is*`/`has*`): a callable that LOOKS like a checker but has no reachable
+ * failure exit anywhere in its body — no throw, no rejection, no
+ * error-result construction, and (for boolean predicates specifically) no
+ * return of anything other than the literal `true`. It always "passes"
+ * because there is nothing in it that can make it fail.
+ */
+type DecorativeCheckerNameKind = 'imperative' | 'predicate';
+type DecorativeCheckerResolution = 'direct' | 'one-hop-delegate';
+interface DecorativeCheckerFinding {
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    loc: number;
+    nameKind: DecorativeCheckerNameKind;
+    resolvedVia: DecorativeCheckerResolution;
+    /** Short name of the resolved one-hop delegate target, when resolvedVia is 'one-hop-delegate'. */
+    delegateTarget?: string;
+}
+declare function decorativeCheckers(db: ScipDatabase, opts?: {
+    scope?: string;
+    limit?: number;
+    scanLimit?: number;
+}): DecorativeCheckerFinding[];
+
+export { type DecorativeCheckerFinding, type DecorativeCheckerNameKind, type DecorativeCheckerResolution, decorativeCheckers };

package/dist/queries/decorative-checkers.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-TXXOEMZJ.js";import"../chunk-WOQBZPIF.js";import"../chunk-T3DGWPXM.js";import"../chunk-OVTS4DKB.js";import"../chunk-4WKDMDEW.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 decorativeCheckers};
+//# sourceMappingURL=decorative-checkers.js.map

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

@@ -0,0 +1,5 @@
+import '../db-D7sauVFH.js';
+import '../file-dep-graph-Bqg3t3Px.js';
+export { DeepChainResult, deepChains, dependencyDepth } from './dependency-depth.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';

package/dist/queries/deep-chains.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-TRRC4ZJ7.js";import"../chunk-35NLDRZC.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{b as deepChains,a as dependencyDepth};
+//# sourceMappingURL=deep-chains.js.map

package/dist/queries/dependence-slice.d.ts

@@ -0,0 +1,46 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { G as GraphEvidenceCoverage, a as GraphEvidenceEdge, b as GraphEvidenceTarget } from '../graph-evidence-BIFqyisO.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+import '../exploration-topology-BG4v30HZ.js';
+
+type DependenceSliceDirection = 'backward' | 'forward';
+interface DependenceSliceEdge extends GraphEvidenceEdge {
+    traversalDepth: number;
+    supporting: boolean;
+}
+/** Coverage of the partial dependence graph used for this slice. */
+interface DependenceSliceCoverage {
+    status: GraphEvidenceCoverage['status'];
+    criterionKind: 'symbol-summary' | 'source-location-summary';
+    basis: 'partial-system-dependence-graph';
+    analysisBasis: 'typescript-cfg-reaching-definitions-plus-system-edges';
+    providers: readonly ['typescript-local-dependence', 'bounded-static-value-flow'];
+    graph: GraphEvidenceCoverage;
+    unsupportedRelations: string[];
+}
+interface DependenceSliceResult {
+    kind: 'dependence-slice';
+    direction: DependenceSliceDirection;
+    criterion: string;
+    targets: GraphEvidenceTarget[];
+    nodeIds: string[];
+    edges: DependenceSliceEdge[];
+    coverage: DependenceSliceCoverage;
+}
+/**
+ * Compute a directional slice over the currently proved program-dependence
+ * projection around one exact symbol or source location.
+ *
+ * The criterion is a summary root rather than the classic `(program point,
+ * variable)` pair. Data-transfer and control-dependence edges carry the slice;
+ * ownership, call, and exact runtime edges connect those dependencies across
+ * callable boundaries and are marked as supporting edges in the result.
+ */
+declare function dependenceSlice(db: ScipDatabase, criterion: string, options?: {
+    direction?: DependenceSliceDirection;
+    maxDepth?: number;
+    maxEdges?: number;
+}): DependenceSliceResult;
+
+export { type DependenceSliceCoverage, type DependenceSliceDirection, type DependenceSliceEdge, type DependenceSliceResult, dependenceSlice };

package/dist/queries/dependence-slice.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-VUIYB2V3.js";import"../chunk-SZD2KF7Q.js";import"../chunk-MOVBWNIP.js";import"../chunk-MVB3DAEY.js";import"../chunk-YSNONTJ2.js";import"../chunk-QHRNXP3C.js";import"../chunk-L57ZKWVG.js";import"../chunk-SMRBZ6EC.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 dependenceSlice};
+//# sourceMappingURL=dependence-slice.js.map

package/dist/queries/dependency-depth.d.ts

@@ -0,0 +1,49 @@
+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 DeepChainResult {
+    /** Canonical representative file for each condensed dependency component. */
+    chain: string[];
+    /** Full component membership; arrays with multiple files are dependency cycles. */
+    components: string[][];
+    /** Number of condensed dependency components, not the number of files inside cycles. */
+    depth: number;
+    /** Total files represented by the condensed component path. */
+    fileCount: number;
+    /** The file relation whose condensed depth was measured. */
+    edgeBasis?: FileDependencyEdgeBasis;
+    actionTier: 'signal';
+    chainKind: 'transitive-dependency-depth';
+    evidenceReasons: string[];
+    recommendation: string;
+}
+/**
+ * Find the longest transitive dependency chains between files.
+ * A chain A → B → C → D means A depends on B, B on C, C on D.
+ *
+ * Long chains = high coupling depth = changes at the end ripple through many layers.
+ *
+ * Implementation: condense the graph into strongly-connected components
+ * (each cycle becomes one super-node), then run a single-pass longest-path
+ * DP over the resulting DAG via topological order. Linear in nodes+edges.
+ * For each starting node we record one representative longest chain;
+ * within a cycle we pick a canonical representative file. This avoids the
+ * exponential blow-up of enumerating every simple path (which OOMs on
+ * dense graphs with cycles, like cross-crate Rust workspaces).
+ */
+declare function dependencyDepth(db: ScipDatabase, opts?: {
+    limit?: number;
+    scope?: string;
+    minDepth?: number;
+    edgeBasis?: FileDependencyEdgeBasis;
+}): DeepChainResult[];
+/** @deprecated Prefer `dependencyDepth`, which names the computed graph property. */
+declare function deepChains(db: ScipDatabase, opts?: {
+    limit?: number;
+    scope?: string;
+    minDepth?: number;
+}): DeepChainResult[];
+
+export { type DeepChainResult, deepChains, dependencyDepth };

package/dist/queries/dependency-depth.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-TRRC4ZJ7.js";import"../chunk-35NLDRZC.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{b as deepChains,a as dependencyDepth};
+//# sourceMappingURL=dependency-depth.js.map

package/dist/queries/deps.d.ts

@@ -0,0 +1,15 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface DepResult {
+    relativePath: string;
+    edgeBasis?: 'symbol-references';
+    evidence?: 'cross-file SCIP references plus resolved source imports';
+}
+/** What internal files does this file depend on? (forward dependencies) */
+declare function deps(db: ScipDatabase, filePattern: string): DepResult[];
+/** What files depend on this file/module? (reverse dependencies) */
+declare function rdeps(db: ScipDatabase, filePattern: string): DepResult[];
+
+export { type DepResult, deps, rdeps };

package/dist/queries/deps.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-AKB7V7TV.js";import"../chunk-GW6Z3WGY.js";import"../chunk-GTXSJDCO.js";import"../chunk-UZGZB3VB.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 deps,b as rdeps};
+//# sourceMappingURL=deps.js.map

package/dist/queries/diff-impact.d.ts

@@ -0,0 +1,165 @@
+import { C as ChangedLineRange } from '../change-analysis-types-CCtoCHbC.js';
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { I as IndexedDefinition } from '../symbol-types-BIQwfoAx.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface DiffImpactResult {
+    changedFiles: string[];
+    changedSymbols: Array<{
+        symbol: string;
+        shortName: string;
+        file: string;
+        startLine: number;
+        endLine: number;
+        fanIn: number;
+    }>;
+    affectedConsumers: Array<{
+        file: string;
+        consumedSymbols: number;
+    }>;
+    attributionNotes: AttributionNote[];
+    /** Whether each non-SCIP consumer-discovery tier completed. */
+    evidenceTiers: DiffImpactEvidenceTierStatus[];
+    summary: {
+        totalChangedFiles: number;
+        totalChangedSymbols: number;
+        totalAffectedFiles: number;
+        note?: string;
+    };
+}
+type ChangedSymbol = DiffImpactResult['changedSymbols'][number];
+interface DiffImpactPlan {
+    changedFileLines: string[];
+    changedFiles: string[];
+    changedRanges: ChangedLineRange[];
+    renamedFiles: RenamedFile[];
+    note?: string;
+}
+/** Plan note when git itself failed (not a repo, bad ref) — vs an empty diff. */
+declare const GIT_DIFF_UNAVAILABLE_NOTE = "Unable to compute git diff.";
+interface RenamedFile {
+    from: string;
+    to: string;
+    similarity: number;
+}
+type BaseContentReader = (relativePath: string) => string | null;
+type BaseContentResult = {
+    state: 'present';
+    content: string;
+} | {
+    state: 'absent';
+} | {
+    state: 'unavailable';
+    reason: string;
+};
+type BaseContentResultReader = (relativePath: string) => BaseContentResult;
+interface BaseContentLookupOptions {
+    projectRoot: string;
+    base: string;
+    relativePath: string;
+}
+interface BaseContentsLookupOptions {
+    projectRoot: string;
+    base: string;
+    relativePaths: readonly string[];
+}
+interface BaseContentReaderOptions {
+    projectRoot: string;
+    base: string;
+    preloadPaths?: readonly string[];
+}
+interface BaseContentGitRuntime {
+    resolveCommit(projectRoot: string, base: string): string;
+    readBatch(input: {
+        projectRoot: string;
+        resolvedBase: string;
+        relativePaths: readonly string[];
+    }): Buffer;
+}
+type DiffImpactEvidenceTier = 'semantic-consumers' | 'source-fallback-consumers';
+type DiffImpactEvidenceTierStatus = {
+    tier: DiffImpactEvidenceTier;
+    state: 'complete';
+    attemptedSymbols: number;
+} | {
+    tier: DiffImpactEvidenceTier;
+    state: 'failed';
+    attemptedSymbols: number;
+    reason: string;
+};
+interface DiffImpactEvidenceRuntime {
+    semanticConsumers(db: ScipDatabase, definitions: ReadonlyArray<IndexedDefinition>): Map<number, Set<string>>;
+    sourceFallbackConsumers(db: ScipDatabase, definitions: ReadonlyArray<IndexedDefinition>): Map<number, Set<string>>;
+}
+interface DiffImpactPartialOptions {
+    evidenceRuntime?: DiffImpactEvidenceRuntime;
+}
+interface DiffImpactPartial {
+    changedSymbols: ChangedSymbol[];
+    consumerEntries: Array<{
+        file: string;
+        symbols: string[];
+    }>;
+    attributionNotes: AttributionNote[];
+    evidenceTiers: DiffImpactEvidenceTierStatus[];
+}
+interface AttributionNote {
+    file: string;
+    startLine: number;
+    endLine: number;
+    method: 'ast-widened' | 'nearest-preceding' | 'unattributed';
+}
+interface DeclarationSpan {
+    file: string;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Given a git diff, compute the affected symbol set.
+ * Finds all symbols defined in changed files, their fan-in,
+ * and the files that consume them downstream.
+ */
+declare function diffImpact(db: ScipDatabase, opts?: {
+    base?: string;
+    plan?: DiffImpactPlan;
+}): DiffImpactResult;
+declare function diffImpactPlan(db: ScipDatabase, opts?: {
+    base?: string;
+}): DiffImpactPlan;
+declare function diffImpactPartial(db: ScipDatabase, filesToAnalyze: readonly string[], allChangedFiles: readonly string[], changedRanges?: readonly ChangedLineRange[], opts?: DiffImpactPartialOptions): DiffImpactPartial;
+declare function mergeDiffImpactPartials(changedFiles: readonly string[], partials: readonly DiffImpactPartial[]): DiffImpactResult;
+declare function fileContentAtBase(options: BaseContentLookupOptions): string | null;
+/**
+ * @deprecated Use `fileContentAtBase({ projectRoot, base, relativePath })` so
+ * the project root, Git revision, and project-relative path cannot be
+ * transposed.
+ */
+declare function fileContentAtBase(projectRoot: string, base: string, relativePath: string): string | null;
+declare function readBaseContent(opts: BaseContentLookupOptions, runtime?: BaseContentGitRuntime): BaseContentResult;
+declare function readBaseContents(opts: BaseContentsLookupOptions, runtime?: BaseContentGitRuntime): Map<string, BaseContentResult>;
+declare function createBaseContentResultReader(opts: {
+    projectRoot: string;
+    base: string;
+    preloadPaths?: readonly string[];
+}, runtime?: BaseContentGitRuntime): BaseContentResultReader;
+declare function createBaseContentReader(options: BaseContentReaderOptions): BaseContentReader;
+/**
+ * @deprecated Use `createBaseContentReader({ projectRoot, base, preloadPaths })`
+ * so the project root and Git revision cannot be transposed.
+ */
+declare function createBaseContentReader(projectRoot: string, base: string, preloadPaths?: readonly string[]): BaseContentReader;
+declare function baseContentPathsForDiffPlan(diffPlan: DiffImpactPlan, changedFiles?: readonly string[]): string[];
+declare function fileContentsAtBase(options: BaseContentsLookupOptions): Map<string, string | null>;
+/**
+ * @deprecated Use `fileContentsAtBase({ projectRoot, base, relativePaths })`
+ * so the project root, Git revision, and project-relative paths cannot be
+ * transposed.
+ */
+declare function fileContentsAtBase(projectRoot: string, base: string, relativePaths: readonly string[]): Map<string, string | null>;
+declare function attributeResidue(definitions: readonly IndexedDefinition[], changedRanges: readonly ChangedLineRange[], declarationSpans: readonly DeclarationSpan[]): {
+    definitions: IndexedDefinition[];
+    notes: AttributionNote[];
+};
+
+export { type AttributionNote, type BaseContentGitRuntime, type BaseContentLookupOptions, type BaseContentReader, type BaseContentReaderOptions, type BaseContentResult, type BaseContentResultReader, type BaseContentsLookupOptions, ChangedLineRange, type DeclarationSpan, type DiffImpactEvidenceRuntime, type DiffImpactEvidenceTier, type DiffImpactEvidenceTierStatus, type DiffImpactPartial, type DiffImpactPartialOptions, type DiffImpactPlan, type DiffImpactResult, GIT_DIFF_UNAVAILABLE_NOTE, type RenamedFile, attributeResidue, baseContentPathsForDiffPlan, createBaseContentReader, createBaseContentResultReader, diffImpact, diffImpactPartial, diffImpactPlan, fileContentAtBase, fileContentsAtBase, mergeDiffImpactPartials, readBaseContent, readBaseContents };

package/dist/queries/diff-impact.js

@@ -0,0 +1,2 @@
+import{a,b,c,d,e,f,g,h,i,j,k,l,m}from"../chunk-L4NRUAGJ.js";import"../chunk-QOKYJ33H.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 GIT_DIFF_UNAVAILABLE_NOTE,m as attributeResidue,k as baseContentPathsForDiffPlan,j as createBaseContentReader,i as createBaseContentResultReader,b as diffImpact,d as diffImpactPartial,c as diffImpactPlan,f as fileContentAtBase,l as fileContentsAtBase,e as mergeDiffImpactPartials,g as readBaseContent,h as readBaseContents};
+//# sourceMappingURL=diff-impact.js.map

package/dist/queries/doc-drift.d.ts

@@ -0,0 +1,115 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { G as GitHistoryMode } from '../git-history-ChNHbfZQ.js';
+import { D as DocCitationKind } from '../change-analysis-types-CCtoCHbC.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type DocDriftIntent = 'current-guidance' | 'historical-note' | 'unknown';
+type DocDriftActionTier = 'direct' | 'signal' | 'support';
+interface DocDriftSubject {
+    file: string;
+    /**
+     * 'reference': the doc's text mentions this file path.
+     * 'co-change': the doc historically changed in the same commits as this file.
+     * 'both': both evidence sources agree — strongest signal.
+     */
+    evidence: 'reference' | 'co-change' | 'both';
+    /** Commits where doc and subject changed together (0 for pure references). */
+    coChanges: number;
+    /** Commits touching the subject AFTER the doc's last change. */
+    changesSinceDocUpdate: number;
+    /** Strength of action implied by the evidence and doc intent. */
+    actionTier: DocDriftActionTier;
+    /** Whether the doc reads like current guidance, historical context, or neither. */
+    docIntent: DocDriftIntent;
+    /** Bounded reasons for the doc intent classification. */
+    docIntentReasons: string[];
+    /** Nearby doc text that gives the file citation its meaning, when available. */
+    citationContexts?: string[];
+    /** Citation kind from the shared doc-reference policy, when text cites the file. */
+    citationKind?: DocCitationKind;
+    citationKindReasons?: string[];
+    /** Line suffixes from citations like `src/file.ts:42`; recorded, not drift-checked yet. */
+    citedLines?: number[];
+}
+interface DocFileCitation {
+    file: string;
+    /** Bounded nearby doc text for each citation of this file. */
+    contexts: string[];
+    /** Optional line suffixes cited for this file; recorded, not drift-checked yet. */
+    lineReferences?: number[];
+}
+interface DocDriftFinding {
+    doc: string;
+    /** Unix seconds of the doc's last change; 0 = never changed in the window. */
+    docLastChangedAt: number;
+    /** Σ subject changes since the doc last changed — the staleness score. */
+    staleness: number;
+    subjects: DocDriftSubject[];
+    /** File paths the doc mentions that no longer exist (spec points at deleted code). */
+    brokenReferences: string[];
+    /**
+     * True when this doc matched the docs.snapshotPaths policy (or carries a
+     * `<!-- codebaseiq: snapshot -->` marker). Snapshot docs are excluded from
+     * default findings; only present when `includeSnapshotExcluded` requested
+     * them explicitly — never silently dropped, always labeled.
+     */
+    snapshotExcluded?: boolean;
+    /**
+     * True when `docLastChangedAt` came from filesystem mtime, not git
+     * history — the doc had zero entries in the (capped) commit-history scan,
+     * most commonly a staged-but-uncommitted addition or one whose only
+     * appearance was in a bulk commit dropped wholesale by the shared
+     * git-history file cap (see BULK_COMMIT_FILE_CAP in git-history.ts).
+     * Fixes the 2026-07-01 Vega calibration finding: every sampled finding
+     * reported `docLastChangedAt: 0` (epoch) even for docs committed the same
+     * day, which read as "doc never changed" and inflated staleness.
+     */
+    docLastChangedAtEstimated?: boolean;
+}
+interface DocDriftResult {
+    /** False when git history is unavailable. */
+    available: boolean;
+    commitsAnalyzed: number;
+    /** Doc files scanned for content references. */
+    docsScanned: number;
+    findings: DocDriftFinding[];
+}
+/**
+ * Archival docs (dated plans, ADRs, RFCs, changelogs) record a moment in
+ * time — they cite code as of their date and are never meant to track it.
+ */
+declare function isArchivalDoc(path: string): boolean;
+/**
+ * Standards/docs drift, from two evidence sources:
+ *
+ * 1. CONTENT REFERENCES — the doc's text names file paths; those files kept
+ *    changing after the doc last changed. Covers standards docs from day one
+ *    (no history needed) and finds BROKEN references: paths the doc cites
+ *    that no longer exist — a spec pointing at deleted code.
+ * 2. CO-CHANGE — the doc historically changed in the same commits as code
+ *    files, then stopped while they kept churning. Catches implicit coupling
+ *    the doc never names.
+ *
+ * A stale standards doc is worse than none when agents read it before
+ * implementing — they implement to a dead spec.
+ */
+declare function docDrift(db: ScipDatabase, opts?: {
+    doc?: string;
+    limit?: number;
+    minCoupling?: number;
+    includeSnapshotExcluded?: boolean;
+    historyMode?: GitHistoryMode;
+}): DocDriftResult;
+/**
+ * Docs whose text cites any of the target files — callers use this to ask
+ * "you changed these files; which docs claim to describe them?"
+ */
+declare function docsCitingFiles(db: ScipDatabase, targets: ReadonlySet<string>): Array<{
+    doc: string;
+    cited: string[];
+    citations: DocFileCitation[];
+    citedClaims: string[];
+}>;
+
+export { type DocDriftActionTier, type DocDriftFinding, type DocDriftIntent, type DocDriftResult, type DocDriftSubject, type DocFileCitation, docDrift, docsCitingFiles, isArchivalDoc };

package/dist/queries/doc-drift.js

@@ -0,0 +1,2 @@
+import{a,b,c}from"../chunk-NE6IU5ZD.js";import"../chunk-QOKYJ33H.js";import"../chunk-4WKDMDEW.js";import"../chunk-QDCCHMVZ.js";import"../chunk-P5XHIJHI.js";import"../chunk-YUKYB54I.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{b as docDrift,c as docsCitingFiles,a as isArchivalDoc};
+//# sourceMappingURL=doc-drift.js.map

package/dist/queries/drift.d.ts

@@ -0,0 +1,79 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { ArchitectureBoundaryEdge, ArchitectureReport } from './architecture.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type DriftActionTier = 'direct' | 'signal';
+/** `inferred` and `unknown-layer` remain only for compatibility with older result consumers. */
+type DriftPolicyBasis = 'explicit' | 'inferred' | 'unknown-layer';
+interface DriftArchitectureEvidence {
+    fromBoundary: string;
+    toBoundary: string;
+    fileEdgeCount: number;
+    importerCount: number;
+    importedFileCount: number;
+    examples: ArchitectureBoundaryEdge['examples'];
+}
+interface DriftResult {
+    file: string;
+    kind: 'unused-import' | 'architecture-violation' | 'layer-violation' | 'pattern-deviation';
+    description: string;
+    /** The dependency involved */
+    dep: string;
+    /** For boundary violations: the expected dependency direction. */
+    detail?: string;
+    actionTier: DriftActionTier;
+    /** Architecture violations are emitted only from explicit project rules. */
+    policyBasis?: DriftPolicyBasis;
+    /** Grouped boundary evidence for declared architecture violations. */
+    architecture?: DriftArchitectureEvidence;
+    evidenceReasons: string[];
+    recommendation: string;
+}
+interface DriftSummary {
+    results: DriftResult[];
+    unusedImports: number;
+    architectureViolations: number;
+    /** @deprecated Use `architectureViolations`. */
+    layerViolations: number;
+    patternDeviations: number;
+    /** Full boundary report, included only when `includeArchitecture` is true. */
+    architecture?: ArchitectureReport;
+    /** Total results before `limit` was applied — set only when truncated. */
+    totalResults?: number;
+}
+/**
+ * Detect structural drift using the reference graph, not just import patterns.
+ *
+ * Three types of drift, each detecting a real problem:
+ *
+ * 1. **Unused imports** — file depends on a module but never references
+ *    any of its symbols. Dead dependency, safe to remove.
+ *
+ * 2. **Architecture violations** — one or more files cross a project-owned
+ *    boundary whose declared dependency row rejects the target boundary.
+ *
+ * 3. **Pattern deviations** — file imports something no sibling does,
+ *    suggesting it's reaching outside its expected scope. Only flagged
+ *    when the file is the ONLY one in its directory with that dep.
+ */
+declare function drift(db: ScipDatabase, opts?: {
+    scope?: string;
+    minDeviation?: number;
+    semantic?: boolean;
+    /**
+     * Pattern-deviation ("only sibling importing X") is opt-in as of the
+     * 21.2 calibration retune — external calibration measured 0/10 and 1/8
+     * actionable on Vega_2.0/Stable_Management respectively (894 and 233
+     * same-shaped findings drowning the direct structural-drift channel).
+     * Default false. `includePatternDeviations: true` restores the old
+     * always-on behavior for exploration/opt-in callers.
+     */
+    includePatternDeviations?: boolean;
+    /** Include the full architecture graph and report-only signals in the summary. */
+    includeArchitecture?: boolean;
+    /** Cap on `results` after all three families are combined. Default 50. */
+    limit?: number;
+}): DriftSummary;
+
+export { type DriftActionTier, type DriftArchitectureEvidence, type DriftPolicyBasis, type DriftResult, type DriftSummary, drift };

package/dist/queries/drift.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-EMNIHCRB.js";import"../chunk-WMPRTGH2.js";import"../chunk-QDCCHMVZ.js";import"../chunk-35NLDRZC.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 drift};
+//# sourceMappingURL=drift.js.map