context-probe 0.1.0

package/dist/src/analyzers/architecture-pattern-runtime-resolution-shared.d.ts

@@ -0,0 +1,16 @@
+import type { ArchitecturePatternFamily, ArchitecturePatternRuntimeObservationSet } from "../core/contracts.js";
+export type PatternRuntimeBlockName = "layeredRuntime" | "serviceBasedRuntime" | "cqrsRuntime" | "eventDrivenRuntime";
+export type WeightedSignalSet = Record<string, number | undefined>;
+export interface PatternRuntimeSpec {
+    blockName: PatternRuntimeBlockName;
+    families: ArchitecturePatternFamily[];
+    weights: Record<string, number>;
+}
+export declare const FAMILY_SPECS: readonly PatternRuntimeSpec[];
+export declare function clamp01(value: number): number;
+export declare function unique(values: string[]): string[];
+export declare function specForFamily(family: ArchitecturePatternFamily | undefined): PatternRuntimeSpec | undefined;
+export declare function blockEntries(observations: ArchitecturePatternRuntimeObservationSet | undefined): {
+    blockName: PatternRuntimeBlockName;
+    value: WeightedSignalSet;
+}[];

package/dist/src/analyzers/architecture-pattern-runtime-resolution-shared.js

@@ -0,0 +1,65 @@
+export const FAMILY_SPECS = [
+    {
+        blockName: "layeredRuntime",
+        families: ["layered", "clean", "hexagonal"],
+        weights: {
+            FailureContainmentScore: 0.6,
+            DependencyIsolationScore: 0.4,
+        },
+    },
+    {
+        blockName: "serviceBasedRuntime",
+        families: ["modular-monolith", "microservices"],
+        weights: {
+            PartialFailureContainmentScore: 0.4,
+            RetryAmplificationScore: 0.3,
+            SyncHopDepthScore: 0.3,
+        },
+    },
+    {
+        blockName: "cqrsRuntime",
+        families: ["cqrs"],
+        weights: {
+            ProjectionFreshnessScore: 0.4,
+            ReplayDivergenceScore: 0.3,
+            StaleReadAcceptabilityScore: 0.3,
+        },
+    },
+    {
+        blockName: "eventDrivenRuntime",
+        families: ["event-driven"],
+        weights: {
+            DeadLetterHealthScore: 0.35,
+            ConsumerLagScore: 0.35,
+            ReplayRecoveryScore: 0.3,
+        },
+    },
+];
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function unique(values) {
+    return Array.from(new Set(values));
+}
+export function specForFamily(family) {
+    return family ? FAMILY_SPECS.find((spec) => spec.families.includes(family)) : undefined;
+}
+export function blockEntries(observations) {
+    const entries = [];
+    if (!observations) {
+        return entries;
+    }
+    if (observations.layeredRuntime) {
+        entries.push({ blockName: "layeredRuntime", value: { ...observations.layeredRuntime } });
+    }
+    if (observations.serviceBasedRuntime) {
+        entries.push({ blockName: "serviceBasedRuntime", value: { ...observations.serviceBasedRuntime } });
+    }
+    if (observations.cqrsRuntime) {
+        entries.push({ blockName: "cqrsRuntime", value: { ...observations.cqrsRuntime } });
+    }
+    if (observations.eventDrivenRuntime) {
+        entries.push({ blockName: "eventDrivenRuntime", value: { ...observations.eventDrivenRuntime } });
+    }
+    return entries;
+}

package/dist/src/analyzers/architecture-pattern-runtime-resolution.d.ts

