context-probe 0.1.0

package/dist/src/analyzers/code-shared.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+import ts from "typescript";
+import { readDataFile, relativePath } from "../core/io.js";
+export const ECMASCRIPT_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
+export const DART_EXTENSION = ".dart";
+const DART_GENERATED_SUFFIXES = [".g.dart", ".freezed.dart", ".mocks.dart", ".gen.dart", ".gr.dart"];
+export const DART_DIRECTIVE_PATTERN = /^\s*(import|export|part)\s+(?!of\b)[^"'`]*["']([^"']+)["'][^;]*;/gm;
+export const DART_PART_OF_PATTERN = /^\s*part\s+of\b/m;
+function fileExists(filePath) {
+    return ts.sys.fileExists(filePath);
+}
+export function isDartSourceFile(filePath) {
+    return path.extname(filePath).toLowerCase() === DART_EXTENSION;
+}
+export function inferSourceLanguage(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === DART_EXTENSION) {
+        return "dart";
+    }
+    if (extension === ".js" || extension === ".jsx" || extension === ".mjs" || extension === ".cjs") {
+        return "javascript";
+    }
+    return "typescript";
+}
+export function isGeneratedDartFile(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    return DART_GENERATED_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+}
+export function stripComments(source) {
+    return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+}
+export function resolveWithCandidates(root, specifier, candidates) {
+    for (const candidate of candidates) {
+        if (fileExists(candidate)) {
+            return {
+                target: relativePath(root, candidate),
+                targetKind: "file",
+            };
+        }
+    }
+    return {
+        target: specifier,
+        targetKind: "missing",
+    };
+}
+export async function loadDartPackageContext(root) {
+    const pubspecPath = path.join(root, "pubspec.yaml");
+    if (!fileExists(pubspecPath)) {
+        return {};
+    }
+    try {
+        const pubspec = await readDataFile(pubspecPath);
+        if (typeof pubspec.name !== "string" || pubspec.name.trim().length === 0) {
+            return {};
+        }
+        return {
+            packageName: pubspec.name.trim(),
+            packageRoot: path.join(root, "lib"),
+        };
+    }
+    catch {
+        return {};
+    }
+}

package/dist/src/analyzers/code.d.ts

@@ -0,0 +1,3 @@
+import type { CodebaseAnalysis } from "../core/contracts.js";
+export { detectBoundaryLeaks, detectContractUsage, getScorableDependencies } from "./code-contracts.js";
+export declare function parseCodebase(root: string): Promise<CodebaseAnalysis>;

package/dist/src/analyzers/code.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { listFiles, readText, relativePath } from "../core/io.js";
+export { detectBoundaryLeaks, detectContractUsage, getScorableDependencies } from "./code-contracts.js";
+import { parseDartSourceFile } from "./code-dart.js";
+import { parseEcmaSourceFile } from "./code-ecma.js";
+import { DART_EXTENSION, ECMASCRIPT_EXTENSIONS, isDartSourceFile, loadDartPackageContext } from "./code-shared.js";
+export async function parseCodebase(root) {
+    const dartPackageContext = await loadDartPackageContext(root);
+    const absoluteFiles = (await listFiles(root)).filter((filePath) => {
+        const extension = path.extname(filePath).toLowerCase();
+        return ECMASCRIPT_EXTENSIONS.has(extension) || extension === DART_EXTENSION;
+    });
+    const files = [];
+    const dependencies = [];
+    for (const absolutePath of absoluteFiles) {
+        const relative = relativePath(root, absolutePath);
+        const source = await readText(absolutePath);
+        const parsedFile = isDartSourceFile(relative)
+            ? parseDartSourceFile(root, absolutePath, relative, source, dartPackageContext)
+            : parseEcmaSourceFile(root, absolutePath, relative, source);
+        files.push(parsedFile);
+        dependencies.push(...parsedFile.imports);
+    }
+    const sourceFiles = files.map((file) => file.path);
+    const scorableSourceFiles = files
+        .filter((file) => !file.generated && file.libraryRole !== "part")
+        .map((file) => file.path);
+    return {
+        files,
+        dependencies,
+        sourceFiles,
+        scorableSourceFiles,
+    };
+}

