@interf/compiler 0.6.1 → 0.6.4

package/dist/lib/runtime-runs.d.ts

@@ -1,11 +1 @@
-import { type RuntimeRun, type RuntimeStageContract } from "./schema.js";
-import { type RuntimeRunPatch, type RuntimeStageExecutionOptions, type RuntimeSummarizeExecutionOptions } from "./runtime-types.js";
-export declare function loadRuntimeRun(dirPath: string): RuntimeRun | null;
-export declare function saveRuntimeRun(dirPath: string, run: RuntimeRun): void;
-export declare function writeStageContract(dirPath: string, contract: RuntimeStageContract): string;
-export declare function runExecutorStage(options: RuntimeStageExecutionOptions): Promise<number>;
-export declare function runExecutorSummarizeStage(options: RuntimeSummarizeExecutionOptions): Promise<number>;
-export declare function beginRuntimeRun(dirPath: string, run: RuntimeRun): RuntimeRun;
-export declare function updateRuntimeRun(dirPath: string, patch: RuntimeRunPatch): RuntimeRun | null;
-export declare function markRuntimeRunFailedAfterValidation(dirPath: string, summary: string): RuntimeRun | null;
-export declare function markRuntimeRunSucceededAfterValidation(dirPath: string, summary: string): RuntimeRun | null;
+export * from "../packages/compiler/runtime-runs.js";

package/dist/lib/runtime-runs.js

@@ -1,262 +1 @@
-import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import chalk from "chalk";
-import { countFilesRecursive } from "./filesystem.js";
-import { buildRuntimeExecutorInfo } from "./executors.js";
-import { RuntimeRunSchema, } from "./schema.js";
-import { getWorkflowStageDefinition, getWorkflowStagePosition, getWorkflowStages, } from "./workflow-definitions.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);
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(path, "utf8"));
-        const parsed = RuntimeRunSchema.safeParse(raw);
-        if (parsed.success)
-            return parsed.data;
-        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)}`);
-        return null;
-    }
-}
-export function saveRuntimeRun(dirPath, run) {
-    mkdirSync(dirname(runPath(dirPath)), { recursive: true });
-    writeFileSync(runPath(dirPath), JSON.stringify(run, null, 2) + "\n");
-}
-export function writeStageContract(dirPath, contract) {
-    mkdirSync(dirname(stageContractPath(dirPath)), { recursive: true });
-    const path = stageContractPath(dirPath);
-    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 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, 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 startedRun = startRuntimeRun(options);
-    const prompt = options.buildPrompt(startedRun.activeContractPath);
-    let lastReported = 0;
-    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, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
-        completionCheck: options.completionCheck,
-    });
-    const timer = setInterval(() => {
-        const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
-        const completed = Math.max(0, Math.min(options.targetCount, currentSummaryCount - options.startingSummaryCount));
-        if (completed <= lastReported)
-            return;
-        lastReported = completed;
-        updateRuntimeRun(options.compiledPath, {
-            counts: {
-                ...startedRun.run.counts,
-                completed_summaries: completed,
-                target_summaries: options.targetCount,
-            },
-            summary: `${options.stageLabel} ${completed}/${options.targetCount} source files into summaries.`,
-        });
-        console.log(chalk.dim(`  STATUS: wrote ${completed}/${options.targetCount} summaries`));
-    }, 10000);
-    try {
-        const code = await progressPromise;
-        finalizeRuntimeRun(options.compiledPath, code);
-        return code;
-    }
-    finally {
-        clearInterval(timer);
-    }
-}
-export function beginRuntimeRun(dirPath, run) {
-    saveRuntimeRun(dirPath, run);
-    return run;
-}
-export function updateRuntimeRun(dirPath, patch) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const next = {
-        ...current,
-        ...patch,
-        updated_at: new Date().toISOString(),
-    };
-    saveRuntimeRun(dirPath, next);
-    return next;
-}
-export function markRuntimeRunFailedAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "failed",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 1,
-        error: summary,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-export function markRuntimeRunSucceededAfterValidation(dirPath, summary) {
-    const current = loadRuntimeRun(dirPath);
-    if (!current)
-        return null;
-    const finishedAt = current.finished_at ?? new Date().toISOString();
-    const next = {
-        ...current,
-        status: "succeeded",
-        updated_at: new Date().toISOString(),
-        finished_at: finishedAt,
-        exit_code: 0,
-        error: null,
-        summary,
-    };
-    saveRuntimeRun(dirPath, next);
-    replaceOrAppendRunHistoryEntry(dirPath, next);
-    return next;
-}
-function startRuntimeRun(options) {
-    const runId = createRunId();
-    const generatedAt = new Date().toISOString();
-    const workflowStages = getWorkflowStages(options.workflow, options.workflowSourcePath);
-    const stagePosition = getWorkflowStagePosition(options.workflow, options.stage, options.workflowSourcePath);
-    const stageDefinition = getWorkflowStageDefinition(options.workflow, options.stage, options.workflowSourcePath);
-    const contract = {
-        kind: "interf-stage-contract",
-        version: 1,
-        generated_at: generatedAt,
-        run_id: runId,
-        target_type: "compiled",
-        target_name: options.compiledName,
-        workflow: {
-            id: options.workflow,
-            stage_index: stagePosition?.stageIndex ?? null,
-            stage_total: stagePosition?.stageTotal ?? workflowStages.length,
-            stages: stagePosition?.stages ?? workflowStages,
-        },
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        executor: buildRuntimeExecutorInfo(options.executor),
-        instructions: options.contract.instructions,
-        counts: options.contract.counts,
-        ...(options.contract.acceptance ? { acceptance: options.contract.acceptance } : {}),
-        artifacts: options.contract.artifacts,
-        policies: options.contract.policies,
-    };
-    const activeContractPath = writeStageContract(options.compiledPath, contract);
-    const archivedContractPath = writeArchivedStageContract(options.compiledPath, runId, contract);
-    const run = {
-        kind: "interf-run",
-        version: 1,
-        run_id: runId,
-        target_type: "compiled",
-        target_name: options.compiledName,
-        workflow: options.workflow,
-        stage: options.stage,
-        stage_label: stageDefinition?.label ?? options.stageLabel,
-        contract_type: options.contractType,
-        status: "running",
-        executor: buildRuntimeExecutorInfo(options.executor),
-        started_at: generatedAt,
-        updated_at: generatedAt,
-        finished_at: null,
-        contract_path: relative(options.compiledPath, archivedContractPath),
-        ...(options.executionPath ? { execution_path: relative(options.compiledPath, options.executionPath) } : {}),
-        counts: { ...contract.counts },
-        output_artifacts: [...contract.artifacts.writes],
-        logs: {
-            prompt_path: relative(options.compiledPath, promptLogPath(options.compiledPath, runId)),
-            event_stream_path: relative(options.compiledPath, eventLogPath(options.compiledPath, runId)),
-            status_path: relative(options.compiledPath, statusLogPath(options.compiledPath, runId)),
-        },
-        summary: options.summary,
-        exit_code: null,
-        error: null,
-    };
-    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);
-    if (!current)
-        return null;
-    const finishedAt = new Date().toISOString();
-    const next = {
-        ...current,
-        status: code === 0 ? "succeeded" : "failed",
-        updated_at: finishedAt,
-        finished_at: finishedAt,
-        exit_code: code,
-        error: code === 0 ? null : `Executor exited with code ${code}.`,
-        summary: code === 0
-            ? `${current.stage_label} completed successfully.`
-            : `${current.stage_label} failed with exit code ${code}.`,
-    };
-    saveRuntimeRun(dirPath, next);
-    appendFileSync(runHistoryPath(dirPath), JSON.stringify(next) + "\n");
-    return next;
-}
-function writeRuntimeRunPrompt(dirPath, runId, prompt) {
-    mkdirSync(logsDirPath(dirPath), { recursive: true });
-    writeFileSync(promptLogPath(dirPath, runId), `${prompt}\n`);
-}
-function createRunId() {
-    return `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function replaceOrAppendRunHistoryEntry(dirPath, run) {
-    const historyPath = runHistoryPath(dirPath);
-    if (!existsSync(historyPath)) {
-        appendFileSync(historyPath, JSON.stringify(run) + "\n");
-        return;
-    }
-    const raw = readFileSync(historyPath, "utf8");
-    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
-    let replaced = false;
-    const nextLines = lines.map((line) => {
-        try {
-            const entry = JSON.parse(line);
-            if (entry.run_id === run.run_id) {
-                replaced = true;
-                return JSON.stringify(run);
-            }
-        }
-        catch {
-            // preserve malformed history lines as-is
-        }
-        return line;
-    });
-    if (!replaced)
-        nextLines.push(JSON.stringify(run));
-    writeFileSync(historyPath, `${nextLines.join("\n")}\n`);
-}
+export * from "../packages/compiler/runtime-runs.js";