@@ -0,0 +1,15 @@
+import type { ArchitecturePatternRuntimeObservationSet } from "../core/contracts.js";
+import { type WeightedSignalSet } from "./architecture-pattern-runtime-resolution-shared.js";
+import type { PatternRuntimeFinding, SelectedPatternRuntimeSpec } from "./architecture-pattern-runtime-types.js";
+export { clamp01, unique } from "./architecture-pattern-runtime-resolution-shared.js";
+export declare function weightedObservedAverage(signals: WeightedSignalSet, weights: Record<string, number>): {
+    value: number;
+    coverage: number;
+    usedSignals: string[];
+    missingSignals: string[];
+};
+export declare function resolveSelectedSpec(input: {
+    observations: ArchitecturePatternRuntimeObservationSet | undefined;
+    findings: PatternRuntimeFinding[];
+    unknowns: string[];
+}): SelectedPatternRuntimeSpec;

package/dist/src/analyzers/architecture-pattern-runtime-resolution.js

@@ -0,0 +1,99 @@
+import { blockEntries, clamp01, FAMILY_SPECS, specForFamily, } from "./architecture-pattern-runtime-resolution-shared.js";
+export { clamp01, unique } from "./architecture-pattern-runtime-resolution-shared.js";
+export function weightedObservedAverage(signals, weights) {
+    const usedSignals = [];
+    const missingSignals = [];
+    let weightedSum = 0;
+    let observedWeight = 0;
+    let totalWeight = 0;
+    for (const [signal, weight] of Object.entries(weights)) {
+        totalWeight += weight;
+        const observed = signals[signal];
+        if (observed === undefined || !Number.isFinite(observed)) {
+            missingSignals.push(signal);
+            continue;
+        }
+        usedSignals.push(signal);
+        observedWeight += weight;
+        weightedSum += clamp01(observed) * weight;
+    }
+    const value = observedWeight > 0 ? weightedSum / observedWeight : 0.5;
+    const coverage = totalWeight > 0 ? observedWeight / totalWeight : 0;
+    return {
+        value: clamp01(value),
+        coverage: clamp01(coverage),
+        usedSignals,
+        missingSignals,
+    };
+}
+export function resolveSelectedSpec(input) {
+    const { observations, findings, unknowns } = input;
+    if (!observations) {
+        return {};
+    }
+    const declaredFamily = observations.patternFamily;
+    const declaredSpec = specForFamily(declaredFamily);
+    const providedBlocks = blockEntries(observations);
+    if (providedBlocks.length === 0) {
+        const result = {};
+        if (declaredSpec) {
+            result.spec = declaredSpec;
+        }
+        if (declaredFamily) {
+            result.family = declaredFamily;
+        }
+        return result;
+    }
+    if (providedBlocks.length > 1) {
+        unknowns.push("Multiple pattern runtime blocks were provided, so PatternRuntime is approximated from the highest-priority block.");
+        const finding = {
+            kind: "pattern_runtime_multiple_blocks",
+            confidence: 0.66,
+            note: "Multiple pattern runtime blocks were provided, so the highest-priority block was selected.",
+            source: "family",
+        };
+        if (declaredFamily) {
+            finding.patternFamily = declaredFamily;
+        }
+        findings.push(finding);
+    }
+    if (declaredSpec) {
+        const exactMatch = providedBlocks.find((entry) => entry.blockName === declaredSpec.blockName);
+        if (exactMatch) {
+            const result = {
+                spec: declaredSpec,
+                block: exactMatch.value,
+            };
+            if (declaredFamily) {
+                result.family = declaredFamily;
+            }
+            return result;
+        }
+    }
+    const selected = providedBlocks[0];
+    if (!selected) {
+        return {};
+    }
+    const selectedSpec = FAMILY_SPECS.find((entry) => entry.blockName === selected.blockName);
+    if (declaredFamily && selectedSpec && !selectedSpec.families.includes(declaredFamily)) {
+        unknowns.push(`patternFamily=${declaredFamily}, but PatternRuntime is being estimated from ${selected.blockName}.`);
+        findings.push({
+            kind: "pattern_runtime_family_mismatch",
+            confidence: 0.58,
+            note: `patternFamily=${declaredFamily} is inconsistent with ${selected.blockName}.`,
+            patternFamily: declaredFamily,
+            source: "family",
+        });
+    }
+    const result = {
+        block: selected.value,
+    };
+    if (selectedSpec) {
+        result.spec = selectedSpec;
+    }
+    const resolvedFamily = declaredFamily ?? selectedSpec?.families[0];
+    if (resolvedFamily) {
+        result.family = resolvedFamily;
+    }
+    return result;
+}

