onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/reconstruct/material-profile-validation.js

@@ -0,0 +1,191 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { isTargetMaterialKind, } from "../target-material-kind.js";
+import { loadReconstructContractRegistry, resolveRegistryRef, } from "./contract-registry.js";
+function isoNow() {
+    return new Date().toISOString();
+}
+function violation(args) {
+    return {
+        code: args.code,
+        message: args.message,
+        subject_id: args.subjectId ?? null,
+    };
+}
+async function readYamlDocument(filePath) {
+    return parseYaml(await fs.readFile(filePath, "utf8"));
+}
+async function writeYamlDocument(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, stringifyYaml(value), "utf8");
+}
+function sourceProfileKey(args) {
+    return `${args.profile_id}\u0000${args.target_material_kind}`;
+}
+function sourceProfileRecordsByKey(registry) {
+    return new Map(registry.source_profile_records.map((record) => [
+        sourceProfileKey(record),
+        record,
+    ]));
+}
+function projectRootFromRegistryPath(registryPath) {
+    if (!registryPath)
+        return process.cwd();
+    return path.resolve(path.dirname(registryPath), "../../..");
+}
+function requiredSelectedProfileFields(registry) {
+    const fields = registry.version_policy?.selected_source_profile_snapshot_required_fields;
+    if (!fields || fields.length === 0) {
+        throw new Error("registry version_policy.selected_source_profile_snapshot_required_fields is required");
+    }
+    return fields;
+}
+function selectedProfileFieldMissing(selected, field) {
+    return selected[field] === undefined;
+}
+export function validateTargetMaterialProfile(args) {
+    const profile = args.targetMaterialProfile;
+    const violations = [];
+    const projectRoot = projectRootFromRegistryPath(args.registryRef);
+    if (!isTargetMaterialKind(profile.target_material_kind)) {
+        violations.push(violation({
+            code: "schema_shape_invalid",
+            message: `invalid target_material_kind: ${profile.target_material_kind}`,
+            subjectId: "target_material_kind",
+        }));
+    }
+    const targetKindRecord = args.contractRegistry.source_profile_records.find((record) => record.target_material_kind === profile.target_material_kind);
+    if (!targetKindRecord) {
+        violations.push(violation({
+            code: "target_kind_registry_record_missing",
+            message: `target material kind has no registry source_profile_records row: ${profile.target_material_kind}`,
+            subjectId: profile.target_material_kind,
+        }));
+    }
+    if (profile.target_refs.length === 0) {
+        violations.push(violation({
+            code: "target_refs_empty",
+            message: "target material profile must include at least one target ref",
+            subjectId: "target_refs",
+        }));
+    }
+    const detectionRefs = new Set(profile.detection.per_ref.map((detection) => path.resolve(detection.ref)));
+    for (const targetRef of profile.target_refs) {
+        if (!detectionRefs.has(path.resolve(targetRef))) {
+            violations.push(violation({
+                code: "detection_ref_mismatch",
+                message: `target ref has no matching detection row: ${targetRef}`,
+                subjectId: targetRef,
+            }));
+        }
+    }
+    if (profile.target_material_kind === "mixed") {
+        const selectedKinds = new Set(profile.selected_source_profiles.map((selected) => selected.target_material_kind));
+        if (!selectedKinds.has("mixed")) {
+            violations.push(violation({
+                code: "mixed_candidate_profile_missing",
+                message: "mixed material profiles must include the registry mixed-source-profile row as the composite authority record",
+                subjectId: "mixed",
+            }));
+        }
+        for (const candidate of profile.target_material_kind_candidates) {
+            if (!selectedKinds.has(candidate)) {
+                violations.push(violation({
+                    code: "mixed_candidate_profile_missing",
+                    message: `mixed material profile is missing per-member selected source profile for ${candidate}`,
+                    subjectId: candidate,
+                }));
+            }
+        }
+    }
+    if (profile.support_status === "supported" ||
+        profile.support_status === "partial" ||
+        profile.support_status === "supported_composite" ||
+        profile.support_status === "partial_composite") {
+        if (profile.selected_source_profiles.length === 0) {
+            violations.push(violation({
+                code: "selected_profile_missing",
+                message: "supported material profile must select at least one source profile",
+                subjectId: "selected_source_profiles",
+            }));
+        }
+    }
+    if ((profile.support_status === "unsupported" ||
+        profile.support_status === "unknown" ||
+        profile.support_status === "reserved_future") &&
+        !profile.unsupported_reason) {
+        violations.push(violation({
+            code: "unsupported_reason_missing",
+            message: "unsupported, unknown, or future-reserved material profiles must explain unsupported_reason",
+            subjectId: "unsupported_reason",
+        }));
+    }
+    const registryProfiles = sourceProfileRecordsByKey(args.contractRegistry);
+    const requiredFields = requiredSelectedProfileFields(args.contractRegistry);
+    for (const selected of profile.selected_source_profiles) {
+        for (const field of requiredFields) {
+            if (selectedProfileFieldMissing(selected, field)) {
+                violations.push(violation({
+                    code: "selected_profile_required_field_missing",
+                    message: `selected source profile ${selected.profile_id} is missing required snapshot field: ${field}`,
+                    subjectId: selected.profile_id,
+                }));
+            }
+        }
+        const registryRecord = registryProfiles.get(sourceProfileKey(selected));
+        if (!registryRecord) {
+            violations.push(violation({
+                code: "selected_profile_registry_mismatch",
+                message: `selected source profile is not present in registry: ${selected.profile_id}`,
+                subjectId: selected.profile_id,
+            }));
+            continue;
+        }
+        const expectedProfileRef = registryRecord.definition_ref === null
+            ? `registry:${registryRecord.profile_id}`
+            : resolveRegistryRef({
+                projectRoot,
+                ref: registryRecord.definition_ref,
+            });
+        const mismatchedFields = [...requiredFields, "profile_ref"].filter((field) => field === "profile_ref"
+            ? selected.profile_ref !== expectedProfileRef
+            : JSON.stringify(selected[field]) !==
+                JSON.stringify(registryRecord[field]));
+        if (mismatchedFields.length > 0) {
+            violations.push(violation({
+                code: "selected_profile_registry_mismatch",
+                message: `selected source profile ${selected.profile_id} does not match registry fields: ${mismatchedFields.join(", ")}`,
+                subjectId: selected.profile_id,
+            }));
+        }
+    }
+    return {
+        schema_version: "1",
+        session_id: profile.session_id,
+        created_at: isoNow(),
+        target_material_profile_ref: args.targetMaterialProfileRef ?? null,
+        registry_ref: args.registryRef ?? null,
+        validation_status: violations.length === 0 ? "valid" : "invalid",
+        target_ref_count: profile.target_refs.length,
+        selected_source_profile_count: profile.selected_source_profiles.length,
+        validation_results: violations.length === 0
+            ? ["target_material_profile_valid"]
+            : ["target_material_profile_invalid"],
+        violations,
+    };
+}
+export async function writeTargetMaterialProfileValidationArtifact(args) {
+    const [targetMaterialProfile, contractRegistry] = await Promise.all([
+        readYamlDocument(args.targetMaterialProfilePath),
+        loadReconstructContractRegistry({ registryPath: args.registryPath }),
+    ]);
+    const validation = validateTargetMaterialProfile({
+        targetMaterialProfile,
+        contractRegistry,
+        targetMaterialProfileRef: path.resolve(args.targetMaterialProfilePath),
+        registryRef: path.resolve(args.registryPath),
+    });
+    await writeYamlDocument(args.outputPath, validation);
+    return validation;
+}