package/dist/src/analyzers/contract-files.d.ts

@@ -0,0 +1,13 @@
+import type { ArchitectureConstraints, CodebaseAnalysis, LayerDefinition, ParsedSourceFile } from "../core/contracts.js";
+export declare function classifyArchitectureLayer(filePath: string, constraints: ArchitectureConstraints): LayerDefinition | undefined;
+export declare function isMeasuredContractFilePath(options: {
+    filePath: string;
+    constraints: ArchitectureConstraints;
+    parsedFile?: ParsedSourceFile;
+    allowDartDomainFallback?: boolean;
+}): boolean;
+export declare function collectContractFilePaths(options: {
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+    allowDartDomainFallback?: boolean;
+}): string[];

package/dist/src/analyzers/contract-files.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { matchGlobs } from "../core/io.js";
+const CONTRACT_DIRECTORY_SIGNAL = /(^|\/)(contracts?|dtos?|schemas?|protocols?|interfaces?|apis?)(\/|$)/i;
+const CONTRACT_BASENAME_SIGNAL = /(?:^|[_-])(contract|dto|event|schema|protocol|interface|api)s?\.[^.]+$/i;
+const CONTRACT_LAYER_NAME_SIGNAL = /\b(contracts?|dtos?|schemas?|protocols?|interfaces?|apis?)\b/i;
+const DART_DOMAIN_LAYER_SIGNAL = /\bdomain\b/i;
+export function classifyArchitectureLayer(filePath, constraints) {
+    return constraints.layers.find((layer) => matchGlobs(filePath, layer.globs));
+}
+function hasContractDirectorySignal(filePath) {
+    return CONTRACT_DIRECTORY_SIGNAL.test(filePath);
+}
+function hasContractBasenameSignal(filePath) {
+    return CONTRACT_BASENAME_SIGNAL.test(path.basename(filePath));
+}
+function hasContractLayerNameSignal(layer) {
+    return CONTRACT_LAYER_NAME_SIGNAL.test(layer.name);
+}
+function hasContractLayerGlobSignal(layer) {
+    return layer.globs.some((glob) => hasContractDirectorySignal(glob));
+}
+function isArchitectureContractLayer(layer) {
+    return hasContractLayerNameSignal(layer) || hasContractLayerGlobSignal(layer);
+}
+function hasNamedExplicitContractLayer(constraints) {
+    return constraints.layers.some((layer) => hasContractLayerNameSignal(layer));
+}
+function hasExplicitContractLayer(constraints) {
+    return constraints.layers.some((layer) => isArchitectureContractLayer(layer));
+}
+function isDartDomainFallbackContract(options) {
+    if (!options.allowDartDomainFallback || options.explicitContractLayerExists) {
+        return false;
+    }
+    if (options.parsedFile?.language !== "dart") {
+        return false;
+    }
+    return Boolean(options.layer && DART_DOMAIN_LAYER_SIGNAL.test(options.layer.name));
+}
+export function isMeasuredContractFilePath(options) {
+    const namedExplicitContractLayerExists = hasNamedExplicitContractLayer(options.constraints);
+    const explicitContractLayerExists = hasExplicitContractLayer(options.constraints);
+    const layer = classifyArchitectureLayer(options.filePath, options.constraints);
+    // Architecture constraints define the measurement scope. Contract-like files
+    // outside those layer globs must not influence IPS/CTI for the current repo.
+    if (!layer) {
+        return false;
+    }
+    if (namedExplicitContractLayerExists) {
+        return hasContractLayerNameSignal(layer);
+    }
+    if (explicitContractLayerExists) {
+        return isArchitectureContractLayer(layer);
+    }
+    if (hasContractDirectorySignal(options.filePath) ||
+        hasContractBasenameSignal(options.filePath) ||
+        isArchitectureContractLayer(layer)) {
+        return true;
+    }
+    return isDartDomainFallbackContract({
+        parsedFile: options.parsedFile,
+        layer,
+        allowDartDomainFallback: options.allowDartDomainFallback ?? false,
+        explicitContractLayerExists,
+    });
+}
+export function collectContractFilePaths(options) {
+    const fileMap = new Map(options.codebase.files.map((file) => [file.path, file]));
+    return options.codebase.scorableSourceFiles.filter((filePath) => {
+        const parsedFile = fileMap.get(filePath);
+        return isMeasuredContractFilePath({
+            filePath,
+            constraints: options.constraints,
+            ...(parsedFile ? { parsedFile } : {}),
+            ...(options.allowDartDomainFallback !== undefined
+                ? { allowDartDomainFallback: options.allowDartDomainFallback }
+                : {}),
+        });
+    });
+}

