context-probe 0.1.0

package/dist/src/command-input-loaders-architecture-compat-topology-boundary.js

@@ -0,0 +1,178 @@
+import { asString, asStringArray, asTopologyEdgeKind, asTopologyNodeKind, isRecord, toVersion, withOptionalBoolean, withOptionalString, } from "./command-input-loaders-architecture-compat-shared.js";
+function sanitizeTopologyNodes(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const nodeId = asString(entry.nodeId) ?? asString(entry.id);
+        if (!nodeId) {
+            return [];
+        }
+        const kindHint = asString(entry.kind) ?? asString(entry.runtime);
+        return [
+            {
+                nodeId,
+                kind: asTopologyNodeKind(entry.kind) ?? inferNodeKind(kindHint),
+                ...withOptionalString("isolationBoundary", asString(entry.isolationBoundary) ?? asString(entry.isolation_boundary)),
+            },
+        ];
+    });
+}
+function sanitizeTopologyEdges(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const source = asString(entry.source);
+        const target = asString(entry.target);
+        const kind = asTopologyEdgeKind(entry.kind);
+        if (!source || !target || !kind) {
+            return [];
+        }
+        const shared = typeof entry.shared === "boolean" ? entry.shared : undefined;
+        return [
+            {
+                source,
+                target,
+                kind,
+                ...withOptionalBoolean("shared", shared),
+            },
+        ];
+    });
+}
+function sanitizeBoundaryDefinitions(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const name = asString(entry.name);
+        if (!name) {
+            return [];
+        }
+        return [
+            {
+                name,
+                pathGlobs: asStringArray(entry.pathGlobs),
+            },
+        ];
+    });
+}
+function inferNodeKind(value) {
+    const normalized = (value ?? "").toLowerCase();
+    if (normalized.includes("gateway")) {
+        return "gateway";
+    }
+    if (normalized.includes("database") ||
+        normalized.includes("datastore") ||
+        normalized.includes("storage") ||
+        normalized.includes("table") ||
+        normalized.includes("bucket")) {
+        return "datastore";
+    }
+    if (normalized.includes("queue")) {
+        return "queue";
+    }
+    if (normalized.includes("worker") || normalized.includes("lambda") || normalized.includes("pipeline")) {
+        return "worker";
+    }
+    if (normalized.includes("service") || normalized.includes("app") || normalized.includes("runtime")) {
+        return "service";
+    }
+    return "unknown";
+}
+export function normalizeArchitectureTopologyModel(input) {
+    if (!isRecord(input)) {
+        return { version: "1.0", nodes: [], edges: [] };
+    }
+    if (Array.isArray(input.nodes) && Array.isArray(input.edges)) {
+        return {
+            version: toVersion(input),
+            nodes: sanitizeTopologyNodes(input.nodes),
+            edges: sanitizeTopologyEdges(input.edges),
+        };
+    }
+    const nodeMap = new Map();
+    const ensureNode = (nodeId, kindHint, isolationBoundary) => {
+        if (!nodeId) {
+            return undefined;
+        }
+        const existing = nodeMap.get(nodeId);
+        if (existing) {
+            if (!existing.isolationBoundary && isolationBoundary) {
+                existing.isolationBoundary = isolationBoundary;
+            }
+            return existing;
+        }
+        const node = {
+            nodeId,
+            kind: inferNodeKind(kindHint),
+            ...(isolationBoundary ? { isolationBoundary } : {}),
+        };
+        nodeMap.set(nodeId, node);
+        return node;
+    };
+    const edges = [];
+    const deployables = Array.isArray(input.deployables) ? input.deployables.filter(isRecord) : [];
+    for (const deployable of deployables) {
+        ensureNode(asString(deployable.id), asString(deployable.kind) ?? asString(deployable.runtime));
+    }
+    const datastores = Array.isArray(input.datastores) ? input.datastores.filter(isRecord) : [];
+    for (const datastore of datastores) {
+        ensureNode(asString(datastore.id), asString(datastore.kind) ?? "datastore", "data");
+    }
+    const services = Array.isArray(input.services) ? input.services.filter(isRecord) : [];
+    for (const service of services) {
+        const serviceId = asString(service.id);
+        const deployable = asString(service.deployable);
+        ensureNode(serviceId, asString(service.kind) ?? "service", deployable);
+        for (const dependency of asStringArray(service.depends_on)) {
+            const [scope, rawTarget] = dependency.split(":");
+            const target = rawTarget || scope;
+            const targetNode = ensureNode(target, scope === "datastore" ? "datastore" : scope === "deployable" ? "runtime" : "service", scope === "datastore" ? "data" : undefined) ?? ensureNode(target);
+            if (!serviceId || !targetNode) {
+                continue;
+            }
+            edges.push({
+                source: serviceId,
+                target: targetNode.nodeId,
+                kind: scope === "datastore"
+                    ? "shared_resource"
+                    : scope === "deployable"
+                        ? "runtime_dependency"
+                        : scope === "queue"
+                            ? "async_message"
+                            : "sync_call",
+                ...(scope === "datastore" ? { shared: true } : {}),
+            });
+        }
+    }
+    return {
+        version: toVersion(input),
+        nodes: Array.from(nodeMap.values()),
+        edges,
+    };
+}
+export function normalizeArchitectureBoundaryMap(input) {
+    if (!isRecord(input)) {
+        return { version: "1.0", boundaries: [] };
+    }
+    if (Array.isArray(input.boundaries)) {
+        return {
+            version: toVersion(input),
+            boundaries: sanitizeBoundaryDefinitions(input.boundaries),
+        };
+    }
+    return {
+        version: toVersion(input),
+        boundaries: sanitizeBoundaryDefinitions(input.contexts),
+    };
+}

