@interf/compiler 0.7.2 → 0.9.1

package/dist/packages/execution/lib/schema.js

@@ -0,0 +1,319 @@
+import { z } from "zod";
+import { ReadinessStateSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, WorkflowIdSchema, } from "../../compiler/lib/schema.js";
+import { PreparationNameSchema, } from "../../project-model/lib/schema.js";
+const RunIdSchema = z.string().min(1);
+const JsonObjectSchema = z.record(z.string(), z.unknown());
+export const WorkflowTraceRunStatusSchema = z.enum([
+    "pending",
+    "running",
+    "completed",
+    "failed",
+    "cancelled",
+]);
+export const WorkflowTraceEventTypeSchema = z.enum([
+    "run_created",
+    "run_started",
+    "run_completed",
+    "run_failed",
+    "run_cancelled",
+    "step_created",
+    "step_started",
+    "step_completed",
+    "step_failed",
+    "step_retrying",
+    "hook_created",
+    "hook_received",
+    "hook_disposed",
+    "hook_conflict",
+    "wait_created",
+    "wait_completed",
+]);
+export const WorkflowTraceStructuredErrorSchema = z.object({
+    message: z.string().min(1),
+    stack: z.string().min(1).optional(),
+    code: z.string().min(1).optional(),
+}).strict();
+export const WorkflowTraceRunSchema = z.object({
+    runId: RunIdSchema,
+    status: WorkflowTraceRunStatusSchema,
+    deploymentId: z.string().min(1),
+    workflowName: z.string().min(1),
+    specVersion: z.literal(1),
+    executionContext: JsonObjectSchema.optional(),
+    input: z.unknown(),
+    output: z.unknown().optional(),
+    error: WorkflowTraceStructuredErrorSchema.optional(),
+    expiredAt: z.string().min(1).optional(),
+    startedAt: z.string().min(1).optional(),
+    completedAt: z.string().min(1).optional(),
+    createdAt: z.string().min(1),
+    updatedAt: z.string().min(1),
+}).strict();
+export const WorkflowTraceEventSchema = z.object({
+    runId: RunIdSchema,
+    eventId: z.string().min(1),
+    eventType: WorkflowTraceEventTypeSchema,
+    correlationId: z.string().min(1).optional(),
+    specVersion: z.literal(1),
+    createdAt: z.string().min(1),
+    eventData: z.unknown().optional(),
+}).strict();
+export const WorkflowTraceStreamChunkSchema = z.object({
+    streamId: z.string().min(1),
+    chunkId: z.string().min(1),
+    index: z.number().int().min(0),
+    createdAt: z.string().min(1),
+    text: z.string(),
+    data: z.unknown().optional(),
+}).strict();
+export const WorkflowTraceSchema = z.object({
+    run: WorkflowTraceRunSchema,
+    events: z.array(WorkflowTraceEventSchema).default([]),
+    streams: z.array(WorkflowTraceStreamChunkSchema).default([]),
+}).strict();
+export const ObservableRunTypeSchema = z.enum([
+    "preparation-setup",
+    "compile",
+    "test",
+    "readiness-check-draft",
+    "method-authoring",
+    "method-improvement",
+    "job",
+]);
+export const ObservableRunStatusSchema = z.enum([
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+]);
+export const ObservableRunMetricSchema = z.object({
+    label: z.string().min(1),
+    value: z.string().min(1),
+    detail: z.string().min(1).optional(),
+}).strict();
+export const ExecutionBackendKindSchema = z.enum([
+    "native",
+    "workflow-sdk",
+]);
+export const CompileRunStatusSchema = z.enum([
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+]);
+export const StageRunStatusSchema = z.enum([
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "skipped",
+]);
+export const ArtifactRoleSchema = z.enum([
+    "source",
+    "output",
+    "proof",
+    "runtime",
+    "test",
+]);
+export const ArtifactRefSchema = z.object({
+    path: z.string().min(1),
+    role: ArtifactRoleSchema,
+    stage_id: RuntimeStageSchema.nullable().optional(),
+    label: z.string().min(1).optional(),
+    sha256: z.string().min(1).optional(),
+}).strict();
+export const ProofCheckSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    ok: z.boolean(),
+    detail: z.string().min(1).optional(),
+}).strict();
+function normalizePreparationMethodFields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const input = value;
+    const output = { ...input };
+    if (typeof output.preparation !== "string" && typeof input.dataset === "string") {
+        output.preparation = input.dataset;
+    }
+    if (typeof output.method !== "string" && typeof input.workflow === "string") {
+        output.method = input.workflow;
+    }
+    if (output.run_type === "dataset-setup")
+        output.run_type = "preparation-setup";
+    if (output.run_type === "workflow-authoring")
+        output.run_type = "method-authoring";
+    if (output.run_type === "workflow-improvement")
+        output.run_type = "method-improvement";
+    delete output.dataset;
+    delete output.workflow;
+    return output;
+}
+export const RunObservabilitySchema = z.preprocess(normalizePreparationMethodFields, z.object({
+    kind: z.literal("interf-run-observability"),
+    version: z.literal(1),
+    run_id: RunIdSchema,
+    run_type: ObservableRunTypeSchema,
+    title: z.string().min(1),
+    status: ObservableRunStatusSchema,
+    preparation: PreparationNameSchema.nullable().optional(),
+    method: WorkflowIdSchema.nullable().optional(),
+    source_path: z.string().min(1).nullable().optional(),
+    output_path: z.string().min(1).nullable().optional(),
+    executor: RuntimeExecutorInfoSchema.nullable().optional(),
+    agent_label: z.string().min(1).nullable().optional(),
+    created_at: z.string().min(1),
+    started_at: z.string().min(1).nullable().optional(),
+    finished_at: z.string().min(1).nullable().optional(),
+    metrics: z.array(ObservableRunMetricSchema).default([]),
+    artifacts: z.array(ArtifactRefSchema).default([]),
+    proof: z.array(ProofCheckSchema).default([]),
+    readiness: ReadinessStateSchema.nullable().optional(),
+    trace: WorkflowTraceSchema,
+}).strict());
+export const ProofRecordSchema = z.object({
+    id: z.string().min(1),
+    run_id: RunIdSchema,
+    stage_id: RuntimeStageSchema.nullable().optional(),
+    generated_at: z.string().min(1),
+    summary: z.string().min(1),
+    files_processed: z.number().int().min(0).optional(),
+    artifacts: z.array(ArtifactRefSchema).default([]),
+    checks: z.array(ProofCheckSchema).default([]),
+}).strict();
+export const StageRunContractSchema = z.object({
+    stage_label: z.string().min(1).optional(),
+    stage_index: z.number().int().min(0).optional(),
+    stage_total: z.number().int().min(1).optional(),
+    reads: z.array(z.string().min(1)).default([]),
+    writes: z.array(z.string().min(1)).default([]),
+    acceptance: z.record(z.string(), z.unknown()).optional(),
+}).strict();
+export const StageRunLogsSchema = z.object({
+    prompt_path: z.string().min(1).optional(),
+    event_stream_path: z.string().min(1).optional(),
+    status_path: z.string().min(1).optional(),
+    contract_path: z.string().min(1).optional(),
+}).strict();
+const RunEventBaseSchema = z.object({
+    event_id: z.string().min(1),
+    run_id: RunIdSchema,
+    timestamp: z.string().min(1),
+});
+export const RunStartedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("run.started"),
+    preparation: PreparationNameSchema,
+    method: WorkflowIdSchema,
+    portable_context_path: z.string().min(1),
+    backend: ExecutionBackendKindSchema,
+}).strict();
+export const StageStartedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("stage.started"),
+    stage_id: RuntimeStageSchema,
+    stage_index: z.number().int().min(0).optional(),
+    stage_total: z.number().int().min(1).optional(),
+}).strict();
+export const FileProcessedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("file.processed"),
+    stage_id: RuntimeStageSchema,
+    path: z.string().min(1),
+}).strict();
+export const ArtifactWrittenEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("artifact.written"),
+    stage_id: RuntimeStageSchema,
+    artifact: ArtifactRefSchema,
+}).strict();
+export const ProofUpdatedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("proof.updated"),
+    stage_id: RuntimeStageSchema.nullable().optional(),
+    proof: ProofRecordSchema,
+}).strict();
+export const LogAppendedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("log.appended"),
+    stage_id: RuntimeStageSchema.nullable().optional(),
+    stream: z.enum(["status", "trace", "system"]),
+    message: z.string().min(1),
+}).strict();
+export const StagePassedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("stage.passed"),
+    stage_id: RuntimeStageSchema,
+    summary: z.string().min(1).optional(),
+}).strict();
+export const StageFailedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("stage.failed"),
+    stage_id: RuntimeStageSchema,
+    error: z.string().min(1),
+}).strict();
+export const RunCompletedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("run.completed"),
+    summary: z.string().min(1).optional(),
+}).strict();
+export const RunFailedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("run.failed"),
+    error: z.string().min(1),
+}).strict();
+export const ChecksEvaluatedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("checks.evaluated"),
+    passed: z.number().int().min(0),
+    total: z.number().int().min(0),
+    target: z.enum(["raw", "compiled"]).optional(),
+    checks_fingerprint: z.string().min(1).optional(),
+    stale: z.boolean().optional(),
+    test_run_id: z.string().min(1).optional(),
+}).strict();
+export const ReadinessUpdatedEventSchema = RunEventBaseSchema.extend({
+    type: z.literal("readiness.updated"),
+    preparation: PreparationNameSchema,
+    readiness: ReadinessStateSchema,
+}).strict();
+export const InterfRunEventSchema = z.preprocess(normalizePreparationMethodFields, z.discriminatedUnion("type", [
+    RunStartedEventSchema,
+    StageStartedEventSchema,
+    FileProcessedEventSchema,
+    ArtifactWrittenEventSchema,
+    ProofUpdatedEventSchema,
+    LogAppendedEventSchema,
+    StagePassedEventSchema,
+    StageFailedEventSchema,
+    RunCompletedEventSchema,
+    RunFailedEventSchema,
+    ChecksEvaluatedEventSchema,
+    ReadinessUpdatedEventSchema,
+]));
+export const StageRunSchema = z.object({
+    run_id: RunIdSchema,
+    stage_id: RuntimeStageSchema,
+    stage_label: z.string().min(1).optional(),
+    stage_index: z.number().int().min(0).optional(),
+    stage_total: z.number().int().min(1).optional(),
+    status: StageRunStatusSchema,
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    summary: z.string().nullable().optional(),
+    contract: StageRunContractSchema.optional(),
+    executor: RuntimeExecutorInfoSchema.nullable().optional(),
+    artifacts: z.array(ArtifactRefSchema).default([]),
+    logs: StageRunLogsSchema.optional(),
+    latest_proof: ProofRecordSchema.nullable().optional(),
+    failure: z.string().nullable().optional(),
+}).strict();
+export const CompileRunSchema = z.preprocess(normalizePreparationMethodFields, z.object({
+    kind: z.literal("interf-compile-run"),
+    version: z.literal(1),
+    run_id: RunIdSchema,
+    status: CompileRunStatusSchema,
+    preparation: PreparationNameSchema,
+    method: WorkflowIdSchema,
+    backend: ExecutionBackendKindSchema,
+    source_path: z.string().min(1),
+    portable_context_path: z.string().min(1),
+    created_at: z.string().min(1),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    stages: z.array(StageRunSchema).default([]),
+    events: z.array(InterfRunEventSchema).default([]),
+    latest_proof: ProofRecordSchema.nullable().optional(),
+    readiness: ReadinessStateSchema.nullable().optional(),
+}).strict());