package/dist/src/analyzers/cti-complexity-components.d.ts

@@ -0,0 +1,12 @@
+import type { ArchitectureConstraints, CodebaseAnalysis } from "../core/contracts.js";
+import type { ComplexityTaxRecorder } from "./cti-complexity-recorder.js";
+interface ComplexityTaxComponentContext {
+    constraints: ArchitectureConstraints;
+    metadata: ArchitectureConstraints["complexity"];
+    recorder: ComplexityTaxRecorder;
+}
+export declare function recordComplexityTaxComponents(options: {
+    codebase: CodebaseAnalysis;
+    context: ComplexityTaxComponentContext;
+}): void;
+export {};

package/dist/src/analyzers/cti-complexity-components.js

@@ -0,0 +1,83 @@
+import { collectContractFilePaths } from "./contract-files.js";
+function recordConstraintComponent(recorder, input) {
+    recorder.recordObservedComponent({
+        ...input,
+        source: "constraints",
+    });
+}
+export function recordComplexityTaxComponents(options) {
+    const { codebase, context } = options;
+    const { metadata, recorder } = context;
+    const deployableCount = metadata?.deployableCount;
+    const teamCount = metadata?.teamCount;
+    recordConstraintComponent(recorder, {
+        component: "DeployablesPerTeam",
+        kind: "deployables_per_team",
+        observed: deployableCount !== undefined && teamCount !== undefined && teamCount > 0
+            ? deployableCount / teamCount
+            : undefined,
+        note: "Evaluating deployables per team as a complexity-tax component.",
+        missingUnknown: "DeployablesPerTeam cannot be approximated because teamCount or deployableCount is missing.",
+    });
+    recordConstraintComponent(recorder, {
+        component: "PipelinesPerDeployable",
+        kind: "pipelines_per_deployable",
+        observed: metadata?.pipelineCount !== undefined && deployableCount !== undefined && deployableCount > 0
+            ? metadata.pipelineCount / deployableCount
+            : undefined,
+        note: "Evaluating pipelines per deployable as a complexity-tax component.",
+        missingUnknown: "PipelinesPerDeployable cannot be approximated because pipelineCount or deployableCount is missing.",
+    });
+    const observedContractCount = metadata?.contractOrSchemaCount ??
+        collectContractFilePaths({
+            codebase,
+            constraints: context.constraints,
+            allowDartDomainFallback: false,
+        }).length;
+    const serviceCount = metadata?.serviceCount ?? metadata?.deployableCount;
+    recorder.recordObservedComponent({
+        component: "ContractsOrSchemasPerService",
+        kind: "contracts_or_schemas_per_service",
+        observed: serviceCount !== undefined && serviceCount > 0 ? observedContractCount / serviceCount : undefined,
+        source: metadata?.contractOrSchemaCount !== undefined ? "constraints" : "codebase",
+        note: "Evaluating contracts or schemas per service as a complexity-tax component.",
+        missingUnknown: "ContractsOrSchemasPerService cannot be approximated because serviceCount or deployableCount is missing.",
+    });
+    if (metadata?.contractOrSchemaCount === undefined && observedContractCount === 0) {
+        recorder.noteUnknown("Contract/schema observations are sparse, so ContractsOrSchemasPerService is conservative.");
+    }
+    recordConstraintComponent(recorder, {
+        component: "DatastoresPerServiceGroup",
+        kind: "datastores_per_service_group",
+        observed: metadata?.datastoreCount !== undefined &&
+            metadata?.serviceGroupCount !== undefined &&
+            metadata.serviceGroupCount > 0
+            ? metadata.datastoreCount / metadata.serviceGroupCount
+            : undefined,
+        note: "Evaluating datastores per service group as a complexity-tax component.",
+        missingUnknown: "DatastoresPerServiceGroup cannot be approximated because datastoreCount or serviceGroupCount is missing.",
+    });
+    recordConstraintComponent(recorder, {
+        component: "OnCallSurface",
+        kind: "oncall_surface",
+        observed: metadata?.onCallSurface !== undefined && teamCount !== undefined && teamCount > 0
+            ? metadata.onCallSurface / teamCount
+            : undefined,
+        note: "Evaluating on-call surface per team as a complexity-tax component.",
+        missingUnknown: "OnCallSurface cannot be approximated because onCallSurface or teamCount is missing.",
+    });
+    recordConstraintComponent(recorder, {
+        component: "SyncDepthOverhead",
+        kind: "sync_depth_overhead",
+        observed: metadata?.syncDepthP95,
+        note: "Evaluating p95 synchronous hop depth as a complexity-tax component.",
+        missingUnknown: "SyncDepthOverhead cannot be approximated because syncDepthP95 is missing.",
+    });
+    recordConstraintComponent(recorder, {
+        component: "RunCostPerBusinessTransaction",
+        kind: "run_cost_per_business_transaction",
+        observed: metadata?.runCostPerBusinessTransaction,
+        note: "Evaluating run cost per business transaction as a complexity-tax component.",
+        missingUnknown: "RunCostPerBusinessTransaction cannot be approximated because runCostPerBusinessTransaction is missing.",
+    });
+}

