onto-mcp 0.3.0 → 0.3.2

package/dist/core-api/reconstruct-api.js

@@ -2,12 +2,16 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
+import { RECONSTRUCT_STAGE_IDS, } from "../core-runtime/reconstruct/artifact-types.js";
 import { materializeReconstructPreparationArtifacts, } from "../core-runtime/reconstruct/materialize-preparation.js";
 import { assembleReconstructRecord, } from "../core-runtime/reconstruct/record.js";
-import { createAutoAcceptReconstructConfirmationProvider, createMockReconstructDirectiveAuthor, runReconstruct, } from "../core-runtime/reconstruct/run.js";
+import { createAutoAcceptReconstructConfirmationProvider, createDirectCallReconstructConfirmationProvider, createDirectCallReconstructDirectiveAuthor, createMockReconstructDirectiveAuthor, runReconstruct, } from "../core-runtime/reconstruct/run.js";
+import { resolveSettingsChain, } from "../core-runtime/discovery/settings-chain.js";
+import { resolveLlmProviderConfig, } from "../core-runtime/llm/llm-caller.js";
 import { writeSeedCandidateValidationArtifact, } from "../core-runtime/reconstruct/seed-candidate-validation.js";
 import { writeSourceObservationDirectiveValidationArtifact, } from "../core-runtime/reconstruct/directive-validation.js";
 import { loadReconstructSourceProfiles, } from "../core-runtime/reconstruct/source-profiles.js";
+import { buildReconstructPipelineExecutionLedger, } from "../core-runtime/reconstruct/pipeline-execution-ledger.js";
 async function directoryExists(directoryPath) {
     try {
         const stat = await fs.stat(directoryPath);
@@ -75,10 +79,66 @@ async function readTextIfPresent(filePath) {
         return null;
     }
 }
+function deriveReconstructProgress(args) {
+    const stepById = new Map(args.runManifest?.steps.map((step) => [step.step_id, step]) ?? []);
+    const stages = RECONSTRUCT_STAGE_IDS.map((stageId) => {
+        const step = stepById.get(stageId);
+        return {
+            stageId,
+            state: step?.status === "completed"
+                ? "completed"
+                : step?.status === "skipped"
+                    ? "skipped"
+                    : step?.status === "failed"
+                        ? "halted"
+                        : "pending",
+            owner: step?.owner ?? null,
+            artifactRefs: step?.artifact_refs ?? [],
+            reason: step?.reason ?? null,
+            authorityImpact: step?.authority_impact ?? null,
+        };
+    });
+    const lastReachedStage = [...stages].reverse().find((stage) => stage.state !== "pending") ??
+        stages[0];
+    return {
+        executionProfile: args.runManifest?.execution_profile ?? null,
+        currentStageId: lastReachedStage.stageId,
+        stageCount: RECONSTRUCT_STAGE_IDS.length,
+        liveness: {
+            state: args.record.record_stage === "completed"
+                ? "completed"
+                : "halted_or_partial",
+            recommendedPollIntervalMs: args.record.record_stage === "completed" ? null : 1000,
+        },
+        countSummary: {
+            sourceObservationCount: args.metrics?.source_observation_count ?? null,
+            selectedObservationCount: args.metrics?.selected_observation_count ?? null,
+            semanticClaimCount: args.metrics?.semantic_claim_count ??
+                args.record.validation_summary.semantic_claim_count,
+            confirmedClaimCount: args.metrics?.confirmed_claim_count ??
+                args.record.validation_summary.confirmed_claim_count,
+            partialClaimCount: args.metrics?.partial_claim_count ??
+                args.record.validation_summary.partial_claim_count,
+            deferredClaimCount: args.metrics?.deferred_claim_count ??
+                args.record.validation_summary.deferred_claim_count,
+            competencyQuestionCount: args.metrics?.competency_question_count ??
+                args.record.validation_summary.competency_question_count,
+            assessmentCount: args.metrics?.competency_question_assessment_count ??
+                args.record.validation_summary.competency_question_assessment_count,
+            failureCount: args.record.validation_summary.failure_count,
+            revisionProposalCount: args.record.validation_summary.revision_proposal_count,
+            unresolvedCount: args.metrics?.unresolved_question_count ??
+                args.record.validation_summary.unresolved_count,
+            passRate: args.metrics?.pass_rate ?? args.record.validation_summary.pass_rate,
+        },
+        stages,
+    };
+}
 function recordArtifactRefsFromPreparation(refs) {
     return {
         target_material_profile: refs.target_material_profile,
         source_inventory: refs.source_inventory,
+        initial_source_frontier: refs.initial_source_frontier,
         source_observations: refs.source_observations,
     };
 }
@@ -143,16 +203,27 @@ export function createOntoReconstructCoreApi(options = {}) {
                 ...(ontoHome ? { ontoHome } : {}),
             });
             const targetRefs = request.targetRefs.map((targetRef) => resolveFromBase(projectRoot, targetRef));