package/dist/src/command-input-loaders-architecture-compat.d.ts

@@ -0,0 +1,4 @@
+export { normalizeArchitectureComplexityExportBundle, normalizeArchitectureDeliveryExportBundle, } from "./command-input-loaders-architecture-compat-delivery-complexity.js";
+export { normalizeArchitectureScenarioCatalog, normalizeArchitectureScenarioObservations, } from "./command-input-loaders-architecture-compat-scenario.js";
+export { normalizeArchitectureTelemetryExportBundle, normalizeArchitectureTelemetryObservations, } from "./command-input-loaders-architecture-compat-telemetry.js";
+export { normalizeArchitectureBoundaryMap, normalizeArchitectureTopologyModel, } from "./command-input-loaders-architecture-compat-topology-boundary.js";

package/dist/src/command-input-loaders-architecture-compat.js

@@ -0,0 +1,4 @@
+export { normalizeArchitectureComplexityExportBundle, normalizeArchitectureDeliveryExportBundle, } from "./command-input-loaders-architecture-compat-delivery-complexity.js";
+export { normalizeArchitectureScenarioCatalog, normalizeArchitectureScenarioObservations, } from "./command-input-loaders-architecture-compat-scenario.js";
+export { normalizeArchitectureTelemetryExportBundle, normalizeArchitectureTelemetryObservations, } from "./command-input-loaders-architecture-compat-telemetry.js";
+export { normalizeArchitectureBoundaryMap, normalizeArchitectureTopologyModel, } from "./command-input-loaders-architecture-compat-topology-boundary.js";

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

@@ -0,0 +1,34 @@
+import type { CommandArgs } from "./command-path-helpers.js";
+import type { ArchitectureComplexitySourceConfig, ArchitectureContractBaselineSourceConfig, ArchitectureDeliveryNormalizationProfile, ArchitectureDeliverySourceConfig, ArchitecturePatternRuntimeNormalizationProfile, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetrySourceConfig, CommandContext } from "./core/contracts.js";
+export declare function loadScenarioObservationSourceConfigIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureScenarioObservationSourceConfig;
+    configPath: string;
+} | undefined>;
+export declare function loadContractBaselineSourceConfigIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureContractBaselineSourceConfig;
+    configPath: string;
+} | undefined>;
+export declare function loadDeliveryNormalizationProfileIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureDeliveryNormalizationProfile;
+    configPath: string;
+} | undefined>;
+export declare function loadDeliverySourceConfigIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureDeliverySourceConfig;
+    configPath: string;
+} | undefined>;
+export declare function loadTelemetryNormalizationProfileIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureTelemetryNormalizationProfile;
+    configPath: string;
+} | undefined>;
+export declare function loadTelemetrySourceConfigIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureTelemetrySourceConfig;
+    configPath: string;
+} | undefined>;
+export declare function loadPatternRuntimeNormalizationProfileIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitecturePatternRuntimeNormalizationProfile;
+    configPath: string;
+} | undefined>;
+export declare function loadComplexitySourceConfigIfRequested(args: CommandArgs, context: CommandContext): Promise<{
+    config: ArchitectureComplexitySourceConfig;
+    configPath: string;
+} | undefined>;

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