package/dist/src/analyzers/cti-complexity-recorder.d.ts

@@ -0,0 +1,31 @@
+import type { ArchitectureConstraints, ComplexityTaxComponentName } from "../core/contracts.js";
+export interface ComplexityTaxFinding {
+    component: ComplexityTaxComponentName;
+    kind: "deployables_per_team" | "pipelines_per_deployable" | "contracts_or_schemas_per_service" | "datastores_per_service_group" | "oncall_surface" | "sync_depth_overhead" | "run_cost_per_business_transaction";
+    observed: number;
+    normalized: number;
+    confidence: number;
+    source: "constraints" | "codebase" | "derived";
+    note: string;
+}
+export interface ComplexityTaxScore {
+    components: Record<ComplexityTaxComponentName, number>;
+    confidence: number;
+    unknowns: string[];
+    findings: ComplexityTaxFinding[];
+}
+export interface ComplexityTaxObservationInput {
+    component: ComplexityTaxComponentName;
+    kind: ComplexityTaxFinding["kind"];
+    observed: number | undefined;
+    source: ComplexityTaxFinding["source"];
+    note: string;
+    missingUnknown: string;
+}
+export interface ComplexityTaxRecorder {
+    components: Record<ComplexityTaxComponentName, number>;
+    recordObservedComponent(input: ComplexityTaxObservationInput): void;
+    noteUnknown(message: string): void;
+    finalize(): ComplexityTaxScore;
+}
+export declare function createComplexityTaxRecorder(constraints: ArchitectureConstraints): ComplexityTaxRecorder;

package/dist/src/analyzers/cti-complexity-recorder.js