package/dist/src/analyzers/architecture-pattern-runtime-shared.d.ts

@@ -0,0 +1,2 @@
+export { clamp01, resolveSelectedSpec, unique, weightedObservedAverage, } from "./architecture-pattern-runtime-resolution.js";
+export type { PatternRuntimeFinding, PatternRuntimeResolution, PatternRuntimeSource, SelectedPatternRuntimeSpec, } from "./architecture-pattern-runtime-types.js";

package/dist/src/analyzers/architecture-pattern-runtime-shared.js

@@ -0,0 +1 @@
+export { clamp01, resolveSelectedSpec, unique, weightedObservedAverage, } from "./architecture-pattern-runtime-resolution.js";

package/dist/src/analyzers/architecture-pattern-runtime-types.d.ts

@@ -0,0 +1,29 @@
+import type { ArchitecturePatternFamily } from "../core/contracts.js";
+export type PatternRuntimeSource = "family" | "legacy" | "tis_bridge" | "neutral";
+export interface PatternRuntimeFinding {
+    kind: "pattern_runtime_signal_missing" | "pattern_runtime_family_mismatch" | "pattern_runtime_multiple_blocks" | "pattern_runtime_legacy_overridden" | "pattern_runtime_legacy_used" | "pattern_runtime_tis_bridge" | "pattern_runtime_neutral";
+    confidence: number;
+    note: string;
+    patternFamily?: ArchitecturePatternFamily;
+    signal?: string;
+    source?: PatternRuntimeSource;
+}
+export interface PatternRuntimeResolution {
+    value: number;
+    confidence: number;
+    unknowns: string[];
+    findings: PatternRuntimeFinding[];
+    source: PatternRuntimeSource;
+    patternFamily?: ArchitecturePatternFamily;
+    usedSignals: string[];
+    missingSignals: string[];
+}
+export interface SelectedPatternRuntimeSpec {
+    spec?: {
+        blockName: "layeredRuntime" | "serviceBasedRuntime" | "cqrsRuntime" | "eventDrivenRuntime";
+        families: ArchitecturePatternFamily[];
+        weights: Record<string, number>;
+    };
+    block?: Record<string, number | undefined>;
+    family?: ArchitecturePatternFamily;
+}

package/dist/src/analyzers/architecture-pattern-runtime-types.js

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

package/dist/src/analyzers/architecture-pattern-runtime.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitecturePatternRuntimeObservationSet } from "../core/contracts.js";
+import type { PatternRuntimeResolution } from "./architecture-pattern-runtime-shared.js";
+export type { PatternRuntimeFinding, PatternRuntimeResolution, PatternRuntimeSource, } from "./architecture-pattern-runtime-shared.js";
+export declare function scorePatternRuntime(input: {
+    observations?: ArchitecturePatternRuntimeObservationSet;
+    topologyIsolationBridge?: number;
+}): PatternRuntimeResolution;

package/dist/src/analyzers/architecture-pattern-runtime.js

@@ -0,0 +1,20 @@
+import { resolveFallbackPatternRuntime } from "./architecture-pattern-runtime-fallback.js";
+import { resolveFamilyPatternRuntime } from "./architecture-pattern-runtime-family.js";
+export function scorePatternRuntime(input) {
+    const findings = [];
+    const unknowns = [];
+    const familyResolution = resolveFamilyPatternRuntime({
+        observations: input.observations,
+        findings,
+        unknowns,
+    });
+    if (familyResolution) {
+        return familyResolution;
+    }
+    return resolveFallbackPatternRuntime({
+        observations: input.observations,
+        ...(input.topologyIsolationBridge !== undefined ? { topologyIsolationBridge: input.topologyIsolationBridge } : {}),
+        findings,
+        unknowns,
+    });
+}

