@interf/compiler 0.9.4 → 0.9.5

package/dist/cli/commands/create-method-wizard.js

@@ -2,15 +2,12 @@ import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { resolve } from "node:path";
 import { listCompiledMethodChoices, getCompiledMethod, } from "../../packages/method-package/method-definitions.js";
-import { createLocalMethodPackageFromTemplate } from "../../packages/method-package/interf-method-package.js";
-import { rmSync } from "node:fs";
-import { isMethodId, loadMethodDefinitionFromDir, seedLocalDefaultMethod, } from "../../packages/method-package/local-methods.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runMethodAuthoringDraft } from "../../packages/method-authoring/method-authoring.js";
+import { loadMethodDefinitionFromDir, } from "../../packages/method-package/local-methods.js";
 import { listSourcePreparationConfigs, loadSourceFolderConfig, resolveSourcePreparationPath, } from "../../packages/project-model/source-config.js";
-import { slugify } from "../../packages/shared/naming.js";
-import { submitMethodAuthoringRunToLocalService } from "../../packages/local-service/index.js";
+import { MethodChangeCreateRequestSchema, submitMethodAuthoringRunToLocalService, submitMethodChangeToLocalService, } from "../../packages/local-service/index.js";
+import { MethodAuthoringActionValuesSchema, buildCreateMethodActionDefinition, buildMethodChangeActionDefinition, methodAuthoringTaskPrompt, } from "../../packages/local-service/action-definitions.js";
 import { DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER, listSourceFolderChoices, normalizeSourceFolderPathForConfig, } from "./source-config-wizard.js";
