context-probe 0.1.0

package/dist/src/core/aggregate-fitness-shared.js

@@ -0,0 +1,127 @@
+import { normalizeDomainDesignLabel, scoreTextAgainstLabel } from "./domain-design-matching.js";
+import { average, clamp01Finite as clamp01, unique } from "./shared-utils.js";
+const STRONG_CONSISTENCY_SIGNALS = [
+    /一致/u,
+    /整合/u,
+    /同時/u,
+    /両方/u,
+    /またが/u,
+    /跨/u,
+    /同じ.*(?:更新|確定)/u,
+    /\bconsistent\b/i,
+    /\bsame transaction\b/i,
+];
+const OBLIGATION_SIGNALS = [/なければならない/u, /べき/u, /\bmust\b/i];
+export { average, clamp01, unique };
+export function localizationScore(contexts) {
+    if (contexts.length === 0) {
+        return 0.35;
+    }
+    return 1 / contexts.length;
+}
+function isStrongConsistencyInvariant(statement) {
+    return STRONG_CONSISTENCY_SIGNALS.some((pattern) => pattern.test(statement));
+}
+export function impliesStrongConsistencyWrite(statement) {
+    return isStrongConsistencyInvariant(statement) || OBLIGATION_SIGNALS.some((pattern) => pattern.test(statement));
+}
+export function collectAggregateTargets(aggregateDefinitions, contexts, invariant, mappedTerms = []) {
+    if (aggregateDefinitions.length === 0) {
+        return { targets: [], unknowns: [], hasAnchorEvidence: false };
+    }
+    const unknowns = [];
+    const eligibleAggregates = contexts.length === 0
+        ? aggregateDefinitions
+        : aggregateDefinitions.filter((aggregate) => contexts.includes(aggregate.context));
+    const relatedTerms = invariant.relatedTerms ?? [];
+    const statementBackedTermLabels = unique(mappedTerms
+        .filter((term) => term.contexts.length > 0 &&
+        (contexts.length === 0 || term.contexts.some((context) => contexts.includes(context))))
+        .filter((term) => term.labels.some((label) => scoreTextAgainstLabel(invariant.statement, label) > 0) ||
+        relatedTerms.some((relatedTerm) => term.labels.some((label) => scoreTextAgainstLabel(relatedTerm, label) > 0)))
+        .flatMap((term) => term.labels));
+    const scoredCandidates = eligibleAggregates
+        .map((aggregate) => {
+        const labels = unique([aggregate.name, ...(aggregate.aliases ?? [])]);
+        const directScore = Math.max(0, ...labels.map((label) => scoreTextAgainstLabel(invariant.statement, label)));
+        const relatedScore = Math.max(0, ...relatedTerms.flatMap((term) => labels.map((label) => scoreTextAgainstLabel(term, label))));
+        const glossaryScore = Math.max(0, ...statementBackedTermLabels.flatMap((term) => labels.map((label) => scoreTextAgainstLabel(term, label))));
+        return {
+            aggregate,
+            bestDirectLabels: directScore > 0
+                ? labels.filter((label) => scoreTextAgainstLabel(invariant.statement, label) === directScore)
+                : [],
+            bestRelatedLabels: relatedScore > 0
+                ? labels.filter((label) => relatedTerms.some((term) => scoreTextAgainstLabel(term, label) === relatedScore))
+                : [],
+            directScore,
+            relatedScore,
+            score: directScore * 3 + relatedScore * 2 + glossaryScore,
+        };
+    })
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score);
+    if (scoredCandidates.length > 0) {
+        const strongMatches = scoredCandidates.filter((candidate) => candidate.directScore >= 2 || candidate.relatedScore >= 2);
+        if (strongMatches.length > 0) {
+            const distinctStrongLabels = unique(strongMatches.flatMap((candidate) => (candidate.directScore >= 2 ? candidate.bestDirectLabels : candidate.bestRelatedLabels).map((label) => normalizeDomainDesignLabel(label))));
+            if (strongMatches.length === 1 || distinctStrongLabels.length > 1) {
+                return {
+                    targets: strongMatches.map((candidate) => `${candidate.aggregate.context}::${candidate.aggregate.name}`),
+                    unknowns,
+                    hasAnchorEvidence: true,
+                };
+            }
+            if (contexts.length === 1) {
+                unknowns.push(`Invariant "${invariant.invariantId}" could not be mapped to a specific aggregate within ${contexts[0]}.`);
+            }
+            return {
+                targets: [],
+                unknowns,
+                hasAnchorEvidence: true,
+            };
+        }
+        const best = scoredCandidates[0];
+        const runnerUp = scoredCandidates[1];
+        const topCandidates = best ? scoredCandidates.filter((candidate) => candidate.score === best.score) : [];
+        if (topCandidates.length > 1 && best) {
+            const distinctDirectLabels = unique(topCandidates.flatMap((candidate) => candidate.bestDirectLabels.map((label) => normalizeDomainDesignLabel(label))));
+            if (distinctDirectLabels.length > 1) {
+                return {
+                    targets: topCandidates.map((candidate) => `${candidate.aggregate.context}::${candidate.aggregate.name}`),
+                    unknowns,
+                    hasAnchorEvidence: true,
+                };
+            }
+            if (contexts.length === 1) {
+                unknowns.push(`Invariant "${invariant.invariantId}" could not be mapped to a specific aggregate within ${contexts[0]}.`);
+            }
+            return { targets: [], unknowns, hasAnchorEvidence: true };
+        }
+        if (best && (!runnerUp || best.score > runnerUp.score)) {
+            return {
+                targets: [`${best.aggregate.context}::${best.aggregate.name}`],
+                unknowns,
+                hasAnchorEvidence: true,
+            };
+        }
+        if (contexts.length === 1) {
+            unknowns.push(`Invariant "${invariant.invariantId}" could not be mapped to a specific aggregate within ${contexts[0]}.`);
+        }
+        return { targets: [], unknowns, hasAnchorEvidence: true };
+    }
+    if (contexts.length === 1) {
+        const sameContextAggregates = aggregateDefinitions.filter((aggregate) => aggregate.context === contexts[0]);
+        if (sameContextAggregates.length === 1) {
+            return {
+                targets: [`${sameContextAggregates[0]?.context}::${sameContextAggregates[0]?.name}`],
+                unknowns,
+                hasAnchorEvidence: false,
+            };
+        }
+        if (sameContextAggregates.length > 1) {
+            unknowns.push(`Invariant "${invariant.invariantId}" could not be mapped to a specific aggregate within ${contexts[0]}.`);
+        }
+    }
+    return { targets: [], unknowns, hasAnchorEvidence: false };
+}