package/dist/src/analyzers/architecture-purity-signals.d.ts

@@ -0,0 +1,6 @@
+import type { LayerDefinition } from "../core/contracts.js";
+export declare function isFrameworkish(filePath: string, layerName?: string): boolean;
+export declare function isInternalish(filePath: string, layerName?: string): boolean;
+export declare function isAllowedFrameworkLayer(layer: LayerDefinition, maxRank: number): boolean;
+export declare function average(values: number[], fallback: number): number;
+export declare function clamp01(value: number): number;

package/dist/src/analyzers/architecture-purity-signals.js

@@ -0,0 +1,21 @@
+const FRAMEWORK_SIGNAL = /(infrastructure|infra|adapter|adapters|framework|frameworks|controller|controllers|gateway|gateways|schema|logger|http|web|ui)/i;
+const INTERNAL_SIGNAL = /(internal|infra|infrastructure|adapter|adapters|schema|logger|gateway|gateways)/i;
+const SHARED_FRAMEWORK_LAYER_SIGNAL = /(shared|common|platform|core|foundation|theme|ui)/i;
+export function isFrameworkish(filePath, layerName) {
+    return FRAMEWORK_SIGNAL.test(filePath) || (layerName ? FRAMEWORK_SIGNAL.test(layerName) : false);
+}
+export function isInternalish(filePath, layerName) {
+    return INTERNAL_SIGNAL.test(filePath) || (layerName ? INTERNAL_SIGNAL.test(layerName) : false);
+}
+export function isAllowedFrameworkLayer(layer, maxRank) {
+    return layer.rank === maxRank || isFrameworkish(layer.name) || SHARED_FRAMEWORK_LAYER_SIGNAL.test(layer.name);
+}
+export function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}

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

@@ -0,0 +1,2 @@
+export { scoreBoundaryPurity } from "../core/architecture-purity-core.js";
+export type { BoundaryPurityScore, PurityFinding } from "../core/architecture-purity-types.js";

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

@@ -0,0 +1 @@
+export { scoreBoundaryPurity } from "../core/architecture-purity-core.js";

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

@@ -0,0 +1,22 @@
+import type { ArchitectureScenarioCatalog, ScenarioObservationSet } from "../core/contracts.js";
+export interface QualityScenarioFinding {
+    scenarioId: string;
+    confidence: number;
+    normalized?: number;
+    observed?: number;
+    source: "catalog" | "observation";
+    note: string;
+}
+export interface QualityScenarioFitScore {
+    QSF: number;
+    scenarioCount: number;
+    weightedCoverage: number;
+    averageNormalizedScore: number;
+    confidence: number;
+    unknowns: string[];
+    findings: QualityScenarioFinding[];
+}
+export declare function scoreQualityScenarioFit(input: {
+    catalog?: ArchitectureScenarioCatalog;
+    observations?: ScenarioObservationSet;
+}): QualityScenarioFitScore;

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