@@ -0,0 +1,25 @@
+import { loadOptionalConfigFile } from "./command-input-loaders-core.js";
+export function loadScenarioObservationSourceConfigIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "scenario-observation-source", context);
+}
+export function loadContractBaselineSourceConfigIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "contract-baseline-source", context);
+}
+export function loadDeliveryNormalizationProfileIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "delivery-normalization-profile", context);
+}
+export function loadDeliverySourceConfigIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "delivery-source", context);
+}
+export function loadTelemetryNormalizationProfileIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "telemetry-normalization-profile", context);
+}
+export function loadTelemetrySourceConfigIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "telemetry-source", context);
+}
+export function loadPatternRuntimeNormalizationProfileIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "pattern-runtime-normalization-profile", context);
+}
+export function loadComplexitySourceConfigIfRequested(args, context) {
+    return loadOptionalConfigFile(args, "complexity-source", context);
+}

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

@@ -0,0 +1,17 @@
+import type { CommandArgs } from "./command-path-helpers.js";
+import type { ArchitectureBoundaryMap, ArchitectureComplexityExportBundle, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureDeliveryObservationSet, ArchitectureDeliveryRawObservationSet, ArchitecturePatternRuntimeObservationSet, ArchitecturePatternRuntimeRawObservationSet, ArchitectureScenarioCatalog, ArchitectureTelemetryExportBundle, ArchitectureTelemetryObservationSet, ArchitectureTelemetryRawObservationSet, ArchitectureTopologyModel, CommandContext, ScenarioObservationSet, TopologyRuntimeObservationSet } from "./core/contracts.js";
+export declare function loadScenarioCatalogIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureScenarioCatalog | undefined>;
+export declare function loadScenarioObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ScenarioObservationSet | undefined>;
+export declare function loadTopologyModelIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureTopologyModel | undefined>;
+export declare function loadBoundaryMapIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureBoundaryMap | undefined>;
+export declare function loadContractBaselineIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureContractBaseline | undefined>;
+export declare function loadRuntimeObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<TopologyRuntimeObservationSet | undefined>;
+export declare function loadDeliveryObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureDeliveryObservationSet | undefined>;
+export declare function loadDeliveryRawObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureDeliveryRawObservationSet | undefined>;
+export declare function loadDeliveryExportIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureDeliveryExportBundle | undefined>;
+export declare function loadTelemetryObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureTelemetryObservationSet | undefined>;
+export declare function loadTelemetryRawObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureTelemetryRawObservationSet | undefined>;
+export declare function loadTelemetryExportIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureTelemetryExportBundle | undefined>;
+export declare function loadPatternRuntimeObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitecturePatternRuntimeObservationSet | undefined>;
+export declare function loadPatternRuntimeRawObservationsIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitecturePatternRuntimeRawObservationSet | undefined>;
+export declare function loadComplexityExportIfRequested(args: CommandArgs, context: CommandContext): Promise<ArchitectureComplexityExportBundle | undefined>;

package/dist/src/command-input-loaders-architecture-data.js