package/dist/packages/local-service/action-values.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const ActionValueIdPattern: RegExp;
+export declare const ActionValueIdSchema: z.ZodString;
+export declare const OptionalActionValueIdSchema: z.ZodString;
+export declare const PreparationSetupActionValuesSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    about: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    readiness_notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MethodAuthoringActionValuesSchema: z.ZodObject<{
+    method_id: z.ZodString;
+    label: z.ZodString;
+    hint: z.ZodString;
+    task_prompt: z.ZodString;
+    portable_output: z.ZodOptional<z.ZodString>;
+    readiness_notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PreparationSetupActionValues = z.infer<typeof PreparationSetupActionValuesSchema>;
+export type MethodAuthoringActionValues = z.infer<typeof MethodAuthoringActionValuesSchema>;
+export declare function methodAuthoringTaskPrompt(values: MethodAuthoringActionValues): string;

package/dist/packages/local-service/action-values.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export const ActionValueIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const ActionValueIdSchema = z.string().trim().regex(ActionValueIdPattern, "Use lowercase letters, numbers, and dashes.");
+export const OptionalActionValueIdSchema = z.string().trim().refine((value) => value === "" || ActionValueIdPattern.test(value), "Use lowercase letters, numbers, and dashes.");
+export const PreparationSetupActionValuesSchema = z.object({
+    name: ActionValueIdSchema,
+    path: z.string().trim().min(1, "Source Folder is required."),
+    about: z.string().trim().min(1, "Agent work is required."),
+    method: OptionalActionValueIdSchema.optional(),
+    workflow: OptionalActionValueIdSchema.optional(),
+    readiness_notes: z.string().trim().optional(),
+}).strict();
+export const MethodAuthoringActionValuesSchema = z.object({
+    method_id: ActionValueIdSchema,
+    label: z.string().trim().min(1, "Label is required."),
+    hint: z.string().trim().min(1, "Summary is required."),
+    task_prompt: z.string().trim().min(1, "Agent work is required."),
+    portable_output: z.string().trim().optional(),
+    readiness_notes: z.string().trim().optional(),
+}).strict();
+function optionalLine(label, value) {
+    const trimmed = value?.trim();
+    return trimmed ? `${label}: ${trimmed}` : null;
+}
+export function methodAuthoringTaskPrompt(values) {
+    return [
+        `Agent work: ${values.task_prompt}`,
+        optionalLine("Portable-context output", values.portable_output),
+        optionalLine("Readiness checks", values.readiness_notes),
+    ].filter((line) => Boolean(line)).join("\n");
+}

package/dist/packages/local-service/client.d.ts

@@ -0,0 +1,119 @@
+import { type CompileRunCreateRequest, type CompileRunListResponse, type CompileRunResource, type LocalJobEventAppendRequest, type LocalJobRunCreateRequest, type LocalJobRunListResponse, type LocalJobRunResource, type LocalServiceHealth, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ReadinessListResponse, type TestRunCreateRequest, type TestRunListResponse, type TestRunResource, type WorkflowAuthoringCreateRequest, type WorkflowAuthoringResult } from "./lib/schema.js";
+export interface LocalServiceConnection {
+    serviceUrl: string;
+    health: LocalServiceHealth;
+}
+export interface LocalServiceJobSubmission<T> {
+    serviceUrl: string;
+    job: LocalJobRunResource;
+    result: T | null;
+    error?: string;
+}
+export interface LocalServiceJobSubmitted {
+    serviceUrl: string;
+    job: LocalJobRunResource;
+}
+export interface LocalServiceRunSnapshot {
+    jobs: LocalJobRunResource[];
+    compileRuns: CompileRunResource[];
+    testRuns: TestRunResource[];
+}
+export declare function configuredLocalServiceUrl(): string;
+export declare function findLocalService(options: {
+    projectPath: string;
+    timeoutMs?: number;
+}): Promise<LocalServiceConnection | null>;
+export declare function submitCompileRunToLocalService(options: {
+    projectPath: string;
+    request: CompileRunCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: CompileRunResource;
+} | null>;
+export declare function submitTestRunToLocalService(options: {
+    projectPath: string;
+    request: TestRunCreateRequest;
+}): Promise<{
+    serviceUrl: string;
+    resource: TestRunResource;
+} | null>;
+export declare function getLocalCompileRun(options: {
+    serviceUrl: string;
+    runId: string;
+}): Promise<CompileRunResource>;
+export declare function listLocalCompileRuns(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<CompileRunListResponse>;
+export declare function listLocalReadiness(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<ReadinessListResponse>;
+export declare function waitForLocalCompileRun(options: {
+    serviceUrl: string;
+    runId: string;
+    pollMs?: number;
+    onUpdate?: (resource: CompileRunResource) => void;
+}): Promise<CompileRunResource>;
+export declare function getLocalTestRun(options: {
+    serviceUrl: string;
+    runId: string;
+}): Promise<TestRunResource>;
+export declare function listLocalTestRuns(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<TestRunListResponse>;
+export declare function waitForLocalTestRun(options: {
+    serviceUrl: string;
+    runId: string;
+    pollMs?: number;
+    onUpdate?: (resource: TestRunResource) => void;
+}): Promise<TestRunResource>;
+export declare function getLocalJobRun(options: {
+    serviceUrl: string;
+    runId: string;
+}): Promise<LocalJobRunResource>;
+export declare function listLocalJobRuns(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<LocalJobRunListResponse>;
+export declare function readLocalServiceRunSnapshot(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<LocalServiceRunSnapshot>;
+export declare function waitForLocalJobRun(options: {
+    serviceUrl: string;
+    runId: string;
+    pollMs?: number;
+    timeoutMs?: number;
+    onUpdate?: (job: LocalJobRunResource) => void;
+}): Promise<LocalJobRunResource>;
+export declare function submitReadinessCheckDraftToLocalService(options: {
+    projectPath: string;
+    request: ReadinessCheckDraftCreateRequest;
+    onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
+    onUpdate?: (job: LocalJobRunResource) => void;
+}): Promise<LocalServiceJobSubmission<ReadinessCheckDraftResult> | null>;
+export declare function submitWorkflowAuthoringRunToLocalService(options: {
+    projectPath: string;
+    request: WorkflowAuthoringCreateRequest;
+    onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
+    onUpdate?: (job: LocalJobRunResource) => void;
+}): Promise<LocalServiceJobSubmission<WorkflowAuthoringResult> | null>;
+export interface LocalJobTracker {
+    serviceUrl: string;
+    runId: string;
+    resource: LocalJobRunResource;
+    emit(event: LocalJobEventAppendRequest): void;
+    complete(message?: string): Promise<void>;
+    fail(message: string): Promise<void>;
+}
+export declare function appendLocalJobRunEvent(options: {
+    projectPath: string;
+    runId: string;
+    event: LocalJobEventAppendRequest;
+}): Promise<LocalJobRunResource | null>;
+export declare function startLocalJobRun(options: {
+    projectPath: string;
+    request: LocalJobRunCreateRequest;
+}): Promise<LocalJobTracker | null>;