@interf/compiler 0.9.1 → 0.9.4

package/dist/packages/local-service/lib/schema.js

@@ -1,86 +1,9 @@
 import { z } from "zod";
 import { ArtifactRefSchema, CompileRunSchema, CompileRunStatusSchema, InterfRunEventSchema, ProofRecordSchema, RunObservabilitySchema, } from "../../execution/lib/schema.js";
-import { DatasetNameSchema, PreparationNameSchema, SourceDatasetConfigSchema, SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../../project-model/lib/schema.js";
-import { TestRunComparisonSchema, TestRunModeSchema, } from "../../testing/lib/schema.js";
-import { ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, WorkflowIdSchema, } from "../../compiler/lib/schema.js";
+import { SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../../project-model/lib/schema.js";
+import { PreparationNameSchema, ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, } from "../../contracts/lib/schema.js";
+import { ReadinessCheckRunSchema, TestRunModeSchema, } from "../../testing/lib/schema.js";
 const JsonObjectSchema = z.record(z.string(), z.unknown());
-function normalizePreparationMethodRequest(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const input = value;
-    const normalized = { ...input };
-    if (normalized.preparation == null || normalized.preparation === "") {
-        delete normalized.preparation;
-    }
-    if (normalized.method == null || normalized.method === "") {
-        delete normalized.method;
-    }
-    if (typeof normalized.preparation !== "string" && typeof input.dataset === "string") {
-        normalized.preparation = input.dataset;
-    }
-    if (typeof normalized.method !== "string" && typeof input.workflow === "string") {
-        normalized.method = input.workflow;
-    }
-    delete normalized.dataset;
-    delete normalized.workflow;
-    return normalized;
-}
-function normalizePreparationObjectRequest(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const input = value;
-    const normalized = { ...input };
-    if (!normalized.preparation && input.dataset && typeof input.dataset === "object") {
-        normalized.preparation = input.dataset;
-    }
-    delete normalized.dataset;
-    return normalized;
-}
-function normalizePublicActionType(value) {
-    const normalized = normalizePreparationMethodRequest(value);
-    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
-        return normalized;
-    }
-    const output = { ...normalized };
-    if (output.action_type === "dataset-setup")
-        output.action_type = "preparation-setup";
-    if (output.action_type === "workflow-authoring")
-        output.action_type = "method-authoring";
-    if (output.action_type === "workflow-improvement")
-        output.action_type = "method-improvement";
-    for (const key of ["title", "summary", "assistant_message", "command_preview"]) {
-        if (output[key] == null || output[key] === "") {
-            delete output[key];
-        }
-    }
-    return output;
-}
-function normalizeWorkflowAuthoringRequest(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const input = value;
-    const normalized = normalizePreparationMethodRequest(input);
-    if (typeof normalized.source_folder_path !== "string" && typeof input.dataset_path === "string") {
-        normalized.source_folder_path = input.dataset_path;
-    }
-    if (typeof normalized.method_id !== "string") {
-        if (typeof input.workflow_id === "string")
-            normalized.method_id = input.workflow_id;
-        else if (typeof normalized.method === "string")
-            normalized.method_id = normalized.method;
-    }
-    if (typeof normalized.base_method_id !== "string" && typeof input.base_workflow_id === "string") {
-        normalized.base_method_id = input.base_workflow_id;
-    }
-    if (typeof normalized.reference_method_id !== "string" && typeof input.reference_workflow_id === "string") {
-        normalized.reference_method_id = input.reference_workflow_id;
-    }
-    delete normalized.dataset_path;
-    delete normalized.workflow_id;
-    delete normalized.base_workflow_id;
-    delete normalized.reference_workflow_id;
-    return normalized;
-}
 export const LocalServiceHostSchema = z.string().min(1);
 export const LocalServicePortSchema = z.number().int().min(1).max(65535);
 export const LocalServiceConfigSchema = z.object({
@@ -107,19 +30,12 @@ export const LocalServiceInstancePointerSchema = z.object({
     control_path: z.string().min(1),
     started_at: z.string().min(1),
 }).strict();
-export const DatasetResourceSchema = z.object({
-    dataset: SourceDatasetConfigSchema,
-    portable_context_path: z.string().min(1).nullable(),
-    readiness: ReadinessStateSchema,
-    latest_compile_run_id: z.string().min(1).nullable().optional(),
-    latest_test_run_id: z.string().min(1).nullable().optional(),
-}).strict();
 export const PreparationReadinessStateSchema = ReadinessStateSchema;
 export const PortableContextMappingSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1).nullable(),
     exists: z.boolean(),
-    method_id: WorkflowIdSchema.nullable(),
+    method_id: MethodIdSchema.nullable(),
     latest_compile_run_id: z.string().min(1).nullable(),
     latest_test_run_id: z.string().min(1).nullable(),
 }).strict();
