@interf/compiler 0.5.0 → 0.6.1

package/dist/lib/runtime-reconcile.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
-import { join, relative } from "node:path";
+import { extname, join, relative } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
 import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { parseJsonFrontmatter } from "./parse.js";
@@ -7,7 +7,7 @@ import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
 import { compiledRuntimeRoot } from "./compiled-paths.js";
-import { isOutputMarkdownFile } from "./validate.js";
+import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
     if (!run)
@@ -49,72 +49,101 @@ function summaryAbstract(content) {
     const parsed = parseJsonFrontmatter(content);
     if (!parsed)
         return null;
-    const frontmatterAbstract = typeof parsed.frontmatter.abstract === "string"
-        ? parsed.frontmatter.abstract.trim()
-        : "";
-    if (frontmatterAbstract.length > 0)
-        return frontmatterAbstract;
-    const match = parsed.body.match(/^## Abstract\s+([\s\S]*?)(?:\n## |\n# |$)/m);
-    const bodyAbstract = match?.[1]?.trim() ?? "";
-    return bodyAbstract.length > 0 ? bodyAbstract : null;
+    return extractSynthAbstract(parsed.frontmatter, parsed.body);
+}
+function listZoneArtifacts(dirPath, zone) {
+    const absolutePath = compiledZoneAbsolutePath(dirPath, zone);
+    if (!existsSync(absolutePath) || zone.kind === "runtime")
+        return [];
+    if (zone.kind === "file") {
+        try {
+            return statSync(absolutePath).isFile() ? [absolutePath] : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return listFilesRecursive(absolutePath);
+}
+function buildInventoryMetadata(options) {
+    const metadata = {
+        zone_id: options.zoneId,
+        zone_kind: options.zoneKind,
+        file_extension: extname(options.filePath).toLowerCase() || null,
+    };
+    if (!options.parsedFrontmatter) {
+        return metadata;
+    }
+    metadata.frontmatter_scanned = true;
+    const abstract = summaryAbstract(readFileSync(options.filePath, "utf8"));
+    if (abstract) {
+        metadata.abstract = abstract;
+        metadata.abstract_read = true;
+    }
+    const frontmatter = options.parsedFrontmatter.frontmatter;
+    if (typeof frontmatter.source_kind === "string") {
+        metadata.source_kind = frontmatter.source_kind;
+    }
+    if (typeof frontmatter.evidence_tier === "string") {
+        metadata.evidence_tier = frontmatter.evidence_tier;
+    }
+    if (typeof frontmatter.truth_mode === "string") {
+        metadata.truth_mode = frontmatter.truth_mode;
+    }
+    return metadata;
 }
 function buildStageInventoryEntries(dirPath, stage) {
     const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
     if (!schema)
         return [];
-    const inputZone = stage.reads
+    const readableInputZones = stage.reads
         .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .find((zone) => zone && zone.kind !== "runtime");
-    const outputZone = stage.writes
+        .filter((zone) => zone !== null && zone.kind !== "runtime");
+    const outputZones = stage.writes
         .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .find((zone) => zone && zone.kind !== "runtime");
-    if (!inputZone || !outputZone)
+        .filter((zone) => zone !== null && zone.kind !== "runtime");
+    if (outputZones.length === 0)
         return [];
-    const outputRoot = compiledZoneAbsolutePath(dirPath, outputZone);
-    if (!existsSync(outputRoot))
-        return [];
-    return listFilesRecursive(outputRoot, isOutputMarkdownFile)
-        .map((filePath) => {
-        const content = readFileSync(filePath, "utf8");
-        const parsed = parseJsonFrontmatter(content);
-        if (!parsed)
-            return null;
-        const inputPath = typeof parsed.frontmatter.source === "string"
-            ? parsed.frontmatter.source.trim()
-            : typeof parsed.frontmatter.source_file === "string"
-                ? parsed.frontmatter.source_file.trim()
-                : typeof parsed.frontmatter.raw === "string"
-                    ? parsed.frontmatter.raw.trim()
-                    : "";
-        if (inputPath.length === 0)
-            return null;
-        const abstract = summaryAbstract(content);
-        return {
-            input_zone: inputZone.id,
-            input_path: inputPath,
-            output_zone: outputZone.id,
-            output_path: relative(dirPath, filePath).replaceAll("\\", "/"),
-            state: typeof parsed.frontmatter.state === "string"
-                ? parsed.frontmatter.state
-                : "complete",
-            metadata: {
-                source_kind: typeof parsed.frontmatter.source_kind === "string"
-                    ? parsed.frontmatter.source_kind
-                    : "unknown",
-                evidence_tier: typeof parsed.frontmatter.evidence_tier === "string"
-                    ? parsed.frontmatter.evidence_tier
-                    : "primary",
-                truth_mode: typeof parsed.frontmatter.truth_mode === "string"
-                    ? parsed.frontmatter.truth_mode
-                    : "reported-data",
-                abstract,
-                frontmatter_scanned: true,
-                abstract_read: Boolean(abstract),
-            },
-        };
-    })
-        .filter((entry) => entry !== null)
-        .sort((left, right) => left.input_path.localeCompare(right.input_path));
+    const entries = [];
+    for (const outputZone of outputZones) {
+        for (const filePath of listZoneArtifacts(dirPath, outputZone)) {
+            const relativeOutputPath = relative(dirPath, filePath).replaceAll("\\", "/");
+            const parsed = isOutputMarkdownFile(filePath)
+                ? parseJsonFrontmatter(readFileSync(filePath, "utf8"))
+                : null;
+            const sourcePath = typeof parsed?.frontmatter.source === "string"
+                ? parsed.frontmatter.source.trim()
+                : "";
+            const sourceZoneId = typeof parsed?.frontmatter.source_zone === "string"
+                ? parsed.frontmatter.source_zone.trim()
+                : "";
+            const inputZone = sourceZoneId.length > 0
+                ? readableInputZones.find((zone) => zone.id === sourceZoneId) ?? null
+                : readableInputZones.length === 1
+                    ? readableInputZones[0]
+                    : null;
+            entries.push({
+                ...(inputZone && sourcePath.length > 0
+                    ? {
+                        input_zone: inputZone.id,
+                        input_path: sourcePath,
+                    }
+                    : {}),
+                output_zone: outputZone.id,
+                output_path: relativeOutputPath,
+                ...(typeof parsed?.frontmatter.state === "string"
+                    ? { state: parsed.frontmatter.state }
+                    : {}),
+                metadata: buildInventoryMetadata({
+                    zoneId: outputZone.id,
+                    zoneKind: outputZone.kind,
+                    filePath,
+                    parsedFrontmatter: parsed,
+                }),
+            });
+        }
+    }
+    return entries.sort((left, right) => `${left.output_zone}:${left.output_path}`.localeCompare(`${right.output_zone}:${right.output_path}`));
 }
 function writeStageInventory(dirPath, stageId, entries) {
     writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
@@ -137,10 +166,7 @@ export function reconcileCompiledStageRun(dirPath, stage) {
     if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
         return false;
     }
-    const inventoryEntries = buildStageInventoryEntries(dirPath, stage);
-    if (inventoryEntries.length > 0) {
-        writeStageInventory(dirPath, stage.id, inventoryEntries);
-    }
+    writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
     const currentState = {
         ...initCompiledState(),
         ...(loadState(dirPath) ?? {}),

package/dist/lib/runtime-runs.js

@@ -5,7 +5,7 @@ import { countFilesRecursive } from "./filesystem.js";
 import { buildRuntimeExecutorInfo } from "./executors.js";
 import { RuntimeRunSchema, } from "./schema.js";
 import { getWorkflowStageDefinition, getWorkflowStagePosition, getWorkflowStages, } from "./workflow-definitions.js";
-import { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 import { warnInterf } from "./logger.js";
 export function loadRuntimeRun(dirPath) {
     const path = runPath(dirPath);
@@ -16,7 +16,8 @@ export function loadRuntimeRun(dirPath) {
         const parsed = RuntimeRunSchema.safeParse(raw);
         if (parsed.success)
             return parsed.data;
-        return normalizeRuntimeRunRecord(raw);
+        warnInterf(`Warning: failed to validate runtime run at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
     }
     catch (error) {
         warnInterf(`Warning: failed to read runtime run at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -33,28 +34,34 @@ export function writeStageContract(dirPath, contract) {
     writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
     return path;
 }
+function writeArchivedStageContract(dirPath, runId, contract) {
+    const path = archivedStageContractPath(dirPath, runId);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
+    return path;
+}
 export async function runExecutorStage(options) {
-    const run = startRuntimeRun(options);
-    const prompt = options.buildPrompt(run.contract_path);
-    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    const startedRun = startRuntimeRun(options);
+    const prompt = options.buildPrompt(startedRun.activeContractPath);
+    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
     const executionPath = options.executionPath ?? options.compiledPath;
     const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
     });
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
 }
 export async function runExecutorSummarizeStage(options) {
-    const run = startRuntimeRun(options);
-    const prompt = options.buildPrompt(run.contract_path);
+    const startedRun = startRuntimeRun(options);
+    const prompt = options.buildPrompt(startedRun.activeContractPath);
     let lastReported = 0;
-    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
     const executionPath = options.executionPath ?? options.compiledPath;
     const progressPromise = options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
     });
     const timer = setInterval(() => {
@@ -65,7 +72,7 @@ export async function runExecutorSummarizeStage(options) {
         lastReported = completed;
         updateRuntimeRun(options.compiledPath, {
             counts: {
-                ...run.counts,
+                ...startedRun.run.counts,
                 completed_summaries: completed,
                 target_summaries: options.targetCount,
             },
@@ -163,7 +170,8 @@ function startRuntimeRun(options) {
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };
-    const contractPath = writeStageContract(options.compiledPath, contract);
+    const activeContractPath = writeStageContract(options.compiledPath, contract);
+    const archivedContractPath = writeArchivedStageContract(options.compiledPath, runId, contract);
     const run = {
         kind: "interf-run",
         version: 1,
@@ -179,7 +187,7 @@ function startRuntimeRun(options) {
         started_at: generatedAt,
         updated_at: generatedAt,
         finished_at: null,
-        contract_path: relative(options.compiledPath, contractPath),
+        contract_path: relative(options.compiledPath, archivedContractPath),
         ...(options.executionPath ? { execution_path: relative(options.compiledPath, options.executionPath) } : {}),
         counts: { ...contract.counts },
         output_artifacts: [...contract.artifacts.writes],
@@ -192,7 +200,12 @@ function startRuntimeRun(options) {
         exit_code: null,
         error: null,
     };
-    return beginRuntimeRun(options.compiledPath, run);
+    return {
+        run: beginRuntimeRun(options.compiledPath, run),
+        activeContractPath: options.executionPath
+            ? "runtime/stage-contract.json"
+            : relative(options.compiledPath, activeContractPath),
+    };
 }
 function finalizeRuntimeRun(dirPath, code) {
     const current = loadRuntimeRun(dirPath);
@@ -221,92 +234,6 @@ function writeRuntimeRunPrompt(dirPath, runId, prompt) {
 function createRunId() {
     return `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
-function normalizeRuntimeRunRecord(raw) {
-    if (!raw || typeof raw !== "object")
-        return null;
-    const record = raw;
-    const executor = record.executor;
-    if (record.kind !== "interf-run" ||
-        typeof record.version !== "number" ||
-        typeof record.run_id !== "string" ||
-        typeof record.target_name !== "string" ||
-        typeof record.workflow !== "string" ||
-        typeof record.stage !== "string" ||
-        !executor ||
-        typeof executor !== "object" ||
-        typeof record.started_at !== "string" ||
-        typeof record.updated_at !== "string" ||
-        typeof record.contract_path !== "string" ||
-        typeof record.summary !== "string") {
-        return null;
-    }
-    const normalizedTargetType = inferRuntimeTargetType(record.target_type);
-    if (!normalizedTargetType)
-        return null;
-    const executorRecord = executor;
-    const normalized = {
-        kind: "interf-run",
-        version: record.version,
-        run_id: record.run_id,
-        target_type: normalizedTargetType,
-        target_name: record.target_name,
-        workflow: record.workflow,
-        stage: record.stage,
-        stage_label: typeof record.stage_label === "string" ? record.stage_label : record.stage,
-        contract_type: typeof record.contract_type === "string"
-            ? inferRuntimeContractType(record.contract_type, record.stage)
-            : inferRuntimeContractType(record.target_type, record.stage),
-        status: normalizeRuntimeRunStatus(record),
-        executor: {
-            kind: executorRecord.kind,
-            name: executorRecord.name,
-            display_name: executorRecord.display_name,
-            command: typeof executorRecord.command === "string" ? executorRecord.command : null,
-            model: typeof executorRecord.model === "string" ? executorRecord.model : null,
-            effort: typeof executorRecord.effort === "string" ? executorRecord.effort : null,
-            profile: typeof executorRecord.profile === "string" ? executorRecord.profile : null,
-            timeout_ms: typeof executorRecord.timeout_ms === "number" ? executorRecord.timeout_ms : null,
-        },
-        started_at: record.started_at,
-        updated_at: record.updated_at,
-        finished_at: typeof record.finished_at === "string" ? record.finished_at : null,
-        contract_path: record.contract_path,
-        execution_path: typeof record.execution_path === "string" ? record.execution_path : undefined,
-        counts: record.counts && typeof record.counts === "object" ? record.counts : {},
-        output_artifacts: Array.isArray(record.output_artifacts) ? record.output_artifacts : [],
-        logs: record.logs && typeof record.logs === "object" ? record.logs : undefined,
-        summary: record.summary,
-        exit_code: typeof record.exit_code === "number" ? record.exit_code : null,
-        error: typeof record.error === "string" ? record.error : null,
-    };
-    const parsed = RuntimeRunSchema.safeParse(normalized);
-    return parsed.success ? parsed.data : null;
-}
-function normalizeRuntimeRunStatus(record) {
-    const status = record.status;
-    if (status === "running" || status === "succeeded" || status === "failed")
-        return status;
-    if (typeof record.exit_code === "number")
-        return record.exit_code === 0 ? "succeeded" : "failed";
-    if (typeof record.error === "string" && record.error.length > 0)
-        return "failed";
-    return "running";
-}
-function inferRuntimeTargetType(targetType) {
-    if (targetType === "compiled") {
-        return "compiled";
-    }
-    return null;
-}
-function inferRuntimeContractType(contractType, stage) {
-    if (typeof contractType === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(contractType)) {
-        return contractType;
-    }
-    if (typeof stage === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(stage)) {
-        return stage;
-    }
-    return "compiled";
-}
 function replaceOrAppendRunHistoryEntry(dirPath, run) {
     const historyPath = runHistoryPath(dirPath);
     if (!existsSync(historyPath)) {

package/dist/lib/runtime.d.ts

@@ -1,5 +1,5 @@
 export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeSummarizeExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
-export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";

package/dist/lib/runtime.js

@@ -1,4 +1,4 @@
-export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";