package/dist/src/core/aggregate-fitness.d.ts

@@ -0,0 +1,2 @@
+export type { AggregateFitnessResult } from "./aggregate-fitness-core.js";
+export { computeAggregateFitness } from "./aggregate-fitness-core.js";

package/dist/src/core/aggregate-fitness.js

@@ -0,0 +1 @@
+export { computeAggregateFitness } from "./aggregate-fitness-core.js";

package/dist/src/core/architecture-purity-core.d.ts

@@ -0,0 +1,3 @@
+import type { ArchitectureConstraints, CodebaseAnalysis } from "../core/contracts.js";
+import type { BoundaryPurityScore } from "./architecture-purity-types.js";
+export declare function scoreBoundaryPurity(codebase: CodebaseAnalysis, constraints: ArchitectureConstraints): BoundaryPurityScore;

package/dist/src/core/architecture-purity-core.js

@@ -0,0 +1,94 @@
+import { average, clamp01, isAllowedFrameworkLayer, isFrameworkish, isInternalish, } from "../analyzers/architecture-purity-signals.js";
+import { getScorableDependencies } from "../analyzers/code.js";
+import { classifyArchitectureLayer } from "../analyzers/contract-files.js";
+function classifyLayer(filePath, constraints) {
+    return classifyArchitectureLayer(filePath, constraints);
+}
+export function scoreBoundaryPurity(codebase, constraints) {
+    const unknowns = [];
+    const findings = [];
+    const classifiedFiles = codebase.scorableSourceFiles
+        .map((filePath) => ({
+        path: filePath,
+        layer: classifyLayer(filePath, constraints),
+    }))
+        .filter((entry) => Boolean(entry.layer));
+    const classifiedEdges = getScorableDependencies(codebase)
+        .filter((dependency) => dependency.targetKind === "file")
+        .map((dependency) => ({
+        dependency,
+        sourceLayer: classifyLayer(dependency.source, constraints),
+        targetLayer: classifyLayer(dependency.target, constraints),
+    }))
+        .filter((entry) => Boolean(entry.sourceLayer && entry.targetLayer));
+    const maxRank = constraints.layers.reduce((current, layer) => Math.max(current, layer.rank), 0);
+    const adapterCandidates = classifiedEdges.filter(({ dependency, targetLayer }) => isFrameworkish(dependency.target, targetLayer.name));
+    const adapterLeaks = adapterCandidates.filter(({ sourceLayer, targetLayer }) => sourceLayer.rank < targetLayer.rank);
+    const ALR = adapterCandidates.length === 0 ? 0 : adapterLeaks.length / adapterCandidates.length;
+    if (adapterCandidates.length === 0) {
+        unknowns.push("There are too few adapter/framework-like dependencies, so ALR evidence is limited.");
+    }
+    findings.push(...adapterLeaks.map(({ dependency, sourceLayer, targetLayer }) => ({
+        kind: "adapter_leak",
+        path: dependency.source,
+        source: dependency.source,
+        target: dependency.target,
+        sourceLayer: sourceLayer.name,
+        targetLayer: targetLayer.name,
+        confidence: 0.92,
+        note: `${sourceLayer.name} depends directly on a framework/adapter-like target in ${targetLayer.name}.`,
+    })));
+    const frameworkishFiles = classifiedFiles.filter(({ path, layer }) => isFrameworkish(path, layer.name));
+    const frameworkContaminations = frameworkishFiles.filter(({ layer }) => !isAllowedFrameworkLayer(layer, maxRank));
+    const FCC = frameworkishFiles.length === 0 ? 0.6 : 1 - frameworkContaminations.length / Math.max(1, frameworkishFiles.length);
+    if (frameworkishFiles.length === 0) {
+        unknowns.push("There are too few framework/adapter-like files, so FCC is conservative.");
+    }
+    findings.push(...frameworkContaminations.map(({ path, layer }) => ({
+        kind: "framework_contamination",
+        path,
+        sourceLayer: layer.name,
+        confidence: 0.86,
+        note: `${layer.name} contains framework/adapter-like implementation details.`,
+    })));
+    const internalTargetMap = new Map();
+    for (const { dependency, sourceLayer, targetLayer } of classifiedEdges) {
+        if (!isInternalish(dependency.target, targetLayer.name)) {
+            continue;
+        }
+        const entry = internalTargetMap.get(dependency.target) ?? {
+            targetLayer: targetLayer.name,
+            sourceLayers: new Set(),
+        };
+        entry.sourceLayers.add(sourceLayer.name);
+        internalTargetMap.set(dependency.target, entry);
+    }
+    const internalTargets = Array.from(internalTargetMap.entries());
+    const sharedInternalTargets = internalTargets.filter(([, entry]) => entry.sourceLayers.size > 1);
+    const SICR = internalTargets.length === 0 ? 0 : sharedInternalTargets.length / Math.max(1, internalTargets.length);
+    if (internalTargets.length === 0) {
+        unknowns.push("There are too few internal components to judge sharing, so SICR evidence is limited.");
+    }
+    findings.push(...sharedInternalTargets.map(([path, entry]) => ({
+        kind: "shared_internal_component",
+        path,
+        target: path,
+        targetLayer: entry.targetLayer,
+        confidence: 0.88,
+        note: `${path} is shared by multiple layers (${Array.from(entry.sourceLayers).join(", ")}).`,
+    })));
+    const confidence = clamp01(average([
+        classifiedEdges.length > 0 ? 0.85 : 0.5,
+        adapterCandidates.length > 0 ? 0.82 : 0.6,
+        frameworkishFiles.length > 0 ? 0.8 : 0.58,
+        internalTargets.length > 0 ? 0.8 : 0.58,
+    ], 0.6));
+    return {
+        ALR,
+        FCC,
+        SICR,
+        confidence,
+        unknowns: Array.from(new Set(unknowns)),
+        findings,
+    };
+}

