@interf/compiler 0.9.4 → 0.9.5

package/dist/index.d.ts

@@ -1,26 +1,3 @@
-export * as compiler from "./packages/compiler/index.js";
 export * as contracts from "./packages/contracts/index.js";
-export * as methods from "./packages/methods/index.js";
-export * as methodPackage from "./packages/method-package/index.js";
-export * as methodAuthoring from "./packages/method-authoring/index.js";
 export * as execution from "./packages/execution/index.js";
 export * as localService from "./packages/local-service/index.js";
-export * as projectModel from "./packages/project-model/index.js";
-export * as agents from "./packages/agents/index.js";
-export * as testing from "./packages/testing/index.js";
-export { createCompiled, } from "./packages/project-model/interf.js";
-export { compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./packages/compiler/method-runs.js";
-export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./packages/testing/test.js";
-export { computeCompiledHealth, } from "./packages/compiler/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, loadSourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
-export { validateCompiledSummarize, validateCompiledCompile, } from "./packages/compiler/validate.js";
-export { InterfConfigSchema, SourceFolderConfigSchema, } from "./packages/project-model/lib/schema.js";
-export { TestSpecSchema, } from "./packages/testing/lib/schema.js";
-export { CompiledHealthSchema, } from "./packages/compiler/lib/schema.js";
-export type { InterfConfig } from "./packages/project-model/lib/schema.js";
-export type { TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, LoadedTestSpec, TestTargetCandidate, } from "./packages/testing/index.js";
-export type { SourceReadinessCheck, SourcePreparationConfig, SourceFolderConfig, } from "./packages/project-model/lib/schema.js";
-export type { TestCaseExpect, } from "./packages/testing/lib/schema.js";
-export type { CompiledHealth, } from "./packages/compiler/lib/schema.js";
-export type { CompiledStageValidation, CompiledMethodValidation, } from "./packages/compiler/validate.js";
-export type { CompiledSummarizeResult, CompiledCompileResult, } from "./packages/compiler/method-runs.js";

package/dist/index.js

@@ -1,19 +1,3 @@
-export * as compiler from "./packages/compiler/index.js";
 export * as contracts from "./packages/contracts/index.js";
-export * as methods from "./packages/methods/index.js";
-export * as methodPackage from "./packages/method-package/index.js";
-export * as methodAuthoring from "./packages/method-authoring/index.js";
 export * as execution from "./packages/execution/index.js";
 export * as localService from "./packages/local-service/index.js";
-export * as projectModel from "./packages/project-model/index.js";
-export * as agents from "./packages/agents/index.js";
-export * as testing from "./packages/testing/index.js";
-export { createCompiled, } from "./packages/project-model/interf.js";
-export { compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./packages/compiler/method-runs.js";
-export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./packages/testing/test.js";
-export { computeCompiledHealth, } from "./packages/compiler/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, loadSourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
-export { validateCompiledSummarize, validateCompiledCompile, } from "./packages/compiler/validate.js";
-export { InterfConfigSchema, SourceFolderConfigSchema, } from "./packages/project-model/lib/schema.js";
-export { TestSpecSchema, } from "./packages/testing/lib/schema.js";
-export { CompiledHealthSchema, } from "./packages/compiler/lib/schema.js";

package/dist/packages/agents/lib/shells.js

@@ -956,8 +956,8 @@ export function createMethodImprovementShell(options) {
     if (reviewSources.executionShells) {
         copyIfExists(reviewSources.executionShells, join(shellRoot, "artifacts", "execution-shells"), "method-improvement");
     }
-    if (reviewSources.testComparisons) {
-        copyIfExists(reviewSources.testComparisons, join(shellRoot, "artifacts", "test-comparisons"), "method-improvement");
+    if (reviewSources.readinessRuns) {
+        copyIfExists(reviewSources.readinessRuns, join(shellRoot, "artifacts", "readiness-runs"), "method-improvement");
     }
     if (reviewSources.targetTestRuns) {
         copyIfExists(reviewSources.targetTestRuns, join(shellRoot, "artifacts", "test-runs"), "method-improvement");

package/dist/packages/compiler/lib/schema.d.ts

@@ -475,7 +475,7 @@ export declare const MethodImprovementContextSchema: z.ZodObject<{
     review_paths: z.ZodObject<{
         method_root: z.ZodString;
         compiled_runtime: z.ZodNullable<z.ZodString>;
-        test_comparisons: z.ZodNullable<z.ZodString>;
+        readiness_runs: z.ZodNullable<z.ZodString>;
         execution_shells: z.ZodNullable<z.ZodString>;
         test_runs: z.ZodNullable<z.ZodString>;
         test_sandboxes: z.ZodNullable<z.ZodString>;

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

@@ -260,7 +260,7 @@ export const MethodImprovementContextSchema = z.object({
     review_paths: z.object({
         method_root: z.string(),
         compiled_runtime: z.string().nullable(),
-        test_comparisons: z.string().nullable(),
+        readiness_runs: z.string().nullable(),
         execution_shells: z.string().nullable(),
         test_runs: z.string().nullable(),
         test_sandboxes: z.string().nullable(),

package/dist/packages/contracts/lib/schema.d.ts

@@ -139,7 +139,6 @@ export declare const ReadinessStateSchema: z.ZodObject<{
             run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strict>>;
-        delta: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strict>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         gate: z.ZodEnum<{

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

@@ -68,7 +68,6 @@ export const ReadinessStateSchema = z.object({
         fingerprint: z.string().min(1).nullable(),
         source_files: ReadinessTargetResultSchema.nullable(),
         portable_context: ReadinessTargetResultSchema.nullable(),
-        delta: z.number().nullable(),
     }).strict(),
     checks: z.array(ReadinessCheckSchema).default([]),
 }).strict();

package/dist/packages/execution/lib/schema.d.ts

@@ -155,7 +155,6 @@ export declare const ObservableRunTypeSchema: z.ZodEnum<{
     compile: "compile";
     "method-authoring": "method-authoring";
     "method-improvement": "method-improvement";
-    "preparation-setup": "preparation-setup";
     test: "test";
     "readiness-check-draft": "readiness-check-draft";
     job: "job";
@@ -223,7 +222,6 @@ export declare const RunObservabilitySchema: z.ZodObject<{
         compile: "compile";
         "method-authoring": "method-authoring";
         "method-improvement": "method-improvement";
-        "preparation-setup": "preparation-setup";
         test: "test";
         "readiness-check-draft": "readiness-check-draft";
         job: "job";
@@ -351,7 +349,6 @@ export declare const RunObservabilitySchema: z.ZodObject<{
                 run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strict>>;
-            delta: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
@@ -702,7 +699,6 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
                 run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strict>>;
-            delta: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
@@ -939,7 +935,6 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
                 run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strict>>;
-            delta: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
@@ -1368,7 +1363,6 @@ export declare const CompileRunSchema: z.ZodObject<{
                     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 }, z.core.$strict>>;
-                delta: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strict>;
             checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 gate: z.ZodEnum<{
@@ -1495,7 +1489,6 @@ export declare const CompileRunSchema: z.ZodObject<{
                 run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             }, z.core.$strict>>;
-            delta: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{

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

@@ -71,7 +71,6 @@ export const MethodTraceSchema = z.object({
     streams: z.array(MethodTraceStreamChunkSchema).default([]),
 }).strict();
 export const ObservableRunTypeSchema = z.enum([
-    "preparation-setup",
     "compile",
     "test",
     "readiness-check-draft",

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

@@ -0,0 +1,246 @@
+import { z } from "zod";
+export declare const ActionValueIdPattern: RegExp;
+export declare const ActionValueIdSchema: z.ZodString;
+export declare const OptionalActionValueIdSchema: z.ZodString;
+export declare const SourceReadinessCheckActionValueSchema: z.ZodObject<{
+    question: z.ZodString;
+    answer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const PreparationSetupActionValuesSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    about: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        answer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
+    readiness_notes: z.ZodOptional<z.ZodString>;
+    prepare_after_setup: z.ZodOptional<z.ZodBoolean>;
+    setup_mode: z.ZodOptional<z.ZodEnum<{
+        create: "create";
+        "select-method": "select-method";
+    }>>;
+}, z.core.$strict>;
+export declare const MethodAuthoringActionValuesSchema: z.ZodObject<{
+    method_id: z.ZodOptional<z.ZodString>;
+    base_method_id: z.ZodOptional<z.ZodString>;
+    reference_method_id: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<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 type SourceReadinessCheckActionValue = z.infer<typeof SourceReadinessCheckActionValueSchema>;
+export declare const INTERF_SERVICE_ACTIONS: {
+    readonly createPreparation: {
+        readonly id: "create-preparation";
+        readonly serviceAction: "preparation-setup";
+        readonly title: "Create Preparation";
+        readonly description: "Save a Source Folder and agent job as a Preparation.";
+    };
+    readonly runPreparation: {
+        readonly id: "prepare-run";
+        readonly serviceAction: "compile";
+        readonly title: "Run Preparation";
+        readonly description: "Build portable context for a saved Preparation.";
+    };
+    readonly selectMethod: {
+        readonly id: "select-method";
+        readonly serviceAction: "preparation-setup";
+        readonly title: "Select Method";
+        readonly description: "Save the Method a Preparation should use for future prepare runs.";
+    };
+    readonly createMethod: {
+        readonly id: "create-method";
+        readonly serviceAction: "method-authoring";
+        readonly title: "Create Method";
+        readonly description: "Draft a reusable local Method for an agent-work pattern.";
+    };
+    readonly methodChange: {
+        readonly id: "method-change";
+        readonly serviceAction: "method-change";
+        readonly title: "Method Change";
+        readonly description: "Modify, duplicate, or remove an existing Method.";
+    };
+    readonly preparationChange: {
+        readonly id: "preparation-change";
+        readonly serviceAction: "preparation-change";
+        readonly title: "Preparation Change";
+        readonly description: "Modify, duplicate, or remove an existing Preparation.";
+    };
+    readonly confirmAction: {
+        readonly id: "confirm-action";
+        readonly serviceAction: "action-proposal";
+        readonly title: "Send Request";
+        readonly description: "Confirm the typed Interf service request before it runs.";
+    };
+    readonly checkReadiness: {
+        readonly id: "check-readiness";
+        readonly serviceAction: "test";
+        readonly title: "Check Readiness";
+        readonly description: "Run saved readiness checks against this Preparation.";
+    };
+    readonly draftReadinessChecks: {
+        readonly id: "draft-readiness-checks";
+        readonly serviceAction: "readiness-check-draft";
+        readonly title: "Draft Readiness Checks";
+        readonly description: "Ask the configured local executor to draft saved readiness checks.";
+    };
+    readonly improvePreparation: {
+        readonly id: "improve-preparation";
+        readonly serviceAction: "method-improvement";
+        readonly title: "Improve Preparation";
+        readonly description: "Use readiness evidence to improve the Method for this Preparation.";
+    };
+};
+export type InterfServiceActionKey = keyof typeof INTERF_SERVICE_ACTIONS;
+export type InterfServiceActionId = typeof INTERF_SERVICE_ACTIONS[InterfServiceActionKey]["id"];
+export declare function methodAuthoringTaskPrompt(values: MethodAuthoringActionValues): string;
+export type ActionInputValues = Record<string, string>;
+export type ActionValues = Record<string, unknown>;
+export type ActionInputDraft = {
+    confirmed?: boolean;
+    preparation: string;
+    message: string;
+    values?: ActionValues;
+};
+export type ActionFieldOption = {
+    label: string;
+    value: string;
+};
+export type ActionFieldDefinition = {
+    advanced?: boolean;
+    context: string;
+    help: string;
+    label: string;
+    name: string;
+    options?: ActionFieldOption[];
+    placeholder?: string;
+    readOnly?: boolean;
+    rows?: number;
+    type: "text" | "textarea" | "select";
+};
+export type ActionInputDefinition = {
+    buildDraft: (values: ActionInputValues) => ActionInputDraft;
+    description: string;
+    fields: ActionFieldDefinition[];
+    id: string;
+    initialValues: ActionInputValues;
+    normalizeValues?: (values: ActionInputValues) => ActionInputValues;
+    schema: z.ZodType<ActionInputValues>;
+    submitLabel: string;
+    title: string;
+    validateRequest?: (values: ActionInputValues) => Record<string, string>;
+    valuesPreview: (values: ActionInputValues) => ActionValues;
+};
+export type MethodActionChoice = {
+    id: string;
+    label?: string | null;
+};
+export type CreatePreparationActionContext = {
+    existingNames: string[];
+    methods: MethodActionChoice[];
+    sourcePath: string;
+    suggestedName: string;
+};
+export type PrepareRunActionContext = {
+    about: string;
+    methodId: string;
+    name: string;
+    sourceFolderPath: string;
+};
+export type SelectMethodActionContext = {
+    about: string;
+    checks?: SourceReadinessCheckActionValue[];
+    currentMethodId: string;
+    maxAttempts?: number;
+    maxLoops?: number;
+    methods: MethodActionChoice[];
+    name: string;
+    sourceFolderPath: string;
+};
+export type CreateMethodActionContext = {
+    defaultPreparation: string;
+    existingMethodIds: string[];
+    suggestedMethodId: string;
+};
+export type MethodChangeAction = "modify" | "duplicate" | "remove";
+export type PreparationChangeAction = "modify" | "duplicate" | "remove";
+export type ReadinessAction = "check" | "draft-checks" | "improve";
+export type MethodChangeActionContext = {
+    action: MethodChangeAction;
+    existingMethodIds: string[];
+    hint?: string | null;
+    label?: string | null;
+    methodId: string;
+    preparation: string;
+};
+export type PreparationChangeActionContext = {
+    about?: string | null;
+    action: PreparationChangeAction;
+    existingNames: string[];
+    methodId?: string | null;
+    preparation: string;
+    sourceFolderPath: string;
+};
+export declare function packageSchemaFieldErrors(result: z.ZodSafeParseResult<unknown>, pathMap: Record<string, string>): Record<string, string>;
+export declare function slugForActionId(value: string): string;
+export declare function uniqueActionId(seed: string, usedIds: Set<string>): string;
+export declare function titleFromActionId(value: string): string;
+export declare function maybeActionValue(value: string): string | undefined;
+export declare function methodChoiceOptions(methods: MethodActionChoice[]): ActionFieldOption[];
+export declare function methodTaskPromptFromInput(values: ActionInputValues): string;
+export declare function preparationSetupRequestFromActionValues(input: unknown): {
+    preparation: {
+        about: string;
+        checks: SourceReadinessCheckActionValue[];
+        max_attempts?: number;
+        max_loops?: number;
+        method: string;
+        name: string;
+        path: string;
+    };
+    prepare_after_setup: boolean;
+    setup_mode: "create" | "select-method";
+};
+export declare function methodAuthoringRequestFromActionValues(input: unknown, context: {
+    checks?: SourceReadinessCheckActionValue[];
+    preparation?: string | null;
+    sourceFolderPath: string;
+}): {
+    base_method_id?: string;
+    checks: SourceReadinessCheckActionValue[];
+    hint: string;
+    label: string;
+    method_id: string;
+    preparation?: string;
+    reference_method_id?: string;
+    source_folder_path: string;
+    task_prompt: string;
+};
+export declare function methodImprovementActionValues(options: {
+    checks?: SourceReadinessCheckActionValue[];
+    hint?: string;
+    label?: string;
+    methodId: string;
+    preparationName: string;
+}): MethodAuthoringActionValues;
+export declare function buildCreatePreparationActionDefinition(context: CreatePreparationActionContext): ActionInputDefinition;
+export declare function buildPrepareRunActionDefinition(context: PrepareRunActionContext): ActionInputDefinition;
+export declare function buildPrepareRunActionDraft(context: PrepareRunActionContext): ActionInputDraft;
+export declare function buildSelectMethodActionDefinition(context: SelectMethodActionContext): ActionInputDefinition;
+export declare function buildCreateMethodActionDefinition(context: CreateMethodActionContext): ActionInputDefinition;
+export declare function buildMethodChangeActionDefinition(context: MethodChangeActionContext): ActionInputDefinition;
+export declare function buildPreparationChangeActionDefinition(context: PreparationChangeActionContext): ActionInputDefinition;
+export declare function buildConfirmActionDefinition(draft: ActionInputDraft): ActionInputDefinition;
+export declare function buildReadinessActionDraft(options: {
+    action: ReadinessAction;
+    methodId?: string;
+    preparation: string;
+}): ActionInputDraft;