@interf/compiler 0.9.1 → 0.9.4

package/dist/cli/commands/compile.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { loadCompiledDatasetConfig, sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { loadCompiledPreparationConfig, sourcePreparationConfigFromInterfConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../../packages/project-model/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig, } from "./compiled-flow.js";
 import { resolveConfiguredPreparationSelection } from "./preparation-selection.js";
@@ -10,6 +10,7 @@ import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { runConfiguredCompiledCompile } from "./compile-controller.js";
 import { submitCompileRunToLocalService, waitForLocalCompileRun, } from "../../packages/local-service/index.js";
 import { resolveCommandControlPath } from "./control-path.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
@@ -46,7 +47,7 @@ function readHintedSourcePath(argv) {
         ? argv.sourcePath.trim()
         : null;
 }
-function readRequestedDatasetName(argv) {
+function readRequestedPreparationName(argv) {
     const raw = argv.preparation;
     return typeof raw === "string" && raw.trim().length > 0
         ? raw.trim()
@@ -55,15 +56,15 @@ function readRequestedDatasetName(argv) {
 function shouldSkipCompileConfirm(argv) {
     return argv.skipConfirm === true;
 }
-function shouldSkipDatasetBanner(argv) {
-    return argv.skipDatasetBanner === true;
+function shouldSkipPreparationBanner(argv) {
+    return argv.skipPreparationBanner === true;
 }
 function compileRunTests(options) {
     const checks = options.compiledConfig?.checks ?? [];
     if (checks.length === 0)
         return false;
-    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const configuredMaxAttempts = resolvePreparationCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolvePreparationCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
     const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
     return maxAttempts != null;
 }
@@ -77,15 +78,15 @@ export async function runCompileCommand(argv = {}, deps = {}) {
     const detected = hintedSourcePath ? null : helpers.detectInterf(process.cwd());
     let sourcePath = hintedSourcePath ?? resolveCommandControlPath();
     let compiledConfig = null;
-    const requestedDatasetName = readRequestedDatasetName(argv);
-    const hintedDatasetConfig = (argv.datasetConfig ?? null);
+    const requestedPreparationName = readRequestedPreparationName(argv);
+    const hintedPreparationConfig = (argv.preparationConfig ?? null);
     const skipConfirm = shouldSkipCompileConfirm(argv);
-    const skipDatasetBanner = shouldSkipDatasetBanner(argv);
+    const skipPreparationBanner = shouldSkipPreparationBanner(argv);
     if (detected) {
         compiledPath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
-        compiledConfig = loadCompiledDatasetConfig(detected.path)
-            ?? sourceDatasetConfigFromInterfConfig(detected.config);
+        compiledConfig = loadCompiledPreparationConfig(detected.path)
+            ?? sourcePreparationConfigFromInterfConfig(detected.config);
         if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await helpers.confirm({
                 message: `Prepare files for Preparation "${detected.config.name}" now?`,
@@ -96,11 +97,11 @@ export async function runCompileCommand(argv = {}, deps = {}) {
         }
     }
     else {
-        const selectedCompiled = requestedDatasetName || hintedDatasetConfig
+        const selectedCompiled = requestedPreparationName || hintedPreparationConfig
             ? resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedPreparationName: requestedDatasetName,
-                hintedPreparationConfig: hintedDatasetConfig,
+                requestedPreparationName,
+                hintedPreparationConfig,
             })
             : await helpers.chooseCompiledConfigToBuild({
                 sourcePath,
@@ -110,8 +111,8 @@ export async function runCompileCommand(argv = {}, deps = {}) {
             return null;
         if (!selectedCompiled) {
             process.exitCode = 1;
-            if (requestedDatasetName) {
-                console.log(chalk.red(`  Preparation "${requestedDatasetName}" is not saved in this Source Folder.`));
+            if (requestedPreparationName) {
+                console.log(chalk.red(`  Preparation "${requestedPreparationName}" is not saved in this Source Folder.`));
                 console.log(chalk.dim("  Run `interf list` to see the saved Preparations."));
             }
             else {
@@ -130,7 +131,7 @@ export async function runCompileCommand(argv = {}, deps = {}) {
         }
         compiledConfig = selectedCompiled;
         compiledPath = helpers.ensureCompiledFromConfig(sourcePath, selectedCompiled);
-        if (!skipDatasetBanner) {
+        if (!skipPreparationBanner) {
             console.log(chalk.dim(`  Preparation: ${selectedCompiled.name}`));
         }
     }
@@ -225,6 +226,7 @@ export async function runCompileCommand(argv = {}, deps = {}) {
     }
     const compiled = await helpers.runConfiguredCompiledCompile({
         executor,
+        testExecutor: executor,
         compiledPath,
         sourcePath,
         compiledConfig,
@@ -269,8 +271,8 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
     }
     const savedCompiledConfig = options.compiledConfig
         ?? (currentConfig
-            ? (loadCompiledDatasetConfig(options.compiledPath)
-                ?? sourceDatasetConfigFromInterfConfig(currentConfig))
+            ? (loadCompiledPreparationConfig(options.compiledPath)
+                ?? sourcePreparationConfigFromInterfConfig(currentConfig))
             : null);
     if (!savedCompiledConfig) {
         return {
@@ -287,7 +289,7 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
             initialMaxAttempts: savedCompiledConfig.max_attempts,
             initialMaxLoops: savedCompiledConfig.max_loops,
             intro: [
-                `Method: ${savedCompiledConfig.method ?? savedCompiledConfig.workflow ?? currentConfig?.method ?? currentConfig?.workflow ?? "interf-default"}`,
+                `Method: ${resolveMethodId(savedCompiledConfig, resolveMethodId(currentConfig))}`,
                 "This selection applies to this prepare run only. It does not change the saved Preparation.",
             ],
             message: "How should this prepare run work?",
@@ -333,7 +335,7 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         initialMaxAttempts: savedCompiledConfig.max_attempts,
         initialMaxLoops: savedCompiledConfig.max_loops,
         intro: [
-            `Method: ${savedCompiledConfig.method ?? savedCompiledConfig.workflow ?? currentConfig?.method ?? currentConfig?.workflow ?? "interf-default"}`,
+            `Method: ${resolveMethodId(savedCompiledConfig, resolveMethodId(currentConfig))}`,
             "This applies to this prepare run only. It does not change the saved Preparation.",
         ],
         message: "Override the prepare mode for this run",

package/dist/cli/commands/compiled-flow.d.ts

@@ -1,22 +1,22 @@
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
-import { type StageShellRetentionMode, type CompiledCompileResult } from "../../packages/compiler/workflows.js";
-import type { WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import { type StageShellRetentionMode, type CompiledCompileResult } from "../../packages/compiler/method-runs.js";
+import type { MethodExecutor } from "../../packages/agents/lib/executors.js";
 import type { RunEventSink } from "../../packages/execution/events.js";
-export interface SavedDatasetEntry {
-    config: SourceDatasetConfig;
+export interface SavedPreparationEntry {
+    config: SourcePreparationConfig;
     path: string | null;
     localDraft: boolean;
 }
-export declare function listSavedCompiledEntries(sourcePath: string): SavedDatasetEntry[];
+export declare function listSavedPreparationEntries(sourcePath: string): SavedPreparationEntry[];
 export declare function findBuiltCompiledPath(sourcePath: string, compiledName: string): string | null;
-export declare function findSavedCompiledConfig(sourcePath: string, compiledName: string): SourceDatasetConfig | null;
+export declare function findSavedCompiledConfig(sourcePath: string, compiledName: string): SourcePreparationConfig | null;
 export declare function chooseCompiledConfigToBuild(options: {
     sourcePath: string;
     selectMessage: string;
-}): Promise<SourceDatasetConfig | null | undefined>;
-export declare function createCompiledFromConfig(sourcePath: string, datasetConfig: SourceDatasetConfig): string;
-export declare function ensureCompiledFromConfig(sourcePath: string, datasetConfig: SourceDatasetConfig): string;
-export declare function compileCompiledWithReporter(executor: WorkflowExecutor, compiledPath: string, options?: {
+}): Promise<SourcePreparationConfig | null | undefined>;
+export declare function createCompiledFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;
+export declare function ensureCompiledFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;
+export declare function compileCompiledWithReporter(executor: MethodExecutor, compiledPath: string, options?: {
     heading?: string;
     successMessage?: string;
     preserveStageShells?: StageShellRetentionMode;

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

@@ -1,32 +1,33 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listCompiledDatasetsForSourceFolder } from "../../packages/project-model/interf.js";
-import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
-import { compileCompiled, createCompiled, } from "../../packages/compiler/workflows.js";
-import { formatWorkflowExecutionProfile } from "../../packages/agents/lib/execution-profile.js";
-function formatSavedDatasetHint(entry) {
+import { ensurePortableContextScaffold, listPortableContextsForSourceFolder, } from "../../packages/project-model/interf.js";
+import { listSourcePreparationConfigs, loadCompiledPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncCompiledInterfConfigFromSourcePreparationConfig, } from "../../packages/project-model/source-config.js";
+import { compileCompiled, createCompiled, } from "../../packages/compiler/method-runs.js";
+import { formatMethodExecutionProfile } from "../../packages/agents/lib/execution-profile.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
+function formatSavedPreparationHint(entry) {
     const config = entry.config;
     const checkCount = config.checks.length;
-    const workflowHint = `Method ${config.method ?? config.workflow ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`;
+    const methodHint = `Method ${resolveMethodId(config)}${entry.localDraft ? " (local draft)" : ""}`;
     if (config.about)
-        return `${config.path} · ${config.about} · ${workflowHint}`;
+        return `${config.path} · ${config.about} · ${methodHint}`;
     if (checkCount === 0)
-        return `${config.path} · No readiness checks yet · ${workflowHint}`;
-    return `${config.path} · ${checkCount} readiness check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+        return `${config.path} · No readiness checks yet · ${methodHint}`;
+    return `${config.path} · ${checkCount} readiness check${checkCount === 1 ? "" : "s"} · ${methodHint}`;
 }
-export function listSavedCompiledEntries(sourcePath) {
+export function listSavedPreparationEntries(sourcePath) {
     const builtEntries = new Map();
-    for (const builtCompiled of listCompiledDatasetsForSourceFolder(sourcePath)) {
-        const datasetConfig = loadCompiledDatasetConfig(builtCompiled.path)
-            ?? sourceDatasetConfigFromInterfConfig(builtCompiled.config);
+    for (const builtCompiled of listPortableContextsForSourceFolder(sourcePath)) {
+        const preparationConfig = loadCompiledPreparationConfig(builtCompiled.path)
+            ?? sourcePreparationConfigFromInterfConfig(builtCompiled.config);
         builtEntries.set(builtCompiled.config.name, {
-            config: datasetConfig,
+            config: preparationConfig,
             path: builtCompiled.path,
-            localDraft: builtCompiled.config.workflow_origin?.local_draft === true,
+            localDraft: builtCompiled.config.method_origin?.local_draft === true,
         });
     }
     const entries = new Map();
-    for (const config of listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath))) {
+    for (const config of listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath))) {
         const built = builtEntries.get(config.name);
         entries.set(config.name, {
             config,
@@ -37,13 +38,13 @@ export function listSavedCompiledEntries(sourcePath) {
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
 export function findBuiltCompiledPath(sourcePath, compiledName) {
-    return listSavedCompiledEntries(sourcePath).find((entry) => entry.config.name === compiledName)?.path ?? null;
+    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === compiledName)?.path ?? null;
 }
 export function findSavedCompiledConfig(sourcePath, compiledName) {
-    return listSavedCompiledEntries(sourcePath).find((entry) => entry.config.name === compiledName)?.config ?? null;
+    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === compiledName)?.config ?? null;
 }
 export async function chooseCompiledConfigToBuild(options) {
-    const savedEntries = listSavedCompiledEntries(options.sourcePath);
+    const savedEntries = listSavedPreparationEntries(options.sourcePath);
     if (savedEntries.length === 0) {
         return null;
     }
@@ -56,7 +57,7 @@ export async function chooseCompiledConfigToBuild(options) {
             value: entry.config.name,
             label: entry.config.name,
             hint: [
-                formatSavedDatasetHint(entry),
+                formatSavedPreparationHint(entry),
                 entry.path ? "Portable Context available" : "Portable Context not built yet",
             ].join(" · "),
         })),
@@ -65,25 +66,27 @@ export async function chooseCompiledConfigToBuild(options) {
         return undefined;
     return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
 }
-export function createCompiledFromConfig(sourcePath, datasetConfig) {
-    const workflowId = datasetConfig.method ?? datasetConfig.workflow ?? "interf-default";
-    const datasetSourcePath = resolveSourceDatasetPath(sourcePath, datasetConfig);
-    const compiledPath = createCompiled(datasetConfig.name, sourcePath, workflowId, datasetConfig.about, datasetSourcePath);
-    syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig);
+export function createCompiledFromConfig(sourcePath, preparationConfig) {
+    const methodId = resolveMethodId(preparationConfig);
+    const sourceFolderPath = resolveSourcePreparationPath(sourcePath, preparationConfig);
+    const compiledPath = createCompiled(preparationConfig.name, sourcePath, methodId, preparationConfig.about, sourceFolderPath);
+    syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
     return compiledPath;
 }
-export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
-    const existingPath = findBuiltCompiledPath(sourcePath, datasetConfig.name);
+export function ensureCompiledFromConfig(sourcePath, preparationConfig) {
+    const methodId = resolveMethodId(preparationConfig);
+    const existingPath = findBuiltCompiledPath(sourcePath, preparationConfig.name);
     if (existingPath) {
-        syncCompiledInterfConfigFromSourceDatasetConfig(existingPath, datasetConfig);
+        ensurePortableContextScaffold(sourcePath, preparationConfig.name, methodId);
+        syncCompiledInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
         return existingPath;
     }
-    return createCompiledFromConfig(sourcePath, datasetConfig);
+    return createCompiledFromConfig(sourcePath, preparationConfig);
 }
 export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
     console.log();
     console.log(chalk.bold(`  ${options.heading ?? "Building Portable Context..."}`));
-    const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
+    const profileLabel = formatMethodExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
     }

package/dist/cli/commands/create-method-wizard.d.ts

@@ -0,0 +1,76 @@
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runMethodAuthoringDraft } from "../../packages/method-authoring/method-authoring.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import type { MethodExecutionProfile } from "../../packages/agents/lib/executors.js";
+export interface MethodWizardPrompts {
+    intro(message: string): void;
+    select(options: {
+        message: string;
+        options: Array<{
+            value: string;
+            label: string;
+            hint?: string;
+        }>;
+    }): Promise<string | symbol>;
+    text(options: {
+        message: string;
+        placeholder?: string;
+        initialValue?: string;
+        validate?: (value: string) => string | undefined;
+    }): Promise<string | symbol>;
+    isCancel(value: unknown): value is symbol;
+    log: {
+        info(message: string): void;
+        error?(message: string): void;
+    };
+}
+export interface MethodWizardPreparationContext {
+    config: SourcePreparationConfig;
+    sourceFolderPath: string;
+}
+export declare const clackMethodPrompts: MethodWizardPrompts;
+type MethodCreationMode = "draft-from-scratch" | "fork-existing" | "draft" | "manual";
+export declare function formatMethodLabel(method: {
+    id: string;
+    label: string;
+    hint: string;
+    scope?: "builtin" | "local";
+}): {
+    value: string;
+    label: string;
+    hint: string;
+};
+export declare function buildCompiledMethodOptions(sourcePath: string): {
+    value: string;
+    label: string;
+    hint: string;
+}[];
+export declare function chooseCompiledMethod(sourcePath: string, options?: {
+    currentMethodId?: string;
+    message?: string;
+}): Promise<string | symbol>;
+export declare function chooseOrCreateCompiledMethodForPreparation(sourcePath: string, preparationConfig: SourcePreparationConfig, options?: {
+    currentMethodId?: string;
+    executionProfile?: MethodExecutionProfile;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runMethodAuthoringDraft;
+}, prompts?: MethodWizardPrompts): Promise<string | symbol | null>;
+export declare function createMethodWizard(options?: {
+    intro?: boolean;
+    sourcePath?: string;
+    executionProfile?: MethodExecutionProfile;
+    baseMethodId?: string;
+    creationMode?: MethodCreationMode;
+    preparationContext?: MethodWizardPreparationContext;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runMethodAuthoringDraft;
+}, prompts?: MethodWizardPrompts): Promise<string | symbol | null>;
+export declare function createCompiledMethodWizard(sourcePath: string, prompts?: MethodWizardPrompts, options?: {
+    executionProfile?: MethodExecutionProfile;
+    baseMethodId?: string;
+    creationMode?: MethodCreationMode;
+    preparationContext?: MethodWizardPreparationContext;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runMethodAuthoringDraft;
+}): Promise<string | symbol | null>;
+export {};