@@ -0,0 +1,58 @@
+import { average, clamp01, getBaseline, normalizeTax, round, uniqueUnknowns } from "./cti-helpers.js";
+export function createComplexityTaxRecorder(constraints) {
+    const findings = [];
+    const unknowns = [];
+    const confidenceSignals = [];
+    const components = {
+        DeployablesPerTeam: 0.5,
+        PipelinesPerDeployable: 0.5,
+        ContractsOrSchemasPerService: 0.5,
+        DatastoresPerServiceGroup: 0.5,
+        OnCallSurface: 0.5,
+        SyncDepthOverhead: 0.5,
+        RunCostPerBusinessTransaction: 0.5,
+    };
+    const recorded = new Set();
+    function recordObservedComponent(input) {
+        if (input.observed === undefined || !Number.isFinite(input.observed)) {
+            unknowns.push(input.missingUnknown);
+            confidenceSignals.push(0.4);
+            return;
+        }
+        const baseline = getBaseline(constraints, input.component);
+        const normalized = normalizeTax(input.observed, baseline);
+        const sourceConfidence = input.source === "constraints" ? 0.88 : input.source === "codebase" ? 0.72 : 0.6;
+        components[input.component] = normalized;
+        confidenceSignals.push(sourceConfidence);
+        recorded.add(input.component);
+        findings.push({
+            component: input.component,
+            kind: input.kind,
+            observed: round(input.observed),
+            normalized: round(normalized),
+            confidence: sourceConfidence,
+            source: input.source,
+            note: `${input.note} (observed=${round(input.observed)}, target=${baseline.target}, worst=${baseline.worst})`,
+        });
+    }
+    function noteUnknown(message) {
+        unknowns.push(message);
+    }
+    function finalize() {
+        if (recorded.size < 4) {
+            unknowns.push("Too few complexity-tax components were observed, so CTI confidence is limited.");
+        }
+        return {
+            components,
+            confidence: clamp01(average(confidenceSignals, 0.45)),
+            unknowns: uniqueUnknowns(unknowns),
+            findings,
+        };
+    }
+    return {
+        components,
+        recordObservedComponent,
+        noteUnknown,
+        finalize,
+    };
+}

package/dist/src/analyzers/cti-complexity.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureConstraints, CodebaseAnalysis } from "../core/contracts.js";
+import { type ComplexityTaxScore } from "./cti-complexity-recorder.js";
+export type { ComplexityTaxFinding, ComplexityTaxScore } from "./cti-complexity-recorder.js";
+export declare function scoreComplexityTax(options: {
+    codebase: CodebaseAnalysis;
+    constraints: ArchitectureConstraints;
+}): ComplexityTaxScore;

package/dist/src/analyzers/cti-complexity.js

@@ -0,0 +1,15 @@
+import { recordComplexityTaxComponents } from "./cti-complexity-components.js";
+import { createComplexityTaxRecorder } from "./cti-complexity-recorder.js";
+export function scoreComplexityTax(options) {
+    const { codebase, constraints } = options;
+    const metadata = constraints.complexity;
+    const recorder = createComplexityTaxRecorder(constraints);
+    recordComplexityTaxComponents({
+        codebase,
+        context: { constraints, metadata, recorder },
+    });
+    if (!metadata) {
+        recorder.noteUnknown("Constraints do not include complexity metadata, so CTI is only partially observed.");
+    }
+    return recorder.finalize();
+}

package/dist/src/analyzers/cti-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureConstraints, ComplexityTaxBaseline, ComplexityTaxComponentName } from "../core/contracts.js";
+export declare function clamp01(value: number): number;
+export declare function average(values: number[], fallback: number): number;
+export declare function getBaseline(constraints: ArchitectureConstraints, component: ComplexityTaxComponentName): Required<ComplexityTaxBaseline>;
+export declare function normalizeTax(value: number, baseline: Required<ComplexityTaxBaseline>): number;
+export declare function uniqueUnknowns(entries: string[]): string[];
+export declare function round(value: number): number;

package/dist/src/analyzers/cti-helpers.js

@@ -0,0 +1,40 @@
+const DEFAULT_BASELINES = {
+    DeployablesPerTeam: { target: 1, worst: 8 },
+    PipelinesPerDeployable: { target: 1, worst: 6 },
+    ContractsOrSchemasPerService: { target: 2, worst: 20 },
+    DatastoresPerServiceGroup: { target: 1, worst: 5 },
+    OnCallSurface: { target: 2, worst: 20 },
+    SyncDepthOverhead: { target: 1, worst: 6 },
+    RunCostPerBusinessTransaction: { target: 1, worst: 10 },
+};
+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;
+}
+export function getBaseline(constraints, component) {
+    const override = constraints.complexity?.normalization?.[component];
+    return {
+        target: override?.target ?? DEFAULT_BASELINES[component].target,
+        worst: override?.worst ?? DEFAULT_BASELINES[component].worst,
+    };
+}
+export function normalizeTax(value, baseline) {
+    if (value <= baseline.target) {
+        return 0;
+    }
+    if (value >= baseline.worst) {
+        return 1;
+    }
+    return clamp01((value - baseline.target) / Math.max(0.0001, baseline.worst - baseline.target));
+}
+export function uniqueUnknowns(entries) {
+    return Array.from(new Set(entries));
+}
+export function round(value) {
+    return Math.round(value * 1000) / 1000;
+}

