context-probe 0.1.0

package/dist/src/analyzers/architecture-contract-score-baseline-analysis.js

@@ -0,0 +1,70 @@
+import { compareBaselineEntry } from "./architecture-contract-score-baseline-entry.js";
+import { collectScopedBaselineEntries } from "./architecture-contract-score-baseline-scope.js";
+import { average, clamp01 } from "./architecture-contract-score-shared.js";
+export function analyzeBaselineComparison(options) {
+    const currentByPath = new Map(options.currentStats.map((entry) => [entry.path, entry]));
+    const scopedBaseline = collectScopedBaselineEntries({
+        baseline: options.baseline,
+        constraints: options.constraints,
+    });
+    if (scopedBaseline.entries.length === 0) {
+        return undefined;
+    }
+    let baselineSymbolCount = 0;
+    let comparedFiles = 0;
+    let baselineEntriesWithoutImportStats = 0;
+    let removedSymbols = 0;
+    let regressedSymbols = 0;
+    let loosenedSymbols = 0;
+    let newRiskySymbols = 0;
+    let importRiskDeltas = 0;
+    let baselineImportTotal = 0;
+    const findings = [];
+    const unknowns = [...scopedBaseline.unknowns];
+    for (const baselineEntry of scopedBaseline.entries) {
+        const result = compareBaselineEntry({
+            baselineEntry,
+            currentByPath,
+        });
+        baselineSymbolCount += result.baselineSymbolCount;
+        comparedFiles += result.comparedFiles;
+        baselineEntriesWithoutImportStats += result.baselineEntriesWithoutImportStats;
+        removedSymbols += result.removedSymbols;
+        regressedSymbols += result.regressedSymbols;
+        loosenedSymbols += result.loosenedSymbols;
+        newRiskySymbols += result.newRiskySymbols;
+        importRiskDeltas += result.importRiskDeltas;
+        baselineImportTotal += result.baselineImportTotal;
+        unknowns.push(...result.unknowns);
+        findings.push(...result.findings);
+    }
+    if (baselineEntriesWithoutImportStats > 0) {
+        unknowns.push(`${baselineEntriesWithoutImportStats} contract baseline entries do not include import statistics, so BCR import deltas are partial.`);
+    }
+    if (comparedFiles < scopedBaseline.entries.length) {
+        unknowns.push(`The contract baseline covered ${comparedFiles}/${scopedBaseline.entries.length} in-scope baseline files in the current repo.`);
+    }
+    const currentContractFileCount = options.currentStats.length;
+    const currentPaths = new Set(options.currentStats.map((entry) => entry.path));
+    const baselinePaths = new Set(scopedBaseline.entries.map((entry) => entry.path));
+    const currentFilesOutsideBaseline = currentContractFileCount - Array.from(currentPaths).filter((pathValue) => baselinePaths.has(pathValue)).length;
+    if (currentFilesOutsideBaseline > 0) {
+        unknowns.push(`The contract baseline does not cover ${currentFilesOutsideBaseline} current contract files, so CBC/BCR are partial.`);
+    }
+    const compatibilityFailures = removedSymbols + regressedSymbols + loosenedSymbols;
+    const deltaRiskSignals = compatibilityFailures + newRiskySymbols + importRiskDeltas;
+    const cbcDenominator = Math.max(1, baselineSymbolCount);
+    const bcrDenominator = Math.max(1, baselineSymbolCount + baselineImportTotal + currentFilesOutsideBaseline);
+    return {
+        CBC: clamp01(1 - compatibilityFailures / cbcDenominator),
+        BCR: clamp01(deltaRiskSignals / bcrDenominator),
+        confidence: clamp01(average([
+            0.84,
+            comparedFiles > 0 ? comparedFiles / Math.max(1, scopedBaseline.entries.length) : 0.4,
+            baselineSymbolCount > 0 ? 0.88 : 0.55,
+            baselineEntriesWithoutImportStats === 0 ? 0.86 : 0.7,
+        ], 0.65)),
+        unknowns: Array.from(new Set(unknowns)),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-contract-score-baseline-core.d.ts

@@ -0,0 +1,8 @@
+import type { ArchitectureConstraints, ArchitectureContractBaseline } from "../core/contracts.js";
+import type { BaselineComparisonSummary } from "./architecture-contract-score-shared.js";
+import type { ContractFileStats } from "./architecture-contract-stats.js";
+export declare function compareAgainstBaseline(options: {
+    baseline: ArchitectureContractBaseline;
+    currentStats: ContractFileStats[];
+    constraints: ArchitectureConstraints;
+}): BaselineComparisonSummary | undefined;

package/dist/src/analyzers/architecture-contract-score-baseline-core.js

@@ -0,0 +1,4 @@
+import { analyzeBaselineComparison } from "./architecture-contract-score-baseline-analysis.js";
+export function compareAgainstBaseline(options) {
+    return analyzeBaselineComparison(options);
+}

package/dist/src/analyzers/architecture-contract-score-baseline-entry.d.ts

@@ -0,0 +1,19 @@
+import type { ArchitectureContractBaseline } from "../core/contracts.js";
+import type { ContractFileStats } from "./architecture-contract-stats.js";
+import type { ContractStabilityFinding } from "./architecture-contract-types.js";
+export declare function compareBaselineEntry(options: {
+    baselineEntry: ArchitectureContractBaseline["contracts"][number];
+    currentByPath: Map<string, ContractFileStats>;
+}): {
+    baselineSymbolCount: number;
+    comparedFiles: number;
+    baselineEntriesWithoutImportStats: number;
+    removedSymbols: number;
+    regressedSymbols: number;
+    loosenedSymbols: number;
+    newRiskySymbols: number;
+    importRiskDeltas: number;
+    baselineImportTotal: number;
+    unknowns: string[];
+    findings: ContractStabilityFinding[];
+};

package/dist/src/analyzers/architecture-contract-score-baseline-entry.js

@@ -0,0 +1,89 @@
+export function compareBaselineEntry(options) {
+    const unknowns = [];
+    const findings = [];
+    const baselineSymbols = options.baselineEntry.symbols ?? [];
+    const currentEntry = options.currentByPath.get(options.baselineEntry.path);
+    if (!currentEntry) {
+        return {
+            baselineSymbolCount: Math.max(1, baselineSymbols.length),
+            comparedFiles: 0,
+            baselineEntriesWithoutImportStats: 0,
+            removedSymbols: Math.max(1, baselineSymbols.length),
+            regressedSymbols: 0,
+            loosenedSymbols: 0,
+            newRiskySymbols: 0,
+            importRiskDeltas: 0,
+            baselineImportTotal: 0,
+            unknowns,
+            findings: [
+                {
+                    kind: "contract_backward_compatibility_risk",
+                    path: options.baselineEntry.path,
+                    confidence: 0.94,
+                    note: `${options.baselineEntry.path} existed in the contract baseline but is no longer present in the current contract surface.`,
+                },
+            ],
+        };
+    }
+    let removedSymbols = 0;
+    let regressedSymbols = 0;
+    let loosenedSymbols = 0;
+    let newRiskySymbols = 0;
+    let importRiskDeltas = 0;
+    let baselineImportTotal = 0;
+    const currentSymbolsByName = new Map(currentEntry.symbols.map((symbol) => [symbol.name, symbol]));
+    for (const baselineSymbol of baselineSymbols) {
+        const currentSymbol = currentSymbolsByName.get(baselineSymbol.name);
+        if (!currentSymbol) {
+            removedSymbols += 1;
+            findings.push({
+                kind: "contract_backward_compatibility_risk",
+                path: options.baselineEntry.path,
+                confidence: 0.94,
+                note: `${options.baselineEntry.path} removed public contract symbol ${baselineSymbol.name} since the baseline snapshot.`,
+                symbol: baselineSymbol.name,
+            });
+            continue;
+        }
+        if (baselineSymbol.stability === "stable" && currentSymbol.stability === "risky") {
+            regressedSymbols += 1;
+            findings.push({
+                kind: "contract_backward_compatibility_risk",
+                path: options.baselineEntry.path,
+                confidence: 0.93,
+                note: `${options.baselineEntry.path} regressed ${baselineSymbol.name} from a stable contract declaration to an implementation-coupled export.`,
+                symbol: baselineSymbol.name,
+            });
+        }
+        if (baselineSymbol.looseness === "strict" && currentSymbol.looseness === "loose") {
+            loosenedSymbols += 1;
+            findings.push({
+                kind: "breaking_change_risk",
+                path: options.baselineEntry.path,
+                confidence: 0.92,
+                note: `${options.baselineEntry.path} loosened ${baselineSymbol.name} since the baseline snapshot.`,
+                symbol: baselineSymbol.name,
+            });
+        }
+    }
+    const baselineSymbolNames = new Set(baselineSymbols.map((symbol) => symbol.name));
+    newRiskySymbols += currentEntry.symbols.filter((symbol) => !baselineSymbolNames.has(symbol.name) && (symbol.stability === "risky" || symbol.looseness === "loose")).length;
+    if (options.baselineEntry.imports) {
+        baselineImportTotal += options.baselineEntry.imports.total;
+        importRiskDeltas += Math.max(0, currentEntry.nonContractImports - options.baselineEntry.imports.nonContract);
+        importRiskDeltas += Math.max(0, currentEntry.internalImports - options.baselineEntry.imports.internal);
+    }
+    return {
+        baselineSymbolCount: baselineSymbols.length,
+        comparedFiles: 1,
+        baselineEntriesWithoutImportStats: options.baselineEntry.imports ? 0 : 1,
+        removedSymbols,
+        regressedSymbols,
+        loosenedSymbols,
+        newRiskySymbols,
+        importRiskDeltas,
+        baselineImportTotal,
+        unknowns,
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-contract-score-baseline-scope.d.ts

@@ -0,0 +1,8 @@
+import type { ArchitectureConstraints, ArchitectureContractBaseline } from "../core/contracts.js";
+export declare function collectScopedBaselineEntries(options: {
+    baseline: ArchitectureContractBaseline;
+    constraints: ArchitectureConstraints;
+}): {
+    entries: ArchitectureContractBaseline["contracts"];
+    unknowns: string[];
+};

package/dist/src/analyzers/architecture-contract-score-baseline-scope.js

@@ -0,0 +1,18 @@
+import { isMeasuredContractFilePath } from "./contract-files.js";
+export function collectScopedBaselineEntries(options) {
+    const baselineContracts = Array.isArray(options.baseline.contracts) ? options.baseline.contracts : [];
+    const inScopeBaselineEntries = baselineContracts.filter((entry) => isMeasuredContractFilePath({
+        filePath: entry.path,
+        constraints: options.constraints,
+        allowDartDomainFallback: true,
+    }));
+    const ignoredBaselineEntries = baselineContracts.length - inScopeBaselineEntries.length;
+    return {
+        entries: inScopeBaselineEntries,
+        unknowns: ignoredBaselineEntries > 0
+            ? [
+                `${ignoredBaselineEntries} contract baseline entries are outside the current architecture scope and were ignored.`,
+            ]
+            : [],
+    };
+}

package/dist/src/analyzers/architecture-contract-score-baseline.d.ts

@@ -0,0 +1 @@
+export { compareAgainstBaseline } from "./architecture-contract-score-baseline-core.js";

package/dist/src/analyzers/architecture-contract-score-baseline.js

@@ -0,0 +1 @@
+export { compareAgainstBaseline } from "./architecture-contract-score-baseline-core.js";

package/dist/src/analyzers/architecture-contract-score-current.d.ts

@@ -0,0 +1,3 @@
+import type { ContractCurrentStateSummary } from "./architecture-contract-score-shared.js";
+import type { ContractFileStats } from "./architecture-contract-stats.js";
+export declare function buildCurrentStateScore(stats: ContractFileStats[]): ContractCurrentStateSummary;

package/dist/src/analyzers/architecture-contract-score-current.js

@@ -0,0 +1,39 @@
+import { average, clamp01 } from "./architecture-contract-score-shared.js";
+export function buildCurrentStateScore(stats) {
+    const totalExports = stats.reduce((sum, entry) => sum + entry.exportCount, 0);
+    const stableExports = stats.reduce((sum, entry) => sum + entry.stableExports, 0);
+    const totalImports = stats.reduce((sum, entry) => sum + entry.totalImports, 0);
+    const nonContractImports = stats.reduce((sum, entry) => sum + entry.nonContractImports, 0);
+    const internalImports = stats.reduce((sum, entry) => sum + entry.internalImports, 0);
+    const riskyExports = stats.reduce((sum, entry) => sum + entry.riskyExports + entry.anyExports, 0);
+    const riskSignals = riskyExports + nonContractImports + internalImports;
+    const unknowns = ["CBC/BCR are current-state contract-stability proxies, not baseline deltas."];
+    const stableExportRatio = totalExports === 0 ? 0.5 : stableExports / totalExports;
+    const importAdherence = totalImports === 0 ? 1 : 1 - nonContractImports / Math.max(1, totalImports);
+    const cleanContractFileRatio = stats.filter((entry) => entry.riskyExports === 0 &&
+        entry.anyExports === 0 &&
+        entry.nonContractImports === 0 &&
+        entry.internalImports === 0).length / Math.max(1, stats.length);
+    const CBC = clamp01(stableExportRatio * (1 - Math.min(1, riskSignals / Math.max(1, totalExports + totalImports)) * 0.35));
+    const BCR = clamp01(riskSignals / Math.max(1, totalExports + totalImports + stats.length));
+    const SLA = clamp01(0.6 * importAdherence + 0.4 * cleanContractFileRatio);
+    if (totalImports === 0) {
+        unknowns.push("There are too few contract imports, so SLA evidence is limited.");
+    }
+    if (totalExports === 0) {
+        unknowns.push("There are too few public contract exports, so CBC evidence is limited.");
+    }
+    return {
+        CBC,
+        BCR,
+        SLA,
+        confidence: clamp01(average([
+            stats.length > 0 ? 0.8 : 0.45,
+            totalExports > 0 ? 0.82 : 0.55,
+            totalImports > 0 ? 0.75 : 0.6,
+            riskSignals > 0 ? 0.85 : 0.72,
+        ], 0.6)),
+        unknowns: Array.from(new Set(unknowns)),
+        findings: stats.flatMap((entry) => entry.findings),
+    };
+}

package/dist/src/analyzers/architecture-contract-score-shared.d.ts

@@ -0,0 +1,18 @@
+import type { ContractStabilityFinding } from "./architecture-contract-types.js";
+export interface ContractCurrentStateSummary {
+    CBC: number;
+    BCR: number;
+    SLA: number;
+    confidence: number;
+    unknowns: string[];
+    findings: ContractStabilityFinding[];
+}
+export interface BaselineComparisonSummary {
+    CBC: number;
+    BCR: number;
+    confidence: number;
+    unknowns: string[];
+    findings: ContractStabilityFinding[];
+}
+export declare function clamp01(value: number): number;
+export declare function average(values: number[], fallback: number): number;

package/dist/src/analyzers/architecture-contract-score-shared.js

@@ -0,0 +1,9 @@
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}

package/dist/src/analyzers/architecture-contract-scoring.d.ts

@@ -0,0 +1,15 @@
+import type { ArchitectureConstraints, ArchitectureContractBaseline, CodebaseAnalysis } from "../core/contracts.js";
+import type { InterfaceProtocolStabilityScore } from "./architecture-contract-types.js";
+export declare function captureInterfaceProtocolBaseline(options: {
+    root: string;
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+    capturedAt?: string;
+    note?: string;
+}): Promise<ArchitectureContractBaseline>;
+export declare function scoreInterfaceProtocolStability(options: {
+    root: string;
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+    baseline?: ArchitectureContractBaseline;
+}): Promise<InterfaceProtocolStabilityScore>;

package/dist/src/analyzers/architecture-contract-scoring.js

@@ -0,0 +1,70 @@
+import { compareAgainstBaseline } from "./architecture-contract-score-baseline.js";
+import { buildCurrentStateScore } from "./architecture-contract-score-current.js";
+import { average, clamp01 } from "./architecture-contract-score-shared.js";
+import { collectContractFileStats, toContractBaselineEntry } from "./architecture-contract-stats.js";
+export async function captureInterfaceProtocolBaseline(options) {
+    const stats = await collectContractFileStats(options);
+    return {
+        version: "1.0",
+        ...(options.capturedAt || options.note
+            ? {
+                snapshot: {
+                    ...(options.capturedAt ? { sourceKind: "captured", capturedAt: options.capturedAt } : {}),
+                    ...(options.note ? { note: options.note } : {}),
+                },
+            }
+            : {}),
+        contracts: stats.map((entry) => toContractBaselineEntry(entry)),
+    };
+}
+export async function scoreInterfaceProtocolStability(options) {
+    const stats = await collectContractFileStats(options);
+    const contractPaths = stats.map((entry) => entry.path);
+    if (contractPaths.length === 0) {
+        return {
+            CBC: 0.5,
+            BCR: 0.5,
+            SLA: 0.5,
+            confidence: 0.45,
+            unknowns: ["There are too few contract files, so IPS is conservative."],
+            findings: [],
+        };
+    }
+    const currentState = buildCurrentStateScore(stats);
+    const baselineComparison = options.baseline
+        ? compareAgainstBaseline({
+            baseline: options.baseline,
+            currentStats: stats,
+            constraints: options.constraints,
+        })
+        : undefined;
+    const totalImports = stats.reduce((sum, entry) => sum + entry.totalImports, 0);
+    const importAdherence = totalImports === 0
+        ? 1
+        : 1 - stats.reduce((sum, entry) => sum + entry.nonContractImports, 0) / Math.max(1, totalImports);
+    const cleanContractFileRatio = stats.filter((entry) => entry.riskyExports === 0 &&
+        entry.anyExports === 0 &&
+        entry.nonContractImports === 0 &&
+        entry.internalImports === 0).length / Math.max(1, stats.length);
+    const SLA = clamp01(0.6 * importAdherence + 0.4 * cleanContractFileRatio);
+    const mergedUnknowns = baselineComparison
+        ? [
+            ...baselineComparison.unknowns,
+            ...(totalImports === 0 ? ["There are too few contract imports, so SLA evidence is limited."] : []),
+        ]
+        : currentState.unknowns;
+    const mergedFindings = baselineComparison
+        ? [...currentState.findings, ...baselineComparison.findings]
+        : currentState.findings;
+    const confidence = baselineComparison
+        ? clamp01(average([currentState.confidence, baselineComparison.confidence], currentState.confidence))
+        : currentState.confidence;
+    return {
+        CBC: baselineComparison?.CBC ?? currentState.CBC,
+        BCR: baselineComparison?.BCR ?? currentState.BCR,
+        SLA,
+        confidence,
+        unknowns: Array.from(new Set(mergedUnknowns)),
+        findings: mergedFindings,
+    };
+}

package/dist/src/analyzers/architecture-contract-stats-core.d.ts

@@ -0,0 +1,9 @@
+import type { ArchitectureConstraints, CodebaseAnalysis } from "../core/contracts.js";
+import type { ContractFileStats } from "./architecture-contract-stats-file.js";
+export type { ContractFileStats } from "./architecture-contract-stats-file.js";
+export declare function collectContractFileStats(options: {
+    root: string;
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+}): Promise<ContractFileStats[]>;
+export { toContractBaselineEntry } from "./architecture-contract-stats-file.js";

package/dist/src/analyzers/architecture-contract-stats-core.js

@@ -0,0 +1,20 @@
+import { analyzeContractFileStats } from "./architecture-contract-stats-file.js";
+import { collectContractFilePaths } from "./contract-files.js";
+export async function collectContractFileStats(options) {
+    const contractPaths = collectContractFilePaths({
+        codebase: options.codebase,
+        constraints: options.constraints,
+        allowDartDomainFallback: true,
+    });
+    const contractFiles = new Set(contractPaths);
+    const fileMap = new Map(options.codebase.files.map((file) => [file.path, file]));
+    return Promise.all(contractPaths.map((filePath) => analyzeContractFileStats({
+        root: options.root,
+        path: filePath,
+        codebase: options.codebase,
+        constraints: options.constraints,
+        contractFiles,
+        fileMap,
+    })));
+}
+export { toContractBaselineEntry } from "./architecture-contract-stats-file.js";

package/dist/src/analyzers/architecture-contract-stats-file.d.ts

@@ -0,0 +1,23 @@
+import type { ArchitectureConstraints, ArchitectureContractBaselineEntry, ArchitectureContractBaselineSymbol, CodebaseAnalysis, ParsedSourceFile } from "../core/contracts.js";
+import type { ContractStabilityFinding } from "./architecture-contract-types.js";
+export interface ContractFileStats {
+    path: string;
+    exportCount: number;
+    stableExports: number;
+    riskyExports: number;
+    anyExports: number;
+    totalImports: number;
+    nonContractImports: number;
+    internalImports: number;
+    symbols: ArchitectureContractBaselineSymbol[];
+    findings: ContractStabilityFinding[];
+}
+export declare function analyzeContractFileStats(options: {
+    root: string;
+    path: string;
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+    contractFiles: Set<string>;
+    fileMap: Map<string, ParsedSourceFile>;
+}): Promise<ContractFileStats>;
+export declare function toContractBaselineEntry(stats: ContractFileStats): ArchitectureContractBaselineEntry;

package/dist/src/analyzers/architecture-contract-stats-file.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { readText } from "../core/io.js";
+import { analyzeDartContractDeclarations, analyzeEcmaContractDeclarations, } from "./architecture-contract-declarations.js";
+import { getScorableDependencies } from "./code.js";
+import { classifyArchitectureLayer } from "./contract-files.js";
+const INTERNAL_SIGNAL = /(internal|infra|infrastructure|implementation|impl|adapter|adapters|controller|controllers|logger|gateway|gateways)/i;
+function classifyLayer(filePath, constraints) {
+    return classifyArchitectureLayer(filePath, constraints);
+}
+function isInternalishFile(filePath, layerName) {
+    return INTERNAL_SIGNAL.test(filePath) || (layerName ? INTERNAL_SIGNAL.test(layerName) : false);
+}
+function analyzeDeclarations(input) {
+    return input.parsedFile?.language === "dart"
+        ? analyzeDartContractDeclarations(input.pathValue, input.sourceText)
+        : analyzeEcmaContractDeclarations(input.pathValue, input.sourceText);
+}
+export async function analyzeContractFileStats(options) {
+    const sourceText = await readText(path.join(options.root, options.path));
+    const parsedFile = options.fileMap.get(options.path);
+    const declarationStats = analyzeDeclarations({
+        pathValue: options.path,
+        sourceText,
+        ...(parsedFile ? { parsedFile } : {}),
+    });
+    const dependencies = getScorableDependencies(options.codebase).filter((dependency) => dependency.source === options.path && dependency.targetKind === "file" && dependency.kind !== "part");
+    const findings = [...declarationStats.findings];
+    let nonContractImports = 0;
+    let internalImports = 0;
+    for (const dependency of dependencies) {
+        const targetLayer = classifyLayer(dependency.target, options.constraints);
+        const targetIsContract = options.contractFiles.has(dependency.target);
+        if (!targetIsContract) {
+            nonContractImports += 1;
+            findings.push({
+                kind: "schema_language_violation",
+                path: options.path,
+                symbol: dependency.specifier,
+                confidence: 0.9,
+                note: `${options.path} references a non-contract file: ${dependency.target}.`,
+            });
+        }
+        if (isInternalishFile(dependency.target, targetLayer?.name)) {
+            internalImports += 1;
+            findings.push({
+                kind: "breaking_change_risk",
+                path: options.path,
+                symbol: dependency.specifier,
+                confidence: 0.92,
+                note: `${options.path} references an internal/framework-like file: ${dependency.target}.`,
+            });
+        }
+    }
+    return {
+        path: options.path,
+        exportCount: declarationStats.exportCount,
+        stableExports: declarationStats.stableExports,
+        riskyExports: declarationStats.riskyExports,
+        anyExports: declarationStats.anyExports,
+        totalImports: dependencies.length,
+        nonContractImports,
+        internalImports,
+        symbols: declarationStats.symbols,
+        findings,
+    };
+}
+export function toContractBaselineEntry(stats) {
+    return {
+        path: stats.path,
+        symbols: stats.symbols,
+        imports: {
+            total: stats.totalImports,
+            nonContract: stats.nonContractImports,
+            internal: stats.internalImports,
+        },
+    };
+}

package/dist/src/analyzers/architecture-contract-stats.d.ts

@@ -0,0 +1,2 @@
+export type { ContractFileStats } from "./architecture-contract-stats-core.js";
+export { collectContractFileStats, toContractBaselineEntry } from "./architecture-contract-stats-core.js";

package/dist/src/analyzers/architecture-contract-stats.js

@@ -0,0 +1 @@
+export { collectContractFileStats, toContractBaselineEntry } from "./architecture-contract-stats-core.js";

package/dist/src/analyzers/architecture-contract-types.d.ts

@@ -0,0 +1,24 @@
+import type { ArchitectureContractBaselineSymbol } from "../core/contracts.js";
+export interface ContractStabilityFinding {
+    kind: "contract_backward_compatibility_risk" | "breaking_change_risk" | "schema_language_violation";
+    path: string;
+    symbol?: string;
+    confidence: number;
+    note: string;
+}
+export interface InterfaceProtocolStabilityScore {
+    CBC: number;
+    BCR: number;
+    SLA: number;
+    confidence: number;
+    unknowns: string[];
+    findings: ContractStabilityFinding[];
+}
+export interface ContractDeclarationStats {
+    exportCount: number;
+    stableExports: number;
+    riskyExports: number;
+    anyExports: number;
+    symbols: ArchitectureContractBaselineSymbol[];
+    findings: ContractStabilityFinding[];
+}

package/dist/src/analyzers/architecture-contract-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/analyzers/architecture-contracts.d.ts

@@ -0,0 +1,2 @@
+export { captureInterfaceProtocolBaseline, scoreInterfaceProtocolStability, } from "./architecture-contract-scoring.js";
+export type { ContractStabilityFinding, InterfaceProtocolStabilityScore } from "./architecture-contract-types.js";

package/dist/src/analyzers/architecture-contracts.js

@@ -0,0 +1 @@
+export { captureInterfaceProtocolBaseline, scoreInterfaceProtocolStability, } from "./architecture-contract-scoring.js";

package/dist/src/analyzers/architecture-cti-ingest.d.ts

@@ -0,0 +1,19 @@
+import type { ArchitectureComplexityExportBundle, ArchitectureComplexityMetadata } from "../core/contracts.js";
+export interface ComplexityExportIngestFinding {
+    kind: "complexity_export_metric_mapped" | "complexity_export_metric_missing";
+    confidence: number;
+    note: string;
+    component: keyof ArchitectureComplexityExportBundle["metrics"];
+    observed?: number;
+    sourceSystem?: string;
+}
+export interface IngestedComplexityExport {
+    complexity: ArchitectureComplexityMetadata;
+    confidence: number;
+    unknowns: string[];
+    findings: ComplexityExportIngestFinding[];
+}
+export declare function ingestComplexityExportBundle(input: {
+    bundle: ArchitectureComplexityExportBundle;
+    existing?: ArchitectureComplexityMetadata;
+}): IngestedComplexityExport;

package/dist/src/analyzers/architecture-cti-ingest.js

@@ -0,0 +1,64 @@
+function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+export function ingestComplexityExportBundle(input) {
+    const findings = [];
+    const unknowns = [];
+    const confidenceSignals = [];
+    const metrics = input.bundle.metrics;
+    const mappings = [
+        "teamCount",
+        "deployableCount",
+        "pipelineCount",
+        "contractOrSchemaCount",
+        "serviceCount",
+        "serviceGroupCount",
+        "datastoreCount",
+        "onCallSurface",
+        "syncDepthP95",
+        "runCostPerBusinessTransaction",
+    ];
+    for (const component of mappings) {
+        const observed = metrics[component];
+        if (observed === undefined) {
+            unknowns.push(`The complexity export is missing ${component}.`);
+            findings.push({
+                kind: "complexity_export_metric_missing",
+                confidence: 0.62,
+                note: `The complexity export is missing ${component}.`,
+                component,
+                ...(input.bundle.sourceSystem ? { sourceSystem: input.bundle.sourceSystem } : {}),
+            });
+            confidenceSignals.push(0.55);
+            continue;
+        }
+        findings.push({
+            kind: "complexity_export_metric_mapped",
+            confidence: 0.84,
+            note: `Imported ${component} from the complexity export into CTI metadata.`,
+            component,
+            observed,
+            ...(input.bundle.sourceSystem ? { sourceSystem: input.bundle.sourceSystem } : {}),
+        });
+        confidenceSignals.push(0.84);
+    }
+    return {
+        complexity: {
+            ...(input.existing ?? {}),
+            ...metrics,
+            ...(input.existing?.normalization ? { normalization: input.existing.normalization } : {}),
+        },
+        confidence: clamp01(average(confidenceSignals, 0.6)),
+        unknowns: unique(unknowns),
+        findings,
+    };
+}