@interf/compiler 0.2.5 → 0.3.1

package/dist/commands/init.js

@@ -1,356 +1,355 @@
 import chalk from "chalk";
-import { execSync } from "node:child_process";
-import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectAgents, supportsAutomatedRuns, } from "../lib/agents.js";
-import { createKnowledgeBaseWizard } from "./create.js";
-import { loadUserConfig, saveUserConfig } from "../lib/user-config.js";
-import { appendSourceFolderEvals, loadSourceFolderConfig, saveSourceFolderConfig, SOURCE_FOLDER_CONFIG_FILE, upsertSourceFolderInterfaceConfig, } from "../lib/source-config.js";
-import { DEFAULT_SHARED_EVAL_ANSWER_PLACEHOLDER, DEFAULT_SHARED_EVAL_QUESTION_PLACEHOLDER, promptEvalCases, promptInterfaceConfigs, promptSingleInterfaceConfig, } from "./source-config-wizard.js";
-import { detectInterf, listKnowledgeBasesForSourceFolder, resolveInterfaceKnowledgeBasePath, resolveKnowledgeBaseSourcePath, } from "../lib/interf.js";
-export const initCommand = {
-    command: "init",
-    describe: "Set up Interf — choose a local executor and optionally attach this folder",
-    handler: async () => {
-        const cwd = process.cwd();
-        const existing = loadUserConfig();
-        const detected = detectInterf(cwd);
-        const sourceConfigHere = loadSourceFolderConfig(cwd);
-        const shouldManageFolderFirst = Boolean(existing && (detected || sourceConfigHere));
-        if (shouldManageFolderFirst) {
-            p.intro(chalk.bold("Interf — folder setup"));
-            await maybeAttachCurrentFolder(cwd, { localOnly: true });
-            return;
-        }
-        p.intro(chalk.bold("Interf — global setup"));
-        // Check if already initialized
-        if (existing) {
-            const redo = await p.confirm({
-                message: `Already set up globally (agent: ${existing.agent}). Reconfigure?`,
-                initialValue: false,
-            });
-            if (p.isCancel(redo) || !redo) {
-                await maybeAttachCurrentFolder(cwd);
-                return;
-            }
-        }
-        // Step 1: Detect agents
-        const s = p.spinner();
-        s.start("Detecting coding agents...");
-        const agents = detectAgents();
-        const supportedAgents = agents.filter((agent) => supportsAutomatedRuns(agent));
-        s.stop(agents.length > 0
-            ? `Found: ${agents.map((a) => a.displayName).join(", ")}`
-            : "No agents found");
-        if (supportedAgents.length === 0) {
-            process.exitCode = 1;
-            p.log.error("No coding agents detected.");
-            p.log.info("Install one of: Claude Code or Codex");
-            p.log.info("  Claude Code: https://claude.ai/code");
-            p.log.info("  Codex:       https://openai.com/codex");
-            p.outro("Come back after installing an agent.");
+import { detectInterf, resolveSourceFolderPath, } from "../lib/interf.js";
+import { SOURCE_FOLDER_CONFIG_FILE, listSourceWorkspaceConfigs, loadSourceFolderConfig, upsertSourceWorkspaceConfig, } from "../lib/source-config.js";
+import { promptSingleWorkspaceConfig } from "./source-config-wizard.js";
+import { createWorkflowWizard } from "./create-workflow-wizard.js";
+import { findBuiltWorkspacePath, findSavedWorkspaceConfig, listSavedWorkspaceEntries, ensureWorkspaceFromConfig, compileWorkspaceWithReporter, } from "./workspace-flow.js";
+import { printSavedTestComparison, runSavedRawTest, runSavedWorkspaceTest, } from "./test-flow.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+function describeSavedQuestions(workspace) {
+    const count = workspace.checks.length;
+    if (count === 0)
+        return "No saved questions yet";
+    return `${count} saved question${count === 1 ? "" : "s"}`;
+}
+function printWorkspaceSummary(options) {
+    p.log.info(`Workspace: ${options.workspace.name}`);
+    if (options.workspace.about) {
+        p.log.info(`Focus: ${options.workspace.about}`);
+    }
+    p.log.info(describeSavedQuestions(options.workspace));
+    p.log.info(options.built ? "Compiled workspace is available." : "Compiled workspace has not been built yet.");
+    if (options.sourcePath !== process.cwd()) {
+        p.log.info(`Source folder: ${options.sourcePath}`);
+    }
+}
+async function promptWorkspaceAction(workspace, built) {
+    const options = [
+        {
+            value: "edit",
+            label: "Edit questions and focus",
+            hint: "Update this workspace setup",
+        },
+    ];
+    if (workspace.checks.length > 0) {
+        options.push({
+            value: "raw",
+            label: "Run a baseline test on the raw files",
+            hint: "Measure current performance before compilation",
+        });
+    }
+    options.push({
+        value: "compile",
+        label: built ? "Refresh the compiled workspace" : "Compile the workspace",
+        hint: built ? "Rebuild it from the current files" : "Build it for the first time",
+    });
+    if (workspace.checks.length > 0 && built) {
+        options.push({
+            value: "test",
+            label: "Run the saved test on the compiled workspace",
+            hint: "Score this workspace on its saved questions",
+        });
+    }
+    options.push({
+        value: "workspace",
+        label: "Create another workspace",
+        hint: "Add a separate focus or question set",
+    }, {
+        value: "workflow",
+        label: "Create workflow",
+        hint: "Advanced: customize the compile method",
+    }, {
+        value: "done",
+        label: "Done",
+        hint: "Exit the wizard",
+    });
+    const selected = await p.select({
+        message: "What do you want to do next?",
+        options,
+    });
+    if (p.isCancel(selected))
+        return null;
+    return selected;
+}
+async function chooseWorkspaceForWizard(options) {
+    if (options.fixedWorkspaceName) {
+        return findSavedWorkspaceConfig(options.sourcePath, options.fixedWorkspaceName);
+    }
+    const savedEntries = listSavedWorkspaceEntries(options.sourcePath);
+    if (savedEntries.length === 0)
+        return null;
+    if (savedEntries.length === 1)
+        return savedEntries[0]?.config ?? null;
+    const selected = await p.select({
+        message: "Which workspace do you want to work with?",
+        options: [
+            ...savedEntries.map((entry) => ({
+                value: entry.config.name,
+                label: entry.config.name,
+                hint: [
+                    entry.config.about ?? describeSavedQuestions(entry.config),
+                    entry.path ? "built" : "not built yet",
+                ].join(" · "),
+            })),
+            {
+                value: "__new__",
+                label: "Create another workspace",
+                hint: "Add a separate focus or question set",
+            },
+        ],
+    });
+    if (p.isCancel(selected))
+        return null;
+    if (selected === "__new__")
+        return "__new__";
+    return findSavedWorkspaceConfig(options.sourcePath, String(selected));
+}
+async function promptWorkspaceSetup(options) {
+    const workspaceConfig = await promptSingleWorkspaceConfig({
+        initial: options.initial,
+        ...(options.fixedName ? { fixedName: options.fixedName } : {}),
+        skipNamePrompt: !options.fixedName && options.introStyle === "first",
+        introStyle: options.introStyle,
+    });
+    if (!workspaceConfig)
+        return null;
+    upsertSourceWorkspaceConfig(options.sourcePath, workspaceConfig, {
+        ...(options.fixedName ? { matchName: options.fixedName } : {}),
+    });
+    console.log();
+    console.log(chalk.green(`  ✓ Saved workspace setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
+    console.log(chalk.dim(`  Source folder: ${options.sourcePath}`));
+    console.log(chalk.dim(`  Workspace: ${workspaceConfig.name}`));
+    return workspaceConfig;
+}
+async function compileSelectedWorkspace(sourcePath, workspaceConfig) {
+    const { executor, error } = await resolveOrConfigureLocalExecutor();
+    if (!executor) {
+        process.exitCode = 1;
+        console.log(chalk.red(error ?? "No coding agent detected."));
+        return null;
+    }
+    const workspacePath = ensureWorkspaceFromConfig(sourcePath, workspaceConfig);
+    const result = await compileWorkspaceWithReporter(executor, workspacePath);
+    if (!result.ok) {
+        process.exitCode = 1;
+        console.log(chalk.red("  Workspace compile failed."));
+        return null;
+    }
+    return workspacePath;
+}
+async function runFirstWorkspaceFlow(sourcePath, workspaceConfig) {
+    let rawOutcome = null;
+    let workspaceOutcome = null;
+    if (workspaceConfig.checks.length > 0) {
+        const runRawFirst = await p.confirm({
+            message: "Run a baseline test on the raw files now? (Recommended)",
+            initialValue: true,
+        });
+        if (p.isCancel(runRawFirst))
             return;
-        }
-        // Step 2: Choose primary agent
-        let agent;
-        if (supportedAgents.length === 1) {
-            agent = supportedAgents[0];
-            p.log.info(`Using ${agent.displayName}`);
-        }
-        else {
-            const choice = await p.select({
-                message: "Which agent for compile commands?",
-                options: supportedAgents.map((a) => ({
-                    value: a.name,
-                    label: a.displayName,
-                })),
+        if (runRawFirst) {
+            rawOutcome = await runSavedRawTest({
+                sourcePath,
+                workspaceConfig,
             });
-            if (p.isCancel(choice))
-                return;
-            agent = supportedAgents.find((a) => a.name === choice);
-        }
-        // Step 3: Verify agent connection
-        s.start(`Checking ${agent.displayName} connection...`);
-        try {
-            execSync(`which ${agent.command}`, { stdio: "ignore" });
-            s.stop(`${agent.displayName} CLI available`);
         }
-        catch {
-            s.stop(`${agent.displayName} CLI not found in PATH`);
-            p.log.warn(`Make sure '${agent.command}' is in your PATH`);
+    }
+    else {
+        p.log.info("You can compile this workspace now and add questions later when you want to test it.");
+    }
+    const compileAndTest = workspaceConfig.checks.length > 0 && rawOutcome
+        ? await p.confirm({
+            message: "Compile the workspace and run the same test now? (Recommended)",
+            initialValue: true,
+        })
+        : await p.confirm({
+            message: "Compile the workspace now? (Recommended)",
+            initialValue: true,
+        });
+    if (p.isCancel(compileAndTest) || !compileAndTest) {
+        console.log();
+        console.log(chalk.dim("  Next:"));
+        console.log(chalk.dim("    interf compile"));
+        if (workspaceConfig.checks.length > 0) {
+            console.log(chalk.dim("    interf test"));
         }
-        // Step 4: Save config
-        saveUserConfig({
-            agent: agent.displayName,
-            agentCommand: agent.command,
-            skillsInstalled: false,
-            initialized: new Date().toISOString(),
+        return;
+    }
+    const workspacePath = await compileSelectedWorkspace(sourcePath, workspaceConfig);
+    if (!workspacePath) {
+        printSavedTestComparison(rawOutcome, null);
+        return;
+    }
+    if (workspaceConfig.checks.length === 0) {
+        return;
+    }
+    if (!rawOutcome) {
+        const runWorkspaceTest = await p.confirm({
+            message: "Run the saved test on the compiled workspace now? (Recommended)",
+            initialValue: true,
         });
-        const attachNow = !detectInterf(cwd)
-            ? await p.confirm({
-                message: "Create the main Interf workspace for this folder now?",
-                initialValue: true,
-            })
-            : false;
-        if (p.isCancel(attachNow))
-            return;
-        if (attachNow) {
-            const configured = await ensureSourceFolderConfig(cwd);
-            if (!configured)
-                return;
-            p.log.info("Global setup complete. Continuing with knowledge-base creation in this folder.");
-            await createKnowledgeBaseWizard({ intro: false, skipSkillInstall: true });
+        if (p.isCancel(runWorkspaceTest) || !runWorkspaceTest)
             return;
-        }
-        p.outro([
-            `Global setup complete — ${agent.displayName} connected`,
-            `Runtime stage instructions: bundled with this Interf build`,
-            ``,
-            `Next:`,
-            `  cd <your-folder> && interf create knowledge-base`,
-            `  cd <your-folder> && interf compile`,
-            `  cd <your-folder> && interf create interface`,
-        ].join("\n"));
+    }
+    workspaceOutcome = await runSavedWorkspaceTest({
+        sourcePath,
+        workspaceConfig,
+        workspacePath,
+    });
+    printSavedTestComparison(rawOutcome, workspaceOutcome);
+}
+export const initCommand = {
+    command: "init",
+    describe: "Open the root-folder wizard for this folder",
+    handler: async () => {
+        await runInitCommand();
     },
 };
-async function maybeAttachCurrentFolder(cwd, options = {}) {
+export async function runInitCommand() {
+    p.intro(chalk.bold("Interf"));
+    p.log.info("Measure and improve how accurately your local agent answers questions from this folder.");
+    const cwd = process.cwd();
     const detected = detectInterf(cwd);
-    const summaryLabel = options.localOnly ? "Folder setup ready." : "Global setup unchanged.";
+    const sourcePath = detected ? resolveSourceFolderPath(detected.path, detected.config) : cwd;
     if (detected) {
-        const currentContext = {
-            currentTargetType: detected.config.type,
-            ...(detected.config.type === "interface"
-                ? { currentInterfaceName: basename(detected.path) }
-                : {}),
-        };
-        const sourcePath = detected.config.type === "knowledge-base"
-            ? resolveKnowledgeBaseSourcePath(detected.path, detected.config)
-            : resolveInterfaceKnowledgeBasePath(detected.path)
-                ? resolveKnowledgeBaseSourcePath(resolveInterfaceKnowledgeBasePath(detected.path))
-                : null;
-        if (!sourcePath) {
-            p.outro([
-                "Global setup unchanged.",
-                "",
-                `This folder is already attached to Interf at:`,
-                `  ${detected.path}`,
-                "",
-                `Next:`,
-                `  interf compile`,
-                `  interf create interface`,
-            ].join("\n"));
-            return;
-        }
-        const managed = await maybeManageSourceFolderConfig(sourcePath, currentContext);
-        if (!managed)
+        p.log.info(`Working from the source folder: ${sourcePath}`);
+    }
+    const currentConfig = loadSourceFolderConfig(sourcePath);
+    if (!currentConfig || listSourceWorkspaceConfigs(currentConfig).length === 0) {
+        const workspaceConfig = await promptWorkspaceSetup({
+            sourcePath,
+            initial: { name: "default" },
+            introStyle: "first",
+        });
+        if (!workspaceConfig)
             return;
-        p.outro([
-            summaryLabel,
-            "",
-            `This folder is already attached to Interf at:`,
-            `  ${detected.path}`,
-            `Source config:`,
-            `  ${sourcePath}/${SOURCE_FOLDER_CONFIG_FILE}`,
-            "",
-            `Next:`,
-            `  interf compile`,
-            `  interf create interface`,
-        ].join("\n"));
+        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
         return;
     }
-    const sourceConfig = loadSourceFolderConfig(cwd);
-    if (sourceConfig) {
-        const managed = await maybeManageSourceFolderConfig(cwd);
-        if (!managed)
+    const selectedWorkspace = await chooseWorkspaceForWizard({
+        sourcePath,
+        fixedWorkspaceName: detected?.config.name ?? null,
+    });
+    if (!selectedWorkspace)
+        return;
+    if (selectedWorkspace === "__new__") {
+        const workspaceConfig = await promptWorkspaceSetup({
+            sourcePath,
+            initial: { name: "default" },
+            introStyle: "additional",
+        });
+        if (!workspaceConfig)
             return;
-        const localKnowledgeBases = listKnowledgeBasesForSourceFolder(cwd);
-        p.outro([
-            summaryLabel,
-            "",
-            `Source config:`,
-            `  ${cwd}/${SOURCE_FOLDER_CONFIG_FILE}`,
-            "",
-            `Next:`,
-            ...(localKnowledgeBases.length > 0
-                ? [
-                    `  interf compile`,
-                    `  interf benchmark`,
-                    `  interf create interface`,
-                ]
-                : [
-                    `  interf create knowledge-base`,
-                    `  interf compile`,
-                    `  interf benchmark`,
-                ]),
-        ].join("\n"));
+        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
         return;
     }
-    const attach = await p.confirm({
-        message: "Create the main Interf workspace for this folder now?",
-        initialValue: true,
+    const builtWorkspacePath = findBuiltWorkspacePath(sourcePath, selectedWorkspace.name);
+    printWorkspaceSummary({
+        sourcePath,
+        workspace: selectedWorkspace,
+        built: Boolean(builtWorkspacePath),
     });
-    if (p.isCancel(attach))
+    const action = await promptWorkspaceAction(selectedWorkspace, Boolean(builtWorkspacePath));
+    if (!action)
         return;
-    if (attach) {
-        const configured = await ensureSourceFolderConfig(cwd);
-        if (!configured)
-            return;
-        await createKnowledgeBaseWizard({ intro: false, skipSkillInstall: true });
+    if (action === "done") {
+        p.outro("Nothing changed.");
         return;
     }
-    p.outro([
-        summaryLabel,
-        "",
-        "This command did not create a knowledge base in the current folder.",
-        "",
-        "To attach and compile this folder later, run:",
-        "  interf init",
-        "  interf compile",
-        "  interf benchmark",
-    ].join("\n"));
-}
-async function ensureSourceFolderConfig(sourcePath) {
-    const existing = loadSourceFolderConfig(sourcePath);
-    if (existing) {
-        p.log.info(`Using existing ${SOURCE_FOLDER_CONFIG_FILE} in this folder. You can edit it any time.`);
-        p.log.info("Top-level evals are shared baseline checks for the workspace and every interface. `interfaces[].evals` add task-specific checks in the same file.");
-        p.log.info("These evals become the pass/fail checks used by `interf benchmark`.");
-        return true;
+    if (action === "workflow") {
+        await createWorkflowWizard({ sourcePath });
+        return;
     }
-    p.log.info(`${SOURCE_FOLDER_CONFIG_FILE} is where you define what must be true for this folder before benchmarking.`);
-    p.log.info(`Interf will write ${SOURCE_FOLDER_CONFIG_FILE} in this folder, and you can edit it any time.`);
-    p.log.info("Top-level evals are shared baseline checks for the workspace and every interface. `interfaces[].evals` add task-specific checks in the same file.");
-    p.log.info("`interf benchmark` runs the same evals against the raw folder, the compiled workspace, and any interface you add.");
-    p.log.info("Start with one small check you already know, then add task-specific checks only if you need a dedicated interface.");
-    const evals = await promptEvalCases({
-        heading: "Shared evals",
-        questionMessage: "Shared eval 1 question?",
-        questionPlaceholder: DEFAULT_SHARED_EVAL_QUESTION_PLACEHOLDER,
-        answerMessage: "Shared eval 1 expected answer?",
-        answerPlaceholder: DEFAULT_SHARED_EVAL_ANSWER_PLACEHOLDER,
-        addAnotherMessage: "Add another shared eval?",
-    });
-    if (evals === null)
-        return false;
-    const interfaces = await promptInterfaceConfigs();
-    if (interfaces === null)
-        return false;
-    saveSourceFolderConfig(sourcePath, {
-        evals,
-        ...(interfaces.length > 0 ? { interfaces } : {}),
-    });
-    p.log.info(`Saved ${SOURCE_FOLDER_CONFIG_FILE}. You can edit it any time.`);
-    return true;
-}
-async function maybeManageSourceFolderConfig(sourcePath, options = {}) {
-    const existing = loadSourceFolderConfig(sourcePath);
-    if (!existing) {
-        return ensureSourceFolderConfig(sourcePath);
+    if (action === "workspace") {
+        const workspaceConfig = await promptWorkspaceSetup({
+            sourcePath,
+            initial: { name: "default" },
+            introStyle: "additional",
+        });
+        if (!workspaceConfig)
+            return;
+        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
+        return;
     }
-    p.log.info(`${SOURCE_FOLDER_CONFIG_FILE} stays at the source-folder root.`);
-    p.log.info("It defines the pass/fail checks for `interf benchmark`.");
-    p.log.info("Top-level evals are shared baseline checks for the workspace and every interface. Interface-specific evals also live in this same file under `interfaces`.");
-    const choice = await p.select({
-        message: `Update ${SOURCE_FOLDER_CONFIG_FILE}?`,
-        options: [
-            {
-                value: "keep",
-                label: "Keep current config",
-                hint: "Use the existing evals and interfaces as-is",
-            },
-            {
-                value: "add-shared-evals",
-                label: "Add shared evals",
-                hint: "For the main workspace and every interface benchmark",
-            },
-            {
-                value: "add-interface",
-                label: "Add or update one interface",
-                hint: "Create or edit one task-specific compiled workspace on top of the main one",
-            },
-        ],
-    });
-    if (p.isCancel(choice))
-        return false;
-    if (choice === "keep")
-        return true;
-    if (choice === "add-shared-evals") {
-        const currentSharedEvals = existing.evals ?? existing.knowledge_base?.evals ?? [];
-        const evals = await promptEvalCases({
-            heading: "Add shared evals",
-            questionMessage: `Shared eval ${currentSharedEvals.length + 1} question?`,
-            questionPlaceholder: DEFAULT_SHARED_EVAL_QUESTION_PLACEHOLDER,
-            answerMessage: `Shared eval ${currentSharedEvals.length + 1} expected answer?`,
-            answerPlaceholder: DEFAULT_SHARED_EVAL_ANSWER_PLACEHOLDER,
-            addAnotherMessage: "Add another shared eval?",
-            startIndex: currentSharedEvals.length + 1,
+    if (action === "edit") {
+        const workspaceConfig = await promptWorkspaceSetup({
+            sourcePath,
+            initial: selectedWorkspace,
+            fixedName: selectedWorkspace.name,
+            introStyle: "edit",
         });
-        if (evals === null)
-            return false;
-        appendSourceFolderEvals(sourcePath, evals);
-        p.log.info(`Updated ${SOURCE_FOLDER_CONFIG_FILE}. You can edit it any time.`);
-        return true;
+        if (!workspaceConfig)
+            return;
+        await runFirstWorkspaceFlow(sourcePath, workspaceConfig);
+        return;
     }
-    const existingInterfaces = existing.interfaces ?? [];
-    let initial;
-    let fixedName;
-    let matchName;
-    p.log.info("An interface is a second compiled workspace for one recurring job on top of the main compiled workspace.");
-    p.log.info("Create one when the agent needs narrower retrieval, job-specific outputs, or extra task-specific evals.");
-    if (options.currentTargetType === "interface" && options.currentInterfaceName) {
-        fixedName = options.currentInterfaceName;
-        initial = existingInterfaces.find((entry) => entry.name === fixedName);
-        if (initial) {
-            p.log.info(`Updating interface evals for "${fixedName}" from the current interface folder.`);
-            p.log.info(`Current interface purpose: ${initial.about}`);
+    if (action === "raw") {
+        if (selectedWorkspace.checks.length === 0) {
+            process.exitCode = 1;
+            console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" does not have any saved questions yet.`));
+            console.log(chalk.dim("  Run `interf` or `interf init` to add a few first."));
+            return;
         }
-        else if (existingInterfaces.length === 1) {
-            const fallback = existingInterfaces[0];
-            initial = {
-                ...fallback,
-                name: fixedName,
-            };
-            matchName = fallback.name;
-            p.log.info(`Repairing interface config identity from "${fallback.name}" to "${fixedName}" so it matches the current interface folder.`);
-            p.log.info(`Current interface purpose: ${fallback.about}`);
+        const rawOutcome = await runSavedRawTest({
+            sourcePath,
+            workspaceConfig: selectedWorkspace,
+        });
+        if (!rawOutcome)
+            return;
+        const compileAndCompare = await p.confirm({
+            message: "Compile the workspace and run the same test now? (Recommended)",
+            initialValue: true,
+        });
+        if (p.isCancel(compileAndCompare) || !compileAndCompare) {
+            printSavedTestComparison(rawOutcome, null);
+            return;
         }
-        else {
-            p.log.info(`Writing interface evals for current interface "${fixedName}" into ${SOURCE_FOLDER_CONFIG_FILE}.`);
+        const workspacePath = await compileSelectedWorkspace(sourcePath, selectedWorkspace);
+        if (!workspacePath) {
+            printSavedTestComparison(rawOutcome, null);
+            return;
         }
+        const workspaceOutcome = await runSavedWorkspaceTest({
+            sourcePath,
+            workspaceConfig: selectedWorkspace,
+            workspacePath,
+        });
+        printSavedTestComparison(rawOutcome, workspaceOutcome);
+        return;
     }
-    if (!fixedName && existingInterfaces.length > 0) {
-        const interfaceChoice = await p.select({
-            message: "Which interface config?",
-            options: [
-                ...existingInterfaces.map((entry) => ({
-                    value: entry.name,
-                    label: entry.name,
-                    hint: entry.about,
-                })),
-                {
-                    value: "__create_new__",
-                    label: "Create new interface",
-                    hint: "Add a new interface block to this file",
-                },
-            ],
+    if (action === "compile") {
+        const workspacePath = await compileSelectedWorkspace(sourcePath, selectedWorkspace);
+        if (!workspacePath)
+            return;
+        if (selectedWorkspace.checks.length === 0)
+            return;
+        const runWorkspaceTest = await p.confirm({
+            message: "Run the saved test on the compiled workspace now?",
+            initialValue: true,
         });
-        if (p.isCancel(interfaceChoice))
-            return false;
-        if (interfaceChoice !== "__create_new__") {
-            initial = existingInterfaces.find((entry) => entry.name === interfaceChoice);
-        }
+        if (p.isCancel(runWorkspaceTest) || !runWorkspaceTest)
+            return;
+        const workspaceOutcome = await runSavedWorkspaceTest({
+            sourcePath,
+            workspaceConfig: selectedWorkspace,
+            workspacePath,
+        });
+        printSavedTestComparison(null, workspaceOutcome);
+        return;
     }
-    const interfaceConfig = await promptSingleInterfaceConfig({
-        initial,
-        ...(fixedName ? { fixedName } : {}),
-        ...(initial?.about ? { skipAboutPrompt: true } : {}),
-    });
-    if (!interfaceConfig)
-        return false;
-    upsertSourceFolderInterfaceConfig(sourcePath, interfaceConfig, {
-        ...(matchName ? { matchName } : {}),
+    if (!builtWorkspacePath) {
+        process.exitCode = 1;
+        console.log(chalk.red(`  Workspace "${selectedWorkspace.name}" is not compiled yet.`));
+        console.log(chalk.dim("  Run `interf compile` first."));
+        return;
+    }
+    const workspaceOutcome = await runSavedWorkspaceTest({
+        sourcePath,
+        workspaceConfig: selectedWorkspace,
+        workspacePath: builtWorkspacePath,
     });
-    p.log.info(`Updated ${SOURCE_FOLDER_CONFIG_FILE}. You can edit it any time.`);
-    return true;
+    printSavedTestComparison(null, workspaceOutcome);
 }
 //# sourceMappingURL=init.js.map