@interf/compiler 0.2.5 → 0.3.1

package/dist/commands/create.js

@@ -1,29 +1,21 @@
 import chalk from "chalk";
 import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectInterf, listKnowledgeBasesForSourceFolder, readInterfConfig, resolveInterfaceKnowledgeBasePath, resolveKnowledgeBaseSourcePath, writeInterfaceCompilePlanTemplate, } from "../lib/interf.js";
-import { discoverSourceFiles } from "../lib/discovery.js";
-import { addKnowledgeBaseWithWorkflow, addInterface, loadRegistry } from "../lib/registry.js";
-import { resolveLocalExecutor } from "../lib/executors.js";
-import { formatInterfaceWorkflowStageStep, formatKnowledgeBaseWorkflowStageStep, listInterfaceWorkflowChoices, listKnowledgeBaseInterfaceWorkflowChoices, resolveInterfaceWorkflowFromConfig, resolveKnowledgeBaseWorkflowFromConfig, } from "../lib/workflow-definitions.js";
-import { createKnowledgeBase, createInterface, compileKnowledgeBase as compileKnowledgeBaseWorkflow, compileInterface as compileInterfaceWorkflow, } from "../lib/workflows.js";
+import { detectInterf, defaultWorkspaceNameForSource, listWorkspacesForSourceFolder, } from "../lib/interf.js";
 import { slugify } from "../lib/util.js";
