@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/init.js

@@ -1,771 +0,0 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { existsSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, isAbsolute, relative, resolve } from "node:path";
-import { assertCompiledContainer, detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_PATH, configuredSourceFolderPath, loadSourceFolderConfig, resolveConfiguredSourceFolderPath, saveSourceFolderConfig, } from "../../packages/project-model/source-config.js";
-import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
-import { DEFAULT_PREPARATION_NAME, describeCompileLoopSelection, listSourceFolderChoices, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
-import { seedLocalDefaultMethod } from "../../packages/method-package/local-methods.js";
-import { listSavedPreparationEntries, findBuiltPortableContextPath, findSavedPreparationConfig, } from "../../packages/project-model/preparation-entries.js";
-import { readCurrentSavedReadinessCheckRun, } from "../../packages/testing/readiness-check-run.js";
-import { runCompileCommand } from "./compile.js";
-import { runTestCommand } from "./test.js";
-import { defaultInterfInstanceRoot, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
-import { runWebCommand } from "./web.js";
-import { savePreparationThroughServiceAction } from "./preparation-action.js";
-function displayPath(path) {
-    const resolvedPath = resolve(path);
-    const cwd = process.cwd();
-    if (resolvedPath === cwd)
-        return ".";
-    if (isPathInside(cwd, resolvedPath))
-        return `./${relative(cwd, resolvedPath)}`;
-    const home = homedir();
-    if (resolvedPath === home)
-        return "~";
-    if (isPathInside(home, resolvedPath))
-        return `~/${relative(home, resolvedPath)}`;
-    return resolvedPath;
-}
-function isPathInside(parentPath, childPath) {
-    const relativePath = relative(parentPath, childPath);
-    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-function normalizeSourceFolderInput(cwd, input) {
-    const trimmed = input.trim();
-    if (trimmed.length === 0) {
-        throw new Error("Source Folder is required.");
-    }
-    const sourceFolderPath = resolve(cwd, trimmed);
-    if (!existsSync(sourceFolderPath)) {
-        throw new Error("Pick an existing Source Folder.");
-    }
-    if (!statSync(sourceFolderPath).isDirectory()) {
-        throw new Error("Source Folder must be a directory.");
-    }
-    return sourceFolderPath;
-}
-function normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, input) {
-    const trimmed = input.trim();
-    if (trimmed.length === 0) {
-        throw new Error("Interf Workspace folder is required.");
-    }
-    const controlPath = resolve(cwd, trimmed);
-    if (isPathInside(sourceFolderPath, controlPath)) {
-        throw new Error("Choose an Interf Workspace folder outside the Source Folder so Interf does not write generated state into your source files.");
-    }
-    assertCompiledContainer(controlPath);
-    return controlPath;
-}
-async function promptSourceFolderForInstance(cwd) {
-    const folderChoices = listSourceFolderChoices(cwd);
-    const selected = await p.select({
-        message: "Which Source Folder should Interf prepare?",
-        options: [
-            ...folderChoices,
-            {
-                value: "__current__",
-                label: `Use current folder (${basename(cwd)})`,
-                hint: cwd,
-            },
-            {
-                value: "__manual__",
-                label: "Enter a different path",
-                hint: "Use an absolute path or a path relative to this folder",
-            },
-        ],
-        initialValue: folderChoices.length === 1 ? folderChoices[0]?.value : "__current__",
-    });
-    if (p.isCancel(selected))
-        return null;
-    if (selected === "__manual__") {
-        const sourceInput = await p.text({
-            message: "Source Folder path?",
-            placeholder: cwd,
-            initialValue: cwd,
-            validate: (value) => {
-                try {
-                    normalizeSourceFolderInput(cwd, value);
-                    return undefined;
-                }
-                catch (error) {
-                    return error instanceof Error ? error.message : String(error);
-                }
-            },
-        });
-        if (p.isCancel(sourceInput))
-            return null;
-        return normalizeSourceFolderInput(cwd, String(sourceInput));
-    }
-    return normalizeSourceFolderInput(cwd, selected === "__current__" ? "." : String(selected));
-}
-async function promptInterfInstanceFolder(cwd, sourceFolderPath) {
-    const defaultControlPath = defaultInterfInstanceRoot(sourceFolderPath);
-    p.log.info("Interf stores config, Methods, runs, and portable context outside the Source Folder.");
-    const controlInput = await p.text({
-        message: "Where should Interf store this Interf Workspace?",
-        placeholder: defaultControlPath,
-        initialValue: defaultControlPath,
-        validate: (value) => {
-            try {
-                normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, value);
-                return undefined;
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : String(error);
-            }
-        },
-    });
-    if (p.isCancel(controlInput))
-        return null;
-    return normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, String(controlInput));
-}
-async function setupInterfInstance(cwd) {
-    const sourceFolderPath = await promptSourceFolderForInstance(cwd);
-    if (!sourceFolderPath)
-        return null;
-    const controlPath = await promptInterfInstanceFolder(cwd, sourceFolderPath);
-    if (!controlPath)
-        return null;
-    const sourceFolderConfigPath = relativeSourceFolderPath(controlPath, sourceFolderPath);
-    saveSourceFolderConfig(controlPath, {
-        source_folder: { path: sourceFolderConfigPath },
-        preparations: [],
-    });
-    const seeded = seedLocalDefaultMethod({ sourcePath: controlPath });
-    p.log.info(`Source Folder: ${displayPath(sourceFolderPath)}`);
-    p.log.info(`Interf Workspace: ${displayPath(controlPath)}`);
-    if (!seeded.alreadyExisted)
-        p.log.info(`Method: ${seeded.methodId}`);
-    return {
-        sourceFolderPath,
-        controlPath,
-        sourceFolderConfigPath,
-    };
-}
-async function promptEmptyInstanceAction() {
-    const selected = await p.select({
-        message: "What next?",
-        options: [
-            {
-                value: "web",
-                label: "Open Interf UI (Recommended)",
-                hint: "Start the local UI and API for this Source Folder",
-            },
-            {
-                value: "preparation",
-                label: "Create Preparation",
-                hint: "Describe the agent work, choose a Method, and save readiness checks",
-            },
-            {
-                value: "method",
-                label: "Create Method",
-                hint: "Create or draft a reusable way to process files",
-            },
-            {
-                value: "done",
-                label: "Done",
-                hint: `Leave the empty Interf Workspace at ${SOURCE_FOLDER_CONFIG_PATH}`,
-            },
-        ],
-    });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
-}
-export function currentRunTargetStatus(rows, target) {
-    const outcomes = rows
-        .map((row) => (target === "raw" ? row.rawOutcome : row.compiledOutcome))
-        .filter((outcome) => Boolean(outcome));
-    if (outcomes.length === 0)
-        return "missing";
-    const passFlags = outcomes.map((outcome) => outcome.result.totalCases > 0 && outcome.result.passedCases === outcome.result.totalCases);
-    if (passFlags.every(Boolean))
-        return "pass";
-    if (passFlags.some(Boolean))
-        return "mixed";
-    return "fail";
-}
-function describeSavedReadinessChecks(preparation) {
-    const count = preparation.checks.length;
-    if (count === 0)
-        return "no checks";
-    return `${count} readiness check${count === 1 ? "" : "s"}`;
-}
-function printPreparationSummary(options) {
-    const compiledConfig = options.builtCompiledPath
-        ? readInterfConfig(options.builtCompiledPath)
-        : null;
-    const methodLabel = `${options.preparation.method ?? "interf-default"}${compiledConfig?.method_origin?.local_draft === true ? " (local draft)" : ""}`;
-    const sourceFolderPath = resolve(options.sourcePath, options.preparation.path);
-    p.log.info(`Preparation: ${options.preparation.name} · Method: ${methodLabel}`);
-    if (options.preparation.about) {
-        p.log.info(`Agent work: ${options.preparation.about}`);
-    }
-    p.log.info(`Source Folder: ${displayPath(sourceFolderPath)}`);
-    p.log.info(`Portable Context: ${options.built ? "built" : "not built"} · Readiness: ${describeSavedReadinessChecks(options.preparation)}`);
-    const prepareMode = describeCompileLoopSelection({
-        maxAttempts: options.preparation.max_attempts,
-        maxLoops: options.preparation.max_loops,
-    });
-    if (prepareMode !== "Prepare once.")
-        p.log.info(`Prepare mode: ${prepareMode}`);
-    if (options.latestReadiness?.raw && options.latestReadiness?.compiled) {
-        p.log.info(`Latest readiness evidence: source files ${options.latestReadiness.raw.passed_cases}/${options.latestReadiness.raw.total_cases}, Portable Context ${options.latestReadiness.compiled.passed_cases}/${options.latestReadiness.compiled.total_cases}.`);
-    }
-    else if (options.latestReadiness?.raw) {
-        p.log.info(`Latest source-files readiness run: ${options.latestReadiness.raw.passed_cases}/${options.latestReadiness.raw.total_cases}.`);
-    }
-    else if (options.latestReadiness?.compiled) {
-        p.log.info(`Latest Portable Context readiness run: ${options.latestReadiness.compiled.passed_cases}/${options.latestReadiness.compiled.total_cases}.`);
-    }
-    else if (options.latestReadinessStale) {
-        p.log.info("Saved readiness results are stale for the current checks.");
-    }
-    if (options.sourcePath !== process.cwd()) {
-        p.log.info(`Interf Workspace: ${displayPath(options.sourcePath)}`);
-    }
-}
-async function promptPreparationAction(preparation, built, latestReadiness) {
-    const options = [];
-    const hasSavedRawBaseline = Boolean(latestReadiness?.raw);
-    const latestRawPasses = latestReadiness?.raw &&
-        latestReadiness.raw.passed_cases === latestReadiness.raw.total_cases;
-    const compileOption = {
-        value: "compile",
-        label: built ? "Prepare again" : "Prepare files",
-        hint: built
-            ? "Refresh Portable Context"
-            : preparation.checks.length > 0
-                ? latestRawPasses
-                    ? "Use the latest source-files baseline"
-                    : hasSavedRawBaseline
-                        ? "Run the same readiness checks after prepare"
-                        : "Write Portable Context"
-                : "Write Portable Context",
-    };
-    const webOption = {
-        value: "web",
-        label: "Open Interf UI",
-        hint: "Start the local UI and API for this Interf Workspace",
-    };
-    options.push(webOption);
-    if (preparation.checks.length > 0) {
-        const testOption = {
-            value: "test",
-            label: built
-                ? "Run readiness checks"
-                : hasSavedRawBaseline
-                    ? "Rerun the source-files baseline"
-                    : "Measure the source-files baseline",
-            hint: built
-                ? "Check source files and Portable Context"
-                : hasSavedRawBaseline
-                    ? "Refresh the saved source-files baseline on the current readiness checks"
-                    : "Optional source-files readiness baseline before Interf builds Portable Context",
-        };
-        if (built) {
-            options.push(testOption, compileOption);
-        }
-        else {
-            options.push(compileOption, testOption);
-        }
-    }
-    else {
-        options.push(compileOption);
-    }
-    options.push({
-        value: "preparation",
-        label: "Add another Preparation",
-        hint: "Separate source, focus, or checks",
-    }, {
-        value: "edit",
-        label: preparation.checks.length === 0 ? "Add readiness checks" : "Edit checks and settings",
-        hint: "Checks, focus, Method, or mode",
-    }, {
-        value: "method",
-        label: "Create Method",
-        hint: "Custom file processing",
-    }, {
-        value: "done",
-        label: "Done",
-        hint: "Exit the wizard",
-    });
-    const selected = await p.select({
-        message: "What next?",
-        options,
-    });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
-}
-function printPreparationRecommendation(preparation, built, latestReadiness) {
-    if (preparation.checks.length === 0) {
-        return;
-    }
-    if (!built) {
-        if (latestReadiness?.raw) {
-            p.log.info(latestReadiness.raw.passed_cases === latestReadiness.raw.total_cases
-                ? `Latest source-files readiness run: ${latestReadiness.raw.passed_cases}/${latestReadiness.raw.total_cases}. Prepare files when you want Portable Context for the same agent work.`
-                : `Latest source-files readiness run: ${latestReadiness.raw.passed_cases}/${latestReadiness.raw.total_cases}. Some readiness checks still fail on the source files. Prepare files if you want Interf to process this data and run the same checks.`);
-            return;
-        }
-        p.log.info("Recommended first step: choose a Method and prepare files.");
-        return;
-    }
-    p.log.info("Recommended first step: run readiness checks against source files and Portable Context.");
-}
-async function promptPostBaselineAction(rows) {
-    const status = currentRunTargetStatus(rows, "raw");
-    const subject = rows.length === 1 ? "selected agent" : "selected agents";
-    if (status === "pass") {
-        p.log.info(`Source files passed on all ${subject} in this run.`);
-    }
-    else if (status === "mixed") {
-        p.log.info(`Source files were mixed across the ${subject} in this run.`);
-    }
-    else if (status === "fail") {
-        p.log.info(`Source files did not pass on the ${subject} in this run.`);
-    }
-    const compileRecommended = status !== "pass";
-    const selected = await p.select({
-        message: "What next?",
-        options: [
-            {
-                value: "compile",
-                label: compileRecommended
-                    ? "Prepare files and write Portable Context (Recommended)"
-                    : "Prepare files and write Portable Context",
-                hint: compileRecommended
-                    ? status === "mixed"
-                        ? "Some selected agents still failed on the source files. Prepare files and run the same readiness checks"
-                        : "Prepare files and run the same readiness checks"
-                    : "Prepare files and run the same readiness checks",
-            },
-            {
-                value: "edit",
-                label: "Change readiness checks and settings",
-                hint: "Revise the readiness checks or Preparation settings before the next run",
-            },
-            {
-                value: "rerun",
-                label: "Rerun the source-files baseline",
-                hint: "Run the same readiness checks again, including different local agents if you want",
-            },
-            {
-                value: "done",
-                label: "Stop here",
-                hint: "Leave the Preparation as-is for now",
-            },
-        ],
-    });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
-}
-async function chooseCompiledForWizard(options) {
-    if (options.fixedCompiledName) {
-        return findSavedPreparationConfig(options.sourcePath, options.fixedCompiledName);
-    }
-    const savedEntries = listSavedPreparationEntries(options.sourcePath);
-    if (savedEntries.length === 0)
-        return null;
-    if (savedEntries.length === 1)
-        return savedEntries[0]?.config ?? null;
-    const selected = await p.select({
-        message: "Which saved Preparation do you want to work with?",
-        options: [
-            ...savedEntries.map((entry) => ({
-                value: entry.config.name,
-                label: entry.config.name,
-                hint: [
-                    `path ${entry.config.path}`,
-                    entry.config.about ?? describeSavedReadinessChecks(entry.config),
-                    `Method ${entry.config.method ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`,
-                    entry.path ? "Portable Context available" : "Portable Context not built yet",
-                ].join(" · "),
-            })),
-            {
-                value: "__new__",
-                label: "Add another Preparation",
-                hint: "Add a separate folder, focus, or readiness-check set",
-            },
-        ],
-    });
-    if (p.isCancel(selected))
-        return null;
-    if (selected === "__new__")
-        return "__new__";
-    return findSavedPreparationConfig(options.sourcePath, String(selected));
-}
-async function promptCompiledSetup(options) {
-    const savedConfig = loadSourceFolderConfig(options.sourcePath);
-    const fixedPath = options.fixedPath
-        ?? (options.fixedName ? options.initial?.path : configuredSourceFolderPath(savedConfig) ?? undefined);
-    const compiledConfig = await promptSingleCompiledConfig({
-        projectPath: options.sourcePath,
-        initial: options.initial,
-        ...(options.fixedName ? { fixedName: options.fixedName } : {}),
-        ...(fixedPath ? { fixedPath } : {}),
-        introStyle: options.introStyle,
-    });
-    if (!compiledConfig)
-        return null;
-    const methodChoice = await chooseOrCreateCompiledMethodForPreparation(options.sourcePath, compiledConfig, {
-        currentMethodId: options.initial?.method ?? "interf-default",
-    });
-    if (!methodChoice || p.isCancel(methodChoice))
-        return null;
-    const methodId = String(methodChoice);
-    const compiledConfigWithMethod = {
-        ...compiledConfig,
-        method: methodId,
-    };
-    await savePreparationThroughServiceAction({
-        sourcePath: options.sourcePath,
-        preparation: compiledConfigWithMethod,
-    });
-    console.log();
-    console.log(chalk.green(`  ✓ Saved Preparation in ${SOURCE_FOLDER_CONFIG_PATH}`));
-    console.log(chalk.dim(`  Interf Workspace: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Preparation: ${compiledConfigWithMethod.name}`));
-    console.log(chalk.dim(`  Source folder: ${compiledConfigWithMethod.path}`));
-    console.log(chalk.dim(`  Method: ${methodId} · interf/methods/${methodId}/`));
-    console.log(chalk.dim(`  Prepare mode: ${describeCompileLoopSelection({
-        maxAttempts: compiledConfigWithMethod.max_attempts,
-        maxLoops: compiledConfigWithMethod.max_loops,
-    })}`));
-    return compiledConfigWithMethod;
-}
-export async function compileSelectedCompiled(sourcePath, compiledConfig, deps = {}) {
-    return (deps.runCompileCommand ?? runCompileCommand)({
-        sourcePath,
-        preparation: compiledConfig.name,
-        preparationConfig: compiledConfig,
-        skipConfirm: true,
-        skipPreparationBanner: true,
-    });
-}
-async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
-    const builtCompiledPath = findBuiltPortableContextPath(sourcePath, compiledConfig.name);
-    const { readinessRun: latestReadiness, stale: latestReadinessStale, } = readCurrentSavedReadinessCheckRun({
-        projectPath: sourcePath,
-        preparationName: compiledConfig.name,
-        checks: compiledConfig.checks,
-    });
-    printPreparationSummary({
-        sourcePath,
-        preparation: compiledConfig,
-        built: Boolean(builtCompiledPath),
-        builtCompiledPath,
-        latestReadiness,
-        latestReadinessStale,
-    });
-    printPreparationRecommendation(compiledConfig, Boolean(builtCompiledPath), latestReadiness);
-    const action = await promptPreparationAction(compiledConfig, Boolean(builtCompiledPath), latestReadiness);
-    if (!action)
-        return;
-    if (action === "done") {
-        p.outro(options.justConfigured ? "Saved Preparation." : "Nothing changed.");
-        return;
-    }
-    if (action === "method") {
-        const methodId = await createMethodWizard({
-            sourcePath,
-            preparationContext: {
-                config: compiledConfig,
-                sourceFolderPath: resolve(sourcePath, compiledConfig.path),
-            },
-        });
-        if (typeof methodId === "string") {
-            const nextConfig = {
-                ...compiledConfig,
-                method: methodId,
-            };
-            await savePreparationThroughServiceAction({
-                sourcePath,
-                preparation: nextConfig,
-                setupMode: "select-method",
-            });
-            p.log.info(`Assigned Method "${methodId}" to Preparation "${compiledConfig.name}".`);
-            p.log.info("Next: run `interf compile`, then `interf test`.");
-        }
-        return;
-    }
-    if (action === "web") {
-        await runWebCommand({ "control-path": sourcePath });
-        return;
-    }
-    if (action === "preparation") {
-        const nextCompiled = await promptCompiledSetup({
-            sourcePath,
-            initial: { name: DEFAULT_PREPARATION_NAME },
-            introStyle: "additional",
-        });
-        if (!nextCompiled)
-            return;
-        await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
-        return;
-    }
-    if (action === "edit") {
-        const nextCompiled = await promptCompiledSetup({
-            sourcePath,
-            initial: compiledConfig,
-            fixedName: compiledConfig.name,
-            introStyle: "edit",
-        });
-        if (!nextCompiled)
-            return;
-        await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
-        return;
-    }
-    if (action === "test") {
-        if (compiledConfig.checks.length === 0) {
-            process.exitCode = 1;
-            console.log(chalk.red(`  Preparation "${compiledConfig.name}" does not have any readiness checks yet.`));
-            console.log(chalk.dim("  Run `interf`, edit this Preparation, and add a few readiness checks first."));
-            console.log(chalk.dim("  Then rerun `interf test`."));
-            return;
-        }
-        if (builtCompiledPath) {
-            const baselineRan = await runTestCommand({
-                sourcePath,
-                preparation: compiledConfig.name,
-                preparationConfig: compiledConfig,
-                target: "both",
-            });
-            if (!baselineRan) {
-                return;
-            }
-            return;
-        }
-        while (true) {
-            const baselineCapture = { result: null };
-            const baselineRan = await runTestCommand({
-                sourcePath,
-                preparation: compiledConfig.name,
-                preparationConfig: compiledConfig,
-                target: "source-files",
-                onComplete(result) {
-                    baselineCapture.result = result;
-                },
-            });
-            const baselineResult = baselineCapture.result;
-            if (!baselineRan || !baselineResult) {
-                return;
-            }
-            const nextAction = await promptPostBaselineAction(baselineResult.rows);
-            if (!nextAction || nextAction === "done") {
-                return;
-            }
-            if (nextAction === "rerun") {
-                continue;
-            }
-            if (nextAction === "edit") {
-                const nextCompiled = await promptCompiledSetup({
-                    sourcePath,
-                    initial: compiledConfig,
-                    fixedName: compiledConfig.name,
-                    introStyle: "edit",
-                });
-                if (!nextCompiled) {
-                    return;
-                }
-                await runCompiledActionMenu(sourcePath, nextCompiled, { justConfigured: true });
-                return;
-            }
-            break;
-        }
-        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
-        if (!compileResult) {
-            return;
-        }
-        if (compileResult.testedDuringCompile) {
-            p.log.info("This prepare run already checked the Portable Context on the saved readiness checks.");
-            p.log.info("Run `interf test` later if you want fresh readiness evidence for source files and Portable Context.");
-            return;
-        }
-        await runTestCommand({
-            sourcePath,
-            preparation: compiledConfig.name,
-            preparationConfig: compiledConfig,
-            target: "both",
-        });
-        return;
-    }
-    if (action === "compile") {
-        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
-        if (!compileResult)
-            return;
-        if (compiledConfig.checks.length === 0)
-            return;
-        if (compileResult.testedDuringCompile) {
-            p.log.info("This prepare run already checked the Portable Context on the compile agent.");
-        }
-        const runCompiledTest = await p.confirm({
-            message: compileResult.testedDuringCompile
-                ? "Run fresh readiness checks against source files and Portable Context now?"
-                : builtCompiledPath
-                    ? "Run readiness checks on source files and Portable Context now?"
-                    : "Run readiness checks on source files and Portable Context now?",
-            initialValue: true,
-        });
-        if (p.isCancel(runCompiledTest) || !runCompiledTest)
-            return;
-        await runTestCommand({
-            sourcePath,
-            preparation: compiledConfig.name,
-            preparationConfig: compiledConfig,
-            target: "both",
-        });
-        return;
-    }
-}
-export const initCommand = {
-    command: "init",
-    describe: "Set up Interf or open the Preparation wizard",
-    handler: async () => {
-        await runInitCommand();
-    },
-};
-export async function runInitCommand() {
-    p.intro(chalk.bold("Interf"));
-    const cwd = process.cwd();
-    const detected = detectInterf(cwd);
-    let initContext = detected
-        ? {
-            controlPath: resolveSourceControlPath(detected.path),
-            defaultSourceFolderPath: null,
-            defaultPreparationPath: null,
-        }
-        : resolveInterfInstanceContext(cwd);
-    let sourcePath = initContext.controlPath;
-    if (detected) {
-        p.log.info(`Interf Workspace: ${displayPath(sourcePath)}`);
-    }
-    const hasConfig = Boolean(loadSourceFolderConfig(sourcePath));
-    let initialSourceFolderPath = initContext.defaultSourceFolderPath;
-    let initialSourceFolderConfigPath = initContext.defaultPreparationPath;
-    if (!detected && !hasConfig) {
-        const setup = await setupInterfInstance(cwd);
-        if (!setup)
-            return;
-        sourcePath = setup.controlPath;
-        initialSourceFolderPath = setup.sourceFolderPath;
-        initialSourceFolderConfigPath = setup.sourceFolderConfigPath;
-        initContext = {
-            controlPath: sourcePath,
-            defaultSourceFolderPath: initialSourceFolderPath,
-            defaultPreparationPath: initialSourceFolderConfigPath,
-        };
-    }
-    else {
-        const seeded = seedLocalDefaultMethod({ sourcePath });
-        if (!seeded.alreadyExisted) {
-            p.log.info(`Method: ${seeded.methodId}`);
-        }
-    }
-    let currentConfig = loadSourceFolderConfig(sourcePath);
-    if (!currentConfig?.source_folder && !detected) {
-        const currentEntries = currentConfig?.preparations ?? [];
-        if (initialSourceFolderPath && initialSourceFolderConfigPath) {
-            saveSourceFolderConfig(sourcePath, {
-                source_folder: { path: initialSourceFolderConfigPath },
-                preparations: currentEntries,
-            });
-            currentConfig = loadSourceFolderConfig(sourcePath);
-        }
-        else if (currentConfig && currentEntries.length === 0) {
-            const sourceFolderPath = await promptSourceFolderForInstance(cwd);
-            if (!sourceFolderPath)
-                return;
-            const sourceFolderConfigPath = relativeSourceFolderPath(sourcePath, sourceFolderPath);
-            saveSourceFolderConfig(sourcePath, {
-                source_folder: { path: sourceFolderConfigPath },
-                preparations: [],
-            });
-            initialSourceFolderPath = sourceFolderPath;
-            initialSourceFolderConfigPath = sourceFolderConfigPath;
-            currentConfig = loadSourceFolderConfig(sourcePath);
-            p.log.info(`Source Folder: ${sourceFolderPath}`);
-            p.log.info(`Source Folder path in Interf config: ${sourceFolderConfigPath}`);
-        }
-        else if (!currentConfig) {
-            const setup = await setupInterfInstance(cwd);
-            if (!setup)
-                return;
-            sourcePath = setup.controlPath;
-            initialSourceFolderPath = setup.sourceFolderPath;
-            initialSourceFolderConfigPath = setup.sourceFolderConfigPath;
-            currentConfig = loadSourceFolderConfig(sourcePath);
-        }
-    }
-    const configuredSourcePath = resolveConfiguredSourceFolderPath(sourcePath, currentConfig);
-    const configuredSourceConfigPath = configuredSourceFolderPath(currentConfig);
-    if (configuredSourcePath && configuredSourceConfigPath) {
-        initialSourceFolderPath = configuredSourcePath;
-        initialSourceFolderConfigPath = configuredSourceConfigPath;
-    }
-    const savedEntries = listSavedPreparationEntries(sourcePath);
-    if (savedEntries.length === 0) {
-        p.log.info("No Preparations yet. Create one when you are ready to describe the agent work.");
-        const action = await promptEmptyInstanceAction();
-        if (!action || action === "done") {
-            p.outro("Interf Workspace is ready. Next: run `interf web` or `interf create preparation`.");
-            return;
-        }
-        if (action === "web") {
-            await runWebCommand({ "control-path": sourcePath });
-            return;
-        }
-        if (action === "method") {
-            const methodId = await createMethodWizard({ sourcePath });
-            if (typeof methodId === "string") {
-                p.outro(`Saved Method "${methodId}". Next: create a Preparation and assign this Method.`);
-            }
-            return;
-        }
-        const compiledConfig = await promptCompiledSetup({
-            sourcePath,
-            initial: initialSourceFolderPath && initialSourceFolderConfigPath
-                ? {
-                    name: defaultPreparationNameForPath(initialSourceFolderPath),
-                    path: initialSourceFolderConfigPath,
-                }
-                : { name: DEFAULT_PREPARATION_NAME },
-            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
-            introStyle: "first",
-        });
-        if (!compiledConfig)
-            return;
-        await runCompiledActionMenu(sourcePath, compiledConfig, { justConfigured: true });
-        return;
-    }
-    const selectedCompiled = await chooseCompiledForWizard({
-        sourcePath,
-        fixedCompiledName: detected?.config.name ?? null,
-    });
-    if (!selectedCompiled)
-        return;
-    if (selectedCompiled === "__new__") {
-        const compiledConfig = await promptCompiledSetup({
-            sourcePath,
-            initial: initialSourceFolderPath && initialSourceFolderConfigPath
-                ? {
-                    name: defaultPreparationNameForPath(initialSourceFolderPath),
-                    path: initialSourceFolderConfigPath,
-                }
-                : { name: DEFAULT_PREPARATION_NAME },
-            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
-            introStyle: "additional",
-        });
-        if (!compiledConfig)
-            return;
-        await runCompiledActionMenu(sourcePath, compiledConfig, { justConfigured: true });
-        return;
-    }
-    await runCompiledActionMenu(sourcePath, selectedCompiled);
-}