@interf/compiler 0.9.1 → 0.9.4

package/dist/packages/local-service/run-observability.js

@@ -0,0 +1,592 @@
+import { createRunEventTimestamp, } from "../execution/events.js";
+import { RunObservabilityResourceSchema, } from "./lib/schema.js";
+export function uniqueArtifacts(artifacts) {
+    const seen = new Set();
+    const result = [];
+    for (const artifact of artifacts) {
+        const key = `${artifact.role}:${artifact.stage_id ?? ""}:${artifact.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(artifact);
+    }
+    return result;
+}
+function observableRunStatus(status) {
+    if (status === "queued" || status === "pending")
+        return "queued";
+    if (status === "running")
+        return "running";
+    if (status === "failed")
+        return "failed";
+    if (status === "cancelled")
+        return "cancelled";
+    return "succeeded";
+}
+function methodTraceRunStatus(status) {
+    if (status === "queued" || status === "pending")
+        return "pending";
+    if (status === "running")
+        return "running";
+    if (status === "failed")
+        return "failed";
+    if (status === "cancelled")
+        return "cancelled";
+    return "completed";
+}
+function safeMethodNamePart(value) {
+    return value
+        .replace(/[^a-zA-Z0-9._/-]+/g, "-")
+        .replace(/\/+/g, "/")
+        .replace(/^-+|-+$/g, "")
+        || "run";
+}
+function methodTraceName(runType, name) {
+    return `workflow//./interf/${runType}//${safeMethodNamePart(name)}`;
+}
+function methodStepName(runType, label) {
+    return `step//./interf/${runType}//${safeMethodNamePart(label)}`;
+}
+function structuredMethodError(message) {
+    return {
+        message: message || "Run failed.",
+        code: "INTERF_RUN_ERROR",
+    };
+}
+function traceEvent(runId, eventType, createdAt, index, eventData, correlationId) {
+    return {
+        runId,
+        eventId: `${runId}:event:${index}`,
+        eventType,
+        specVersion: 1,
+        createdAt: createdAt ?? createRunEventTimestamp(),
+        ...(correlationId ? { correlationId } : {}),
+        ...(eventData === undefined ? {} : { eventData }),
+    };
+}
+function traceStreamChunk(runId, index, createdAt, text, data) {
+    return {
+        streamId: `${runId}:events`,
+        chunkId: `${runId}:events:${index}`,
+        index,
+        createdAt: createdAt ?? createRunEventTimestamp(),
+        text,
+        ...(data === undefined ? {} : { data }),
+    };
+}
+function buildTraceStreamChunks(runId, events) {
+    return events.map((event, index) => traceStreamChunk(runId, index, event.timestamp, JSON.stringify({
+        time: event.timestamp ?? null,
+        type: event.type,
+        scope: event.stage_id ?? event.step_id ?? event.type,
+        message: event.message ?? event.summary ?? event.error ?? event.type,
+    }), event));
+}
+function proofChecksForCompileRun(run) {
+    return run.stages.flatMap((stage) => (stage.latest_proof?.checks ?? []).map((check) => ({
+        ...check,
+        detail: check.detail ?? `${stage.stage_label ?? stage.stage_id} / ${stage.status}`,
+    })));
+}
+function agentLabelForJob(job) {
+    return job.agent?.display_name ?? job.agent?.name ?? null;
+}
+function jobTypeLabelForMetric(type) {
+    if (type === "readiness-check-draft")
+        return "Readiness-check draft";
+    if (type === "method-authoring")
+        return "Method draft";
+    if (type === "method-improvement")
+        return "Method improvement";
+    if (type === "compile")
+        return "Compile";
+    if (type === "test")
+        return "Readiness check";
+    return "Local job";
+}
+function stageTracePayload(stage) {
+    return {
+        status: stage.status,
+        ...(stage.summary ? { summary: stage.summary } : {}),
+        ...(stage.artifacts.length > 0 ? { artifacts: stage.artifacts } : {}),
+        ...(stage.logs ? { logs: stage.logs } : {}),
+        ...(stage.latest_proof ? { proof: stage.latest_proof } : {}),
+    };
+}
+export function compileRunToObservability(run) {
+    const artifacts = uniqueArtifacts(run.stages.flatMap((stage) => stage.artifacts));
+    const proof = proofChecksForCompileRun(run);
+    const executor = run.stages.find((stage) => stage.executor)?.executor ?? null;
+    const traceStatus = methodTraceRunStatus(run.status);
+    const methodName = methodTraceName("compile", `Prepare ${run.preparation}`);
+    const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? run.started_at ?? run.created_at
+        : undefined);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(run.run_id, "run_created", run.created_at, eventIndex++, {
+            deploymentId: "local-interf",
+            methodName,
+            input: {
+                kind: "compile",
+                preparation: run.preparation,
+                method: run.method,
+                source_path: run.source_path,
+            },
+            executionContext: {
+                backend: run.backend,
+                executor,
+            },
+        }),
+    ];
+    if (run.started_at) {
+        events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
+            methodName,
+            input: {
+                preparation: run.preparation,
+                method: run.method,
+            },
+            executionContext: {
+                backend: run.backend,
+                executor,
+            },
+        }));
+    }
+    for (const stage of run.stages) {
+        if (stage.status === "queued")
+            continue;
+        const stepName = methodStepName("compile", stage.stage_label ?? stage.stage_id);
+        const stepCreatedAt = stage.started_at ?? run.started_at ?? run.created_at;
+        const stepStartedAt = stage.started_at ?? stepCreatedAt;
+        const stepCompletedAt = stage.finished_at ?? run.finished_at ?? completedAt ?? stepCreatedAt;
+        events.push(traceEvent(run.run_id, "step_created", stepCreatedAt, eventIndex++, {
+            stepName,
+            input: {
+                stage_id: stage.stage_id,
+                stage_label: stage.stage_label ?? null,
+                stage_index: stage.stage_index ?? null,
+                stage_total: stage.stage_total ?? null,
+                reads: stage.contract?.reads ?? [],
+                writes: stage.contract?.writes ?? [],
+                acceptance: stage.contract?.acceptance ?? null,
+                executor: stage.executor ?? null,
+            },
+        }, stage.stage_id));
+        events.push(traceEvent(run.run_id, "step_started", stepStartedAt, eventIndex++, {
+            attempt: 1,
+        }, stage.stage_id));
+        if (stage.status === "failed") {
+            events.push(traceEvent(run.run_id, "step_failed", stepCompletedAt, eventIndex++, {
+                error: structuredMethodError(stage.failure ?? stage.summary),
+                output: stageTracePayload(stage),
+            }, stage.stage_id));
+        }
+        else if (stage.status === "succeeded") {
+            events.push(traceEvent(run.run_id, "step_completed", stepCompletedAt, eventIndex++, {
+                result: stageTracePayload(stage),
+            }, stage.stage_id));
+        }
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
+            output: {
+                portable_context_path: run.portable_context_path,
+                artifacts,
+                proof,
+                latest_proof: run.latest_proof ?? null,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(run.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredMethodError(run.stages.find((stage) => stage.failure)?.failure ?? run.latest_proof?.summary),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(run.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: run.run_id,
+        run_type: "compile",
+        title: `Prepare ${run.preparation}`,
+        status: observableRunStatus(run.status),
+        preparation: run.preparation,
+        method: run.method,
+        source_path: run.source_path,
+        output_path: run.portable_context_path,
+        executor,
+        agent_label: executor?.display_name ?? run.backend,
+        created_at: run.created_at,
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        metrics: [
+            { label: "Preparation", value: run.preparation },
+            { label: "Method", value: run.method },
+            { label: "Executor", value: executor?.display_name ?? run.backend },
+            { label: "Stages", value: `${run.stages.filter((stage) => stage.status === "succeeded").length}/${run.stages.length}` },
+            { label: "Proof", value: `${proof.filter((check) => check.ok).length}/${proof.length}` },
+            { label: "Artifacts", value: String(artifacts.length) },
+        ],
+        artifacts,
+        proof,
+        trace: {
+            run: {
+                runId: run.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                methodName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: "compile",
+                    preparation: run.preparation,
+                    method: run.method,
+                    backend: run.backend,
+                    executor,
+                },
+                input: {
+                    preparation: run.preparation,
+                    method: run.method,
+                    source_path: run.source_path,
+                },
+                ...(traceStatus === "completed"
+                    ? {
+                        output: {
+                            portable_context_path: run.portable_context_path,
+                            artifacts,
+                            proof,
+                        },
+                    }
+                    : {}),
+                ...(traceStatus === "failed" ? { error: structuredMethodError(run.stages.find((stage) => stage.failure)?.failure) } : {}),
+                ...(run.started_at ? { startedAt: run.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: run.created_at,
+                updatedAt: completedAt ?? run.started_at ?? run.created_at,
+            },
+            events,
+            streams: buildTraceStreamChunks(run.run_id, run.events),
+        },
+    });
+}
+export function testRunToObservability(run) {
+    const traceStatus = methodTraceRunStatus(run.status);
+    const title = `Check readiness ${run.preparation}`;
+    const methodName = methodTraceName("test", title);
+    const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? run.started_at ?? new Date().toISOString()
+        : undefined);
+    const raw = run.comparison?.raw ?? null;
+    const compiled = run.comparison?.compiled ?? null;
+    const proofCandidates = [
+        raw
+            ? {
+                id: `${run.run_id}-source-files`,
+                label: "source files baseline",
+                ok: raw.ok ?? raw.passed_cases === raw.total_cases,
+                detail: `${raw.passed_cases}/${raw.total_cases} checks`,
+            }
+            : null,
+        compiled
+            ? {
+                id: `${run.run_id}-portable-context`,
+                label: "portable context",
+                ok: compiled.ok ?? compiled.passed_cases === compiled.total_cases,
+                detail: `${compiled.passed_cases}/${compiled.total_cases} checks`,
+            }
+            : null,
+    ];
+    const proof = proofCandidates.filter((value) => value !== null);
+    const artifacts = uniqueArtifacts([
+        ...(raw?.run_path ? [{ path: raw.run_path, role: "test", label: "source files readiness run" }] : []),
+        ...(compiled?.run_path ? [{ path: compiled.run_path, role: "test", label: "portable context readiness run" }] : []),
+    ]);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(run.run_id, "run_created", run.started_at, eventIndex++, {
+            deploymentId: "local-interf",
+            methodName,
+            input: {
+                kind: "test",
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+        }),
+    ];
+    if (run.started_at) {
+        events.push(traceEvent(run.run_id, "run_started", run.started_at, eventIndex++, {
+            methodName,
+            input: {
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+        }));
+    }
+    const targetStepCandidates = [
+        raw
+            ? {
+                id: "source-files-baseline",
+                label: "Source files baseline",
+                status: raw.ok ?? raw.passed_cases === raw.total_cases ? "succeeded" : "failed",
+                input: raw.target ?? { type: "source-files", path: run.source_path ?? null },
+                output: raw,
+            }
+            : null,
+        compiled
+            ? {
+                id: "portable-context-check",
+                label: "Portable context",
+                status: compiled.ok ?? compiled.passed_cases === compiled.total_cases ? "succeeded" : "failed",
+                input: compiled.target ?? { type: "portable-context", path: run.portable_context_path ?? null },
+                output: compiled,
+            }
+            : null,
+    ];
+    const targetSteps = targetStepCandidates.filter((value) => value !== null);
+    if (targetSteps.length === 0) {
+        targetSteps.push({
+            id: "check-readiness",
+            label: "Run readiness checks",
+            status: run.status === "failed" ? "failed" : "succeeded",
+            input: {
+                preparation: run.preparation,
+                mode: run.mode,
+            },
+            output: run.comparison ?? null,
+        });
+    }
+    for (const step of targetSteps) {
+        const timestamp = run.started_at ?? run.finished_at ?? new Date().toISOString();
+        events.push(traceEvent(run.run_id, "step_created", timestamp, eventIndex++, {
+            stepName: methodStepName("test", step.label),
+            input: step.input,
+        }, step.id));
+        events.push(traceEvent(run.run_id, "step_started", timestamp, eventIndex++, {
+            attempt: 1,
+        }, step.id));
+        events.push(traceEvent(run.run_id, step.status === "failed" ? "step_failed" : "step_completed", run.finished_at ?? timestamp, eventIndex++, step.status === "failed"
+            ? { error: structuredMethodError(run.error ?? `${step.label} did not pass.`), output: step.output }
+            : { result: step.output }, step.id));
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(run.run_id, "run_completed", completedAt, eventIndex++, {
+            output: {
+                comparison: run.comparison,
+                proof,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(run.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredMethodError(run.error),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(run.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: run.run_id,
+        run_type: "test",
+        title,
+        status: observableRunStatus(run.status),
+        preparation: run.preparation,
+        method: compiled?.target?.method ?? null,
+        source_path: run.source_path ?? null,
+        output_path: run.portable_context_path ?? null,
+        created_at: run.started_at ?? completedAt ?? new Date().toISOString(),
+        started_at: run.started_at ?? null,
+        finished_at: run.finished_at ?? null,
+        metrics: [
+            { label: "Preparation", value: run.preparation },
+            { label: "Mode", value: run.mode },
+            { label: "Readiness checks", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : raw ? `${raw.passed_cases}/${raw.total_cases}` : "0/0" },
+            { label: "Source files", value: raw ? `${raw.passed_cases}/${raw.total_cases}` : "-" },
+            { label: "Portable context", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : "-" },
+        ],
+        artifacts,
+        proof,
+        trace: {
+            run: {
+                runId: run.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                methodName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: "test",
+                    preparation: run.preparation,
+                    mode: run.mode,
+                },
+                input: {
+                    preparation: run.preparation,
+                    mode: run.mode,
+                    source_path: run.source_path ?? null,
+                    portable_context_path: run.portable_context_path ?? null,
+                },
+                ...(traceStatus === "completed" ? { output: { comparison: run.comparison, proof } } : {}),
+                ...(traceStatus === "failed" ? { error: structuredMethodError(run.error) } : {}),
+                ...(run.started_at ? { startedAt: run.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: run.started_at ?? completedAt ?? new Date().toISOString(),
+                updatedAt: completedAt ?? run.started_at ?? new Date().toISOString(),
+            },
+            events,
+            streams: buildTraceStreamChunks(run.run_id, run.events ?? []),
+        },
+    });
+}
+export function jobRunToObservability(job) {
+    const runType = (job.job_type === "preparation-setup" ||
+        job.job_type === "readiness-check-draft" ||
+        job.job_type === "method-authoring" ||
+        job.job_type === "method-improvement"
+        ? job.job_type
+        : "job");
+    const executor = job.agent
+        ? {
+            kind: "local-agent",
+            name: job.agent.name,
+            display_name: job.agent.display_name,
+            command: job.agent.command ?? null,
+        }
+        : null;
+    const traceStatus = methodTraceRunStatus(job.status);
+    const methodName = methodTraceName(runType, job.title);
+    const completedAt = job.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
+        ? job.started_at ?? job.created_at
+        : undefined);
+    let eventIndex = 0;
+    const events = [
+        traceEvent(job.run_id, "run_created", job.created_at, eventIndex++, {
+            deploymentId: "local-interf",
+            methodName,
+            input: {
+                job_type: job.job_type,
+                preparation: job.preparation ?? null,
+                method: job.method ?? null,
+            },
+            executionContext: {
+                executor,
+            },
+        }),
+    ];
+    if (job.started_at) {
+        events.push(traceEvent(job.run_id, "run_started", job.started_at, eventIndex++, {
+            methodName,
+            input: {
+                job_type: job.job_type,
+                preparation: job.preparation ?? null,
+            },
+            executionContext: {
+                executor,
+            },
+        }));
+    }
+    for (const step of job.steps) {
+        const timestamp = step.started_at ?? job.started_at ?? job.created_at;
+        events.push(traceEvent(job.run_id, "step_created", timestamp, eventIndex++, {
+            stepName: methodStepName(runType, step.label),
+            input: step.input ?? {
+                step_id: step.id,
+                label: step.label,
+            },
+        }, step.id));
+        if (step.started_at || step.status !== "queued") {
+            events.push(traceEvent(job.run_id, "step_started", step.started_at ?? timestamp, eventIndex++, {
+                attempt: 1,
+            }, step.id));
+        }
+        if (step.status === "failed") {
+            events.push(traceEvent(job.run_id, "step_failed", step.finished_at ?? completedAt ?? timestamp, eventIndex++, {
+                error: structuredMethodError(step.summary ?? job.error),
+                output: step.output ?? null,
+            }, step.id));
+        }
+        else if (step.status === "succeeded") {
+            events.push(traceEvent(job.run_id, "step_completed", step.finished_at ?? completedAt ?? timestamp, eventIndex++, {
+                result: step.output ?? {
+                    summary: step.summary ?? null,
+                },
+            }, step.id));
+        }
+    }
+    if (traceStatus === "completed") {
+        events.push(traceEvent(job.run_id, "run_completed", completedAt, eventIndex++, {
+            output: job.result ?? {
+                output_path: job.output_path ?? null,
+            },
+        }));
+    }
+    else if (traceStatus === "failed") {
+        events.push(traceEvent(job.run_id, "run_failed", completedAt, eventIndex++, {
+            error: structuredMethodError(job.error),
+        }));
+    }
+    else if (traceStatus === "cancelled") {
+        events.push(traceEvent(job.run_id, "run_cancelled", completedAt, eventIndex++));
+    }
+    const outputPath = job.output_path ?? (typeof job.result?.path === "string" ? job.result.path : null);
+    const artifacts = uniqueArtifacts(outputPath ? [{ path: outputPath, role: "output" }] : []);
+    return RunObservabilityResourceSchema.parse({
+        kind: "interf-run-observability",
+        version: 1,
+        run_id: job.run_id,
+        run_type: runType,
+        title: job.title,
+        status: observableRunStatus(job.status),
+        preparation: job.preparation ?? null,
+        method: job.method ?? null,
+        source_path: job.source_path ?? null,
+        output_path: outputPath,
+        executor,
+        agent_label: agentLabelForJob(job),
+        created_at: job.created_at,
+        started_at: job.started_at ?? null,
+        finished_at: job.finished_at ?? null,
+        metrics: [
+            { label: "Kind", value: jobTypeLabelForMetric(job.job_type) },
+            { label: "Executor", value: agentLabelForJob(job) ?? "local executor" },
+            { label: "Phases", value: `${job.steps.filter((step) => step.status === "succeeded").length}/${job.steps.length}` },
+            { label: "Preparation", value: job.preparation ?? "-" },
+            { label: "Method", value: job.method ?? "-" },
+        ],
+        artifacts,
+        proof: [],
+        trace: {
+            run: {
+                runId: job.run_id,
+                status: traceStatus,
+                deploymentId: "local-interf",
+                methodName,
+                specVersion: 1,
+                executionContext: {
+                    product: "Interf",
+                    run_type: runType,
+                    job_type: job.job_type,
+                    preparation: job.preparation ?? null,
+                    method: job.method ?? null,
+                    executor,
+                },
+                input: {
+                    job_type: job.job_type,
+                    preparation: job.preparation ?? null,
+                    method: job.method ?? null,
+                    source_path: job.source_path ?? null,
+                },
+                ...(traceStatus === "completed" ? { output: job.result ?? { output_path: outputPath } } : {}),
+                ...(traceStatus === "failed" ? { error: structuredMethodError(job.error) } : {}),
+                ...(job.started_at ? { startedAt: job.started_at } : {}),
+                ...(completedAt ? { completedAt } : {}),
+                createdAt: job.created_at,
+                updatedAt: completedAt ?? job.started_at ?? job.created_at,
+            },
+            events,
+            streams: buildTraceStreamChunks(job.run_id, job.events),
+        },
+    });
+}