@interf/compiler 0.4.0 → 0.5.0

package/dist/commands/compile.js

@@ -1,23 +1,22 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { sourceWorkspaceConfigFromInterfConfig, } from "../lib/source-config.js";
+import { sourceDatasetConfigFromInterfConfig, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { chooseWorkspaceConfigToBuild, ensureWorkspaceFromConfig, } from "./workspace-flow.js";
+import { chooseCompiledConfigToBuild, ensureCompiledFromConfig, } from "./compiled-flow.js";
 import { promptCompileLoopSelection, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredWorkspaceCompile } from "./compile-controller.js";
-export { runConfiguredWorkspaceCompile } from "./compile-controller.js";
+import { runConfiguredCompiledCompile } from "./compile-controller.js";
+export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build a workspace for this dataset",
+    describe: "Build the compiled dataset for the selected dataset",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
-        alias: "max-retries",
         type: "number",
-        describe: "Retry compile + test for the same workflow until the workspace passes or reaches this total attempt limit",
+        describe: "Retry compile + test for the same workflow until the dataset passes or reaches this total attempt limit",
     }).option("max-loops", {
         type: "number",
-        describe: "After retries fail, let Interf edit the workflow and test new workflow variations up to this loop limit",
+        describe: "After retries fail, let Interf edit the workflow and test new workflow variations for this dataset up to this loop limit",
     }).option("keep-stage-shells", {
         type: "boolean",
         default: false,
@@ -28,17 +27,17 @@ export const compileCommand = {
     },
 };
 export async function runCompileCommand(argv = {}) {
-    let workspacePath = null;
+    let compiledPath = null;
     let sourcePath = process.cwd();
-    let workspaceConfig = null;
+    let compiledConfig = null;
     const detected = detectInterf(process.cwd());
     if (detected) {
-        workspacePath = detected.path;
+        compiledPath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
-        workspaceConfig = sourceWorkspaceConfigFromInterfConfig(detected.config);
+        compiledConfig = sourceDatasetConfigFromInterfConfig(detected.config);
         if (process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await p.confirm({
-                message: `Compile workspace "${detected.config.name}" now?`,
+                message: `Compile dataset "${detected.config.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
@@ -46,29 +45,29 @@ export async function runCompileCommand(argv = {}) {
         }
     }
     else {
-        const selectedWorkspace = await chooseWorkspaceConfigToBuild({
+        const selectedCompiled = await chooseCompiledConfigToBuild({
             sourcePath: process.cwd(),
-            selectMessage: "Which workspace do you want to compile?",
+            selectMessage: "Which dataset do you want to compile?",
         });
-        if (selectedWorkspace === undefined)
+        if (selectedCompiled === undefined)
             return;
-        if (!selectedWorkspace) {
+        if (!selectedCompiled) {
             process.exitCode = 1;
-            console.log(chalk.red("  No workspaces are set up for this folder yet."));
+            console.log(chalk.red("  No datasets are set up for this folder yet."));
             console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
             return;
         }
         if (process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await p.confirm({
-                message: `Compile workspace "${selectedWorkspace.name}" now?`,
+                message: `Compile dataset "${selectedCompiled.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
                 return;
         }
-        workspaceConfig = selectedWorkspace;
-        workspacePath = ensureWorkspaceFromConfig(process.cwd(), selectedWorkspace);
-        console.log(chalk.dim(`  Workspace: ${selectedWorkspace.name}`));
+        compiledConfig = selectedCompiled;
+        compiledPath = ensureCompiledFromConfig(process.cwd(), selectedCompiled);
+        console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
     }
     let maxAttemptsOverride = null;
     let maxLoopsOverride = null;
@@ -82,14 +81,14 @@ export async function runCompileCommand(argv = {}) {
         return;
     }
     const interactiveOverrides = await resolveInteractiveCompileLoopOverrides({
-        workspacePath,
-        workspaceConfig,
+        compiledPath,
+        compiledConfig,
         maxAttemptsOverride,
         maxLoopsOverride,
     });
     if (!interactiveOverrides)
         return;
-    workspaceConfig = interactiveOverrides.workspaceConfig;
+    compiledConfig = interactiveOverrides.compiledConfig;
     maxAttemptsOverride = interactiveOverrides.maxAttemptsOverride;
     maxLoopsOverride = interactiveOverrides.maxLoopsOverride;
     const executionProfile = executionProfileFromArgv(argv);
@@ -104,11 +103,11 @@ export async function runCompileCommand(argv = {}) {
         console.log(chalk.red(error ?? "No coding agent detected."));
         return;
     }
-    await runConfiguredWorkspaceCompile({
+    await runConfiguredCompiledCompile({
         executor,
-        workspacePath,
+        compiledPath,
         sourcePath,
-        workspaceConfig,
+        compiledConfig,
         executionProfile,
         maxAttemptsOverride,
         maxLoopsOverride,
@@ -118,56 +117,56 @@ export async function runCompileCommand(argv = {}) {
 export async function resolveInteractiveCompileLoopOverrides(options) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
         return {
-            workspaceConfig: options.workspaceConfig,
+            compiledConfig: options.compiledConfig,
             maxAttemptsOverride: options.maxAttemptsOverride,
             maxLoopsOverride: options.maxLoopsOverride,
         };
     }
     if (options.maxAttemptsOverride != null || options.maxLoopsOverride != null) {
         return {
-            workspaceConfig: options.workspaceConfig,
+            compiledConfig: options.compiledConfig,
             maxAttemptsOverride: options.maxAttemptsOverride,
             maxLoopsOverride: options.maxLoopsOverride,
         };
     }
-    const currentConfig = readInterfConfig(options.workspacePath);
-    const checks = options.workspaceConfig?.checks.length
-        ? options.workspaceConfig.checks
+    const currentConfig = readInterfConfig(options.compiledPath);
+    const checks = options.compiledConfig?.checks.length
+        ? options.compiledConfig.checks
         : (currentConfig?.checks ?? []);
     if (checks.length === 0) {
         return {
-            workspaceConfig: options.workspaceConfig,
+            compiledConfig: options.compiledConfig,
             maxAttemptsOverride: options.maxAttemptsOverride,
             maxLoopsOverride: options.maxLoopsOverride,
         };
     }
-    const savedWorkspaceConfig = options.workspaceConfig
-        ?? (currentConfig ? sourceWorkspaceConfigFromInterfConfig(currentConfig) : null);
-    if (!savedWorkspaceConfig) {
+    const savedCompiledConfig = options.compiledConfig
+        ?? (currentConfig ? sourceDatasetConfigFromInterfConfig(currentConfig) : null);
+    if (!savedCompiledConfig) {
         return {
-            workspaceConfig: options.workspaceConfig,
+            compiledConfig: options.compiledConfig,
             maxAttemptsOverride: options.maxAttemptsOverride,
             maxLoopsOverride: options.maxLoopsOverride,
         };
     }
-    const hasSavedPolicy = typeof savedWorkspaceConfig.max_attempts === "number" ||
-        typeof savedWorkspaceConfig.max_loops === "number";
+    const hasSavedPolicy = typeof savedCompiledConfig.max_attempts === "number" ||
+        typeof savedCompiledConfig.max_loops === "number";
     if (!hasSavedPolicy) {
         const overrideSelection = await promptCompileLoopSelection({
             hasChecks: true,
-            initialMaxAttempts: savedWorkspaceConfig.max_attempts,
-            initialMaxLoops: savedWorkspaceConfig.max_loops,
+            initialMaxAttempts: savedCompiledConfig.max_attempts,
+            initialMaxLoops: savedCompiledConfig.max_loops,
             intro: [
-                `Workflow: ${savedWorkspaceConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
-                "This selection applies to this compile run only. It does not change the saved workspace setup.",
+                `Workflow: ${savedCompiledConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
+                "This selection applies to this compile run only. It does not change the saved dataset setup.",
             ],
             message: "How should this compile run?",
         });
         if (overrideSelection === null)
             return null;
         return {
-            workspaceConfig: {
-                ...savedWorkspaceConfig,
+            compiledConfig: {
+                ...savedCompiledConfig,
                 max_attempts: undefined,
                 max_loops: undefined,
             },
@@ -181,12 +180,12 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
             {
                 value: "saved",
                 label: "Use saved compile mode (Recommended)",
-                hint: `${savedWorkspaceConfig.max_loops ? "Self-improving" : savedWorkspaceConfig.max_attempts && savedWorkspaceConfig.max_attempts > 1 ? "Retry" : "Single attempt"} · ${formatCompileModeHint(savedWorkspaceConfig)}`,
+                hint: `${savedCompiledConfig.max_loops ? "Self-improving" : savedCompiledConfig.max_attempts && savedCompiledConfig.max_attempts > 1 ? "Retry" : "Single attempt"} · ${formatCompileModeHint(savedCompiledConfig)}`,
             },
             {
                 value: "override",
                 label: "Change it for this run only",
-                hint: "Keep the saved workspace setup unchanged",
+                hint: "Keep the saved dataset setup unchanged",
             },
         ],
     });
@@ -194,27 +193,27 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         return null;
     if (savedMode === "saved") {
         return {
-            workspaceConfig: savedWorkspaceConfig,
+            compiledConfig: savedCompiledConfig,
             maxAttemptsOverride: null,
             maxLoopsOverride: null,
         };
     }
     const selection = await promptCompileLoopSelection({
         hasChecks: true,
-        initialMaxAttempts: savedWorkspaceConfig.max_attempts,
-        initialMaxLoops: savedWorkspaceConfig.max_loops,
+        initialMaxAttempts: savedCompiledConfig.max_attempts,
+        initialMaxLoops: savedCompiledConfig.max_loops,
         intro: [
-            `Workflow: ${savedWorkspaceConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
-            "This applies to this compile run only. It does not change the saved workspace setup.",
+            `Workflow: ${savedCompiledConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
+            "This applies to this compile run only. It does not change the saved dataset setup.",
         ],
         message: "Override the compile mode for this run",
     });
     if (selection === null)
         return null;
     return {
-        ...savedWorkspaceConfig,
-        workspaceConfig: {
-            ...savedWorkspaceConfig,
+        ...savedCompiledConfig,
+        compiledConfig: {
+            ...savedCompiledConfig,
             max_attempts: undefined,
             max_loops: undefined,
         },
@@ -222,13 +221,13 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         maxLoopsOverride: selection.max_loops ?? null,
     };
 }
-function formatCompileModeHint(workspaceConfig) {
-    if (typeof workspaceConfig.max_loops === "number" && workspaceConfig.max_loops > 0) {
-        const attempts = workspaceConfig.max_attempts ?? 1;
-        return `${attempts} attempt${attempts === 1 ? "" : "s"} per variation, ${workspaceConfig.max_loops} loop${workspaceConfig.max_loops === 1 ? "" : "s"}`;
+function formatCompileModeHint(compiledConfig) {
+    if (typeof compiledConfig.max_loops === "number" && compiledConfig.max_loops > 0) {
+        const attempts = compiledConfig.max_attempts ?? 1;
+        return `${attempts} attempt${attempts === 1 ? "" : "s"} per variation, ${compiledConfig.max_loops} loop${compiledConfig.max_loops === 1 ? "" : "s"}`;
     }
-    if (typeof workspaceConfig.max_attempts === "number" && workspaceConfig.max_attempts > 1) {
-        return `${workspaceConfig.max_attempts} attempts`;
+    if (typeof compiledConfig.max_attempts === "number" && compiledConfig.max_attempts > 1) {
+        return `${compiledConfig.max_attempts} attempts`;
     }
     return "1 attempt";
 }

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

@@ -0,0 +1,23 @@
+import type { SourceDatasetConfig } from "../lib/schema.js";
+import { type StageShellRetentionMode } from "../lib/workflows.js";
+import type { WorkflowExecutor } from "../lib/executors.js";
+import type { CompiledCompileResult } from "../lib/workflows.js";
+export interface SavedDatasetEntry {
+    config: SourceDatasetConfig;
+    path: string | null;
+    localDraft: boolean;
+}
+export declare function listSavedCompiledEntries(sourcePath: string): SavedDatasetEntry[];
+export declare function findBuiltCompiledPath(sourcePath: string, compiledName: string): string | null;
+export declare function findSavedCompiledConfig(sourcePath: string, compiledName: string): SourceDatasetConfig | 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?: {
+    heading?: string;
+    successMessage?: string;
+    preserveStageShells?: StageShellRetentionMode;
+}): Promise<CompiledCompileResult>;

package/dist/commands/compiled-flow.js

@@ -0,0 +1,112 @@
+import chalk from "chalk";
+import * as p from "@clack/prompts";
+import { listCompiledDatasetsForSourceFolder } from "../lib/interf.js";
+import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../lib/source-config.js";
+import { compileCompiled, createCompiled, } from "../lib/workflows.js";
+import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
+function formatSavedDatasetHint(entry) {
+    const config = entry.config;
+    const checkCount = config.checks.length;
+    const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
+    if (config.about)
+        return `${config.about} · ${workflowHint}`;
+    if (checkCount === 0)
+        return "No saved truth checks yet";
+    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+}
+export function listSavedCompiledEntries(sourcePath) {
+    const builtEntries = new Map();
+    for (const builtCompiled of listCompiledDatasetsForSourceFolder(sourcePath)) {
+        const datasetConfig = loadCompiledDatasetConfig(builtCompiled.path)
+            ?? sourceDatasetConfigFromInterfConfig(builtCompiled.config);
+        builtEntries.set(builtCompiled.config.name, {
+            config: datasetConfig,
+            path: builtCompiled.path,
+            localDraft: builtCompiled.config.workflow_origin?.local_draft === true,
+        });
+    }
+    const entries = new Map();
+    for (const config of listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath))) {
+        const built = builtEntries.get(config.name);
+        entries.set(config.name, {
+            config,
+            path: built?.path ?? null,
+            localDraft: built?.localDraft ?? false,
+        });
+    }
+    for (const [name, built] of builtEntries.entries()) {
+        if (entries.has(name))
+            continue;
+        entries.set(name, built);
+    }
+    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;
+}
+export function findSavedCompiledConfig(sourcePath, compiledName) {
+    return listSavedCompiledEntries(sourcePath).find((entry) => entry.config.name === compiledName)?.config ?? null;
+}
+export async function chooseCompiledConfigToBuild(options) {
+    const savedEntries = listSavedCompiledEntries(options.sourcePath);
+    if (savedEntries.length === 0) {
+        return null;
+    }
+    if (savedEntries.length === 1) {
+        return savedEntries[0]?.config ?? null;
+    }
+    const selected = await p.select({
+        message: options.selectMessage,
+        options: savedEntries.map((entry) => ({
+            value: entry.config.name,
+            label: entry.config.name,
+            hint: [
+                formatSavedDatasetHint(entry),
+                entry.path ? "built" : "not built yet",
+            ].join(" · "),
+        })),
+    });
+    if (p.isCancel(selected))
+        return undefined;
+    return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
+}
+export function createCompiledFromConfig(sourcePath, datasetConfig) {
+    const workflowId = datasetConfig.workflow ?? "interf";
+    const datasetSourcePath = resolveSourceDatasetPath(sourcePath, datasetConfig);
+    const compiledPath = createCompiled(datasetConfig.name, sourcePath, workflowId, datasetConfig.about, datasetSourcePath);
+    syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig);
+    return compiledPath;
+}
+export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
+    const existingPath = findBuiltCompiledPath(sourcePath, datasetConfig.name);
+    if (existingPath) {
+        syncCompiledInterfConfigFromSourceDatasetConfig(existingPath, datasetConfig);
+        return existingPath;
+    }
+    return createCompiledFromConfig(sourcePath, datasetConfig);
+}
+export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
+    console.log();
+    console.log(chalk.bold(`  ${options.heading ?? "Building compiled dataset..."}`));
+    const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
+    if (profileLabel) {
+        console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
+    }
+    console.log();
+    const reporter = {
+        line: (message) => console.log(chalk.dim(`  ${message}`)),
+        blankLine: () => console.log(),
+    };
+    const result = await compileCompiled({
+        executor,
+        compiledPath,
+        reporter,
+        preserveStageShells: options.preserveStageShells,
+    });
+    if (!result.ok) {
+        return result;
+    }
+    console.log();
+    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled dataset ready."}`));
+    return result;
+}

package/dist/commands/create-workflow-wizard.d.ts

@@ -30,12 +30,12 @@ export declare function formatWorkflowLabel(workflow: {
     label: string;
     hint: string;
 };
-export declare function buildWorkspaceWorkflowOptions(sourcePath: string): {
+export declare function buildCompiledWorkflowOptions(sourcePath: string): {
     value: string;
     label: string;
     hint: string;
 }[];
-export declare function chooseWorkspaceWorkflow(sourcePath: string, options?: {
+export declare function chooseCompiledWorkflow(sourcePath: string, options?: {
     currentWorkflowId?: string;
     message?: string;
 }): Promise<string | symbol>;
@@ -43,4 +43,4 @@ export declare function createWorkflowWizard(options?: {
     intro?: boolean;
     sourcePath?: string;
 }, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
-export declare function createWorkspaceWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
+export declare function createCompiledWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;

package/dist/commands/create-workflow-wizard.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listWorkspaceWorkflowChoices, } from "../lib/workflow-definitions.js";
+import { listCompiledWorkflowChoices, } from "../lib/workflow-definitions.js";
 import { createLocalWorkflowPackageFromTemplate } from "../lib/interf-workflow-package.js";
 import { isWorkflowId, } from "../lib/local-workflows.js";
 import { slugify } from "../lib/util.js";
@@ -20,12 +20,12 @@ export function formatWorkflowLabel(workflow) {
         hint: workflow.hint,
     };
 }
-export function buildWorkspaceWorkflowOptions(sourcePath) {
-    return listWorkspaceWorkflowChoices(sourcePath).map(formatWorkflowLabel);
+export function buildCompiledWorkflowOptions(sourcePath) {
+    return listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel);
 }
-export async function chooseWorkspaceWorkflow(sourcePath, options = {}) {
+export async function chooseCompiledWorkflow(sourcePath, options = {}) {
     const currentWorkflowId = options.currentWorkflowId;
-    const workflowOptions = buildWorkspaceWorkflowOptions(sourcePath);
+    const workflowOptions = buildCompiledWorkflowOptions(sourcePath);
     const orderedOptions = workflowOptions
         .map((option) => option.value === currentWorkflowId
         ? {
@@ -45,7 +45,7 @@ export async function chooseWorkspaceWorkflow(sourcePath, options = {}) {
         return orderedOptions[0]?.value ?? "interf";
     }
     return p.select({
-        message: options.message ?? "Workspace workflow?",
+        message: options.message ?? "Dataset workflow?",
         options: orderedOptions,
     });
 }
@@ -54,12 +54,12 @@ export async function createWorkflowWizard(options = {}, prompts = clackWorkflow
         prompts.intro(chalk.bold("Create a workflow"));
     }
     const sourcePath = options.sourcePath ?? process.cwd();
-    return createWorkspaceWorkflowWizard(sourcePath, prompts);
+    return createCompiledWorkflowWizard(sourcePath, prompts);
 }
-export async function createWorkspaceWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts) {
+export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWorkflowPrompts) {
     const baseWorkflow = await prompts.select({
         message: "Start from which existing workflow?",
-        options: listWorkspaceWorkflowChoices(sourcePath).map(formatWorkflowLabel),
+        options: listCompiledWorkflowChoices(sourcePath).map(formatWorkflowLabel),
     });
     if (prompts.isCancel(baseWorkflow))
         return baseWorkflow;
@@ -72,7 +72,7 @@ export async function createWorkspaceWorkflowWizard(sourcePath, prompts = clackW
             const workflowId = slugify(value);
             if (!isWorkflowId(workflowId))
                 return "Use letters, numbers, and dashes only";
-            if (listWorkspaceWorkflowChoices(sourcePath).some((workflow) => workflow.id === workflowId)) {
+            if (listCompiledWorkflowChoices(sourcePath).some((workflow) => workflow.id === workflowId)) {
                 return "That workflow name already exists";
             }
             return undefined;
@@ -105,7 +105,7 @@ export async function createWorkspaceWorkflowWizard(sourcePath, prompts = clackW
         return structureBias;
     const shapeBias = await prompts.text({
         message: "What should shape emphasize?",
-        placeholder: "Bias home.md and navigation toward the questions this workspace should answer best",
+        placeholder: "Bias home.md and navigation toward the questions this dataset should answer best",
         validate: (value) => (value.trim().length === 0 ? "Shape guidance is required" : undefined),
     });
     if (prompts.isCancel(shapeBias))

package/dist/commands/create.d.ts

@@ -1,8 +1,8 @@
 import type { CommandModule } from "yargs";
 import type { WorkflowExecutionProfile } from "../lib/executors.js";
 export declare const createCommand: CommandModule;
-export declare function createWorkspaceWizard(options?: {
+export declare function createCompiledWizard(options?: {
     intro?: boolean;
     executionProfile?: WorkflowExecutionProfile;
 }): Promise<void>;
-export { type WorkflowWizardPrompts, formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
+export { type WorkflowWizardPrompts, formatWorkflowLabel, chooseCompiledWorkflow, createWorkflowWizard, createCompiledWorkflowWizard, } from "./create-workflow-wizard.js";