@interf/compiler 0.2.5 → 0.3.0

package/dist/commands/create.d.ts

@@ -1,18 +1,9 @@
 import type { CommandModule } from "yargs";
 import type { WorkflowExecutionProfile } from "../lib/executors.js";
-import type { SourceInterfaceConfig } from "../lib/schema.js";
-export { type WorkflowWizardPrompts, buildKnowledgeBaseWorkflowOptions, buildInterfaceWorkflowOptions, buildStandaloneInterfaceWorkflowOptions, selectWorkflowTargetType, formatWorkflowLabel, CREATE_NEW_WORKFLOW_VALUE, chooseKnowledgeBaseWorkflow, chooseInterfaceWorkflow, createWorkflowWizard, createKnowledgeBaseWorkflowWizard, createInterfaceWorkflowWizard, } from "./create-workflow-wizard.js";
 export declare const createCommand: CommandModule;
-export declare function createKnowledgeBaseWizard(options?: {
+export declare function createWorkspaceWizard(options?: {
     intro?: boolean;
-    skipSkillInstall?: boolean;
     executionProfile?: WorkflowExecutionProfile;
 }): Promise<void>;
-export declare function createInterfaceWizard(options?: {
-    intro?: boolean;
-    knowledgeBasePathOverride?: string;
-    knowledgeBaseNameOverride?: string;
-    executionProfile?: WorkflowExecutionProfile;
-    suggestedInterface?: SourceInterfaceConfig;
-}): Promise<void>;
+export { type WorkflowWizardPrompts, formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
 //# sourceMappingURL=create.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAO3C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAKpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAQ9D,OAAO,EACL,KAAK,qBAAqB,EAC1B,iCAAiC,EACjC,6BAA6B,EAC7B,uCAAuC,EACvC,wBAAwB,EACxB,mBAAmB,EACnB,yBAAyB,EACzB,2BAA2B,EAC3B,uBAAuB,EACvB,oBAAoB,EACpB,iCAAiC,EACjC,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC;AAwErC,eAAO,MAAM,aAAa,EAAE,aA8D3B,CAAC;AAEF,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;CACxC,iBA4JP;AAED,wBAAsB,qBAAqB,CACzC,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C,kBAAkB,CAAC,EAAE,qBAAqB,CAAC;CACvC,iBA+QP"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAO3C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAyCpE,eAAO,MAAM,aAAa,EAAE,aAmC3B,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;CACxC,iBAmFP;AAkCD,OAAO,EACL,KAAK,qBAAqB,EAC1B,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC"}

package/dist/commands/create.js

@@ -1,29 +1,20 @@
 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 { detectInterf, defaultWorkspaceNameForSource, listWorkspacesForSourceFolder, } from "../lib/interf.js";
+import { addWorkspace, } 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 { createWorkspace, compileWorkspace, } from "../lib/workflows.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 { chooseWorkspaceWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.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 +23,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 +62,105 @@ 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"}. Creating another is fine when you want to compare workflows or keep separate compiled surfaces.`);
     }
-    const defaultName = slugify(basename(cwd));
+    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 defaultName = slugify(defaultWorkspaceNameForSource(cwd) || basename(cwd));
     const rawName = await p.text({
-        message: "Knowledge base name?",
-        placeholder: defaultName || "my-knowledge-base",
+        message: "Workspace name?",
+        placeholder: defaultName || "my-workspace",
         initialValue: defaultName,
-        validate: (v) => (v.length === 0 ? "Name is required" : undefined),
+        validate: (value) => (value.trim().length === 0 ? "Name is required" : undefined),
     });
     if (p.isCancel(rawName))
         return;
     const name = slugify(rawName);
     if (name !== rawName) {
-        p.log.info(`Knowledge base name: ${name}`);
+        p.log.info(`Workspace name: ${name}`);
     }
-    const workflowChoice = await chooseKnowledgeBaseWorkflow(cwd);
+    const about = await p.text({
+        message: "What is this workspace for? (optional)",
+        placeholder: "Quarterly results workspace for finance reporting and strategy questions",
+    });
+    if (p.isCancel(about))
+        return;
+    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;
+    const workflowId = workflowChoice;
+    const spinner = p.spinner();
+    spinner.start("Creating workspace...");
+    let workspacePath = "";
     try {
-        knowledgeBasePath = createKnowledgeBase(name, cwd, selectedWorkflow);
+        workspacePath = createWorkspace(name, cwd, workflowId, String(about).trim().length > 0 ? String(about).trim() : undefined);
+        addWorkspace(name, workspacePath, workflowId);
+        spinner.stop("Workspace created.");
     }
     catch (error) {
-        s.stop("Create failed");
+        spinner.stop("Workspace creation failed.");
         process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : "Failed to create knowledge base.");
+        p.log.error(error instanceof Error ? error.message : String(error));
         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?",
+    const compileNow = await p.confirm({
+        message: "Build the compiled workspace 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;
+    if (p.isCancel(compileNow) || !compileNow) {
+        p.outro(`Next: cd ${workspacePath}\n  interf compile`);
         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) {
         process.exitCode = 1;
-        p.log.error(error ?? "No coding agent detected. Install Claude Code or Codex to create interfaces.");
+        p.log.error(error ?? "No coding agent detected.");
         return;
     }
+    await compileWorkspaceAfterCreate(executor, workspacePath);
+}
+async function compileWorkspaceAfterCreate(executor, workspacePath) {
+    console.log();
     const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
     if (profileLabel) {
-        p.log.info(`Execution profile: ${profileLabel}`);
-    }
-    let dirPath;
-    try {
-        dirPath = createInterface(name, knowledgeBasePath, connectedKnowledgeBaseName, selectedWorkflow);
-    }
-    catch (error) {
-        process.exitCode = 1;
-        p.log.error(error instanceof Error ? error.message : "Failed to create interface scaffold.");
-        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?",
-        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;
-        return;
+        console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
+        console.log();
     }
-    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 {
+    const reporter = {
         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({
+    const result = await compileWorkspace({
         executor,
-        knowledgeBasePath,
-        reporter: createWizardReporter(),
+        workspacePath,
+        reporter,
     });
     if (!result.ok) {
         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;
-    }
-    console.log();
-    console.log(chalk.green("  ✓ Knowledge base ready."));
-    return true;
-}
-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) {
-        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;
+    console.log(chalk.green("  ✓ Compiled workspace ready."));
 }
+export { formatWorkflowLabel, chooseWorkspaceWorkflow, createWorkflowWizard, createWorkspaceWorkflowWizard, } from "./create-workflow-wizard.js";
 //# sourceMappingURL=create.js.map