onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/reconstruct/seed-claim-projections.js

@@ -0,0 +1,268 @@
+function uniqueEvidenceRefs(refs) {
+    const byKey = new Map();
+    for (const ref of refs) {
+        byKey.set(`${ref.observation_id}\u0000${ref.target_material_kind}\u0000${ref.source_ref}\u0000${ref.location}`, ref);
+    }
+    return [...byKey.values()];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function recordValue(value) {
+    return isRecord(value) ? value : null;
+}
+function recordArray(owner, key) {
+    const value = owner?.[key];
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : null;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+}
+function evidenceRefs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => isRecord(item) &&
+        typeof item.observation_id === "string" &&
+        typeof item.target_material_kind === "string" &&
+        typeof item.source_ref === "string" &&
+        typeof item.location === "string");
+}
+function directEvidence(record) {
+    return record ? uniqueEvidenceRefs(evidenceRefs(record.evidence_refs)) : [];
+}
+function purposeClaimId(seedId) {
+    return seedId ? `${seedId}#purpose` : "ontology-seed-purpose";
+}
+function claim(args) {
+    if (!args.id)
+        return null;
+    return {
+        claim_id: args.id,
+        seed_ref_path: args.seed_ref_path,
+        projection_source: "actionable_ontology_seed",
+        evidence_policy: "direct_evidence_only",
+        name: args.name ?? args.fallbackName,
+        statement: args.statement ?? args.name ?? args.fallbackName,
+        evidence_refs: args.evidence_refs,
+    };
+}
+function collectRecordClaims(args) {
+    return args.records
+        .map((record, index) => claim({
+        id: stringValue(record[args.idKey]),
+        seed_ref_path: `${args.pathPrefix}[${index}].${args.idKey}`,
+        name: args.nameKeys.map((key) => stringValue(record[key])).find(Boolean) ?? null,
+        statement: args.statementKeys.map((key) => stringValue(record[key])).find(Boolean) ?? null,
+        evidence_refs: directEvidence(record),
+        fallbackName: `${args.fallbackPrefix} ${index + 1}`,
+    }))
+        .filter((item) => item !== null);
+}
+export function ontologySeedClaimProjections(ontologySeed) {
+    const seed = recordValue(ontologySeed) ?? {};
+    const seedIdentity = recordValue(seed.seed_identity);
+    const purpose = recordValue(seed.purpose);
+    const conceptualFrame = recordValue(seed.conceptual_frame);
+    const semanticLayer = recordValue(seed.semantic_layer);
+    const kineticLayer = recordValue(seed.kinetic_layer);
+    const dynamicLayer = recordValue(seed.dynamic_layer);
+    const dataBindingLayer = recordValue(seed.data_binding_layer);
+    const purposeClaim = claim({
+        id: purposeClaimId(stringValue(seedIdentity?.seed_id)),
+        seed_ref_path: "purpose.declared_purpose",
+        name: stringValue(seedIdentity?.title) ?? "Ontology Seed Purpose",
+        statement: stringValue(purpose?.declared_purpose),
+        evidence_refs: directEvidence(purpose),
+        fallbackName: "Ontology Seed Purpose",
+    });
+    return [
+        ...(purposeClaim ? [purposeClaim] : []),
+        ...collectRecordClaims({
+            records: recordArray(conceptualFrame, "concepts"),
+            idKey: "concept_id",
+            nameKeys: ["name"],
+            statementKeys: ["definition", "purpose_role"],
+            fallbackPrefix: "Concept",
+            pathPrefix: "conceptual_frame.concepts",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(conceptualFrame, "associations"),
+            idKey: "association_id",
+            nameKeys: ["association_kind"],
+            statementKeys: ["statement"],
+            fallbackPrefix: "Association",
+            pathPrefix: "conceptual_frame.associations",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(semanticLayer, "object_types"),
+            idKey: "object_type_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Object Type",
+            pathPrefix: "semantic_layer.object_types",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(semanticLayer, "link_types"),
+            idKey: "link_type_id",
+            nameKeys: ["business_meaning"],
+            statementKeys: ["business_meaning"],
+            fallbackPrefix: "Link Type",
+            pathPrefix: "semantic_layer.link_types",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(semanticLayer, "value_types"),
+            idKey: "value_type_id",
+            nameKeys: ["name"],
+            statementKeys: ["representation"],
+            fallbackPrefix: "Value Type",
+            pathPrefix: "semantic_layer.value_types",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(semanticLayer, "constraints"),
+            idKey: "constraint_id",
+            nameKeys: ["constraint_kind"],
+            statementKeys: ["statement"],
+            fallbackPrefix: "Constraint",
+            pathPrefix: "semantic_layer.constraints",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dynamicLayer, "actor_types"),
+            idKey: "actor_type_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Actor Type",
+            pathPrefix: "dynamic_layer.actor_types",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dynamicLayer, "actor_roles"),
+            idKey: "role_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Actor Role",
+            pathPrefix: "dynamic_layer.actor_roles",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dynamicLayer, "permission_policies"),
+            idKey: "policy_id",
+            nameKeys: ["permission_kind"],
+            statementKeys: ["condition", "permission_kind"],
+            fallbackPrefix: "Permission Policy",
+            pathPrefix: "dynamic_layer.permission_policies",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dynamicLayer, "state_models"),
+            idKey: "state_model_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "State Model",
+            pathPrefix: "dynamic_layer.state_models",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dynamicLayer, "lifecycle_rules"),
+            idKey: "rule_id",
+            nameKeys: ["name", "rule_kind"],
+            statementKeys: ["statement", "description"],
+            fallbackPrefix: "Lifecycle Rule",
+            pathPrefix: "dynamic_layer.lifecycle_rules",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(kineticLayer, "action_types"),
+            idKey: "action_type_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Action Type",
+            pathPrefix: "kinetic_layer.action_types",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(kineticLayer, "functions"),
+            idKey: "function_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Function",
+            pathPrefix: "kinetic_layer.functions",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(kineticLayer, "workflows"),
+            idKey: "workflow_id",
+            nameKeys: ["name"],
+            statementKeys: ["description"],
+            fallbackPrefix: "Workflow",
+            pathPrefix: "kinetic_layer.workflows",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dataBindingLayer, "source_bindings"),
+            idKey: "binding_id",
+            nameKeys: ["binding_kind"],
+            statementKeys: ["statement"],
+            fallbackPrefix: "Source Binding",
+            pathPrefix: "data_binding_layer.source_bindings",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dataBindingLayer, "read_models"),
+            idKey: "read_model_id",
+            nameKeys: ["name"],
+            statementKeys: ["transformation_summary"],
+            fallbackPrefix: "Read Model",
+            pathPrefix: "data_binding_layer.read_models",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dataBindingLayer, "writebacks"),
+            idKey: "writeback_id",
+            nameKeys: ["name"],
+            statementKeys: ["writeback_summary", "description"],
+            fallbackPrefix: "Writeback",
+            pathPrefix: "data_binding_layer.writebacks",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(dataBindingLayer, "provenance_bindings"),
+            idKey: "provenance_id",
+            nameKeys: ["author_or_system"],
+            statementKeys: ["timestamp_ref", "statement"],
+            fallbackPrefix: "Provenance Binding",
+            pathPrefix: "data_binding_layer.provenance_bindings",
+        }),
+        ...collectRecordClaims({
+            records: recordArray(seed, "handoff_limitations"),
+            idKey: "limitation_id",
+            nameKeys: ["limitation_kind"],
+            statementKeys: ["description", "mitigation_or_next_action"],
+            fallbackPrefix: "Handoff Limitation",
+            pathPrefix: "handoff_limitations",
+        }),
+    ];
+}
+export function ontologySeedExcludedClaimIds(ontologySeed) {
+    const seed = recordValue(ontologySeed) ?? {};
+    return new Set(recordArray(seed, "handoff_limitations")
+        .map((limitation) => stringValue(limitation.limitation_id))
+        .filter((id) => id !== null));
+}
+export function ontologySeedAnswerabilitySummary(ontologySeed) {
+    const seed = recordValue(ontologySeed) ?? {};
+    const validationLayer = recordValue(seed.validation_layer);
+    const kineticLayer = recordValue(seed.kinetic_layer);
+    const handoffLimitations = recordArray(seed, "handoff_limitations");
+    const coverageAxes = stringArray(validationLayer?.coverage_axes);
+    const unsupportedQuestionCandidates = recordArray(validationLayer, "unsupported_question_candidates");
+    const actionTypes = recordArray(kineticLayer, "action_types");
+    const actionIds = new Set(actionTypes
+        .map((action) => stringValue(action.action_type_id))
+        .filter((id) => id !== null));
+    const limitedActionIds = new Set(handoffLimitations.flatMap((limitation) => stringArray(limitation.affected_refs))
+        .filter((ref) => actionIds.has(ref)));
+    return {
+        declared_question_count: coverageAxes.length,
+        supported_question_count: Math.max(0, coverageAxes.length - unsupportedQuestionCandidates.length),
+        deferred_question_count: handoffLimitations.length,
+        unsupported_question_count: unsupportedQuestionCandidates.length,
+        supported_action_count: Math.max(0, actionTypes.length - limitedActionIds.size),
+        unsupported_action_count: limitedActionIds.size,
+    };
+}