-import { addExecutionProfileOptions, executionProfileFromArgv, formatWorkflowExecutionProfile, } from "../lib/execution-profile.js";
-import { loadSourceFolderConfig, upsertSourceFolderInterfaceConfig, } from "../lib/source-config.js";
-import { promptSingleInterfaceConfig } from "./source-config-wizard.js";
-import { chooseKnowledgeBaseWorkflow, chooseInterfaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
-export { buildKnowledgeBaseWorkflowOptions, buildInterfaceWorkflowOptions, buildStandaloneInterfaceWorkflowOptions, selectWorkflowTargetType, formatWorkflowLabel, CREATE_NEW_WORKFLOW_VALUE, chooseKnowledgeBaseWorkflow, chooseInterfaceWorkflow, createWorkflowWizard, createKnowledgeBaseWorkflowWizard, createInterfaceWorkflowWizard, } from "./create-workflow-wizard.js";
+import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
+import { loadSourceFolderConfig, upsertSourceWorkspaceConfig } from "../lib/source-config.js";
+import { chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { compileWorkspaceWithReporter, ensureWorkspaceFromConfig, } from "./workspace-flow.js";
+import { promptSingleWorkspaceConfig } from "./source-config-wizard.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 function normalizeCreateTarget(value) {
     if (!value)
         return null;
     switch (value) {
-        case "knowledge-base":
-        case "knowledgebase":
-        case "base":
-        case "kb":
-            return "knowledge-base";
-        case "interface":
-            return "interface";
+        case "workspace":
+        case "ws":
+            return "workspace";
         case "workflow":
         case "wf":
             return "workflow";
@@ -32,57 +24,28 @@ function normalizeCreateTarget(value) {
     }
 }
 async function selectCreateTarget() {
-    const detected = detectInterf(process.cwd());
-    const registry = loadRegistry();
-    if (!detected && registry.knowledgeBases.length === 0) {
-        return "knowledge-base";
-    }
-    const recommendInterface = Boolean(detected);
     return p.select({
         message: "Create what?",
-        options: recommendInterface
-            ? [
-                {
-                    value: "interface",
-                    label: "Interface (Recommended)",
-                    hint: "Create a task-specific interface on top of an existing knowledge base",
-                },
-                {
-                    value: "knowledge-base",
-                    label: "Knowledge Base",
-                    hint: "Attach the current folder as a new local knowledge base",
-                },
-                {
-                    value: "workflow",
-                    label: "Workflow",
-                    hint: "Create a reusable workflow package for knowledge bases or interfaces",
-                },
-            ]
-            : [
-                {
-                    value: "knowledge-base",
-                    label: "Knowledge Base (Recommended)",
-                    hint: "Attach the current folder as a new local knowledge base",
-                },
-                {
-                    value: "interface",
-                    label: "Interface",
-                    hint: "Create an interface from a knowledge base already in your registry",
-                },
-                {
-                    value: "workflow",
-                    label: "Workflow",
-                    hint: "Create a reusable workflow package for knowledge bases or interfaces",
-                },
-            ],
+        options: [
+            {
+                value: "workspace",
+                label: "Workspace (Recommended)",
+                hint: "Create a compiled workspace for this folder",
+            },
+            {
+                value: "workflow",
+                label: "Workflow",
+                hint: "Create a reusable local workflow package",
+            },
+        ],
     });
 }
 export const createCommand = {
     command: "create [type]",
-    describe: "Create a knowledge base, interface, or reusable workflow, or choose when omitted",
+    describe: "Create a compiled workspace or reusable workflow",
     builder: (yargs) => addExecutionProfileOptions(yargs.positional("type", {
         type: "string",
-        describe: "Type to create (`knowledge-base`, `interface`, or `workflow`)",
+        describe: "Type to create (`workspace` or `workflow`)",
         default: undefined,
     })),
     handler: async (argv) => {
@@ -100,456 +63,94 @@ export const createCommand = {
                 return;
             type = selected;
         }
-        if (type === "knowledge-base") {
-            await createKnowledgeBaseWizard({ executionProfile });
-            return;
-        }
         if (type === "workflow") {
-            const cwd = process.cwd();
-            const detected = detectInterf(cwd);
-            let sourcePath = cwd;
-            let knowledgeBasePath;
-            if (detected?.config.type === "knowledge-base") {
-                knowledgeBasePath = detected.path;
-                sourcePath = resolveKnowledgeBaseSourcePath(detected.path);
-            }
-            else if (detected?.config.type === "interface") {
-                const parentKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(detected.path);
-                if (parentKnowledgeBasePath) {
-                    knowledgeBasePath = parentKnowledgeBasePath;
-                    sourcePath = resolveKnowledgeBaseSourcePath(parentKnowledgeBasePath);
-                }
-            }
-            else {
-                const localKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
-                if (localKnowledgeBases.length === 1) {
-                    const localKnowledgeBase = localKnowledgeBases[0];
-                    knowledgeBasePath = localKnowledgeBase.path;
-                    sourcePath = resolveKnowledgeBaseSourcePath(localKnowledgeBase.path);
-                }
-            }
-            await createWorkflowWizard({ sourcePath, knowledgeBasePath });
+            await createWorkflowWizard({ sourcePath: process.cwd() });
             return;
         }
-        await createInterfaceWizard({ executionProfile });
+        await createWorkspaceWizard({ executionProfile });
     },
 };
-export async function createKnowledgeBaseWizard(options = {}) {
+export async function createWorkspaceWizard(options = {}) {
     if (options.intro !== false) {
-        p.intro(chalk.bold("Create a knowledge base"));
+        p.intro(chalk.bold("Create a workspace"));
     }
-    p.log.info("Interf prepares a shared workspace beside this folder for your agent.");
-    p.log.info("In Interf, that shared workspace is called a knowledge base. Your raw files stay where they are; the knowledge base lives under `./interf/<name>/`.");
     const cwd = process.cwd();
-    const currentConfig = readInterfConfig(cwd);
-    if (currentConfig) {
+    const detected = detectInterf(cwd);
+    if (detected) {
         process.exitCode = 1;
-        p.log.error("You are already inside an Interf knowledge base or interface.");
+        p.log.error("You are already inside a compiled workspace.");
         return;
     }
-    const existingKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
-    if (existingKnowledgeBases.length > 0) {
-        p.log.info(`This source folder already has ${existingKnowledgeBases.length} knowledge base${existingKnowledgeBases.length === 1 ? "" : "s"}. Creating another is fine when you want to compare workflows on the same data.`);
+    const existing = listWorkspacesForSourceFolder(cwd);
+    if (existing.length > 0) {
+        p.log.info(`This folder already has ${existing.length} workspace${existing.length === 1 ? "" : "s"}. Add another only when you need a separate set of questions or a different focus.`);
     }
-    const defaultName = slugify(basename(cwd));
-    const rawName = await p.text({
-        message: "Knowledge base name?",
-        placeholder: defaultName || "my-knowledge-base",
-        initialValue: defaultName,
-        validate: (v) => (v.length === 0 ? "Name is required" : undefined),
+    p.log.info("Interf builds a compiled workspace on top of your raw files. Your files stay where they are and stay the source of truth.");
+    const existingConfig = loadSourceFolderConfig(cwd);
+    const suggestedName = slugify(defaultWorkspaceNameForSource(cwd) || basename(cwd)) || "default";
+    const draft = await promptSingleWorkspaceConfig({
+        initial: { name: suggestedName },
+        introStyle: existingConfig ? "additional" : "first",
     });
-    if (p.isCancel(rawName))
+    if (!draft)
         return;
-    const name = slugify(rawName);
-    if (name !== rawName) {
-        p.log.info(`Knowledge base name: ${name}`);
-    }
-    const workflowChoice = await chooseKnowledgeBaseWorkflow(cwd);
+    const workflowChoice = await chooseWorkspaceWorkflow(cwd);
     if (p.isCancel(workflowChoice))
         return;
-    const selectedWorkflow = workflowChoice;
-    const s = p.spinner();
-    if (!options.skipSkillInstall) {
-        p.log.info("Interf uses bundled stage instructions and local workflow docs by default. Run `interf init` to choose a default executor for compile and benchmark runs.");
-    }
-    // Create
-    s.start("Creating knowledge base...");
-    let knowledgeBasePath;
-    try {
-        knowledgeBasePath = createKnowledgeBase(name, cwd, selectedWorkflow);
-    }
-    catch (error) {
-        s.stop("Create failed");
-        process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : "Failed to create knowledge base.");
-        return;
-    }
-    addKnowledgeBaseWithWorkflow(name, knowledgeBasePath, selectedWorkflow);
-    s.stop(`Knowledge base "${name}" created`);
-    const createdKnowledgeBaseConfig = readInterfConfig(knowledgeBasePath);
-    if (createdKnowledgeBaseConfig?.workflow) {
-        p.log.info(`Workflow: ${createdKnowledgeBaseConfig.workflow}`);
-    }
-    // Discovery preflight
-    const discovery = discoverSourceFiles(cwd, knowledgeBasePath);
-    p.log.info(`Found ${discovery.totalCount} source files ready to summarize and compile.`);
-    if (discovery.ignoredCount > 0) {
-        p.log.info("This count already excludes Interf files, hidden folders, and anything matched by `.interfignore`.");
-    }
-    p.log.info("Interf writes a normal folder you can open in Obsidian or any markdown app.");
-    const buildNow = await p.confirm({
-        message: "Compile this knowledge base now?",
-        initialValue: true,
-    });
-    if (p.isCancel(buildNow))
-        return;
-    if (buildNow) {
-        const { executor, error } = resolveLocalExecutor({ executionProfile: options.executionProfile });
-        if (!executor) {
-            process.exitCode = 1;
-            p.log.warn(error ?? "No local executor detected.");
-            p.outro([
-                `Knowledge base: ${knowledgeBasePath}`,
-                `Next: run \`interf compile\` from ${cwd} once an executor is configured.`,
-            ].join("\n"));
-            return;
-        }
-        const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
-        if (profileLabel) {
-            p.log.info(`Execution profile: ${profileLabel}`);
-        }
-        const compiled = await runKnowledgeBaseCompile(executor, knowledgeBasePath);
-        if (compiled) {
-            const configuredInterface = loadSourceFolderConfig(cwd)?.interfaces?.[0];
-            const createFirstInterface = await p.confirm({
-                message: configuredInterface
-                    ? `Create the configured interface "${configuredInterface.name}" now?`
-                    : "Create a first interface now?",
-                initialValue: Boolean(configuredInterface),
-            });
-            if (p.isCancel(createFirstInterface))
-                return;
-            if (createFirstInterface) {
-                await createInterfaceWizard({
-                    intro: false,
-                    knowledgeBasePathOverride: knowledgeBasePath,
-                    knowledgeBaseNameOverride: name,
-                    executionProfile: options.executionProfile,
-                    suggestedInterface: configuredInterface
-                        ? { name: configuredInterface.name, about: configuredInterface.about }
-                        : undefined,
-                });
-                return;
-            }
-            p.outro([
-                `Knowledge base ready: ${knowledgeBasePath}`,
-                `CLI control plane: ${cwd}`,
-                `Workspace entrypoint: ${knowledgeBasePath}`,
-                `Open this folder to inspect the compiled workspace: ${knowledgeBasePath}`,
-                `If you use Obsidian, open this folder as the vault to browse the graph.`,
-                `Next: \`interf create interface\` from ${cwd} when you want a focused interface for a specific job.`,
-            ].join("\n"));
-            return;
-        }
-        p.outro([
-            `Knowledge base created: ${knowledgeBasePath}`,
-            `The compile did not complete cleanly.`,
-            `Next: rerun \`cd ${knowledgeBasePath} && interf compile\` after fixing the reported issue, or run \`interf compile\` from ${cwd}.`,
-        ].join("\n"));
-        process.exitCode = 1;
-        return;
-    }
-    p.outro([
-        `Knowledge base created: ${knowledgeBasePath}`,
-        `CLI control plane: ${cwd}`,
-        `Workspace entrypoint: ${knowledgeBasePath}`,
-        `Open this folder to inspect the compiled workspace: ${knowledgeBasePath}`,
-        `Next: run \`cd ${knowledgeBasePath} && interf compile\`, or run \`interf compile\` from ${cwd}.`,
-    ].join("\n"));
-}
-export async function createInterfaceWizard(options = {}) {
-    if (options.intro !== false) {
-        p.intro(chalk.bold("Create an interface"));
-    }
-    p.log.info("Start with the main compiled workspace first.");
-    p.log.info("An interface is a second compiled workspace for one recurring job on top of the main compiled workspace.");
-    p.log.info("Use it when one shared workspace is not enough and your agent needs narrower retrieval, job-specific outputs, or extra task-specific evals.");
-    // Find the knowledge-base — either cwd has interf/ or we look up registry
-    const cwd = process.cwd();
-    const detected = detectInterf(cwd);
-    const localKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
-    let knowledgeBasePath;
-    let connectedKnowledgeBaseName;
-    if (options.knowledgeBasePathOverride && options.knowledgeBaseNameOverride) {
-        knowledgeBasePath = options.knowledgeBasePathOverride;
-        connectedKnowledgeBaseName = options.knowledgeBaseNameOverride;
-    }
-    else if (detected && detected.config.type === "knowledge-base") {
-        const useCurrentKnowledgeBase = await p.confirm({
-            message: `Use the current knowledge base "${detected.config.name}"?`,
-            initialValue: true,
-        });
-        if (p.isCancel(useCurrentKnowledgeBase))
-            return;
-        if (useCurrentKnowledgeBase) {
-            knowledgeBasePath = detected.path;
-            connectedKnowledgeBaseName = detected.config.name;
-        }
-        else {
-            const availableKnowledgeBases = [
-                ...localKnowledgeBases
-                    .filter((knowledgeBase) => knowledgeBase.path !== detected.path)
-                    .map((knowledgeBase) => ({
-                    path: knowledgeBase.path,
-                    name: knowledgeBase.config.name,
-                    label: `${knowledgeBase.config.name} (${knowledgeBase.path})`,
-                })),
-                ...loadRegistry().knowledgeBases
-                    .filter((knowledgeBase) => knowledgeBase.path !== detected.path)
-                    .map((knowledgeBase) => ({
-                    path: knowledgeBase.path,
-                    name: knowledgeBase.name,
-                    label: `${knowledgeBase.name} (${knowledgeBase.path})`,
-                })),
-            ];
-            const uniqueKnowledgeBases = Array.from(new Map(availableKnowledgeBases.map((knowledgeBase) => [knowledgeBase.path, knowledgeBase])).values());
-            if (uniqueKnowledgeBases.length === 0) {
-                process.exitCode = 1;
-                p.log.error("No other knowledge bases found. Use the current one or create another knowledge base first.");
-                return;
-            }
-            const choice = await p.select({
-                message: "Which knowledge base?",
-                options: uniqueKnowledgeBases.map((knowledgeBase) => ({
-                    value: knowledgeBase.path,
-                    label: knowledgeBase.label,
-                })),
-            });
-            if (p.isCancel(choice))
-                return;
-            const knowledgeBase = uniqueKnowledgeBases.find((entry) => entry.path === choice);
-            knowledgeBasePath = knowledgeBase.path;
-            connectedKnowledgeBaseName = knowledgeBase.name;
-        }
-    }
-    else if (localKnowledgeBases.length > 0) {
-        const choice = await p.select({
-            message: "Which local knowledge base?",
-            options: localKnowledgeBases.map((knowledgeBase) => ({
-                value: knowledgeBase.path,
-                label: `${knowledgeBase.config.name} (${knowledgeBase.path})`,
-            })),
-        });
-        if (p.isCancel(choice))
-            return;
-        const knowledgeBase = localKnowledgeBases.find((entry) => entry.path === choice);
-        knowledgeBasePath = knowledgeBase.path;
-        connectedKnowledgeBaseName = knowledgeBase.config.name;
-    }
-    else {
-        const reg = loadRegistry();
-        if (reg.knowledgeBases.length === 0) {
-            process.exitCode = 1;
-            p.log.error("No knowledge bases found. Create one first: interf create knowledge-base");
-            return;
-        }
-        const choice = await p.select({
-            message: "Which knowledge base?",
-            options: reg.knowledgeBases.map((knowledgeBase) => ({
-                value: knowledgeBase.path,
-                label: `${knowledgeBase.name} (${knowledgeBase.path})`,
-            })),
-        });
-        if (p.isCancel(choice))
-            return;
-        const knowledgeBase = reg.knowledgeBases.find((entry) => entry.path === choice);
-        knowledgeBasePath = knowledgeBase.path;
-        connectedKnowledgeBaseName = knowledgeBase.name;
-    }
-    const sourcePath = resolveKnowledgeBaseSourcePath(knowledgeBasePath);
-    const configuredInterfaces = loadSourceFolderConfig(sourcePath)?.interfaces ?? [];
-    let interfaceConfig = null;
-    let createdFromConfigWizard = false;
-    if (options.suggestedInterface?.name) {
-        interfaceConfig =
-            configuredInterfaces.find((entry) => entry.name === options.suggestedInterface?.name) ??
-                options.suggestedInterface;
-        p.log.info(`Using configured interface "${interfaceConfig.name}" from ${sourcePath}/interf.config.json.`);
-        p.log.info(`Interface purpose: ${interfaceConfig.about}`);
-    }
-    else if (configuredInterfaces.length === 1) {
-        interfaceConfig = configuredInterfaces[0];
-        p.log.info(`Using configured interface "${interfaceConfig.name}" from ${sourcePath}/interf.config.json.`);
-        p.log.info(`Interface purpose: ${interfaceConfig.about}`);
-    }
-    else if (configuredInterfaces.length > 1) {
-        const choice = await p.select({
-            message: "Which configured interface?",
-            options: [
-                ...configuredInterfaces.map((entry) => ({
-                    value: entry.name,
-                    label: entry.name,
-                    hint: entry.about,
-                })),
-                {
-                    value: "__create_new__",
-                    label: "Create new interface",
-                    hint: "Add a new interface to interf.config.json first",
-                },
-            ],
-        });
-        if (p.isCancel(choice))
-            return;
-        if (choice !== "__create_new__") {
-            interfaceConfig = configuredInterfaces.find((entry) => entry.name === choice);
-            p.log.info(`Using configured interface "${interfaceConfig.name}" from ${sourcePath}/interf.config.json.`);
-            p.log.info(`Interface purpose: ${interfaceConfig.about}`);
-        }
-    }
-    if (!interfaceConfig) {
-        interfaceConfig = await promptSingleInterfaceConfig();
-        if (!interfaceConfig)
-            return;
-        upsertSourceFolderInterfaceConfig(sourcePath, interfaceConfig);
-        createdFromConfigWizard = true;
-        p.log.info(`Saved interface "${interfaceConfig.name}" to ${sourcePath}/interf.config.json.`);
-    }
-    const name = interfaceConfig.name;
-    const workflowChoices = Array.from(new Map([
-        ...listKnowledgeBaseInterfaceWorkflowChoices(knowledgeBasePath),
-        ...listInterfaceWorkflowChoices(sourcePath),
-    ].map((option) => [option.id, option])).values());
-    let selectedWorkflow;
-    if (workflowChoices.length === 1) {
-        selectedWorkflow = workflowChoices[0].id;
-        p.log.info(`Workflow: ${workflowChoices[0].label}`);
-    }
-    else {
-        const workflow = await chooseInterfaceWorkflow(knowledgeBasePath);
-        if (p.isCancel(workflow))
-            return;
-        selectedWorkflow = workflow;
-    }
-    const workflowInfo = workflowChoices.find((option) => option.id === selectedWorkflow);
-    const interfaceStageSequence = workflowInfo.stages.map((stage) => stage.label).join(" -> ");
-    p.log.info(`Interface workflow = the default ${interfaceStageSequence} method for this interface. You can edit it later in \`workflow/\` or create your own saved workflow.`);
-    p.log.info(`${workflowInfo.label}: ${workflowInfo.hint}`);
-    const { executor, error } = resolveLocalExecutor({ executionProfile: options.executionProfile });
-    if (!executor) {
+    const workflowId = workflowChoice;
+    const configToSave = {
+        ...draft,
+        workflow: workflowId,
+    };
+    const existingNames = new Set((existingConfig?.workspaces ?? []).map((workspace) => workspace.name));
+    if (existingNames.has(configToSave.name)) {
         process.exitCode = 1;
-        p.log.error(error ?? "No coding agent detected. Install Claude Code or Codex to create interfaces.");
+        p.log.error(`Workspace "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
         return;
     }
-    const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
-    if (profileLabel) {
-        p.log.info(`Execution profile: ${profileLabel}`);
-    }
-    let dirPath;
+    upsertSourceWorkspaceConfig(cwd, configToSave);
+    const name = configToSave.name;
+    const about = configToSave.about;
+    const spinner = p.spinner();
+    spinner.start("Creating workspace...");
+    let workspacePath = "";
     try {
-        dirPath = createInterface(name, knowledgeBasePath, connectedKnowledgeBaseName, selectedWorkflow);
+        workspacePath = ensureWorkspaceFromConfig(cwd, configToSave);
+        spinner.stop("Workspace created.");
     }
     catch (error) {
+        spinner.stop("Workspace creation failed.");
         process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : "Failed to create interface scaffold.");
+        p.log.error(error instanceof Error ? error.message : String(error));
         return;
     }
-    p.log.info(`Created interface scaffold at ${dirPath}`);
-    p.log.info(`This interface is for: ${interfaceConfig.about.trim()}`);
-    p.log.info("When you compile it, Interf narrows retrieval and writes outputs for that recurring job.");
-    if (createdFromConfigWizard) {
-        p.log.info("The interface config is now the source of truth. This command used it to create the scaffold.");
-    }
-    const createdInterfaceConfig = readInterfConfig(dirPath);
-    if (createdInterfaceConfig?.workflow) {
-        p.log.info(`Workflow: ${createdInterfaceConfig.workflow}`);
-    }
-    writeInterfaceCompilePlanTemplate(dirPath, {
-        workflowId: selectedWorkflow,
-        sourcePath,
-        interfaceName: name,
-        useCase: interfaceConfig.about.trim(),
-    });
-    addInterface(name, dirPath, connectedKnowledgeBaseName, knowledgeBasePath, selectedWorkflow);
-    const buildNow = await p.confirm({
-        message: "Compile this interface now?",
+    const compileNow = await p.confirm({
+        message: "Build it now? (Recommended)",
         initialValue: true,
     });
-    if (p.isCancel(buildNow))
-        return;
-    if (buildNow) {
-        const built = await runInterfaceCompile(executor, dirPath);
-        if (built) {
-            p.outro([
-                `Interface ready: ${dirPath}`,
-                `CLI control plane: ${sourcePath}`,
-                `Workspace entrypoint: ${dirPath}`,
-                `Open the main workspace here: ${knowledgeBasePath}`,
-                `Open the interface here: ${dirPath}`,
-                `If you use Obsidian, open the knowledge-base folder as the vault so interface links resolve cleanly.`,
-            ].join("\n"));
-            return;
-        }
-        p.outro([
-            `Interface created: ${dirPath}`,
-            `The compile did not complete cleanly.`,
-            `Next: rerun \`cd ${dirPath} && interf compile\` after fixing the reported issue, or run \`interf compile\` from the source folder.`,
-        ].join("\n"));
-        process.exitCode = 1;
+    if (p.isCancel(compileNow) || !compileNow) {
+        p.outro(configToSave.checks.length > 0
+            ? "Next:\n  interf compile\n  interf test"
+            : "Next:\n  interf compile\n  interf or interf init");
         return;
     }
-    p.outro([
-        `Interface created: ${dirPath}`,
-        `CLI control plane: ${sourcePath}`,
-        `Workspace entrypoint: ${dirPath}`,
-        `Open the interface here: ${dirPath}`,
-        `If you use Obsidian, open the knowledge-base folder as the vault: ${knowledgeBasePath}`,
-        `Next: run \`cd ${dirPath} && interf compile\`, or run \`interf compile\` from ${sourcePath}.`,
-    ].join("\n"));
-}
-function createWizardReporter() {
-    return {
-        line: (message) => console.log(chalk.dim(`  ${message}`)),
-        blankLine: () => console.log(),
-    };
-}
-async function runKnowledgeBaseCompile(executor, knowledgeBasePath) {
-    console.log();
-    console.log(chalk.bold("  Compiling knowledge base..."));
-    console.log();
-    const result = await compileKnowledgeBaseWorkflow({
-        executor,
-        knowledgeBasePath,
-        reporter: createWizardReporter(),
+    const { executor, error } = await resolveOrConfigureLocalExecutor({
+        executionProfile: options.executionProfile,
     });
-    if (!result.ok) {
+    if (!executor) {
         process.exitCode = 1;
-        const workflowId = resolveKnowledgeBaseWorkflowFromConfig(readInterfConfig(knowledgeBasePath));
-        const failedStage = formatKnowledgeBaseWorkflowStageStep(workflowId, result.failedStage ?? "compile", { workspacePath: knowledgeBasePath });
-        console.log(chalk.red(`  ${failedStage} failed.`));
-        return false;
+        p.log.error(error ?? "No coding agent detected.");
+        return;
     }
-    console.log();
-    console.log(chalk.green("  ✓ Knowledge base ready."));
-    return true;
+    await compileWorkspaceAfterCreate(executor, workspacePath);
 }
-async function runInterfaceCompile(executor, interfacePath) {
-    console.log();
-    console.log(chalk.bold("  Compiling interface..."));
-    console.log();
-    const result = await compileInterfaceWorkflow({
-        executor,
-        knowledgeBasePath: interfacePath,
-        reporter: createWizardReporter(),
-    });
-    if (!result.ok) {
+async function compileWorkspaceAfterCreate(executor, workspacePath) {
+    const compiled = await compileWorkspaceWithReporter(executor, workspacePath);
+    if (!compiled.ok) {
         process.exitCode = 1;
-        const workflowId = resolveInterfaceWorkflowFromConfig(readInterfConfig(interfacePath));
-        const failedStage = formatInterfaceWorkflowStageStep(workflowId, result.failedStage ?? "compile", { workspacePath: interfacePath });
-        console.log(chalk.red(`  ${failedStage} failed.`));
-        return false;
+        console.log(chalk.red("  Workspace compile failed."));
+        return;
     }
-    console.log();
-    console.log(chalk.green("  ✓ Interface ready."));
-    return true;
 }
+export { formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
 //# sourceMappingURL=create.js.map