package/dist/core-runtime/reconstruct/materialize-preparation.js

@@ -48,11 +48,21 @@ function supportForMaterial(args) {
             unsupported_reason: "no reconstruct source profile exists for the detected target material kind",
         };
     }
+    const runnableProfiles = args.selectedProfiles.filter((profile) => isRunnableProfileRuntimeStatus(profile.runtime_implementation_status));
+    if (runnableProfiles.length === 0) {
+        return {
+            support_status: "unsupported",
+            unsupported_reason: `selected source profile runtime status is ${args.selectedProfiles.map((profile) => profile.runtime_implementation_status).join(", ")}`,
+        };
+    }
     return {
         support_status: "partial",
         unsupported_reason: "source profile exists, but only minimal structural observation is implemented",
     };
 }
+function isRunnableProfileRuntimeStatus(status) {
+    return status === "partially_wired" || status === "wired" || status === "supported";
+}
 function inventoryUnitForMaterial(kind) {
     switch (kind) {
         case "code":
@@ -69,25 +79,41 @@ function inventoryUnitForMaterial(kind) {
             return "unknown_material_unit";
     }
 }
-function profileRefForKind(profiles, kind) {
-    return profiles.find((profile) => profile.target_material_kind === kind)
-        ?.profile_path ?? null;
-}
 function selectedProfileRefs(profiles, candidates) {
     const selected = [];
     for (const kind of candidates) {
-        const profile = profiles.find((candidate) => candidate.target_material_kind === kind);
+        const profile = defaultProfileForKind(profiles, kind);
         if (!profile)
             continue;
         selected.push({
+            profile_id: profile.profile_id,
             target_material_kind: profile.target_material_kind,
+            is_default_for_kind: profile.is_default_for_kind,
+            definition_ref: profile.definition_ref,
+            definition_sha256: profile.definition_sha256,
             profile_ref: profile.profile_path,
+            contract_status: profile.contract_status,
+            runtime_implementation_status: profile.runtime_implementation_status,
+            schema_version: profile.schema_version,
+            profile_version: profile.profile_version,
+            migration_status: profile.migration_status,
+            supersedes: profile.supersedes,
+            replaced_by: profile.replaced_by,
+            split_from: profile.split_from,
+            split_into: profile.split_into,
+            merged_from: profile.merged_from,
+            merged_into: profile.merged_into,
             support_summary: profile.support_summary,
             scan_targets: profile.scan_targets,
         });
     }
     return selected;
 }
+function defaultProfileForKind(profiles, kind) {
+    const matchingProfiles = profiles.filter((candidate) => candidate.target_material_kind === kind);
+    return matchingProfiles.find((candidate) => candidate.is_default_for_kind) ??
+        matchingProfiles[0];
+}
 async function textStats(ref) {
     try {
         const text = await fs.readFile(ref, "utf8");
@@ -95,6 +121,7 @@ async function textStats(ref) {
         return {
             line_count: text.length === 0 ? 0 : text.split(/\r?\n/).length,
             char_count: text.length,
+            content_sha256: crypto.createHash("sha256").update(text).digest("hex"),
             content_excerpt: text.slice(0, excerptLimit),
             excerpt_truncated: text.length > excerptLimit,
         };
@@ -103,6 +130,7 @@ async function textStats(ref) {
         return {
             line_count: null,
             char_count: null,
+            content_sha256: null,
             content_excerpt: null,
             excerpt_truncated: false,
         };
@@ -118,6 +146,7 @@ async function buildObservation(detection) {
     const stats = stat.isFile() ? await textStats(detection.ref) : {
         line_count: null,
         char_count: null,
+        content_sha256: null,
         content_excerpt: null,
         excerpt_truncated: false,
     };
@@ -139,6 +168,7 @@ async function buildObservation(detection) {
             size_bytes: stat.isFile() ? stat.size : null,
             line_count: stats.line_count,
             char_count: stats.char_count,
+            content_sha256: stats.content_sha256,
             content_excerpt: stats.content_excerpt,
             excerpt_truncated: stats.excerpt_truncated,
         },
@@ -185,10 +215,15 @@ function buildInitialSourceFrontier(args) {
 }
 function buildInventoryUnits(args) {
     return args.detections.map((detection) => {
-        const profileRef = profileRefForKind(args.profiles, detection.kind);
+        const profile = defaultProfileForKind(args.profiles, detection.kind);
+        const profileRef = profile?.profile_path ?? null;
+        const runnable = profile
+            ? isRunnableProfileRuntimeStatus(profile.runtime_implementation_status)
+            : false;
         const planned = detection.exists &&
             isConcreteTargetMaterialKind(detection.kind) &&
-            profileRef !== null;
+            profileRef !== null &&
+            runnable;
         return {
             ref: detection.ref,
             exists: detection.exists,
@@ -199,7 +234,9 @@ function buildInventoryUnits(args) {
             skip_reason: planned
                 ? null
                 : detection.exists
-                    ? `no runnable source adapter for target_material_kind=${detection.kind}`
+                    ? profile
+                        ? `source profile ${profile.profile_id} runtime_implementation_status=${profile.runtime_implementation_status}`
+                        : `no reconstruct source profile for target_material_kind=${detection.kind}`
                     : "target ref does not exist",
         };
     });
@@ -214,9 +251,10 @@ export async function materializeReconstructPreparationArtifacts(params) {
     const profiles = await loadReconstructSourceProfiles(params.profilesRoot);
     const perRefDetections = await detectTargetMaterialRefs(targetRefs);
     const detection = aggregateTargetMaterialDetections(perRefDetections);
-    const selectedProfiles = selectedProfileRefs(profiles, detection.target_material_kind === "mixed"
-        ? detection.target_material_kind_candidates
-        : [detection.target_material_kind]);
+    const profileCandidateKinds = detection.target_material_kind === "mixed"
+        ? ["mixed", ...detection.target_material_kind_candidates]
+        : [detection.target_material_kind];
+    const selectedProfiles = selectedProfileRefs(profiles, profileCandidateKinds);
     const support = supportForMaterial({
         targetMaterialKind: detection.target_material_kind,
         selectedProfiles,