@@ -0,0 +1,95 @@
+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 normalizeObservedValue(input) {
+    const { direction, observed, target, worstAcceptable } = input;
+    if (direction === "lower_is_better") {
+        return clamp01((worstAcceptable - observed) / Math.max(0.0001, worstAcceptable - target));
+    }
+    return clamp01((observed - worstAcceptable) / Math.max(0.0001, target - worstAcceptable));
+}
+export function scoreQualityScenarioFit(input) {
+    if (!input.catalog || input.catalog.scenarios.length === 0) {
+        return {
+            QSF: 0,
+            scenarioCount: 0,
+            weightedCoverage: 0,
+            averageNormalizedScore: 0,
+            confidence: 0.2,
+            unknowns: ["No scenario catalog was provided, so QSF is unobserved."],
+            findings: [],
+        };
+    }
+    const observationById = new Map((input.observations?.observations ?? []).map((observation) => [observation.scenarioId, observation]));
+    const findings = [];
+    const unknowns = [];
+    const normalizedScores = [];
+    let totalPriority = 0;
+    let observedPriority = 0;
+    let weightedScore = 0;
+    for (const scenario of input.catalog.scenarios) {
+        totalPriority += scenario.priority;
+        if (scenario.priority <= 0) {
+            unknowns.push(`${scenario.scenarioId} has priority <= 0, so it does not contribute to QSF.`);
+            findings.push({
+                scenarioId: scenario.scenarioId,
+                confidence: 0.5,
+                source: "catalog",
+                note: `${scenario.scenarioId} has priority <= 0.`,
+            });
+            continue;
+        }
+        const observation = observationById.get(scenario.scenarioId);
+        if (!observation) {
+            unknowns.push(`${scenario.scenarioId} is missing an observed value.`);
+            findings.push({
+                scenarioId: scenario.scenarioId,
+                confidence: 0.45,
+                source: "catalog",
+                note: `${scenario.scenarioId} cannot be fully reflected in QSF because no observed value was provided.`,
+            });
+            continue;
+        }
+        const normalized = normalizeObservedValue({
+            direction: scenario.direction,
+            observed: observation.observed,
+            target: scenario.target,
+            worstAcceptable: scenario.worstAcceptable,
+        });
+        observedPriority += scenario.priority;
+        weightedScore += scenario.priority * normalized;
+        normalizedScores.push(normalized);
+        findings.push({
+            scenarioId: scenario.scenarioId,
+            confidence: 0.88,
+            normalized,
+            observed: observation.observed,
+            source: "observation",
+            note: `${scenario.scenarioId} has a normalized score of ${normalized.toFixed(3)}.`,
+        });
+    }
+    if (!input.observations || input.observations.observations.length === 0) {
+        unknowns.push("No scenario observations were provided, so QSF is a conservative approximation.");
+    }
+    const weightedCoverage = totalPriority === 0 ? 0 : observedPriority / totalPriority;
+    const QSF = totalPriority === 0 ? 0 : weightedScore / totalPriority;
+    return {
+        QSF,
+        scenarioCount: input.catalog.scenarios.length,
+        weightedCoverage,
+        averageNormalizedScore: average(normalizedScores, 0),
+        confidence: clamp01(average([
+            input.catalog.scenarios.length > 0 ? 0.85 : 0.2,
+            weightedCoverage > 0 ? 0.82 : 0.35,
+            normalizedScores.length > 0 ? 0.88 : 0.3,
+        ], 0.4)),
+        unknowns: Array.from(new Set(unknowns)),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-source-loader-command.d.ts

@@ -0,0 +1,8 @@
+import type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet } from "../core/contracts.js";
+import { type ResolvedCanonicalSource } from "./architecture-source-loader-shared.js";
+export declare function resolveCommandSourceConfig<T>(input: {
+    config: ArchitectureCanonicalSourceConfig;
+    configPath: string;
+    label: string;
+}): Promise<ResolvedCanonicalSource<T>>;
+export type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet, };

package/dist/src/analyzers/architecture-source-loader-command.js