+            const settings = await resolveSettingsChain(ontoHome ?? projectRoot, projectRoot);
+            const llmConfig = resolveLlmProviderConfig({ config: settings });
+            const semanticAuthorRealization = request.semanticAuthorRealization ?? "direct_call";
+            const confirmationProviderRealization = request.confirmationProviderRealization ?? "direct_call";
+            const directiveAuthor = semanticAuthorRealization === "mock"
+                ? createMockReconstructDirectiveAuthor()
+                : createDirectCallReconstructDirectiveAuthor({ llmConfig });
+            const confirmationProvider = confirmationProviderRealization === "mock"
+                ? createAutoAcceptReconstructConfirmationProvider()
+                : createDirectCallReconstructConfirmationProvider({ llmConfig });
             return runReconstruct({
                 projectRoot,
                 targetRefs,
                 intent: request.intent,
                 sessionRoot,
                 profilesRoot,
-                semanticAuthorRealization: request.semanticAuthorRealization,
-                confirmationProviderRealization: request.confirmationProviderRealization,
-                directiveAuthor: createMockReconstructDirectiveAuthor(),
-                confirmationProvider: createAutoAcceptReconstructConfirmationProvider(),
+                semanticAuthorRealization,
+                confirmationProviderRealization,
+                directiveAuthor,
+                confirmationProvider,
+                llmConfig,
                 filesystemAllowedRoots: request.filesystemAllowedRoots?.map((root) => resolveFromBase(projectRoot, root)) ??
                     [projectRoot],
             });
@@ -198,11 +269,27 @@ export function createOntoReconstructCoreApi(options = {}) {
         async getRunStatus(sessionRoot) {
             const resolvedSessionRoot = path.resolve(sessionRoot);
             const reconstructRecord = await readYamlArtifact(path.join(resolvedSessionRoot, "reconstruct-record.yaml"));
+            const reconstructRunManifest = await readYamlArtifactIfPresent(reconstructRecord.artifact_refs.reconstruct_run_manifest);
+            const reconstructMetrics = await readYamlArtifactIfPresent(reconstructRecord.artifact_refs.reconstruct_metrics);
+            const reconstructRecordRef = path.join(resolvedSessionRoot, "reconstruct-record.yaml");
+            const pipelineExecutionLedger = await buildReconstructPipelineExecutionLedger({
+                sessionRoot: resolvedSessionRoot,
+                reconstructRecord,
+                reconstructRecordRef,
+                reconstructRunManifest,
+                reconstructRunManifestRef: reconstructRecord.artifact_refs.reconstruct_run_manifest,
+            });
             return {
                 sessionId: path.basename(resolvedSessionRoot),
                 sessionRoot: resolvedSessionRoot,
                 status: reconstructRecord.record_stage,
                 artifactRefs: reconstructRecord.artifact_refs,
+                progress: deriveReconstructProgress({
+                    record: reconstructRecord,
+                    runManifest: reconstructRunManifest,
+                    metrics: reconstructMetrics,
+                }),
+                pipelineExecutionLedger,
                 reconstructRecord,
             };
         },