+import { promptActionInputValues } from "./action-input-cli.js";
 export const clackMethodPrompts = {
     intro: p.intro,
     select: (options) => p.select(options),
@@ -112,6 +109,35 @@ function methodUseLabel(method) {
 function methodForkLabel(method) {
     return `Fork ${methodUseLabel(method)}`;
 }
+async function promptMethodAuthoringValues(options) {
+    const existingMethodIds = listCompiledMethodChoices(options.sourcePath).map((method) => method.id);
+    const definition = buildCreateMethodActionDefinition({
+        defaultPreparation: options.defaultPreparation ?? "",
+        existingMethodIds,
+        suggestedMethodId: options.defaultPreparation ? `${options.defaultPreparation}-method` : "custom-method",
+    });
+    const values = await promptActionInputValues(definition, {
+        prompts: options.prompts,
+        omitFields: options.includeOutputFields
+            ? undefined
+            : new Set(["portable_output", "readiness_notes"]),
+    });
+    if (!values)
+        return null;
+    const parsed = MethodAuthoringActionValuesSchema.parse(values);
+    const methodId = parsed.method_id;
+    const label = parsed.label;
+    const hint = parsed.hint;
+    if (!methodId || !label || !hint) {
+        throw new Error("Create Method action did not produce complete Method metadata.");
+    }
+    return {
+        methodId,
+        label,
+        hint,
+        taskPrompt: methodAuthoringTaskPrompt(parsed),
+    };
+}
 export async function chooseCompiledMethod(sourcePath, options = {}) {
     const currentMethodId = options.currentMethodId;
     const methodOptions = buildCompiledMethodOptions(sourcePath);
@@ -179,15 +205,9 @@ export async function chooseOrCreateCompiledMethodForPreparation(sourcePath, pre
     if (prompts.isCancel(selected))
         return selected;
     if (selected === "__current__") {
-        if (currentMethod?.value === "interf-default") {
-            seedLocalDefaultMethod({ sourcePath });
-        }
         return currentMethod?.value ?? currentMethodId;
     }
     if (selected === "__draft_from_scratch__" || selected === "__fork_existing__") {
-        if (selected === "__fork_existing__" && currentMethod?.value === "interf-default") {
-            seedLocalDefaultMethod({ sourcePath });
-        }
         const methodId = await createMethodWizard({
             intro: false,
             sourcePath,
@@ -195,9 +215,6 @@ export async function chooseOrCreateCompiledMethodForPreparation(sourcePath, pre
                 ? currentMethod?.value ?? currentMethodId
                 : undefined,
             creationMode: selected === "__draft_from_scratch__" ? "draft-from-scratch" : "fork-existing",
-            executionProfile: options.executionProfile,
-            resolveExecutor: options.resolveExecutor,
-            runDraft: options.runDraft,
             preparationContext: {
                 config: preparationConfig,
                 sourceFolderPath: resolveSourcePreparationPath(sourcePath, preparationConfig),
@@ -213,12 +230,9 @@ export async function createMethodWizard(options = {}, prompts = clackMethodProm
     }
     const sourcePath = options.sourcePath ?? process.cwd();
     return createCompiledMethodWizard(sourcePath, prompts, {
-        executionProfile: options.executionProfile,
         baseMethodId: options.baseMethodId,
         creationMode: options.creationMode,
         preparationContext: options.preparationContext,
-        resolveExecutor: options.resolveExecutor,
-        runDraft: options.runDraft,
     });
 }
 export async function createCompiledMethodWizard(sourcePath, prompts = clackMethodPrompts, options = {}) {
@@ -252,32 +266,6 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
     const resolvedBaseMethod = baseMethodId
         ? getCompiledMethod(baseMethodId, { sourcePath })
         : null;
-    const rawName = await prompts.text({
-        message: "New Method name?",
-        placeholder: "customer-research",
-        validate: (value) => {
-            if (value.trim().length === 0)
-                return "Name is required";
-            const methodId = slugify(value);
-            if (!isMethodId(methodId))
-                return "Use letters, numbers, and dashes only";
-            if (listCompiledMethodChoices(sourcePath).some((method) => method.id === methodId)) {
-                return "That Method name already exists";
-            }
-            return undefined;
-        },
-    });
-    if (prompts.isCancel(rawName))
-        return rawName;
-    const methodId = slugify(rawName);
-    const label = rawName.trim();
-    const hint = await prompts.text({
-        message: "One-line Method description?",
-        placeholder: "Bias toward evidence-backed summaries and strong retrieval structure",
-        validate: (value) => (value.trim().length === 0 ? "Description is required" : undefined),
-    });
-    if (prompts.isCancel(hint))
-        return hint;
     if (creationModeValue === "draft-from-scratch") {
         let sourceFolderPath = options.preparationContext?.sourceFolderPath ?? null;
         let matchedPreparation = options.preparationContext?.config ?? null;
@@ -318,13 +306,16 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
             sourceFolderPath = String(sourceFolderPrompt);
             matchedPreparation = matchedPreparation ?? findMatchingPreparationConfig(sourcePath, sourceFolderPath);
         }
-        const taskPrompt = await prompts.text({
-            message: "What should this Method prepare for agents, and what evidence should show the data is ready?",
-            placeholder: "Data: research interviews. Output: per-file summaries, themes, entities, claims, and source links. Evidence: every file processed, evidence linked to sources, required outputs created.",
-            validate: (value) => (value.trim().length === 0 ? "A description is required" : undefined),
+        const methodValues = await promptMethodAuthoringValues({
+            defaultPreparation: matchedPreparation?.name ?? options.preparationContext?.config.name,
+            includeOutputFields: true,
+            prompts,
+            sourcePath,
         });
-        if (prompts.isCancel(taskPrompt))
-            return taskPrompt;
+        if (prompts.isCancel(methodValues))
+            return methodValues;
+        if (!methodValues)
+            return null;
         if (matchedPreparation) {
             prompts.log.info(`Shaping this Method from Preparation "${matchedPreparation.name}".`);
         }
@@ -338,10 +329,10 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
             request: {
                 preparation: matchedPreparation?.name ?? null,
                 source_folder_path: sourceFolderPath,
-                method_id: methodId,
-                label,
-                hint: hint.trim(),
-                task_prompt: taskPrompt.trim(),
+                method_id: methodValues.methodId,
+                label: methodValues.label,
+                hint: methodValues.hint,
+                task_prompt: methodValues.taskPrompt,
                 checks: matchedPreparation?.checks ?? [],
             },
             onSubmitted: (submission) => {
@@ -360,59 +351,36 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
                     : `Method draft run: ${job.status}`);
             },
         });
-        const result = serviceRun
-            ? serviceRun.result
-                ? {
-                    status: serviceRun.result.status,
-                    changed: serviceRun.result.changed,
-                    summary: serviceRun.result.summary,
-                    validation: serviceRun.result.validation ?? null,
-                    methodPath: serviceRun.result.method_path,
-                    shellPath: serviceRun.result.shell_path,
-                }
-                : {
-                    status: "executor-failed",
-                    changed: false,
-                    summary: serviceRun.error ?? "Method authoring failed in the local Interf service.",
-                    validation: null,
-                    methodPath: resolve(sourcePath, "interf", "methods", methodId),
-                    shellPath: resolve(sourcePath, "interf", "methods", methodId),
-                }
-            : await (async () => {
-                const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
-                const runDraft = options.runDraft ?? runMethodAuthoringDraft;
-                const { executor, error } = await resolveExecutor({
-                    executionProfile: options.executionProfile,
-                    purpose: "method",
-                });
-                if (!executor && !error) {
-                    return null;
-                }
-                if (!executor) {
-                    process.exitCode = 1;
-                    (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
-                    return null;
-                }
-                return runDraft({
-                    sourcePath,
-                    sourceFolderPath,
-                    methodId,
-                    label,
-                    hint: hint.trim(),
-                    taskPrompt: taskPrompt.trim(),
-                    checks: matchedPreparation?.checks ?? [],
-                    executor,
-                    onStatus: (line) => prompts.log.info(line),
-                });
-            })();
+        if (!serviceRun) {
+            process.exitCode = 1;
+            (prompts.log.error ?? prompts.log.info)("Interf local service is not running. Start `interf web`, then rerun Method creation so the draft run is visible in Interf.");
+            return null;
+        }
+        const result = serviceRun.result
+            ? {
+                status: serviceRun.result.status,
+                changed: serviceRun.result.changed,
+                summary: serviceRun.result.summary,
+                validation: serviceRun.result.validation ?? null,
+                methodPath: serviceRun.result.method_path,
+                shellPath: serviceRun.result.shell_path,
+            }
+            : {
+                status: "executor-failed",
+                changed: false,
+                summary: serviceRun.error ?? "Method authoring failed in the local Interf service.",
+                validation: null,
+                methodPath: resolve(sourcePath, "interf", "methods", methodValues.methodId),
+                shellPath: resolve(sourcePath, "interf", "methods", methodValues.methodId),
+            };
         if (!result)
             return null;
         if (result.status === "updated") {
             const draft = loadMethodDefinitionFromDir(result.methodPath);
             const stageList = draft?.stages?.map((stage) => stage.id).join(" -> ") ?? "-";
             prompts.log.info(`Draft ready at ${result.methodPath}`);
-            prompts.log.info(`  Name: ${draft?.label ?? label}`);
-            prompts.log.info(`  Description: ${draft?.hint ?? hint.trim()}`);
+            prompts.log.info(`  Name: ${draft?.label ?? methodValues.label}`);
+            prompts.log.info(`  Description: ${draft?.hint ?? methodValues.hint}`);
             if (draft?.purpose)
                 prompts.log.info(`  Purpose: ${draft.purpose}`);
             prompts.log.info(`  Stages: ${stageList}`);
@@ -420,16 +388,15 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
                 message: "Save this Method?",
                 options: [
                     { value: "save", label: "Save", hint: "Keep the draft as your new Method package" },
-                    { value: "cancel", label: "Discard", hint: "Remove the draft folder and exit without saving" },
+                    { value: "cancel", label: "Close", hint: "Leave the service-created draft in place for review" },
                 ],
             });
             if (prompts.isCancel(confirmChoice) || confirmChoice === "cancel") {
-                rmSync(result.methodPath, { recursive: true, force: true });
-                prompts.log.info(`Discarded draft at ${result.methodPath}`);
+                prompts.log.info(`Draft kept at ${result.methodPath}`);
                 return null;
             }
             prompts.log.info(`Saved local Method: ${result.methodPath}`);
-            return methodId;
+            return methodValues.methodId;
         }
         process.exitCode = 1;
         (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
@@ -438,28 +405,30 @@ export async function createCompiledMethodWizard(sourcePath, prompts = clackMeth
         prompts.log.info(`Method shell kept at: ${result.shellPath}`);
         return null;
     }
-    const stagePolicyNotes = {};
     if (!baseMethodId || !resolvedBaseMethod) {
         throw new Error("Fork-existing Method creation needs a base Method.");
     }
-    for (const stage of resolvedBaseMethod.stages) {
-        const stagePrompt = await prompts.text({
-            message: `What should ${stage.id} (${stage.label}) emphasize?`,
-            placeholder: stage.description,
-            validate: (value) => (value.trim().length === 0 ? `${stage.label} guidance is required` : undefined),
-        });
-        if (prompts.isCancel(stagePrompt))
-            return stagePrompt;
-        stagePolicyNotes[stage.id] = [String(stagePrompt).trim()];
-    }
-    const methodPath = createLocalMethodPackageFromTemplate({
-        sourcePath,
-        baseMethodId,
-        methodId,
-        label,
-        hint: hint.trim(),
-        stagePolicyNotes,
+    const duplicateDefinition = buildMethodChangeActionDefinition({
+        action: "duplicate",
+        existingMethodIds: listCompiledMethodChoices(sourcePath).map((method) => method.id),
+        hint: resolvedBaseMethod.hint ?? null,
+        label: resolvedBaseMethod.label ?? baseMethodId,
+        methodId: baseMethodId,
+        preparation: options.preparationContext?.config.name ?? "",
     });
-    prompts.log.info(`Saved local Method: ${methodPath}`);
-    return methodId;
+    const duplicateValues = await promptActionInputValues(duplicateDefinition, { prompts });
+    if (!duplicateValues)
+        return null;
+    const duplicateDraft = duplicateDefinition.buildDraft(duplicateValues);
+    const result = await submitMethodChangeToLocalService({
+        projectPath: sourcePath,
+        request: MethodChangeCreateRequestSchema.parse(duplicateDraft.values),
+    });
+    if (!result) {
+        process.exitCode = 1;
+        (prompts.log.error ?? prompts.log.info)("Interf local service is not running. Start `interf web`, then rerun Method creation so the Method change is visible in Interf.");
+        return null;
+    }
+    prompts.log.info(`Saved local Method: ${result.method_path}`);
+    return result.new_method_id ?? null;
 }

package/dist/cli/commands/create.d.ts

@@ -1,8 +1,6 @@
 import type { CommandModule } from "yargs";
-import type { MethodExecutionProfile } from "../../packages/agents/lib/executors.js";
 export declare const createCommand: CommandModule;
 export declare function createCompiledWizard(options?: {
     intro?: boolean;
-    executionProfile?: MethodExecutionProfile;
 }): Promise<void>;
 export { type MethodWizardPrompts, formatMethodLabel, createMethodWizard, createCompiledMethodWizard, } from "./create-method-wizard.js";

package/dist/cli/commands/create.js

@@ -1,14 +1,13 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, ensurePortableContextScaffold, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
-import { SOURCE_FOLDER_CONFIG_PATH, listSourcePreparationConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../../packages/project-model/source-config.js";
+import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { SOURCE_FOLDER_CONFIG_PATH, listSourcePreparationConfigs, loadSourceFolderConfig, } from "../../packages/project-model/source-config.js";
 import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
-import { findBuiltCompiledPath, } from "./compiled-flow.js";
+import { findBuiltPortableContextPath, } from "../../packages/project-model/preparation-entries.js";
 import { DEFAULT_PREPARATION_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
 import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
 import { resolveCommandControlPath, resolveInterfInstanceContext, } from "./control-path.js";
-import { resolveMethodId } from "../../packages/methods/method-resolution.js";
+import { savePreparationThroughServiceAction } from "./preparation-action.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
@@ -75,16 +74,12 @@ async function maybeAssignMethodToPreparation(sourcePath, methodId) {
         ...targetPreparation,
         method: methodId,
     };
-    upsertSourcePreparationConfig(sourcePath, nextConfig, {
-        matchName: targetPreparation.name,
+    await savePreparationThroughServiceAction({
+        sourcePath,
+        preparation: nextConfig,
+        setupMode: "select-method",
     });
-    const builtCompiledPath = findBuiltCompiledPath(sourcePath, targetPreparation.name);
-    if (builtCompiledPath) {
-        syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, nextConfig);
-    }
-    else {
-        ensurePortableContextScaffold(sourcePath, nextConfig.name, resolveMethodId(nextConfig));
-    }
+    const builtCompiledPath = findBuiltPortableContextPath(sourcePath, targetPreparation.name);
     p.log.info(`Assigned Method "${methodId}" to Preparation "${targetPreparation.name}".`);
     if (builtCompiledPath) {
         p.log.info("The active local Method copy for that Portable Context lives under `.interf/method/`.");
@@ -94,15 +89,14 @@ async function maybeAssignMethodToPreparation(sourcePath, methodId) {
 export const createCommand = {
     command: "create [type]",
     describe: "Create a Preparation or reusable Method",
-    builder: (yargs) => addExecutionProfileOptions(yargs.positional("type", {
+    builder: (yargs) => yargs.positional("type", {
         type: "string",
         describe: "Type to create (`preparation` or `method`)",
         default: undefined,
-    })),
+    }),
     handler: async (argv) => {
         const rawType = argv.type;
         let type = normalizeCreateTarget(rawType);
-        const executionProfile = executionProfileFromArgv(argv);
         if (rawType && !type) {
             process.exitCode = 1;
             p.log.error(`Unknown create target: ${rawType}`);
@@ -119,14 +113,13 @@ export const createCommand = {
             const sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
             const methodId = await createMethodWizard({
                 sourcePath,
-                executionProfile,
             });
             if (typeof methodId === "string") {
                 await maybeAssignMethodToPreparation(sourcePath, methodId);
             }
             return;
         }
-        await createCompiledWizard({ executionProfile });
+        await createCompiledWizard();
     },
 };
 export async function createCompiledWizard(options = {}) {
@@ -172,7 +165,6 @@ export async function createCompiledWizard(options = {}) {
     }
     const methodChoice = await chooseOrCreateCompiledMethodForPreparation(sourcePath, draft, {
         currentMethodId: "interf-default",
-        executionProfile: options.executionProfile,
     });
     if (!methodChoice || p.isCancel(methodChoice))
         return;
@@ -180,8 +172,10 @@ export async function createCompiledWizard(options = {}) {
         ...draft,
         method: String(methodChoice),
     };
-    upsertSourcePreparationConfig(sourcePath, configToSave);
-    ensurePortableContextScaffold(sourcePath, configToSave.name, configToSave.method);
+    await savePreparationThroughServiceAction({
+        sourcePath,
+        preparation: configToSave,
+    });
     p.outro(configToSave.checks.length > 0
         ? "Saved Preparation.\nNext:\n  interf compile\n  interf test"
         : "Saved Preparation.\nNext:\n  interf or interf init");

package/dist/cli/commands/doctor.js

@@ -97,7 +97,7 @@ export const doctorCommand = {
                 id: "live",
                 label: "Live executor preflight",
                 status: "skipped",
-                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before a check draft, Method authoring run, readiness check, or Compilation.",
+                message: "Skipped. Run `interf doctor --live` to exercise the real local agent before drafting readiness checks, Method authoring, a readiness check, or a prepare run.",
             });
         }
         const ok = checks.every((check) => check.status !== "fail");

package/dist/cli/commands/executor-flow.js

@@ -86,7 +86,7 @@ export async function promptForTestAgents() {
 }
 async function promptForRunAgent(purpose) {
     const purposeLabel = purpose === "draft"
-        ? "check draft"
+        ? "draft readiness checks"
         : purpose === "method"
             ? "Method authoring"
             : purpose;

package/dist/cli/commands/init.d.ts

@@ -1,11 +1,26 @@
 import type { CommandModule } from "yargs";
 import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
-import { type AgentTestMatrixRow } from "./test-flow.js";
 import { runCompileCommand } from "./compile.js";
 export type CurrentRunTargetStatus = "pass" | "mixed" | "fail" | "missing";
+interface AgentTestMatrixRow {
+    agentLabel: string;
+    rawOutcome?: {
+        result: {
+            totalCases: number;
+            passedCases: number;
+        };
+    } | null;
+    compiledOutcome?: {
+        result: {
+            totalCases: number;
+            passedCases: number;
+        };
+    } | null;
+}
 export declare function currentRunTargetStatus(rows: AgentTestMatrixRow[], target: "raw" | "compiled"): CurrentRunTargetStatus;
 export declare function compileSelectedCompiled(sourcePath: string, compiledConfig: SourcePreparationConfig, deps?: {
     runCompileCommand?: typeof runCompileCommand;
 }): Promise<import("./compile.js").CompileCommandResult | null>;
 export declare const initCommand: CommandModule;
 export declare function runInitCommand(): Promise<void>;
+export {};