@@ -0,0 +1,73 @@
+import { spawn } from "node:child_process";
+import { resolveFromBase } from "./architecture-source-loader-shared.js";
+async function runCommand(command, cwd, label) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => {
+            stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        child.on("error", (error) => {
+            reject(new Error(`${label} command source failed to start: ${error.message}`));
+        });
+        child.on("close", (code, signal) => {
+            if (signal) {
+                reject(new Error(`${label} command source was terminated by signal ${signal}.`));
+                return;
+            }
+            if (code !== 0) {
+                const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+                reject(new Error(`${label} command source exited with code ${code}.${stderr ? ` stderr: ${stderr}` : ""}`));
+                return;
+            }
+            resolve(Buffer.concat(stdoutChunks).toString("utf8"));
+        });
+    });
+}
+export async function resolveCommandSourceConfig(input) {
+    const baseDir = input.configPath.slice(0, input.configPath.lastIndexOf("/")) || ".";
+    if (!input.config.command) {
+        throw new Error(`${input.label} source config requires 'command' when sourceType=command.`);
+    }
+    const resolvedCwd = input.config.cwd ? resolveFromBase(baseDir, input.config.cwd) : baseDir;
+    const stdout = await runCommand(input.config.command, resolvedCwd, input.label);
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        throw new Error(`${input.label} command source returned empty stdout.`);
+    }
+    let data;
+    try {
+        data = JSON.parse(trimmed);
+    }
+    catch (error) {
+        throw new Error(`${input.label} command source must return JSON on stdout: ${error instanceof Error ? error.message : "parse error"}`);
+    }
+    return {
+        data,
+        configPath: input.configPath,
+        sourceType: "command",
+        command: input.config.command,
+        cwd: resolvedCwd,
+        ...(input.config.note ? { note: input.config.note } : {}),
+        confidence: 0.8,
+        unknowns: [],
+        findings: [
+            {
+                kind: "source_command_loaded",
+                confidence: 0.8,
+                note: `Loaded canonical input from the command source in ${input.label} source config.`,
+                sourceType: "command",
+                command: input.config.command,
+                cwd: resolvedCwd,
+            },
+        ],
+    };
+}

package/dist/src/analyzers/architecture-source-loader-core.d.ts

@@ -0,0 +1,22 @@
+import type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ArchitectureTelemetrySourceConfig, ScenarioObservationSet } from "../core/contracts.js";
+import type { ResolvedCanonicalSource } from "./architecture-source-loader-shared.js";
+export declare function resolveTelemetrySourceConfig(input: {
+    config: ArchitectureTelemetrySourceConfig;
+    configPath: string;
+}): Promise<ResolvedCanonicalSource<ArchitectureTelemetryExportBundle>>;
+export declare function resolveDeliverySourceConfig(input: {
+    config: ArchitectureCanonicalSourceConfig;
+    configPath: string;
+}): Promise<ResolvedCanonicalSource<ArchitectureDeliveryExportBundle>>;
+export declare function resolveComplexitySourceConfig(input: {
+    config: ArchitectureCanonicalSourceConfig;
+    configPath: string;
+}): Promise<ResolvedCanonicalSource<ArchitectureComplexityExportBundle>>;
+export declare function resolveScenarioObservationSourceConfig(input: {
+    config: ArchitectureScenarioObservationSourceConfig;
+    configPath: string;
+}): Promise<ResolvedCanonicalSource<ScenarioObservationSet>>;
+export declare function resolveContractBaselineSourceConfig(input: {
+    config: ArchitectureCanonicalSourceConfig;
+    configPath: string;
+}): Promise<ResolvedCanonicalSource<ArchitectureContractBaseline>>;

package/dist/src/analyzers/architecture-source-loader-core.js

@@ -0,0 +1,41 @@
+import { resolveCommandSourceConfig } from "./architecture-source-loader-command.js";
+import { resolveFileSourceConfig } from "./architecture-source-loader-file.js";
+async function resolveSourceConfig(input) {
+    if (input.config.sourceType === "file") {
+        return resolveFileSourceConfig(input);
+    }
+    if (input.config.sourceType === "command") {
+        return resolveCommandSourceConfig(input);
+    }
+    throw new Error(`${input.label} sourceType=${String(input.config.sourceType)} is not supported.`);
+}
+export async function resolveTelemetrySourceConfig(input) {
+    return resolveSourceConfig({
+        ...input,
+        label: "telemetry",
+    });
+}
+export async function resolveDeliverySourceConfig(input) {
+    return resolveSourceConfig({
+        ...input,
+        label: "delivery",
+    });
+}
+export async function resolveComplexitySourceConfig(input) {
+    return resolveSourceConfig({
+        ...input,
+        label: "complexity",
+    });
+}
+export async function resolveScenarioObservationSourceConfig(input) {
+    return resolveSourceConfig({
+        ...input,
+        label: "scenario observation",
+    });
+}
+export async function resolveContractBaselineSourceConfig(input) {
+    return resolveSourceConfig({
+        ...input,
+        label: "contract baseline",
+    });
+}