@@ -0,0 +1,47 @@
+import { normalizeArchitectureBoundaryMap, normalizeArchitectureComplexityExportBundle, normalizeArchitectureDeliveryExportBundle, normalizeArchitectureScenarioCatalog, normalizeArchitectureScenarioObservations, normalizeArchitectureTelemetryExportBundle, normalizeArchitectureTelemetryObservations, normalizeArchitectureTopologyModel, } from "./command-input-loaders-architecture-compat.js";
+import { loadOptionalDataFile } from "./command-input-loaders-core.js";
+export function loadScenarioCatalogIfRequested(args, context) {
+    return loadOptionalDataFile(args, "scenario-catalog", context).then((value) => value ? normalizeArchitectureScenarioCatalog(value) : undefined);
+}
+export function loadScenarioObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "scenario-observations", context).then((value) => value ? normalizeArchitectureScenarioObservations(value) : undefined);
+}
+export function loadTopologyModelIfRequested(args, context) {
+    return loadOptionalDataFile(args, "topology-model", context).then((value) => value ? normalizeArchitectureTopologyModel(value) : undefined);
+}
+export function loadBoundaryMapIfRequested(args, context) {
+    return loadOptionalDataFile(args, "boundary-map", context).then((value) => value ? normalizeArchitectureBoundaryMap(value) : undefined);
+}
+export function loadContractBaselineIfRequested(args, context) {
+    return loadOptionalDataFile(args, "contract-baseline", context);
+}
+export function loadRuntimeObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "runtime-observations", context);
+}
+export function loadDeliveryObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "delivery-observations", context);
+}
+export function loadDeliveryRawObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "delivery-raw-observations", context);
+}
+export function loadDeliveryExportIfRequested(args, context) {
+    return loadOptionalDataFile(args, "delivery-export", context).then((value) => value ? normalizeArchitectureDeliveryExportBundle(value) : undefined);
+}
+export function loadTelemetryObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "telemetry-observations", context).then((value) => (value ? normalizeArchitectureTelemetryObservations(value) : undefined));
+}
+export function loadTelemetryRawObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "telemetry-raw-observations", context);
+}
+export function loadTelemetryExportIfRequested(args, context) {
+    return loadOptionalDataFile(args, "telemetry-export", context).then((value) => value ? normalizeArchitectureTelemetryExportBundle(value) : undefined);
+}
+export function loadPatternRuntimeObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "pattern-runtime-observations", context);
+}
+export function loadPatternRuntimeRawObservationsIfRequested(args, context) {
+    return loadOptionalDataFile(args, "pattern-runtime-raw-observations", context);
+}
+export function loadComplexityExportIfRequested(args, context) {
+    return loadOptionalDataFile(args, "complexity-export", context).then((value) => value ? normalizeArchitectureComplexityExportBundle(value) : undefined);
+}

package/dist/src/command-input-loaders-architecture.d.ts

@@ -0,0 +1,2 @@
+export { loadComplexitySourceConfigIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadScenarioObservationSourceConfigIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetrySourceConfigIfRequested, } from "./command-input-loaders-architecture-config.js";
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadContractBaselineIfRequested, loadDeliveryExportIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTopologyModelIfRequested, } from "./command-input-loaders-architecture-data.js";

package/dist/src/command-input-loaders-architecture.js

@@ -0,0 +1,2 @@
+export { loadComplexitySourceConfigIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadScenarioObservationSourceConfigIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetrySourceConfigIfRequested, } from "./command-input-loaders-architecture-config.js";
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadContractBaselineIfRequested, loadDeliveryExportIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTopologyModelIfRequested, } from "./command-input-loaders-architecture-data.js";

package/dist/src/command-input-loaders-core.d.ts