package/dist/src/core/architecture-purity-types.d.ts

@@ -0,0 +1,18 @@
+export interface PurityFinding {
+    kind: "adapter_leak" | "framework_contamination" | "shared_internal_component";
+    path: string;
+    source?: string;
+    target?: string;
+    sourceLayer?: string;
+    targetLayer?: string;
+    confidence: number;
+    note: string;
+}
+export interface BoundaryPurityScore {
+    ALR: number;
+    FCC: number;
+    SICR: number;
+    confidence: number;
+    unknowns: string[];
+    findings: PurityFinding[];
+}

package/dist/src/core/architecture-purity-types.js

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

package/dist/src/core/architecture-scenario-quality.d.ts

@@ -0,0 +1,5 @@
+import type { ArchitectureScenarioCatalog, ArchitectureScenarioQualitySummary, ScenarioObservationSet } from "./contracts.js";
+export declare function summarizeArchitectureScenarioQuality(input: {
+    catalog?: ArchitectureScenarioCatalog;
+    observations?: ScenarioObservationSet;
+}): ArchitectureScenarioQualitySummary | undefined;

package/dist/src/core/architecture-scenario-quality.js

@@ -0,0 +1,52 @@
+function normalizeScenarioIntent(name, metric) {
+    return `${name ?? ""}::${metric ?? ""}`.trim().toLowerCase();
+}
+export function summarizeArchitectureScenarioQuality(input) {
+    const catalog = input.catalog;
+    if (!catalog || catalog.scenarios.length === 0) {
+        return undefined;
+    }
+    const observationIds = new Set((input.observations?.observations ?? []).map((entry) => entry.scenarioId));
+    const missingObservationScenarioIds = [];
+    const missingTopPriorityObservationIds = [];
+    const duplicateScenarioIds = new Set();
+    const findings = [];
+    const intentToScenarioIds = new Map();
+    for (const scenario of catalog.scenarios) {
+        const intentKey = normalizeScenarioIntent(scenario.name, scenario.responseMeasure?.metric);
+        if (intentKey) {
+            const current = intentToScenarioIds.get(intentKey) ?? [];
+            current.push(scenario.scenarioId);
+            intentToScenarioIds.set(intentKey, current);
+        }
+        if (!observationIds.has(scenario.scenarioId)) {
+            missingObservationScenarioIds.push(scenario.scenarioId);
+            if (scenario.priority >= 4) {
+                missingTopPriorityObservationIds.push(scenario.scenarioId);
+            }
+        }
+    }
+    for (const [intentKey, scenarioIds] of intentToScenarioIds.entries()) {
+        if (scenarioIds.length <= 1) {
+            continue;
+        }
+        scenarioIds.forEach((scenarioId) => {
+            duplicateScenarioIds.add(scenarioId);
+        });
+        findings.push(`Scenario intent ${intentKey || "unnamed"} is duplicated across ${scenarioIds.join(", ")} and should be tightened.`);
+    }
+    if (missingTopPriorityObservationIds.length > 0) {
+        findings.push(`Top-priority scenarios are missing observations: ${missingTopPriorityObservationIds.join(", ")}.`);
+    }
+    else if (missingObservationScenarioIds.length > 0) {
+        findings.push(`Scenario observations are still missing for ${missingObservationScenarioIds.join(", ")}.`);
+    }
+    return {
+        totalScenarios: catalog.scenarios.length,
+        observedScenarios: catalog.scenarios.length - missingObservationScenarioIds.length,
+        missingObservationScenarioIds,
+        missingTopPriorityObservationIds,
+        duplicateScenarioIds: Array.from(duplicateScenarioIds),
+        findings,
+    };
+}