package/dist/src/analyzers/architecture-source-loader-file.d.ts

@@ -0,0 +1,8 @@
+import type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet } from "../core/contracts.js";
+import { type ResolvedCanonicalSource } from "./architecture-source-loader-shared.js";
+export declare function resolveFileSourceConfig<T>(input: {
+    config: ArchitectureCanonicalSourceConfig;
+    configPath: string;
+    label: string;
+}): Promise<ResolvedCanonicalSource<T>>;
+export type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet, };

package/dist/src/analyzers/architecture-source-loader-file.js

@@ -0,0 +1,28 @@
+import { readDataFile } from "../core/io.js";
+import { resolveFromBase } from "./architecture-source-loader-shared.js";
+export async function resolveFileSourceConfig(input) {
+    const baseDir = input.configPath.slice(0, input.configPath.lastIndexOf("/")) || ".";
+    if (!input.config.path) {
+        throw new Error(`${input.label} source config requires 'path' when sourceType=file.`);
+    }
+    const resolvedPath = resolveFromBase(baseDir, input.config.path);
+    const data = await readDataFile(resolvedPath);
+    return {
+        data,
+        configPath: input.configPath,
+        sourceType: "file",
+        resolvedPath,
+        ...(input.config.note ? { note: input.config.note } : {}),
+        confidence: 0.86,
+        unknowns: [],
+        findings: [
+            {
+                kind: "source_file_loaded",
+                confidence: 0.86,
+                note: `Loaded canonical input from the file source in ${input.label} source config.`,
+                sourceType: "file",
+                sourcePath: resolvedPath,
+            },
+        ],
+    };
+}

package/dist/src/analyzers/architecture-source-loader-shared.d.ts

@@ -0,0 +1,24 @@
+import type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet } from "../core/contracts.js";
+export interface SourceResolutionFinding {
+    kind: "source_file_loaded" | "source_command_loaded";
+    confidence: number;
+    note: string;
+    sourceType: "file" | "command";
+    sourcePath?: string;
+    command?: string;
+    cwd?: string;
+}
+export interface ResolvedCanonicalSource<T> {
+    data: T;
+    configPath: string;
+    sourceType: "file" | "command";
+    resolvedPath?: string;
+    command?: string;
+    cwd?: string;
+    note?: string;
+    confidence: number;
+    unknowns: string[];
+    findings: SourceResolutionFinding[];
+}
+export declare function resolveFromBase(baseDir: string, target: string): string;
+export type { ArchitectureCanonicalSourceConfig, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ScenarioObservationSet, };

package/dist/src/analyzers/architecture-source-loader-shared.js

@@ -0,0 +1,4 @@
+import path from "node:path";
+export function resolveFromBase(baseDir, target) {
+    return path.isAbsolute(target) ? target : path.resolve(baseDir, target);
+}

package/dist/src/analyzers/architecture-source-loader.d.ts

@@ -0,0 +1,2 @@
+export { resolveComplexitySourceConfig, resolveContractBaselineSourceConfig, resolveDeliverySourceConfig, resolveScenarioObservationSourceConfig, resolveTelemetrySourceConfig, } from "./architecture-source-loader-core.js";
+export type { ResolvedCanonicalSource, SourceResolutionFinding, } from "./architecture-source-loader-shared.js";

package/dist/src/analyzers/architecture-source-loader.js

@@ -0,0 +1 @@
+export { resolveComplexitySourceConfig, resolveContractBaselineSourceConfig, resolveDeliverySourceConfig, resolveScenarioObservationSourceConfig, resolveTelemetrySourceConfig, } from "./architecture-source-loader-core.js";