@@ -0,0 +1,20 @@
+import type { CommandArgs } from "./command-path-helpers.js";
+import type { ArchitectureConstraints, CommandContext, DomainDesignShadowRolloutBatchSpec, DomainDesignShadowRolloutRegistry, DomainModel, ReviewResolutionLog } from "./core/contracts.js";
+import type { loadShadowRolloutRegistry } from "./core/shadow-rollout.js";
+declare function loadOptionalDataFile<T>(args: CommandArgs, key: string, context: CommandContext): Promise<T | undefined>;
+declare function loadOptionalConfigFile<T>(args: CommandArgs, key: string, context: CommandContext): Promise<{
+    config: T;
+    configPath: string;
+} | undefined>;
+export declare function requireDomainModel(args: CommandArgs, context: CommandContext): Promise<DomainModel>;
+export declare function requireArchitectureConstraints(args: CommandArgs, context: CommandContext): Promise<ArchitectureConstraints>;
+export declare function requireShadowRolloutBatchSpec(args: CommandArgs, context: CommandContext): Promise<{
+    spec: DomainDesignShadowRolloutBatchSpec;
+    specPath: string;
+}>;
+export declare function requireShadowRolloutRegistry(args: CommandArgs, context: CommandContext, loadRegistry: typeof loadShadowRolloutRegistry): Promise<{
+    registry: DomainDesignShadowRolloutRegistry;
+    registryPath: string;
+}>;
+export declare function loadReviewLogIfRequested(args: CommandArgs, context: CommandContext): Promise<ReviewResolutionLog | undefined>;
+export { loadOptionalConfigFile, loadOptionalDataFile };

package/dist/src/command-input-loaders-core.js

@@ -0,0 +1,58 @@
+import { readDataFile } from "./core/io.js";
+import { loadArchitectureConstraints, loadDomainModel } from "./core/model.js";
+function resolveOptionalPathArg(args, key, context) {
+    return typeof args[key] === "string" ? new URL(args[key], `file://${context.cwd}/`).pathname : undefined;
+}
+async function loadOptionalDataFile(args, key, context) {
+    const filePath = resolveOptionalPathArg(args, key, context);
+    if (!filePath) {
+        return undefined;
+    }
+    return readDataFile(filePath);
+}
+async function loadOptionalConfigFile(args, key, context) {
+    const configPath = resolveOptionalPathArg(args, key, context);
+    if (!configPath) {
+        return undefined;
+    }
+    const config = await readDataFile(configPath);
+    return { config, configPath };
+}
+export async function requireDomainModel(args, context) {
+    const modelPath = resolveOptionalPathArg(args, "model", context);
+    if (!modelPath) {
+        throw new Error("`--model` is required");
+    }
+    return loadDomainModel(modelPath);
+}
+export async function requireArchitectureConstraints(args, context) {
+    const constraintsPath = resolveOptionalPathArg(args, "constraints", context);
+    if (!constraintsPath) {
+        throw new Error("`--constraints` is required");
+    }
+    return loadArchitectureConstraints(constraintsPath);
+}
+export async function requireShadowRolloutBatchSpec(args, context) {
+    const specPath = resolveOptionalPathArg(args, "batch-spec", context);
+    if (!specPath) {
+        throw new Error("`--batch-spec` is required");
+    }
+    const spec = await readDataFile(specPath);
+    if (!Array.isArray(spec.entries) || spec.entries.length === 0) {
+        throw new Error("Shadow rollout batch spec must contain at least one entry");
+    }
+    return { spec, specPath };
+}
+export async function requireShadowRolloutRegistry(args, context, loadRegistry) {
+    const registryPath = resolveOptionalPathArg(args, "shadow-rollout-registry", context) ??
+        resolveOptionalPathArg(args, "registry", context);
+    if (!registryPath) {
+        throw new Error("`--shadow-rollout-registry` or `--registry` is required unless `--batch-spec` is provided");
+    }
+    const registry = await loadRegistry(registryPath);
+    return { registry, registryPath };
+}
+export function loadReviewLogIfRequested(args, context) {
+    return loadOptionalDataFile(args, "review-log", context);
+}
+export { loadOptionalConfigFile, loadOptionalDataFile };

package/dist/src/command-input-loaders.d.ts

@@ -0,0 +1,2 @@
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadComplexitySourceConfigIfRequested, loadContractBaselineIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryExportIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationSourceConfigIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTelemetrySourceConfigIfRequested, loadTopologyModelIfRequested, } from "./command-input-loaders-architecture.js";
+export { loadReviewLogIfRequested, requireArchitectureConstraints, requireDomainModel, requireShadowRolloutBatchSpec, requireShadowRolloutRegistry, } from "./command-input-loaders-core.js";