package/dist/src/core/architecture-scoring-evidence-architecture.d.ts

@@ -0,0 +1,10 @@
+import type { ArchitectureScoringContext } from "./architecture-scoring-types.js";
+import { toEvidence } from "./response.js";
+type EvidenceEntry = ReturnType<typeof toEvidence>;
+export declare function buildDirectionEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildPurityEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildProtocolEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildScenarioEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildTopologyEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildOperationsEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export {};

package/dist/src/core/architecture-scoring-evidence-architecture.js

@@ -0,0 +1,50 @@
+import { toEvidence } from "./response.js";
+export function buildDirectionEvidence(context) {
+    return context.violations.map((violation) => toEvidence(`${violation.sourceLayer} -> ${violation.targetLayer} direction violation`, {
+        source: violation.source,
+        target: violation.target,
+    }, undefined, 0.95));
+}
+export function buildPurityEvidence(context) {
+    return context.purityScore.findings.map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        path: finding.path,
+        ...(finding.source ? { source: finding.source } : {}),
+        ...(finding.target ? { target: finding.target } : {}),
+        ...(finding.sourceLayer ? { sourceLayer: finding.sourceLayer } : {}),
+        ...(finding.targetLayer ? { targetLayer: finding.targetLayer } : {}),
+    }, undefined, finding.confidence));
+}
+export function buildProtocolEvidence(context) {
+    return context.protocolScore.findings.map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        path: finding.path,
+        ...(finding.symbol ? { symbol: finding.symbol } : {}),
+    }, undefined, finding.confidence));
+}
+export function buildScenarioEvidence(context) {
+    return context.scenarioScore.findings.map((finding) => toEvidence(finding.note, {
+        scenarioId: finding.scenarioId,
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.normalized !== undefined ? { normalized: finding.normalized } : {}),
+        source: finding.source,
+    }, undefined, finding.confidence));
+}
+export function buildTopologyEvidence(context) {
+    return context.topologyScore.findings.map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        ...(finding.nodeId ? { nodeId: finding.nodeId } : {}),
+        ...(finding.source ? { source: finding.source } : {}),
+        ...(finding.target ? { target: finding.target } : {}),
+    }, undefined, finding.confidence));
+}
+export function buildOperationsEvidence(context) {
+    return context.operationsScore.findings.map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        ...(finding.bandId ? { bandId: finding.bandId } : {}),
+        ...(finding.component ? { component: finding.component } : {}),
+        ...(finding.patternFamily ? { patternFamily: finding.patternFamily } : {}),
+        ...(finding.signal ? { signal: finding.signal } : {}),
+        ...(finding.source ? { source: finding.source } : {}),
+    }, undefined, finding.confidence));
+}