package/dist/lib/runtime-types.d.ts

@@ -1,43 +1 @@
-import { type WorkflowExecutor } from "./executors.js";
-import { type WorkflowId, type RuntimeContractType, type RuntimeRun, type RuntimeStage, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./schema.js";
-export type RuntimeRunStatus = "running" | "succeeded" | "failed";
-export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "workflow" | "stage" | "stage_label" | "contract_type" | "executor">;
-export interface RuntimeStageExecutionOptions {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    executionPath?: string;
-    compiledName: string;
-    workflow: WorkflowId;
-    workflowSourcePath?: string;
-    stage: RuntimeStage;
-    stageLabel: string;
-    contractType: RuntimeContractType;
-    summary: string;
-    contract: RuntimeStageContractDraft;
-    buildPrompt: (contractPath: string) => string;
-    completionCheck?: (() => boolean) | null;
-}
-export interface RuntimeSummarizeExecutionOptions extends RuntimeStageExecutionOptions {
-    startingSummaryCount: number;
-    targetCount: number;
-}
-export interface RuntimeStageAcceptanceValidation {
-    ok: boolean;
-    summary: string;
-    failures: string[];
-}
-export interface RuntimeStageContractOptions {
-    compiledName: string;
-    stageId: string;
-    stageLabel: string;
-    counts?: Record<string, number>;
-    extraReadArtifacts?: string[];
-    stageReadArtifacts: string[];
-    stageWriteArtifacts: string[];
-    workflowNotes?: string[];
-    localSkillDocs?: string[];
-    instructions: RuntimeStageInstructions;
-    acceptance?: RuntimeStageAcceptance;
-}
-export interface RuntimeRunPatch extends Partial<Pick<RuntimeRun, "counts" | "summary" | "status" | "error" | "exit_code" | "finished_at">> {
-}
+export * from "../packages/compiler/runtime-types.js";

package/dist/lib/runtime-types.js

@@ -1 +1 @@
-export {};
+export * from "../packages/compiler/runtime-types.js";

package/dist/lib/runtime.d.ts

@@ -1,6 +1 @@
-export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeSummarizeExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.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";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
+export * from "../packages/compiler/runtime.js";

package/dist/lib/runtime.js

@@ -1,5 +1 @@
-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";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
+export * from "../packages/compiler/runtime.js";