@@ -132,7 +48,7 @@ export const PreparationResourceSchema = z.object({
     name: PreparationNameSchema,
     preparation: SourcePreparationConfigSchema,
     source_path: z.string().min(1),
-    method_id: WorkflowIdSchema.nullable(),
+    method_id: MethodIdSchema.nullable(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
     portable_context: PortableContextMappingSchema,
     portable_context_path: z.string().min(1).nullable(),
@@ -141,34 +57,15 @@ export const PreparationResourceSchema = z.object({
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
 }).strict();
-export const WorkflowPackageResourceSchema = z.object({
-    id: WorkflowIdSchema,
-    path: z.string().min(1),
-    label: z.string().min(1).optional(),
-    hint: z.string().min(1).optional(),
-    source_kind: z.enum(["builtin", "local"]).default("local"),
-    built_in: z.boolean().default(false),
-    active_for_datasets: z.array(DatasetNameSchema).default([]),
-    stages: z.array(z.object({
-        id: z.string().min(1),
-        label: z.string().min(1),
-        description: z.string().min(1).optional(),
-        contract_type: z.string().min(1),
-        skill_dir: z.string().min(1),
-        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()).default([]),
-}).strict();
 export const MethodResourceSchema = z.object({
-    id: WorkflowIdSchema,
-    method_id: WorkflowIdSchema,
+    id: MethodIdSchema,
+    method_id: MethodIdSchema,
     path: z.string().min(1),
     label: z.string().min(1).optional(),
     hint: z.string().min(1).optional(),
     source_kind: z.enum(["builtin", "local"]).default("local"),
     built_in: z.boolean().default(false),
-    active_for_preparations: z.array(DatasetNameSchema).default([]),
+    active_for_preparations: z.array(PreparationNameSchema).default([]),
     stages: z.array(z.object({
         id: z.string().min(1),
         label: z.string().min(1),
@@ -180,18 +77,18 @@ export const MethodResourceSchema = z.object({
         acceptance: z.record(z.string(), z.unknown()).optional(),
     }).strict()).default([]),
 }).strict();
-export const CompileRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+export const CompileRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
-    method: WorkflowIdSchema.optional(),
+    method: MethodIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
-}).strict());
+}).strict();
 export const CompileRunSummarySchema = z.object({
     run_id: z.string().min(1),
     status: CompileRunStatusSchema,
     preparation: PreparationNameSchema,
-    method: WorkflowIdSchema,
+    method: MethodIdSchema,
     portable_context_path: z.string().min(1),
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
@@ -219,6 +116,7 @@ export const LocalJobStatusSchema = z.enum([
 export const LocalRunHandlerResultSchema = z.object({
     ok: z.boolean(),
     error: z.string().min(1).optional(),
+    comparison: ReadinessCheckRunSchema.nullable().optional(),
 }).strict();
 export const LocalJobAgentSchema = z.object({
     name: z.string().min(1),
@@ -259,11 +157,11 @@ export const LocalJobEventSchema = z.object({
     input: JsonObjectSchema.nullable().optional(),
     output: JsonObjectSchema.nullable().optional(),
 }).strict();
-export const LocalJobRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+export const LocalJobRunCreateRequestSchema = z.object({
     job_type: LocalJobTypeSchema,
     title: z.string().min(1),
     preparation: PreparationNameSchema.nullable().optional(),
-    method: WorkflowIdSchema.nullable().optional(),
+    method: MethodIdSchema.nullable().optional(),
     source_path: z.string().min(1).nullable().optional(),
     output_path: z.string().min(1).nullable().optional(),
     agent: LocalJobAgentSchema.nullable().optional(),
@@ -272,32 +170,32 @@ export const LocalJobRunCreateRequestSchema = z.preprocess(normalizePreparationM
         label: z.string().min(1),
         input: JsonObjectSchema.nullable().optional(),
     }).strict()).default([]),
-}).strict());
-export const PreparationSetupCreateRequestSchema = z.preprocess(normalizePreparationObjectRequest, z.object({
+}).strict();
+export const PreparationSetupCreateRequestSchema = z.object({
     preparation: SourcePreparationConfigSchema,
-}).strict());
-export const DatasetSetupCreateRequestSchema = PreparationSetupCreateRequestSchema;
-export const ReadinessCheckDraftCreateRequestSchema = z.preprocess(normalizeWorkflowAuthoringRequest, z.object({
+    prepare_after_setup: z.boolean().default(false),
+}).strict();
+export const ReadinessCheckDraftCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
     source_folder_path: z.string().min(1),
     about: z.string().min(1).optional(),
     target_count: z.number().int().min(1).max(8).default(4),
-}).strict());
+}).strict();
 export const ReadinessCheckDraftResultSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
 }).strict();