package/dist/src/command-input-loaders.js

@@ -0,0 +1,2 @@
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadComplexitySourceConfigIfRequested, loadContractBaselineIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryExportIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationSourceConfigIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTelemetrySourceConfigIfRequested, loadTopologyModelIfRequested, } from "./command-input-loaders-architecture.js";
+export { loadReviewLogIfRequested, requireArchitectureConstraints, requireDomainModel, requireShadowRolloutBatchSpec, requireShadowRolloutRegistry, } from "./command-input-loaders-core.js";

package/dist/src/command-path-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { CommandContext } from "./core/contracts.js";
+export type CommandArgs = Record<string, string | boolean>;
+export declare function resolveSpecRelativePath(baseDirectory: string, input: string): string;
+export declare function getRootPath(args: CommandArgs, context: CommandContext): string;
+export declare function getDocsRoot(args: CommandArgs, context: CommandContext): string;
+export declare function getProfile(args: CommandArgs): string;

package/dist/src/command-path-helpers.js

@@ -0,0 +1,15 @@
+import path from "node:path";
+export function resolveSpecRelativePath(baseDirectory, input) {
+    return path.isAbsolute(input) ? input : path.resolve(baseDirectory, input);
+}
+export function getRootPath(args, context) {
+    return typeof args.repo === "string" ? new URL(args.repo, `file://${context.cwd}/`).pathname : context.cwd;
+}
+export function getDocsRoot(args, context) {
+    return typeof args["docs-root"] === "string"
+        ? new URL(args["docs-root"], `file://${context.cwd}/`).pathname
+        : context.cwd;
+}
+export function getProfile(args) {
+    return typeof args.profile === "string" ? args.profile : "default";
+}

package/dist/src/command-score-driven.d.ts

@@ -0,0 +1,19 @@
+import type { CommandArgs } from "./command-helpers.js";
+import type { ArchitectureScenarioQualitySummary, CommandContext, CommandResponse, DomainDesignScoreResult, LocalityWatchlistItem, MarkdownReportResult, MeasurementGateResult, MetricScore } from "./core/contracts.js";
+import { listReviewItems } from "./core/review.js";
+interface ArchitectureScoreResult {
+    domainId: "architecture_design";
+    metrics: MetricScore[];
+    leakFindings?: unknown[];
+    violations?: unknown[];
+    scenarioQuality?: ArchitectureScenarioQualitySummary;
+    localityWatchlist?: LocalityWatchlistItem[];
+}
+type ScorePayload = DomainDesignScoreResult | ArchitectureScoreResult;
+type ScoreCommand = (args: CommandArgs, context: CommandContext) => Promise<CommandResponse<unknown>>;
+export declare function handleReviewListUnknowns(args: CommandArgs, context: CommandContext, scoreCompute: ScoreCommand, commandRegistry: Record<string, ScoreCommand>): Promise<CommandResponse<{
+    reviewItems: ReturnType<typeof listReviewItems>;
+}>>;
+export declare function handleReportGenerate(args: CommandArgs, context: CommandContext, scoreCompute: ScoreCommand): Promise<CommandResponse<ScorePayload | MarkdownReportResult>>;
+export declare function handleGateEvaluate(args: CommandArgs, context: CommandContext, scoreCompute: ScoreCommand): Promise<CommandResponse<MeasurementGateResult>>;
+export {};

package/dist/src/command-score-driven.js