package/dist/src/core/architecture-scoring-evidence-findings.d.ts

@@ -0,0 +1,2 @@
+export { buildDirectionEvidence, buildOperationsEvidence, buildProtocolEvidence, buildPurityEvidence, buildScenarioEvidence, buildTopologyEvidence, } from "./architecture-scoring-evidence-architecture.js";
+export { buildComplexityEvidence, buildComplexityExportEvidence, buildDeliveryExportEvidence, buildDeliveryNormalizationEvidence, buildEvolutionEvidence, buildPatternRuntimeNormalizationEvidence, buildTelemetryExportEvidence, buildTelemetryNormalizationEvidence, } from "./architecture-scoring-evidence-observability.js";

package/dist/src/core/architecture-scoring-evidence-findings.js

@@ -0,0 +1,2 @@
+export { buildDirectionEvidence, buildOperationsEvidence, buildProtocolEvidence, buildPurityEvidence, buildScenarioEvidence, buildTopologyEvidence, } from "./architecture-scoring-evidence-architecture.js";
+export { buildComplexityEvidence, buildComplexityExportEvidence, buildDeliveryExportEvidence, buildDeliveryNormalizationEvidence, buildEvolutionEvidence, buildPatternRuntimeNormalizationEvidence, buildTelemetryExportEvidence, buildTelemetryNormalizationEvidence, } from "./architecture-scoring-evidence-observability.js";

