@interf/compiler 0.9.4 → 0.13.0

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 + Method binding so future runs can be invoked by name.";
+    };
+    readonly compileRun: {
+        readonly id: "compile-run";
+        readonly serviceAction: "compile";
+        readonly title: "Compile Method";
+        readonly description: "Run the chosen Method against this Source Folder and write portable context.";
+    };
+    readonly selectMethod: {
+        readonly id: "select-method";
+        readonly serviceAction: "preparation-setup";
+        readonly title: "Select Method";
+        readonly description: "Choose which Method this saved binding should use for future runs.";
+    };
+    readonly createMethod: {
+        readonly id: "create-method";
+        readonly serviceAction: "method-authoring";
+        readonly title: "Draft Method";
+        readonly description: "Draft a reusable local Method that captures a repeatable 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 Method";
+        readonly description: "Use readiness evidence to refine the Method this saved binding uses.";
+    };
+};
+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[];
+    prepDataDir: string;
+    suggestedName: string;
+};
+export type CompileRunActionContext = {
+    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 buildCompileRunActionDefinition(context: CompileRunActionContext): ActionInputDefinition;
+export declare function buildCompileRunActionDraft(context: CompileRunActionContext): 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;