package/dist/core-runtime/reconstruct/source-profiles.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { isTargetMaterialKind, } from "../target-material-kind.js";
+import { loadReconstructContractRegistry, projectRootFromProfilesRoot, resolveRegistryRef, validateSourceProfileDefinitionHashes, } from "./contract-registry.js";
 const TARGET_MATERIAL_KIND_PATTERN = /^>\s*Target material kind:\s*`([^`]+)`\s*$/m;
 function firstMarkdownHeading(markdown) {
     const match = markdown.match(/^#\s+(.+)$/m);
@@ -20,11 +21,14 @@ function sectionBody(markdown, heading) {
     return bodyLines.join("\n").trim();
 }
 function compactSectionText(markdown, heading) {
-    return sectionBody(markdown, heading)
+    const compacted = sectionBody(markdown, heading)
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter((line) => line.length > 0)
         .join(" ");
+    return compacted.length > 0
+        ? compacted
+        : "Source profile definition only; support and migration status are registry-owned.";
 }
 function parseScanTargets(markdown) {
     return sectionBody(markdown, "Scan Targets")
@@ -40,15 +44,97 @@ export function parseReconstructSourceProfile(args) {
     if (!isTargetMaterialKind(rawKind)) {
         throw new Error(`Invalid or missing target material kind in source profile: ${args.profilePath}`);
     }
-    return {
+    if (args.record && args.record.target_material_kind !== rawKind) {
+        throw new Error(`Source profile ${args.profilePath} target_material_kind=${rawKind} does not match registry target_material_kind=${args.record.target_material_kind}`);
+    }
+    const fallbackRecord = args.record ?? {
+        profile_id: `${rawKind}-source-profile`,
         target_material_kind: rawKind,
+        is_default_for_kind: true,
+        definition_ref: args.profilePath,
+        definition_sha256: "unknown",
+        contract_status: "profile_file_only",
+        runtime_implementation_status: "unknown",
+        schema_version: 1,
+        profile_version: 1,
+        migration_status: "unknown",
+        supersedes: [],
+        replaced_by: [],
+        split_from: [],
+        split_into: [],
+        merged_from: [],
+        merged_into: [],
+    };
+    return {
+        ...fallbackRecord,
         profile_path: path.resolve(args.profilePath),
         title: firstMarkdownHeading(args.markdown),
-        support_summary: compactSectionText(args.markdown, "Support Status"),
+        support_summary: args.record
+            ? [
+                `contract_status=${args.record.contract_status}`,
+                `runtime_implementation_status=${args.record.runtime_implementation_status}`,
+                `schema_version=${args.record.schema_version}`,
+                `profile_version=${args.record.profile_version}`,
+                `migration_status=${args.record.migration_status}`,
+            ].join("; ")
+            : compactSectionText(args.markdown, "Support Status"),
         scan_targets: parseScanTargets(args.markdown),
     };
 }
+async function fileExists(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function loadProfilesFromRegistry(args) {
+    if (!(await fileExists(args.registryPath)))
+        return null;
+    const registry = await loadReconstructContractRegistry({
+        registryPath: args.registryPath,
+    });
+    const projectRoot = projectRootFromProfilesRoot(args.profilesRoot);
+    await validateSourceProfileDefinitionHashes({ projectRoot, registry });
+    const records = registry.source_profile_records
+        .sort((left, right) => left.profile_id.localeCompare(right.profile_id));
+    return Promise.all(records.map(async (record) => {
+        if (record.definition_ref === null) {
+            return {
+                ...record,
+                profile_path: `registry:${record.profile_id}`,
+                title: `Source Profile Registry Record: ${record.profile_id}`,
+                support_summary: [
+                    `contract_status=${record.contract_status}`,
+                    `runtime_implementation_status=${record.runtime_implementation_status}`,
+                    `schema_version=${record.schema_version}`,
+                    `profile_version=${record.profile_version}`,
+                    `migration_status=${record.migration_status}`,
+                    "definition_ref=null",
+                ].join("; "),
+                scan_targets: [],
+            };
+        }
+        const profilePath = resolveRegistryRef({
+            projectRoot,
+            ref: record.definition_ref,
+        });
+        return parseReconstructSourceProfile({
+            profilePath,
+            markdown: await fs.readFile(profilePath, "utf8"),
+            record,
+        });
+    }));
+}
 export async function loadReconstructSourceProfiles(profilesRoot) {
+    const registryProfiles = await loadProfilesFromRegistry({
+        profilesRoot,
+        registryPath: path.join(path.dirname(path.resolve(profilesRoot)), "reconstruct-contract-registry.yaml"),
+    });
+    if (registryProfiles)
+        return registryProfiles;
     const entries = await fs.readdir(profilesRoot, { withFileTypes: true });
     const profilePaths = entries
         .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
@@ -69,5 +155,8 @@ export async function loadReconstructSourceProfiles(profilesRoot) {
 }
 export async function resolveReconstructSourceProfile(args) {
     const profiles = await loadReconstructSourceProfiles(args.profilesRoot);
-    return (profiles.find((profile) => profile.target_material_kind === args.targetMaterialKind) ?? null);
+    const matchingProfiles = profiles.filter((profile) => profile.target_material_kind === args.targetMaterialKind);
+    return matchingProfiles.find((profile) => profile.is_default_for_kind) ??
+        matchingProfiles[0] ??
+        null;
 }