package/dist/src/core/architecture-scoring-evidence-inputs-ingest.d.ts

@@ -0,0 +1,5 @@
+import type { EvidenceEntry } from "./architecture-scoring-evidence-inputs-shared.js";
+import type { ArchitectureScoringContext, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+export declare function buildContractBaselineInputEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];
+export declare function buildDeliveryInputEvidence(options: ComputeArchitectureScoresOptions, context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildTelemetryInputEvidence(options: ComputeArchitectureScoresOptions, context: ArchitectureScoringContext): EvidenceEntry[];

package/dist/src/core/architecture-scoring-evidence-inputs-ingest.js

@@ -0,0 +1,68 @@
+import { buildSourceInputEvidence } from "./architecture-scoring-evidence-inputs-shared.js";
+import { toEvidence } from "./response.js";
+export function buildContractBaselineInputEvidence(options) {
+    if (!options.contractBaseline && !options.contractBaselineSource) {
+        return [];
+    }
+    return [
+        toEvidence(`Using a contract baseline for IPS delta comparison${options.contractBaselineSource ? ` (${options.contractBaselineSource.sourceType} source)` : ""}.`, {
+            source: "contract_baseline",
+            ...(options.contractBaselineSource?.resolvedPath
+                ? { sourcePath: options.contractBaselineSource.resolvedPath }
+                : {}),
+            ...(options.contractBaselineSource?.command ? { command: options.contractBaselineSource.command } : {}),
+        }, undefined, options.contractBaselineSource?.confidence ?? 0.82),
+    ];
+}
+export function buildDeliveryInputEvidence(options, context) {
+    if (options.deliveryObservations) {
+        return [
+            toEvidence("Using the normalized scores from delivery observations as-is.", { source: "normalized_input" }, undefined, 0.84),
+        ];
+    }
+    if (options.deliveryRawObservations) {
+        return [
+            toEvidence("Using raw delivery observations after scoring them through the normalization profile.", { source: "raw_normalized" }, undefined, 0.82),
+        ];
+    }
+    if (options.deliveryExport) {
+        return [
+            toEvidence("Ingested the delivery export as the delivery input for EES.", { source: "delivery_export" }, undefined, 0.8),
+        ];
+    }
+    if (options.deliverySource) {
+        return buildSourceInputEvidence(options.deliverySource, "delivery_source", "delivery source", 0.78);
+    }
+    if (context.deliveryNormalizationResult) {
+        return [
+            toEvidence("Using raw delivery observations after scoring them through the normalization profile.", { source: "raw_normalized" }, undefined, 0.82),
+        ];
+    }
+    return [];
+}
+export function buildTelemetryInputEvidence(options, context) {
+    if (options.telemetryObservations) {
+        return [
+            toEvidence("Using the normalized scores from telemetry observations as-is.", { source: "normalized_input" }, undefined, 0.84),
+        ];
+    }
+    if (options.telemetryRawObservations) {
+        return [
+            toEvidence("Using raw telemetry observations after scoring them through the normalization profile.", { source: "raw_normalized" }, undefined, 0.82),
+        ];
+    }
+    if (options.telemetryExport) {
+        return [
+            toEvidence("Ingested the telemetry export as the CommonOps input for OAS.", { source: "telemetry_export" }, undefined, 0.8),
+        ];
+    }
+    if (options.telemetrySource) {
+        return buildSourceInputEvidence(options.telemetrySource, "telemetry_source", "telemetry source", 0.78);
+    }
+    if (context.telemetryNormalizationResult) {
+        return [
+            toEvidence("Using raw telemetry observations after scoring them through the normalization profile.", { source: "raw_normalized" }, undefined, 0.82),
+        ];
+    }
+    return [];
+}

package/dist/src/core/architecture-scoring-evidence-inputs-shared.d.ts

@@ -0,0 +1,20 @@
+import { toEvidence } from "./response.js";
+export type EvidenceEntry = ReturnType<typeof toEvidence>;
+export interface SourceConfigFinding {
+    note: string;
+    kind: string;
+    sourceType: string;
+    sourcePath?: string;
+    command?: string;
+    cwd?: string;
+    confidence: number;
+}
+export interface ResolvedSourceLike {
+    sourceType: string;
+    resolvedPath?: string;
+    command?: string;
+    confidence?: number;
+    findings?: SourceConfigFinding[];
+}
+export declare function buildSourceConfigEvidence(source: ResolvedSourceLike | undefined, evidenceSource: string): EvidenceEntry[];
+export declare function buildSourceInputEvidence(source: ResolvedSourceLike | undefined, evidenceSource: string, label: string, confidence?: number): EvidenceEntry[];

package/dist/src/core/architecture-scoring-evidence-inputs-shared.js

@@ -0,0 +1,24 @@
+import { toEvidence } from "./response.js";
+export function buildSourceConfigEvidence(source, evidenceSource) {
+    return (source?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        sourceType: finding.sourceType,
+        ...(finding.sourcePath ? { sourcePath: finding.sourcePath } : {}),
+        ...(finding.command ? { command: finding.command } : {}),
+        ...(finding.cwd ? { cwd: finding.cwd } : {}),
+        source: evidenceSource,
+    }, undefined, finding.confidence));
+}
+export function buildSourceInputEvidence(source, evidenceSource, label, confidence = 0.78) {
+    if (!source) {
+        return [];
+    }
+    return [
+        toEvidence(`Ingested a canonical export from ${label} (${source.sourceType}).`, {
+            source: evidenceSource,
+            sourceType: source.sourceType,
+            ...(source.resolvedPath ? { sourcePath: source.resolvedPath } : {}),
+            ...(source.command ? { command: source.command } : {}),
+        }, undefined, confidence),
+    ];
+}