-export const WorkflowAuthoringCreateRequestSchema = z.preprocess(normalizeWorkflowAuthoringRequest, z.object({
+export const MethodAuthoringCreateRequestSchema = z.object({
     preparation: PreparationNameSchema.nullable().optional(),
     source_folder_path: z.string().min(1),
-    base_method_id: WorkflowIdSchema.optional(),
-    reference_method_id: WorkflowIdSchema.optional(),
-    method_id: WorkflowIdSchema,
+    base_method_id: MethodIdSchema.optional(),
+    reference_method_id: MethodIdSchema.optional(),
+    method_id: MethodIdSchema,
     label: z.string().min(1),
     hint: z.string().min(1),
     task_prompt: z.string().min(1),
     checks: z.array(SourceReadinessCheckSchema).default([]),
-}).strict());
-export const WorkflowAuthoringResultSchema = z.object({
+}).strict();
+export const MethodAuthoringResultSchema = z.object({
     status: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
     changed: z.boolean(),
     summary: z.string().min(1),
@@ -321,7 +219,7 @@ export const LocalJobRunResourceSchema = z.object({
     status: LocalJobStatusSchema,
     title: z.string().min(1),
     preparation: PreparationNameSchema.nullable().optional(),
-    method: WorkflowIdSchema.nullable().optional(),
+    method: MethodIdSchema.nullable().optional(),
     source_path: z.string().min(1).nullable().optional(),
     output_path: z.string().min(1).nullable().optional(),
     agent: LocalJobAgentSchema.nullable().optional(),
@@ -340,10 +238,10 @@ export const TestRunStatusSchema = z.enum([
     "failed",
     "cancelled",
 ]);
-export const TestRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+export const TestRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
     mode: TestRunModeSchema.default("both"),
-}).strict());
+}).strict();
 export const TestRunResourceSchema = z.object({
     run_id: z.string().min(1),
     status: TestRunStatusSchema,
@@ -353,17 +251,17 @@ export const TestRunResourceSchema = z.object({
     portable_context_path: z.string().min(1).nullable(),
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
-    comparison: TestRunComparisonSchema.nullable(),
+    comparison: ReadinessCheckRunSchema.nullable(),
     readiness: ReadinessStateSchema.nullable().optional(),
     events: z.array(InterfRunEventSchema).default([]),
     error: z.string().min(1).nullable().optional(),
 }).strict();
 export const RunObservabilityResourceSchema = RunObservabilitySchema;
-export const RunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.discriminatedUnion("run_type", [
+export const RunCreateRequestSchema = z.discriminatedUnion("run_type", [
     z.object({
         run_type: z.literal("compile"),
         preparation: PreparationNameSchema,
-        method: WorkflowIdSchema.optional(),
+        method: MethodIdSchema.optional(),
         max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
         max_loops: SourceCompiledMaxLoopsSchema.optional(),
         preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
@@ -371,7 +269,7 @@ export const RunCreateRequestSchema = z.preprocess(normalizePreparationMethodReq
     z.object({
         run_type: z.literal("prepare"),
         preparation: PreparationNameSchema,
-        method: WorkflowIdSchema.optional(),
+        method: MethodIdSchema.optional(),
         max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
         max_loops: SourceCompiledMaxLoopsSchema.optional(),
         preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
@@ -386,7 +284,7 @@ export const RunCreateRequestSchema = z.preprocess(normalizePreparationMethodReq
         preparation: PreparationNameSchema,
         mode: TestRunModeSchema.default("both"),
     }).strict(),
-]));
+]);
 export const LocalExecutorStatusSchema = z.object({
     kind: z.literal("interf-local-executor-status"),
     version: z.literal(1),
@@ -416,21 +314,21 @@ export const ActionProposalStatusSchema = z.enum([
     "submitted",
     "failed",
 ]);
-export const ActionProposalCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+export const ActionProposalCreateRequestSchema = z.object({
     message: z.string().min(1),
     preparation: PreparationNameSchema.optional(),
     values: JsonObjectSchema.optional(),
-}).strict());
-export const ActionProposalPlanSchema = z.preprocess(normalizePublicActionType, z.object({
+}).strict();
+export const ActionProposalPlanSchema = z.object({
     action_type: ActionProposalTypeSchema,
     preparation: PreparationNameSchema.optional(),
-    method: WorkflowIdSchema.optional(),
+    method: MethodIdSchema.optional(),
     values: JsonObjectSchema.optional(),
     title: z.string().min(1).optional(),
     summary: z.string().min(1).optional(),
     assistant_message: z.string().min(1).optional(),
     command_preview: z.string().min(1).optional(),
-}).strict());
+}).strict();
 export const ActionProposalApprovalRequestSchema = z.object({
     approved: z.boolean(),
     note: z.string().min(1).optional(),
@@ -451,7 +349,7 @@ const ActionProposalResourceBaseSchema = z.object({
     command_preview: z.string().min(1).optional(),
     message: z.string().min(1),
     preparation: PreparationNameSchema.nullable().optional(),
-    method: WorkflowIdSchema.nullable().optional(),
+    method: MethodIdSchema.nullable().optional(),
     created_at: z.string().min(1),
     updated_at: z.string().min(1),
     proposed_by_executor: LocalJobAgentSchema.nullable().optional(),
@@ -483,11 +381,11 @@ export const ActionProposalResourceSchema = z.discriminatedUnion("action_type",
     }).strict(),
     ActionProposalResourceBaseSchema.extend({
         action_type: z.literal("method-authoring"),
-        request: WorkflowAuthoringCreateRequestSchema,
+        request: MethodAuthoringCreateRequestSchema,
     }).strict(),
     ActionProposalResourceBaseSchema.extend({
         action_type: z.literal("method-improvement"),
-        request: WorkflowAuthoringCreateRequestSchema,
+        request: MethodAuthoringCreateRequestSchema,
     }).strict(),
 ]);
 export const PortableContextResourceSchema = z.object({
@@ -495,7 +393,7 @@ export const PortableContextResourceSchema = z.object({
     path: z.string().min(1),
     exists: z.boolean(),
     readiness: ReadinessStateSchema,
-    method: WorkflowIdSchema.nullable().optional(),
+    method: MethodIdSchema.nullable().optional(),
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
     artifacts: z.array(ArtifactRefSchema).default([]),
@@ -538,18 +436,10 @@ export const OpenPathResponseSchema = z.object({
     path: z.string().min(1),
 }).strict();
 export const LocalServiceResourceSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("dataset"),
-        value: DatasetResourceSchema,
-    }).strict(),
     z.object({
         kind: z.literal("preparation"),
         value: PreparationResourceSchema,
     }).strict(),
-    z.object({
-        kind: z.literal("workflow-package"),
-        value: WorkflowPackageResourceSchema,
-    }).strict(),
     z.object({
         kind: z.literal("method"),
         value: MethodResourceSchema,
@@ -595,15 +485,9 @@ export const LocalServiceResourceSchema = z.discriminatedUnion("kind", [
         value: WorkspaceFileResourceSchema,
     }).strict(),
 ]);
-export const DatasetListResponseSchema = z.object({
-    datasets: z.array(DatasetResourceSchema),
-}).strict();
 export const PreparationListResponseSchema = z.object({
     preparations: z.array(PreparationResourceSchema),
 }).strict();
-export const WorkflowPackageListResponseSchema = z.object({
-    workflow_packages: z.array(WorkflowPackageResourceSchema),
-}).strict();
 export const MethodListResponseSchema = z.object({
     methods: z.array(MethodResourceSchema),
 }).strict();

package/dist/packages/local-service/run-observability.d.ts

@@ -0,0 +1,6 @@
+import { type ArtifactRef, type CompileRun } from "../execution/lib/schema.js";
+import { type LocalJobRunResource, type RunObservabilityResource, type TestRunResource } from "./lib/schema.js";
+export declare function uniqueArtifacts(artifacts: ArtifactRef[]): ArtifactRef[];
+export declare function compileRunToObservability(run: CompileRun): RunObservabilityResource;
+export declare function testRunToObservability(run: TestRunResource): RunObservabilityResource;
+export declare function jobRunToObservability(job: LocalJobRunResource): RunObservabilityResource;