context-probe 0.1.0

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

@@ -0,0 +1,105 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadContractBaselineIfRequested, loadDeliveryExportIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTopologyModelIfRequested, } from "./command-helpers.js";
+import { getDocsRoot } from "./command-path-helpers.js";
+const STANDARD_ARCHITECTURE_DOC_INPUTS = {
+    "scenario-catalog": ["architecture/context-probe/architecture-scenarios.yaml", "architecture/scenario-catalog.yaml"],
+    "scenario-observations": [
+        "architecture/context-probe/architecture-scenario-observations.yaml",
+        "architecture/context-probe/architecture-scenario-benchmark-summary.json",
+        "architecture/scenario-observations.yaml",
+    ],
+    "topology-model": ["architecture/context-probe/architecture-topology.yaml", "architecture/topology-model.yaml"],
+    "boundary-map": ["architecture/context-probe/architecture-boundary-map.yaml", "architecture/boundary-map.yaml"],
+    "contract-baseline": ["architecture/context-probe/architecture-contract-baseline.yaml"],
+    "runtime-observations": [
+        "architecture/context-probe/architecture-runtime-observations.yaml",
+        "architecture/runtime-observations.yaml",
+    ],
+    "delivery-observations": [
+        "architecture/context-probe/architecture-delivery-observations.yaml",
+        "architecture/delivery-observations.yaml",
+    ],
+    "telemetry-observations": [
+        "architecture/context-probe/architecture-telemetry-observations.yaml",
+        "architecture/telemetry-observations.yaml",
+    ],
+    "pattern-runtime-observations": [
+        "architecture/context-probe/architecture-pattern-runtime-observations.yaml",
+        "architecture/pattern-runtime-observations.yaml",
+    ],
+    "complexity-export": ["architecture/context-probe/architecture-complexity-export.yaml"],
+};
+async function findFirstExistingPath(baseDirectory, candidates) {
+    for (const candidate of candidates) {
+        const resolved = path.resolve(baseDirectory, candidate);
+        try {
+            await access(resolved);
+            return resolved;
+        }
+        catch {
+            // Continue until a matching standard path exists.
+        }
+    }
+    return undefined;
+}
+async function discoverArchitectureInputArgs(args, context) {
+    if (typeof args["docs-root"] !== "string") {
+        return args;
+    }
+    const docsRoot = getDocsRoot(args, context);
+    const resolvedArgs = { ...args };
+    await Promise.all(Object.entries(STANDARD_ARCHITECTURE_DOC_INPUTS).map(async ([argKey, candidates]) => {
+        if (typeof resolvedArgs[argKey] === "string") {
+            return;
+        }
+        const discovered = await findFirstExistingPath(docsRoot, candidates);
+        if (discovered) {
+            resolvedArgs[argKey] = discovered;
+        }
+    }));
+    return resolvedArgs;
+}
+export async function loadArchitectureInputData(args, context) {
+    const resolvedArgs = await discoverArchitectureInputArgs(args, context);
+    const [scenarioCatalog, scenarioObservations, topologyModel, boundaryMap, contractBaseline, runtimeObservations, deliveryObservations, deliveryRawObservations, deliveryExport, deliveryNormalizationProfileResult, telemetryObservations, telemetryRawObservations, telemetryExport, telemetryNormalizationProfileResult, patternRuntimeObservations, patternRuntimeRawObservations, patternRuntimeNormalizationProfileResult, complexityExport,] = await Promise.all([
+        loadScenarioCatalogIfRequested(resolvedArgs, context),
+        loadScenarioObservationsIfRequested(resolvedArgs, context),
+        loadTopologyModelIfRequested(resolvedArgs, context),
+        loadBoundaryMapIfRequested(resolvedArgs, context),
+        loadContractBaselineIfRequested(resolvedArgs, context),
+        loadRuntimeObservationsIfRequested(resolvedArgs, context),
+        loadDeliveryObservationsIfRequested(resolvedArgs, context),
+        loadDeliveryRawObservationsIfRequested(resolvedArgs, context),
+        loadDeliveryExportIfRequested(resolvedArgs, context),
+        loadDeliveryNormalizationProfileIfRequested(resolvedArgs, context),
+        loadTelemetryObservationsIfRequested(resolvedArgs, context),
+        loadTelemetryRawObservationsIfRequested(resolvedArgs, context),
+        loadTelemetryExportIfRequested(resolvedArgs, context),
+        loadTelemetryNormalizationProfileIfRequested(resolvedArgs, context),
+        loadPatternRuntimeObservationsIfRequested(resolvedArgs, context),
+        loadPatternRuntimeRawObservationsIfRequested(resolvedArgs, context),
+        loadPatternRuntimeNormalizationProfileIfRequested(resolvedArgs, context),
+        loadComplexityExportIfRequested(resolvedArgs, context),
+    ]);
+    return {
+        scenarioCatalog,
+        scenarioObservations,
+        topologyModel,
+        boundaryMap,
+        contractBaseline,
+        runtimeObservations,
+        deliveryObservations,
+        deliveryRawObservations,
+        deliveryExport,
+        deliveryNormalizationProfile: deliveryNormalizationProfileResult?.config,
+        telemetryObservations,
+        telemetryRawObservations,
+        telemetryExport,
+        telemetryNormalizationProfile: telemetryNormalizationProfileResult?.config,
+        patternRuntimeObservations,
+        patternRuntimeRawObservations,
+        patternRuntimeNormalizationProfile: patternRuntimeNormalizationProfileResult?.config,
+        complexityExport,
+    };
+}

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