package/dist/src/analyzers/cti.d.ts

@@ -0,0 +1,2 @@
+export type { ComplexityTaxFinding, ComplexityTaxScore } from "./cti-complexity.js";
+export { scoreComplexityTax } from "./cti-complexity.js";

package/dist/src/analyzers/cti.js

@@ -0,0 +1 @@
+export { scoreComplexityTax } from "./cti-complexity.js";

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { COMMANDS, listCommands, maybeWriteOutput } from "./commands.js";
+import { appendCommandEventLog, resolveCommandSessionId } from "./core/command-analytics.js";
+import { createResponse } from "./core/response.js";
+function parseArgs(argv) {
+    const [first, ...remainder] = argv;
+    const command = first?.startsWith("--") ? undefined : first;
+    const rest = command ? remainder : argv;
+    const args = {};
+    for (let index = 0; index < rest.length; index += 1) {
+        const token = rest[index];
+        if (!token) {
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            continue;
+        }
+        const trimmed = token.slice(2);
+        const [key, inlineValue] = trimmed.split("=", 2);
+        if (!key) {
+            continue;
+        }
+        if (inlineValue !== undefined) {
+            args[key] = inlineValue;
+            continue;
+        }
+        const next = rest[index + 1];
+        if (!next || next.startsWith("--")) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        index += 1;
+    }
+    return {
+        command,
+        args,
+    };
+}
+async function main() {
+    const startedAt = Date.now();
+    const { command, args } = parseArgs(process.argv.slice(2));
+    const sessionId = resolveCommandSessionId(process.env);
+    const progressEnabled = process.stderr.isTTY || process.env.CONTEXT_PROBE_PROGRESS === "1" || process.env.CONTEXT_PROBE_PROGRESS === "true";
+    const context = {
+        cwd: process.cwd(),
+        ...(progressEnabled
+            ? {
+                reportProgress(update) {
+                    process.stderr.write(`[context-probe:${update.phase}] ${update.message}${update.elapsedMs !== undefined ? ` (${update.elapsedMs}ms)` : ""}\n`);
+                },
+            }
+            : {}),
+    };
+    if (!command || args.help === true) {
+        process.stdout.write(`${JSON.stringify(createResponse({
+            commands: listCommands(),
+        }), null, 2)}\n`);
+        return;
+    }
+    const handler = COMMANDS[command];
+    if (!handler) {
+        process.stderr.write(`Unknown command: ${command}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const response = await handler(args, context);
+        await maybeWriteOutput(response, args, context);
+        await appendCommandEventLog({
+            env: process.env,
+            command,
+            repoPath: typeof args.repo === "string" ? args.repo : process.cwd(),
+            durationMs: Date.now() - startedAt,
+            response,
+            sessionId,
+        });
+        process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+        if (response.status === "error") {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        const response = createResponse({ command }, {
+            status: "error",
+            confidence: 0,
+            diagnostics: [message],
+        });
+        process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/src/command-architecture-inputs-loaders-config.d.ts

@@ -0,0 +1,24 @@
+import type { ArchitectureComplexitySourceConfig, ArchitectureContractBaselineSourceConfig, ArchitectureDeliverySourceConfig, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetrySourceConfig, CommandContext } from "./core/contracts.js";
+export interface LoadedArchitectureInputSourceConfigs {
+    scenarioObservationSourceConfig?: {
+        config: ArchitectureScenarioObservationSourceConfig;
+        configPath: string;
+    } | undefined;
+    contractBaselineSourceConfig?: {
+        config: ArchitectureContractBaselineSourceConfig;
+        configPath: string;
+    } | undefined;
+    deliverySourceConfig?: {
+        config: ArchitectureDeliverySourceConfig;
+        configPath: string;
+    } | undefined;
+    telemetrySourceConfig?: {
+        config: ArchitectureTelemetrySourceConfig;
+        configPath: string;
+    } | undefined;
+    complexitySourceConfig?: {
+        config: ArchitectureComplexitySourceConfig;
+        configPath: string;
+    } | undefined;
+}
+export declare function loadArchitectureInputSourceConfigs(args: Record<string, string | boolean>, context: CommandContext): Promise<LoadedArchitectureInputSourceConfigs>;

package/dist/src/command-architecture-inputs-loaders-config.js

@@ -0,0 +1,17 @@
+import { loadComplexitySourceConfigIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliverySourceConfigIfRequested, loadScenarioObservationSourceConfigIfRequested, loadTelemetrySourceConfigIfRequested, } from "./command-helpers.js";
+export async function loadArchitectureInputSourceConfigs(args, context) {
+    const [scenarioObservationSourceConfig, contractBaselineSourceConfig, deliverySourceConfig, telemetrySourceConfig, complexitySourceConfig,] = await Promise.all([
+        loadScenarioObservationSourceConfigIfRequested(args, context),
+        loadContractBaselineSourceConfigIfRequested(args, context),
+        loadDeliverySourceConfigIfRequested(args, context),
+        loadTelemetrySourceConfigIfRequested(args, context),
+        loadComplexitySourceConfigIfRequested(args, context),
+    ]);
+    return {
+        scenarioObservationSourceConfig,
+        contractBaselineSourceConfig,
+        deliverySourceConfig,
+        telemetrySourceConfig,
+        complexitySourceConfig,
+    };
+}

package/dist/src/command-architecture-inputs-loaders-data.d.ts

@@ -0,0 +1,22 @@
+import type { ArchitectureBoundaryMap, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryObservationSet, ArchitectureDeliveryRawObservationSet, ArchitecturePatternRuntimeNormalizationProfile, ArchitecturePatternRuntimeObservationSet, ArchitecturePatternRuntimeRawObservationSet, ArchitectureScenarioCatalog, ArchitectureTelemetryExportBundle, ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryObservationSet, ArchitectureTelemetryRawObservationSet, ArchitectureTopologyModel, CommandContext, ScenarioObservationSet, TopologyRuntimeObservationSet } from "./core/contracts.js";
+export interface LoadedArchitectureInputData {
+    scenarioCatalog?: ArchitectureScenarioCatalog | undefined;
+    scenarioObservations?: ScenarioObservationSet | undefined;
+    topologyModel?: ArchitectureTopologyModel | undefined;
+    boundaryMap?: ArchitectureBoundaryMap | undefined;
+    contractBaseline?: ArchitectureContractBaseline | undefined;
+    runtimeObservations?: TopologyRuntimeObservationSet | undefined;
+    deliveryObservations?: ArchitectureDeliveryObservationSet | undefined;
+    deliveryRawObservations?: ArchitectureDeliveryRawObservationSet | undefined;
+    deliveryExport?: ArchitectureDeliveryExportBundle | undefined;
+    deliveryNormalizationProfile?: ArchitectureDeliveryNormalizationProfile | undefined;
+    telemetryObservations?: ArchitectureTelemetryObservationSet | undefined;
+    telemetryRawObservations?: ArchitectureTelemetryRawObservationSet | undefined;
+    telemetryExport?: ArchitectureTelemetryExportBundle | undefined;
+    telemetryNormalizationProfile?: ArchitectureTelemetryNormalizationProfile | undefined;
+    patternRuntimeObservations?: ArchitecturePatternRuntimeObservationSet | undefined;
+    patternRuntimeRawObservations?: ArchitecturePatternRuntimeRawObservationSet | undefined;
+    patternRuntimeNormalizationProfile?: ArchitecturePatternRuntimeNormalizationProfile | undefined;
+    complexityExport?: ArchitectureComplexityExportBundle | undefined;
+}
+export declare function loadArchitectureInputData(args: Record<string, string | boolean>, context: CommandContext): Promise<LoadedArchitectureInputData>;