package/dist/src/core/architecture-scoring-evidence-inputs-source.d.ts

@@ -0,0 +1,7 @@
+import type { EvidenceEntry } from "./architecture-scoring-evidence-inputs-shared.js";
+import type { ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+export declare function buildContractBaselineSourceEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];
+export declare function buildScenarioSourceEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];
+export declare function buildTelemetrySourceEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];
+export declare function buildDeliverySourceEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];
+export declare function buildComplexitySourceEvidence(options: ComputeArchitectureScoresOptions): EvidenceEntry[];

package/dist/src/core/architecture-scoring-evidence-inputs-source.js

@@ -0,0 +1,16 @@
+import { buildSourceConfigEvidence } from "./architecture-scoring-evidence-inputs-shared.js";
+export function buildContractBaselineSourceEvidence(options) {
+    return buildSourceConfigEvidence(options.contractBaselineSource, "contract_baseline_source");
+}
+export function buildScenarioSourceEvidence(options) {
+    return buildSourceConfigEvidence(options.scenarioObservationSource, "scenario_observation_source");
+}
+export function buildTelemetrySourceEvidence(options) {
+    return buildSourceConfigEvidence(options.telemetrySource, "telemetry_source");
+}
+export function buildDeliverySourceEvidence(options) {
+    return buildSourceConfigEvidence(options.deliverySource, "delivery_source");
+}
+export function buildComplexitySourceEvidence(options) {
+    return buildSourceConfigEvidence(options.complexitySource, "complexity_source");
+}

package/dist/src/core/architecture-scoring-evidence-inputs.d.ts

@@ -0,0 +1,2 @@
+export { buildContractBaselineInputEvidence, buildDeliveryInputEvidence, buildTelemetryInputEvidence, } from "./architecture-scoring-evidence-inputs-ingest.js";
+export { buildComplexitySourceEvidence, buildContractBaselineSourceEvidence, buildDeliverySourceEvidence, buildScenarioSourceEvidence, buildTelemetrySourceEvidence, } from "./architecture-scoring-evidence-inputs-source.js";

package/dist/src/core/architecture-scoring-evidence-inputs.js