@@ -0,0 +1,42 @@
+import type { ArchitectureBoundaryMap, ArchitectureComplexityExportBundle, ArchitectureComplexitySourceConfig, ArchitectureContractBaseline, ArchitectureContractBaselineSourceConfig, ArchitectureDeliveryExportBundle, ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryObservationSet, ArchitectureDeliveryRawObservationSet, ArchitectureDeliverySourceConfig, ArchitecturePatternRuntimeNormalizationProfile, ArchitecturePatternRuntimeObservationSet, ArchitecturePatternRuntimeRawObservationSet, ArchitectureScenarioCatalog, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryObservationSet, ArchitectureTelemetryRawObservationSet, ArchitectureTelemetrySourceConfig, ArchitectureTopologyModel, CommandContext, ScenarioObservationSet, TopologyRuntimeObservationSet } from "./core/contracts.js";
+export interface LoadedArchitectureScoreInputs {
+    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;
+    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 loadArchitectureScoreInputs(args: Record<string, string | boolean>, context: CommandContext): Promise<LoadedArchitectureScoreInputs>;

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

@@ -0,0 +1,12 @@
+import { loadArchitectureInputSourceConfigs } from "./command-architecture-inputs-loaders-config.js";
+import { loadArchitectureInputData } from "./command-architecture-inputs-loaders-data.js";
+export async function loadArchitectureScoreInputs(args, context) {
+    const [data, sourceConfigs] = await Promise.all([
+        loadArchitectureInputData(args, context),
+        loadArchitectureInputSourceConfigs(args, context),
+    ]);
+    return {
+        ...data,
+        ...sourceConfigs,
+    };
+}

package/dist/src/command-architecture-inputs-provenance.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "./core/contracts.js";
+export declare function collectDirectInputProvenance(args: Record<string, string | boolean>, context: CommandContext): import("./core/contracts.js").ProvenanceRef[];

package/dist/src/command-architecture-inputs-provenance.js

@@ -0,0 +1,29 @@
+import { toProvenance } from "./core/response.js";
+const DIRECT_ARCHITECTURE_INPUTS = [
+    { argName: "scenario-catalog", note: "scenario_catalog_file" },
+    { argName: "scenario-observations", note: "scenario_observations_file" },
+    { argName: "topology-model", note: "topology_model_file" },
+    { argName: "boundary-map", note: "boundary_map_file" },
+    { argName: "contract-baseline", note: "contract_baseline_file" },
+    { argName: "runtime-observations", note: "runtime_observations_file" },
+    { argName: "delivery-observations", note: "delivery_observations_file" },
+    { argName: "delivery-raw-observations", note: "delivery_raw_observations_file" },
+    { argName: "delivery-export", note: "delivery_export_file" },
+    { argName: "delivery-normalization-profile", note: "delivery_normalization_profile_file" },
+    { argName: "telemetry-observations", note: "telemetry_observations_file" },
+    { argName: "telemetry-raw-observations", note: "telemetry_raw_observations_file" },
+    { argName: "telemetry-export", note: "telemetry_export_file" },
+    { argName: "telemetry-normalization-profile", note: "telemetry_normalization_profile_file" },
+    { argName: "pattern-runtime-observations", note: "pattern_runtime_observations_file" },
+    { argName: "pattern-runtime-raw-observations", note: "pattern_runtime_raw_observations_file" },
+    { argName: "pattern-runtime-normalization-profile", note: "pattern_runtime_normalization_profile_file" },
+    { argName: "complexity-export", note: "complexity_export_file" },
+];
+export function collectDirectInputProvenance(args, context) {
+    return DIRECT_ARCHITECTURE_INPUTS.flatMap(({ argName, note }) => {
+        const inputPath = args[argName];
+        return typeof inputPath === "string"
+            ? [toProvenance(new URL(inputPath, `file://${context.cwd}/`).pathname, note)]
+            : [];
+    });
+}

package/dist/src/command-architecture-inputs-resolved.d.ts

@@ -0,0 +1,44 @@
+import { resolveComplexitySourceConfig, resolveContractBaselineSourceConfig, resolveDeliverySourceConfig, resolveScenarioObservationSourceConfig, resolveTelemetrySourceConfig } from "./analyzers/architecture-source-loader.js";
+import type { ArchitectureComplexityExportBundle, ArchitectureComplexitySourceConfig, ArchitectureContractBaseline, ArchitectureContractBaselineSourceConfig, ArchitectureDeliveryExportBundle, ArchitectureDeliverySourceConfig, ArchitectureScenarioObservationSourceConfig, ArchitectureTelemetryExportBundle, ArchitectureTelemetrySourceConfig, CommandContext, ScenarioObservationSet } from "./core/contracts.js";
+import { toProvenance } from "./core/response.js";
+export interface ResolvedArchitectureInputSources {
+    contractBaselineSource?: Awaited<ReturnType<typeof resolveContractBaselineSourceConfig>> | undefined;
+    scenarioObservationSource?: Awaited<ReturnType<typeof resolveScenarioObservationSourceConfig>> | undefined;
+    telemetrySource?: Awaited<ReturnType<typeof resolveTelemetrySourceConfig>> | undefined;
+    deliverySource?: Awaited<ReturnType<typeof resolveDeliverySourceConfig>> | undefined;
+    complexitySource?: Awaited<ReturnType<typeof resolveComplexitySourceConfig>> | undefined;
+    additionalProvenance: ReturnType<typeof toProvenance>[];
+}
+export declare function resolveArchitectureInputSources(input: {
+    args: Record<string, string | boolean>;
+    context: CommandContext;
+    scenarioObservations?: ScenarioObservationSet | undefined;
+    scenarioObservationSourceConfig?: {
+        config: ArchitectureScenarioObservationSourceConfig;
+        configPath: string;
+    } | undefined;
+    contractBaseline?: ArchitectureContractBaseline | undefined;
+    contractBaselineSourceConfig?: {
+        config: ArchitectureContractBaselineSourceConfig;
+        configPath: string;
+    } | undefined;
+    deliveryObservations?: unknown | undefined;
+    deliveryRawObservations?: unknown | undefined;
+    deliveryExport?: ArchitectureDeliveryExportBundle | undefined;
+    deliverySourceConfig?: {
+        config: ArchitectureDeliverySourceConfig;
+        configPath: string;
+    } | undefined;
+    telemetryObservations?: unknown | undefined;
+    telemetryRawObservations?: unknown | undefined;
+    telemetryExport?: ArchitectureTelemetryExportBundle | undefined;
+    telemetrySourceConfig?: {
+        config: ArchitectureTelemetrySourceConfig;
+        configPath: string;
+    } | undefined;
+    complexityExport?: ArchitectureComplexityExportBundle | undefined;
+    complexitySourceConfig?: {
+        config: ArchitectureComplexitySourceConfig;
+        configPath: string;
+    } | undefined;
+}): Promise<ResolvedArchitectureInputSources>;

package/dist/src/command-architecture-inputs-resolved.js

@@ -0,0 +1,72 @@
+import { resolveComplexitySourceConfig, resolveContractBaselineSourceConfig, resolveDeliverySourceConfig, resolveScenarioObservationSourceConfig, resolveTelemetrySourceConfig, } from "./analyzers/architecture-source-loader.js";
+import { collectDirectInputProvenance } from "./command-architecture-inputs-provenance.js";
+import { toProvenance } from "./core/response.js";
+export async function resolveArchitectureInputSources(input) {
+    const contractBaselineSource = !input.contractBaseline && input.contractBaselineSourceConfig
+        ? await resolveContractBaselineSourceConfig(input.contractBaselineSourceConfig)
+        : undefined;
+    const scenarioObservationSource = !input.scenarioObservations && input.scenarioObservationSourceConfig
+        ? await resolveScenarioObservationSourceConfig(input.scenarioObservationSourceConfig)
+        : undefined;
+    const telemetrySource = !input.telemetryObservations &&
+        !input.telemetryRawObservations &&
+        !input.telemetryExport &&
+        input.telemetrySourceConfig
+        ? await resolveTelemetrySourceConfig(input.telemetrySourceConfig)
+        : undefined;
+    const deliverySource = !input.deliveryObservations && !input.deliveryRawObservations && !input.deliveryExport && input.deliverySourceConfig
+        ? await resolveDeliverySourceConfig(input.deliverySourceConfig)
+        : undefined;
+    const complexitySource = !input.complexityExport && input.complexitySourceConfig
+        ? await resolveComplexitySourceConfig(input.complexitySourceConfig)
+        : undefined;
+    const additionalProvenance = [
+        ...collectDirectInputProvenance(input.args, input.context),
+        ...(contractBaselineSource
+            ? [
+                toProvenance(contractBaselineSource.configPath, "contract_baseline_source_config"),
+                ...(contractBaselineSource.resolvedPath
+                    ? [toProvenance(contractBaselineSource.resolvedPath, "contract_baseline_source_file")]
+                    : []),
+            ]
+            : []),
+        ...(scenarioObservationSource
+            ? [
+                toProvenance(scenarioObservationSource.configPath, "scenario_observation_source_config"),
+                ...(scenarioObservationSource.resolvedPath
+                    ? [toProvenance(scenarioObservationSource.resolvedPath, "scenario_observation_source_file")]
+                    : []),
+            ]
+            : []),
+        ...(telemetrySource
+            ? [
+                toProvenance(telemetrySource.configPath, "telemetry_source_config"),
+                ...(telemetrySource.resolvedPath
+                    ? [toProvenance(telemetrySource.resolvedPath, "telemetry_source_file")]
+                    : []),
+            ]
+            : []),
+        ...(deliverySource
+            ? [
+                toProvenance(deliverySource.configPath, "delivery_source_config"),
+                ...(deliverySource.resolvedPath ? [toProvenance(deliverySource.resolvedPath, "delivery_source_file")] : []),
+            ]
+            : []),
+        ...(complexitySource
+            ? [
+                toProvenance(complexitySource.configPath, "complexity_source_config"),
+                ...(complexitySource.resolvedPath
+                    ? [toProvenance(complexitySource.resolvedPath, "complexity_source_file")]
+                    : []),
+            ]
+            : []),
+    ];
+    return {
+        contractBaselineSource,
+        scenarioObservationSource,
+        telemetrySource,
+        deliverySource,
+        complexitySource,
+        additionalProvenance,
+    };
+}

package/dist/src/command-architecture-inputs-sources.d.ts

@@ -0,0 +1,2 @@
+export type { ResolvedArchitectureInputSources } from "./command-architecture-inputs-resolved.js";
+export { resolveArchitectureInputSources } from "./command-architecture-inputs-resolved.js";

package/dist/src/command-architecture-inputs-sources.js

@@ -0,0 +1 @@
+export { resolveArchitectureInputSources } from "./command-architecture-inputs-resolved.js";

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

@@ -0,0 +1,4 @@
+import type { CommandArgs } from "./command-helpers.js";
+import type { ComputeArchitectureScoresOptions } from "./core/architecture-scoring-types.js";
+import type { CommandContext } from "./core/contracts.js";
+export declare function buildArchitectureScoreOptions(args: CommandArgs, context: CommandContext, policyConfig: ComputeArchitectureScoresOptions["policyConfig"]): Promise<ComputeArchitectureScoresOptions>;

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

@@ -0,0 +1,63 @@
+import { loadArchitectureScoreInputs } from "./command-architecture-inputs-loaders.js";
+import { resolveArchitectureInputSources } from "./command-architecture-inputs-sources.js";
+import { getProfile, getRootPath, requireArchitectureConstraints } from "./command-helpers.js";
+export async function buildArchitectureScoreOptions(args, context, policyConfig) {
+    const repoPath = getRootPath(args, context);
+    const constraints = await requireArchitectureConstraints(args, context);
+    const { scenarioCatalog, scenarioObservations, scenarioObservationSourceConfig, topologyModel, boundaryMap, contractBaseline, contractBaselineSourceConfig, runtimeObservations, deliveryObservations, deliveryRawObservations, deliveryExport, deliveryNormalizationProfile, deliverySourceConfig, telemetryObservations, telemetryRawObservations, telemetryExport, telemetryNormalizationProfile, telemetrySourceConfig, patternRuntimeObservations, patternRuntimeRawObservations, patternRuntimeNormalizationProfile, complexityExport, complexitySourceConfig, } = await loadArchitectureScoreInputs(args, context);
+    const { contractBaselineSource, scenarioObservationSource, telemetrySource, deliverySource, complexitySource, additionalProvenance, } = await resolveArchitectureInputSources({
+        args,
+        context,
+        scenarioObservations,
+        scenarioObservationSourceConfig,
+        contractBaseline,
+        contractBaselineSourceConfig,
+        deliveryObservations,
+        deliveryRawObservations,
+        deliveryExport,
+        deliverySourceConfig,
+        telemetryObservations,
+        telemetryRawObservations,
+        telemetryExport,
+        telemetrySourceConfig,
+        complexityExport,
+        complexitySourceConfig,
+    });
+    return {
+        repoPath,
+        constraints,
+        policyConfig,
+        profileName: getProfile(args),
+        ...(scenarioCatalog ? { scenarioCatalog } : {}),
+        ...(scenarioObservations ? { scenarioObservations } : {}),
+        ...(scenarioObservationSource ? { scenarioObservationSource } : {}),
+        ...(topologyModel ? { topologyModel } : {}),
+        ...(boundaryMap ? { boundaryMap } : {}),
+        ...(contractBaseline ? { contractBaseline } : {}),
+        ...(contractBaselineSource ? { contractBaselineSource } : {}),
+        ...(runtimeObservations ? { runtimeObservations } : {}),
+        ...(deliveryObservations ? { deliveryObservations } : {}),
+        ...(deliveryRawObservations ? { deliveryRawObservations } : {}),
+        ...(deliveryExport ? { deliveryExport } : {}),
+        ...(deliverySource ? { deliverySource } : {}),
+        ...(deliveryNormalizationProfile ? { deliveryNormalizationProfile } : {}),
+        ...(telemetryObservations ? { telemetryObservations } : {}),
+        ...(telemetryRawObservations ? { telemetryRawObservations } : {}),
+        ...(telemetryExport ? { telemetryExport } : {}),
+        ...(telemetrySource ? { telemetrySource } : {}),
+        ...(telemetryNormalizationProfile ? { telemetryNormalizationProfile } : {}),
+        ...(patternRuntimeObservations ? { patternRuntimeObservations } : {}),
+        ...(patternRuntimeRawObservations ? { patternRuntimeRawObservations } : {}),
+        ...(patternRuntimeNormalizationProfile ? { patternRuntimeNormalizationProfile } : {}),
+        ...(complexityExport ? { complexityExport } : {}),
+        ...(complexitySource ? { complexitySource } : {}),
+        additionalProvenance,
+        scenarioObservationSourceRequested: Boolean(scenarioObservationSourceConfig),
+        telemetrySourceRequested: Boolean(telemetrySourceConfig),
+        deliverySourceRequested: Boolean(deliverySourceConfig),
+        complexitySourceRequested: Boolean(complexitySourceConfig),
+        contractBaselineSourceRequested: Boolean(contractBaselineSourceConfig),
+        patternRuntimeRawRequested: Boolean(patternRuntimeRawObservations),
+        patternRuntimeNormalizationProfileRequested: Boolean(patternRuntimeNormalizationProfile),
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./command-types.js";
+export declare function createArchitectureCommands(): Record<string, CommandHandler>;

package/dist/src/command-architecture.js

@@ -0,0 +1,35 @@
+import { detectDirectionViolations, scoreDependencyDirection } from "./analyzers/architecture.js";
+import { parseCodebase } from "./analyzers/code.js";
+import { getRootPath, requireArchitectureConstraints } from "./command-helpers.js";
+import { createResponse, toProvenance } from "./core/response.js";
+import { scaffoldArchitectureConstraints } from "./core/scaffold.js";
+export function createArchitectureCommands() {
+    return {
+        async "arch.load_topology"(args, context) {
+            const constraints = await requireArchitectureConstraints(args, context);
+            return createResponse(constraints);
+        },
+        async "constraints.scaffold"(args, context) {
+            const repoRoot = getRootPath(args, context);
+            const scaffold = await scaffoldArchitectureConstraints({ repoRoot });
+            return createResponse(scaffold.result, {
+                status: scaffold.unknowns.length > 0 ? "warning" : "ok",
+                evidence: scaffold.evidence,
+                confidence: scaffold.confidence,
+                unknowns: scaffold.unknowns,
+                diagnostics: scaffold.diagnostics,
+                provenance: [toProvenance(repoRoot, "architecture_constraints_scaffold")],
+            });
+        },
+        async "arch.detect_direction_violations"(args, context) {
+            const constraints = await requireArchitectureConstraints(args, context);
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse({ violations: detectDirectionViolations(codebase, constraints) });
+        },
+        async "arch.score_dependency_direction"(args, context) {
+            const constraints = await requireArchitectureConstraints(args, context);
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse(scoreDependencyDirection(codebase, constraints));
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./command-types.js";
+export declare function createDomainCommands(): Record<string, CommandHandler>;

package/dist/src/command-domain.js

@@ -0,0 +1,124 @@
+import { detectBoundaryLeaks, detectContractUsage, parseCodebase } from "./analyzers/code.js";
+import { buildExtractionOptions, getDocsRoot, getRootPath, requireDomainModel } from "./command-helpers.js";
+import { normalizeDocuments, registerArtifacts } from "./core/artifacts.js";
+import { extractGlossary, extractInvariants, extractRules } from "./core/document-extractors.js";
+import { createResponse, toProvenance } from "./core/response.js";
+import { scaffoldDomainModel } from "./core/scaffold.js";
+import { buildModelCodeLinks, buildTermTraceLinks } from "./core/trace.js";
+export function createDomainCommands() {
+    return {
+        async "ingest.register_artifacts"(args, context) {
+            const artifacts = await registerArtifacts(getRootPath(args, context));
+            return createResponse({ artifacts }, { provenance: [toProvenance(context.cwd, "artifact_registry")] });
+        },
+        async "ingest.normalize_documents"(args, context) {
+            const fragments = await normalizeDocuments(getDocsRoot(args, context));
+            return createResponse({ fragments }, { provenance: [toProvenance(context.cwd, "document_fragments")] });
+        },
+        async "model.load"(args, context) {
+            const model = await requireDomainModel(args, context);
+            return createResponse(model, { provenance: [toProvenance(context.cwd, "domain_model")] });
+        },
+        async "model.scaffold"(args, context) {
+            const repoRoot = getRootPath(args, context);
+            const docsRoot = typeof args["docs-root"] === "string" ? getDocsRoot(args, context) : undefined;
+            const scaffold = await scaffoldDomainModel({
+                repoRoot,
+                ...(docsRoot ? { docsRoot, extractionOptions: await buildExtractionOptions(args, context) } : {}),
+            });
+            return createResponse(scaffold.result, {
+                status: scaffold.unknowns.length > 0 ? "warning" : "ok",
+                evidence: scaffold.evidence,
+                confidence: scaffold.confidence,
+                unknowns: scaffold.unknowns,
+                diagnostics: scaffold.diagnostics,
+                provenance: [
+                    toProvenance(repoRoot, "domain_model_scaffold"),
+                    ...(docsRoot ? [toProvenance(docsRoot, "domain_model_scaffold_docs")] : []),
+                ],
+            });
+        },
+        async "doc.extract_glossary"(args, context) {
+            const glossary = await extractGlossary(await buildExtractionOptions(args, context));
+            return createResponse(glossary, {
+                status: glossary.diagnostics.length > 0 ? "warning" : "ok",
+                evidence: glossary.terms.flatMap((term) => term.evidence),
+                confidence: glossary.confidence,
+                unknowns: glossary.unknowns,
+                diagnostics: glossary.diagnostics,
+                provenance: [toProvenance(getDocsRoot(args, context), "doc.extract_glossary")],
+            });
+        },
+        async "doc.extract_rules"(args, context) {
+            const rules = await extractRules(await buildExtractionOptions(args, context));
+            return createResponse(rules, {
+                status: rules.diagnostics.length > 0 ? "warning" : "ok",
+                evidence: rules.rules.flatMap((rule) => rule.evidence),
+                confidence: rules.confidence,
+                unknowns: rules.unknowns,
+                diagnostics: rules.diagnostics,
+                provenance: [toProvenance(getDocsRoot(args, context), "doc.extract_rules")],
+            });
+        },
+        async "doc.extract_invariants"(args, context) {
+            const invariants = await extractInvariants(await buildExtractionOptions(args, context));
+            return createResponse(invariants, {
+                status: invariants.diagnostics.length > 0 ? "warning" : "ok",
+                evidence: invariants.invariants.flatMap((invariant) => invariant.evidence),
+                confidence: invariants.confidence,
+                unknowns: invariants.unknowns,
+                diagnostics: invariants.diagnostics,
+                provenance: [toProvenance(getDocsRoot(args, context), "doc.extract_invariants")],
+            });
+        },
+        async "trace.link_terms"(args, context) {
+            const glossary = await extractGlossary(await buildExtractionOptions(args, context));
+            const codebase = typeof args.repo === "string" ? await parseCodebase(getRootPath(args, context)) : undefined;
+            const links = await buildTermTraceLinks({
+                docsRoot: getDocsRoot(args, context),
+                ...(typeof args.repo === "string" ? { repoRoot: getRootPath(args, context) } : {}),
+                ...(codebase ? { codeFiles: codebase.scorableSourceFiles } : {}),
+                terms: glossary.terms,
+            });
+            return createResponse({
+                links,
+                glossary: glossary.terms,
+                metadata: glossary.metadata,
+            }, {
+                status: glossary.diagnostics.length > 0 ? "warning" : "ok",
+                evidence: glossary.terms.flatMap((term) => term.evidence),
+                confidence: glossary.confidence,
+                unknowns: glossary.unknowns,
+                diagnostics: glossary.diagnostics,
+                provenance: [toProvenance(getDocsRoot(args, context), "trace.link_terms")],
+            });
+        },
+        async "trace.link_model_to_code"(args, context) {
+            const model = await requireDomainModel(args, context);
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse({
+                links: buildModelCodeLinks(model, codebase.scorableSourceFiles),
+            }, {
+                provenance: [toProvenance(getRootPath(args, context), "trace.link_model_to_code")],
+            });
+        },
+        async "code.parse"(args, context) {
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse(codebase);
+        },
+        async "code.detect_dependencies"(args, context) {
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse({ dependencies: codebase.dependencies });
+        },
+        async "code.detect_contract_usage"(args, context) {
+            const model = await requireDomainModel(args, context);
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse(detectContractUsage(codebase, model));
+        },
+        async "code.detect_boundary_leaks"(args, context) {
+            const model = await requireDomainModel(args, context);
+            const codebase = await parseCodebase(getRootPath(args, context));
+            return createResponse({ findings: detectBoundaryLeaks(codebase, model) });
+        },
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { CommandArgs } from "./command-path-helpers.js";
+import type { CommandContext, ExtractionBackend, ExtractionProviderName } from "./core/contracts.js";
+export declare function buildExtractionOptions(args: CommandArgs, context: CommandContext): Promise<{
+    readonly applyReviewLog: boolean;
+    readonly reviewLog?: import("./core/contracts.js").ReviewResolutionLog;
+    readonly promptProfile: string;
+    readonly fallback: "heuristic" | "none";
+    readonly providerCommand?: string;
+    readonly provider?: ExtractionProviderName;
+    readonly root: string;
+    readonly cwd: string;
+    readonly extractor: ExtractionBackend;
+}>;

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

@@ -0,0 +1,33 @@
+import { loadReviewLogIfRequested } from "./command-input-loaders.js";
+import { getDocsRoot } from "./command-path-helpers.js";
+function getExtractor(args) {
+    return args.extractor === "cli" ? "cli" : "heuristic";
+}
+function getProvider(args) {
+    if (args.provider === "codex" || args.provider === "claude") {
+        return args.provider;
+    }
+    return undefined;
+}
+function getPromptProfile(args) {
+    return typeof args["prompt-profile"] === "string" ? args["prompt-profile"] : "default";
+}
+function getFallback(args) {
+    return args.fallback === "none" ? "none" : "heuristic";
+}
+export async function buildExtractionOptions(args, context) {
+    const provider = getProvider(args);
+    const providerCommand = typeof args["provider-cmd"] === "string" ? args["provider-cmd"] : undefined;
+    const reviewLog = await loadReviewLogIfRequested(args, context);
+    return {
+        root: getDocsRoot(args, context),
+        cwd: context.cwd,
+        extractor: getExtractor(args),
+        ...(provider ? { provider } : {}),
+        ...(providerCommand ? { providerCommand } : {}),
+        promptProfile: getPromptProfile(args),
+        fallback: getFallback(args),
+        ...(reviewLog ? { reviewLog } : {}),
+        applyReviewLog: args["apply-review-log"] === true,
+    };
+}

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

@@ -0,0 +1,4 @@
+export { buildExtractionOptions } from "./command-extraction-helpers.js";
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadComplexitySourceConfigIfRequested, loadContractBaselineIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryExportIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationSourceConfigIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTelemetrySourceConfigIfRequested, loadTopologyModelIfRequested, requireArchitectureConstraints, requireDomainModel, requireShadowRolloutBatchSpec, requireShadowRolloutRegistry, } from "./command-input-loaders.js";
+export type { CommandArgs } from "./command-path-helpers.js";
+export { getDocsRoot, getProfile, getRootPath, resolveSpecRelativePath, } from "./command-path-helpers.js";

package/dist/src/command-helpers.js

@@ -0,0 +1,3 @@
+export { buildExtractionOptions } from "./command-extraction-helpers.js";
+export { loadBoundaryMapIfRequested, loadComplexityExportIfRequested, loadComplexitySourceConfigIfRequested, loadContractBaselineIfRequested, loadContractBaselineSourceConfigIfRequested, loadDeliveryExportIfRequested, loadDeliveryNormalizationProfileIfRequested, loadDeliveryObservationsIfRequested, loadDeliveryRawObservationsIfRequested, loadDeliverySourceConfigIfRequested, loadPatternRuntimeNormalizationProfileIfRequested, loadPatternRuntimeObservationsIfRequested, loadPatternRuntimeRawObservationsIfRequested, loadRuntimeObservationsIfRequested, loadScenarioCatalogIfRequested, loadScenarioObservationSourceConfigIfRequested, loadScenarioObservationsIfRequested, loadTelemetryExportIfRequested, loadTelemetryNormalizationProfileIfRequested, loadTelemetryObservationsIfRequested, loadTelemetryRawObservationsIfRequested, loadTelemetrySourceConfigIfRequested, loadTopologyModelIfRequested, requireArchitectureConstraints, requireDomainModel, requireShadowRolloutBatchSpec, requireShadowRolloutRegistry, } from "./command-input-loaders.js";
+export { getDocsRoot, getProfile, getRootPath, resolveSpecRelativePath, } from "./command-path-helpers.js";

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

@@ -0,0 +1,2 @@
+import type { CommandHandler } from "./command-types.js";
+export declare function createHistoryCommands(): Record<string, CommandHandler>;