@@ -0,0 +1,96 @@
+import { getProfile } from "./command-helpers.js";
+import { readDataFile } from "./core/io.js";
+import { mergeRuntimeSummary } from "./core/measurement-metadata.js";
+import { loadPolicyConfig } from "./core/policy.js";
+import { evaluateGate, renderMarkdownReport } from "./core/report.js";
+import { createResponse } from "./core/response.js";
+import { listReviewItems } from "./core/review.js";
+import { DOMAIN_PACKS } from "./packs/index.js";
+export async function handleReviewListUnknowns(args, context, scoreCompute, commandRegistry) {
+    const startedAt = Date.now();
+    const inputPath = typeof args.input === "string" ? new URL(args.input, `file://${context.cwd}/`).pathname : undefined;
+    const sourceCommand = typeof args["source-command"] === "string" ? commandRegistry[args["source-command"]] : undefined;
+    const response = inputPath
+        ? await readDataFile(inputPath)
+        : sourceCommand
+            ? await sourceCommand(args, context)
+            : await scoreCompute(args, context);
+    const reviewItems = listReviewItems(response);
+    return createResponse({ reviewItems }, {
+        status: reviewItems.length > 0 ? "warning" : "ok",
+        confidence: response.confidence,
+        unknowns: response.unknowns,
+        evidence: response.evidence,
+        diagnostics: response.diagnostics,
+        progress: response.progress,
+        provenance: response.provenance,
+        meta: {
+            ...(response.meta ?? {}),
+            runtime: mergeRuntimeSummary(response.meta?.runtime, {
+                totalMs: (response.meta?.runtime?.totalMs ?? 0) + (Date.now() - startedAt),
+                stages: { reviewMs: Date.now() - startedAt },
+            }),
+        },
+    });
+}
+export async function handleReportGenerate(args, context, scoreCompute) {
+    const startedAt = Date.now();
+    const response = (await scoreCompute(args, context));
+    const format = typeof args.format === "string" ? args.format : "json";
+    if (format === "md") {
+        const renderStartedAt = Date.now();
+        const renderedReport = renderMarkdownReport(response, getProfile(args));
+        const renderMs = Date.now() - renderStartedAt;
+        return createResponse({
+            format,
+            report: renderedReport,
+        }, {
+            status: response.status,
+            evidence: response.evidence,
+            confidence: response.confidence,
+            unknowns: response.unknowns,
+            diagnostics: response.diagnostics,
+            progress: response.progress,
+            provenance: response.provenance,
+            meta: {
+                ...(response.meta ?? {}),
+                runtime: mergeRuntimeSummary(response.meta?.runtime, {
+                    totalMs: (response.meta?.runtime?.totalMs ?? 0) + (Date.now() - startedAt),
+                    stages: { renderMs },
+                }),
+            },
+        });
+    }
+    return response;
+}
+export async function handleGateEvaluate(args, context, scoreCompute) {
+    const startedAt = Date.now();
+    const response = (await scoreCompute(args, context));
+    const policyConfig = await loadPolicyConfig(typeof args.policy === "string" ? args.policy : undefined);
+    const gate = evaluateGate(response, policyConfig, getProfile(args));
+    const pilot = response.result.domainId === "domain_design" && "pilot" in response.result ? response.result.pilot : undefined;
+    return createResponse({
+        domainId: response.result.domainId,
+        gate,
+        metrics: response.result.metrics,
+        ...(pilot ? { pilot } : {}),
+    }, {
+        status: gate.status,
+        evidence: response.evidence,
+        confidence: response.confidence,
+        unknowns: response.unknowns,
+        diagnostics: [
+            ...response.diagnostics,
+            ...(pilot ? [`Pilot locality source: ${pilot.localitySource} for category ${pilot.category}.`] : []),
+            `Available packs: ${DOMAIN_PACKS.map((pack) => pack.id).join(", ")}`,
+        ],
+        progress: response.progress,
+        meta: {
+            ...(response.meta ?? {}),
+            runtime: mergeRuntimeSummary(response.meta?.runtime, {
+                totalMs: (response.meta?.runtime?.totalMs ?? 0) + (Date.now() - startedAt),
+                stages: { gateMs: Date.now() - startedAt },
+            }),
+        },
+    });
+}

package/dist/src/command-score.d.ts

@@ -0,0 +1,3 @@
+import type { CommandArgs } from "./command-helpers.js";
+import type { CommandContext, CommandResponse } from "./core/contracts.js";
+export declare function handleScoreCompute(args: CommandArgs, context: CommandContext): Promise<CommandResponse<unknown>>;

package/dist/src/command-score.js