@@ -0,0 +1,2 @@
+export { buildContractBaselineInputEvidence, buildDeliveryInputEvidence, buildTelemetryInputEvidence, } from "./architecture-scoring-evidence-inputs-ingest.js";
+export { buildComplexitySourceEvidence, buildContractBaselineSourceEvidence, buildDeliverySourceEvidence, buildScenarioSourceEvidence, buildTelemetrySourceEvidence, } from "./architecture-scoring-evidence-inputs-source.js";

package/dist/src/core/architecture-scoring-evidence-observability.d.ts

@@ -0,0 +1,12 @@
+import type { ArchitectureScoringContext } from "./architecture-scoring-types.js";
+import { toEvidence } from "./response.js";
+type EvidenceEntry = ReturnType<typeof toEvidence>;
+export declare function buildTelemetryNormalizationEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildPatternRuntimeNormalizationEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildTelemetryExportEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildDeliveryNormalizationEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildDeliveryExportEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildComplexityExportEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildComplexityEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export declare function buildEvolutionEvidence(context: ArchitectureScoringContext): EvidenceEntry[];
+export {};

package/dist/src/core/architecture-scoring-evidence-observability.js

@@ -0,0 +1,75 @@
+import { toEvidence } from "./response.js";
+export function buildTelemetryNormalizationEvidence(context) {
+    return (context.telemetryNormalizationResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        bandId: finding.bandId,
+        component: finding.component,
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.normalized !== undefined ? { normalized: finding.normalized } : {}),
+    }, undefined, finding.confidence));
+}
+export function buildPatternRuntimeNormalizationEvidence(context) {
+    return (context.patternRuntimeNormalizationResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        block: finding.block,
+        rawSignal: finding.rawSignal,
+        scoreSignal: finding.scoreSignal,
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.normalized !== undefined ? { normalized: finding.normalized } : {}),
+        source: "pattern_runtime_raw_normalized",
+    }, undefined, finding.confidence));
+}
+export function buildTelemetryExportEvidence(context) {
+    return (context.telemetryExportIngestResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        ...(finding.bandId ? { bandId: finding.bandId } : {}),
+        ...(finding.component ? { component: finding.component } : {}),
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.sourceSystem ? { sourceSystem: finding.sourceSystem } : {}),
+        ...(finding.window ? { window: finding.window } : {}),
+        source: "telemetry_export",
+    }, undefined, finding.confidence));
+}
+export function buildDeliveryNormalizationEvidence(context) {
+    return (context.deliveryNormalizationResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        component: finding.component,
+        scoreComponent: finding.scoreComponent,
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.normalized !== undefined ? { normalized: finding.normalized } : {}),
+        source: "raw_normalized",
+    }, undefined, finding.confidence));
+}
+export function buildDeliveryExportEvidence(context) {
+    return (context.deliveryExportIngestResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        ...(finding.component ? { component: finding.component } : {}),
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.sourceSystem ? { sourceSystem: finding.sourceSystem } : {}),
+        source: "delivery_export",
+    }, undefined, finding.confidence));
+}
+export function buildComplexityExportEvidence(context) {
+    return (context.complexityExportIngestResult?.findings ?? []).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        component: finding.component,
+        ...(finding.observed !== undefined ? { observed: finding.observed } : {}),
+        ...(finding.sourceSystem ? { sourceSystem: finding.sourceSystem } : {}),
+        source: "complexity_export",
+    }, undefined, finding.confidence));
+}
+export function buildComplexityEvidence(context) {
+    return context.complexityScore.findings.map((finding) => toEvidence(finding.note, {
+        component: finding.component,
+        observed: finding.observed,
+        normalized: finding.normalized,
+        source: finding.source,
+    }, undefined, finding.confidence));
+}
+export function buildEvolutionEvidence(context) {
+    return context.evolutionLocalityScore.findings.concat(context.evolutionEfficiencyScore.findings).map((finding) => toEvidence(finding.note, {
+        kind: finding.kind,
+        ...(finding.commitHash ? { commitHash: finding.commitHash } : {}),
+        ...(finding.component ? { component: finding.component } : {}),
+    }, undefined, finding.confidence));
+}