@@ -0,0 +1,78 @@
+import { buildArchitectureScoreOptions } from "./command-architecture-inputs.js";
+import { buildExtractionOptions, getDocsRoot, getProfile, getRootPath, requireDomainModel, requireShadowRolloutRegistry, } from "./command-helpers.js";
+import { mergeRuntimeSummary } from "./core/measurement-metadata.js";
+import { loadPolicyConfig } from "./core/policy.js";
+import { computeArchitectureScores, computeDomainDesignScores } from "./core/scoring.js";
+import { evaluateShadowRolloutGate, loadShadowRolloutRegistry, registryToGateObservations, } from "./core/shadow-rollout.js";
+export async function handleScoreCompute(args, context) {
+    const startedAt = Date.now();
+    const policyConfig = await loadPolicyConfig(typeof args.policy === "string" ? args.policy : undefined);
+    const domain = typeof args.domain === "string" ? args.domain : "domain_design";
+    const pilotPersistence = args["pilot-persistence"] === true;
+    const rolloutCategory = typeof args["rollout-category"] === "string" ? args["rollout-category"] : undefined;
+    if (rolloutCategory && !pilotPersistence) {
+        throw new Error("`--rollout-category` requires `--pilot-persistence`");
+    }
+    if (domain === "architecture_design") {
+        const scoreResponse = await computeArchitectureScores(await buildArchitectureScoreOptions(args, context, policyConfig));
+        return {
+            ...scoreResponse,
+            meta: {
+                ...(scoreResponse.meta ?? {}),
+                runtime: mergeRuntimeSummary(scoreResponse.meta?.runtime, {
+                    totalMs: Date.now() - startedAt,
+                    stages: {
+                        inputLoadMs: Date.now() - startedAt - (scoreResponse.meta?.runtime?.totalMs ?? 0),
+                    },
+                }),
+            },
+        };
+    }
+    const model = await requireDomainModel(args, context);
+    const docsRoot = typeof args["docs-root"] === "string" ? getDocsRoot(args, context) : undefined;
+    const extractionOptions = docsRoot ? await buildExtractionOptions(args, context) : undefined;
+    let pilotGateEvaluation;
+    if (pilotPersistence) {
+        if (!rolloutCategory) {
+            throw new Error("`--rollout-category` is required when `--pilot-persistence` is enabled");
+        }
+        const { registry, registryPath } = await requireShadowRolloutRegistry(args, context, loadShadowRolloutRegistry);
+        pilotGateEvaluation = evaluateShadowRolloutGate(registryToGateObservations(registry, registryPath));
+    }
+    const scoreResponse = await computeDomainDesignScores({
+        repoPath: getRootPath(args, context),
+        model,
+        policyConfig,
+        profileName: getProfile(args),
+        ...(context.reportProgress ? { progressReporter: context.reportProgress } : {}),
+        shadowPersistence: args["shadow-persistence"] === true || pilotPersistence,
+        ...(pilotPersistence && rolloutCategory ? { pilotPersistenceCategory: rolloutCategory } : {}),
+        ...(pilotGateEvaluation ? { pilotGateEvaluation } : {}),
+        ...(docsRoot ? { docsRoot } : {}),
+        ...(extractionOptions
+            ? {
+                extraction: {
+                    extractor: extractionOptions.extractor,
+                    ...(extractionOptions.provider ? { provider: extractionOptions.provider } : {}),
+                    ...(extractionOptions.providerCommand ? { providerCommand: extractionOptions.providerCommand } : {}),
+                    promptProfile: extractionOptions.promptProfile,
+                    fallback: extractionOptions.fallback,
+                    ...(extractionOptions.reviewLog ? { reviewLog: extractionOptions.reviewLog } : {}),
+                    applyReviewLog: extractionOptions.applyReviewLog,
+                },
+            }
+            : {}),
+    });
+    return {
+        ...scoreResponse,
+        meta: {
+            ...(scoreResponse.meta ?? {}),
+            runtime: mergeRuntimeSummary(scoreResponse.meta?.runtime, {
+                totalMs: Date.now() - startedAt,
+                stages: {
+                    inputLoadMs: Date.now() - startedAt - (scoreResponse.meta?.runtime?.totalMs ?? 0),
+                },
+            }),
+        },
+    };
+}