@interf/compiler 0.9.4 → 0.13.0

package/dist/cli/commands/source-config-wizard.js

@@ -1,680 +0,0 @@
-import * as p from "@clack/prompts";
-import { sourceConfig as projectSourceConfig, sourceFolders as projectSourceFolders, } from "../../packages/project-model/index.js";
-import { slugify } from "../../packages/shared/naming.js";
-import { submitReadinessCheckDraftToLocalService, } from "../../packages/local-service/index.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { draftReadinessChecks } from "./check-draft.js";
-export const DEFAULT_PREPARATION_NAME = "default";
-export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
-export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
-export const DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER = "./source-files";
-export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
-export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
-const DEFAULT_SELF_IMPROVING_ATTEMPTS = 1;
-function normalizeOptionalPromptText(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
-}
-export function normalizeSourceFolderPathForConfig(projectPath, value) {
-    return projectSourceFolders.normalizeSourcePreparationPathForConfig(projectPath, value);
-}
-function defaultPreparationNameForPath(sourceFolderPath) {
-    return projectSourceFolders.defaultPreparationNameForPath(sourceFolderPath);
-}
-export function listSourceFolderChoices(cwd = process.cwd()) {
-    return projectSourceFolders.listSourceFolderChoices(cwd);
-}
-export function defaultSourceFolderPathForPrompt(name, introStyle, cwd = process.cwd()) {
-    return projectSourceFolders.defaultSourcePreparationPathForPrompt(name, introStyle, cwd);
-}
-async function promptSourceFolderPath(options) {
-    const folderChoices = listSourceFolderChoices(options.projectPath);
-    if (folderChoices.length > 0) {
-        const selected = await p.select({
-            message: "Which Source Folder should Interf use?",
-            options: [
-                ...folderChoices,
-                {
-                    value: "__manual__",
-                    label: "Enter a different path",
-                    hint: "Use a relative path if the Source Folder is not listed here",
-                },
-            ],
-            initialValue: folderChoices.some((choice) => choice.value === options.initialPath)
-                ? options.initialPath
-                : undefined,
-        });
-        if (p.isCancel(selected))
-            return null;
-        if (selected !== "__manual__") {
-            try {
-                return normalizeSourceFolderPathForConfig(options.projectPath, String(selected));
-            }
-            catch (error) {
-                p.log.error(error instanceof Error ? error.message : String(error));
-                return null;
-            }
-        }
-    }
-    const sourceFolderPath = await p.text({
-        message: "Which Source Folder should Interf use?",
-        placeholder: DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER,
-        initialValue: options.initialPath,
-        validate: (value) => {
-            const normalized = value.trim();
-            if (normalized.length === 0)
-                return "Source Folder is required";
-            try {
-                normalizeSourceFolderPathForConfig(options.projectPath, normalized);
-                return undefined;
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : String(error);
-            }
-        },
-    });
-    if (p.isCancel(sourceFolderPath))
-        return null;
-    return normalizeSourceFolderPathForConfig(options.projectPath, String(sourceFolderPath));
-}
-export function preparationAboutPromptMessage(introStyle) {
-    if (introStyle === "edit") {
-        return "What agent work should this Preparation stay focused on?";
-    }
-    return "What agent work should this Preparation help with?";
-}
-function formatAttemptLabel(count, noun) {
-    return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-export function resolveCompileLoopMode(maxAttempts, maxLoops) {
-    if ((maxLoops ?? 0) > 0)
-        return "self-improving";
-    if ((maxAttempts ?? 0) > 1)
-        return "retry";
-    return "once";
-}
-export function describeCompileLoopSelection(options) {
-    const mode = resolveCompileLoopMode(options.maxAttempts, options.maxLoops);
-    if (mode === "once") {
-        return "Prepare once.";
-    }
-    if (mode === "retry") {
-        const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
-        return `Prepare retries are enabled here (${formatAttemptLabel(attempts, "total attempt")}).`;
-    }
-    const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
-    const attempts = options.maxAttempts ?? DEFAULT_SELF_IMPROVING_ATTEMPTS;
-    return `Self-improving loops are enabled here (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "Method revision")}).`;
-}
-async function promptCompileRetryAttempts(options) {
-    const maxAttempts = await p.text({
-        message: options.message,
-        placeholder: String(DEFAULT_COMPILE_RETRY_ATTEMPTS),
-        initialValue: String(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS),
-        validate: (value) => {
-            const parsed = Number.parseInt(value.trim(), 10);
-            if (!Number.isInteger(parsed) || parsed < 2 || parsed > 5) {
-                return "Enter a whole number from 2 to 5";
-            }
-            return undefined;
-        },
-    });
-    if (p.isCancel(maxAttempts))
-        return null;
-    return projectSourceConfig.compiledMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10))
-        ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
-}
-export async function promptCheckCases(options) {
-    p.log.info(options.heading);
-    const cases = [];
-    const startIndex = options.startIndex ?? 1;
-    while (true) {
-        const question = await p.text({
-            message: cases.length === 0
-                ? options.questionMessage
-                : `Check ${startIndex + cases.length}?`,
-            placeholder: options.questionPlaceholder,
-            validate: (value) => (value.trim().length === 0 ? "Check is required" : undefined),
-        });
-        if (p.isCancel(question))
-            return null;
-        const answer = await p.text({
-            message: cases.length === 0
-                ? options.answerMessage
-                : `Expected answer ${startIndex + cases.length}?`,
-            placeholder: options.answerPlaceholder,
-            validate: (value) => (value.trim().length === 0 ? "Answer is required" : undefined),
-        });
-        if (p.isCancel(answer))
-            return null;
-        cases.push({
-            question: String(question).trim(),
-            answer: String(answer).trim(),
-        });
-        const addAnother = await p.confirm({
-            message: options.addAnotherMessage,
-            initialValue: false,
-        });
-        if (p.isCancel(addAnother))
-            return null;
-        if (!addAnother)
-            return cases;
-    }
-}
-function printDraftReadinessChecks(checks) {
-    console.log();
-    p.log.info(`Draft readiness checks: ${checks.length}`);
-    for (const [index, check] of checks.entries()) {
-        console.log(`  ${index + 1}. ${check.question}`);
-        console.log(`     Expected: ${check.answer ?? ""}`);
-    }
-}
-async function promptDraftReadinessChecks(options) {
-    let resolvedSourceFolderPath;
-    try {
-        const preparationPathConfig = {
-            path: options.sourceFolderPath,
-        };
-        resolvedSourceFolderPath = projectSourceConfig.resolveSourcePreparationPath(options.projectPath, preparationPathConfig);
-    }
-    catch (error) {
-        p.log.error(error instanceof Error ? error.message : String(error));
-        return "manual";
-    }
-    while (true) {
-        p.log.info("Drafting readiness checks from the source files.");
-        let lastServiceStatus = "";
-        const serviceRun = await submitReadinessCheckDraftToLocalService({
-            projectPath: options.projectPath,
-            request: {
-                preparation: options.preparationName,
-                source_folder_path: resolvedSourceFolderPath,
-                about: options.about,
-                target_count: 4,
-            },
-            onSubmitted: (submission) => {
-                p.log.info(`Visible in Interf: ${submission.serviceUrl}/`);
-            },
-            onUpdate: (job) => {
-                const activeStep = job.steps.find((step) => step.status === "running")
-                    ?? [...job.steps].reverse().find((step) => step.status === "succeeded" || step.status === "failed")
-                    ?? null;
-                const statusKey = `${job.status}:${activeStep?.id ?? ""}:${activeStep?.status ?? ""}`;
-                if (statusKey === lastServiceStatus)
-                    return;
-                lastServiceStatus = statusKey;
-                p.log.info(activeStep
-                    ? `${activeStep.label}: ${activeStep.status}`
-                    : `Readiness-check draft run: ${job.status}`);
-            },
-        });
-        const drafted = serviceRun
-            ? {
-                checks: serviceRun.result?.checks ?? null,
-                error: serviceRun.error,
-            }
-            : await (async () => {
-                const resolved = await resolveOrConfigureLocalExecutor({
-                    preflight: true,
-                    purpose: "draft",
-                });
-                if (!resolved.executor) {
-                    if (resolved.cancelled)
-                        return null;
-                    p.log.error(resolved.error ?? "No local agent detected for readiness-check drafting.");
-                    const manualChoice = await p.select({
-                        message: "How do you want to continue?",
-                        options: [
-                            {
-                                value: "manual",
-                                label: "Add readiness checks manually",
-                                hint: "Write the checks and expected answers yourself",
-                            },
-                            {
-                                value: "skip",
-                                label: "Skip for now",
-                                hint: "Save this Preparation without readiness checks",
-                            },
-                        ],
-                    });
-                    if (p.isCancel(manualChoice))
-                        return null;
-                    return manualChoice === "manual"
-                        ? "manual"
-                        : "skip";
-                }
-                return draftReadinessChecks({
-                    preparationName: options.preparationName,
-                    sourceFolderPath: resolvedSourceFolderPath,
-                    about: options.about,
-                    executor: resolved.executor,
-                    targetCount: 4,
-                });
-            })();
-        if (drafted === null)
-            return null;
-        if (drafted === "manual")
-            return "manual";
-        if (drafted === "skip")
-            return [];
-        if (!drafted.checks) {
-            p.log.error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
-            const retryMode = await p.select({
-                message: "How do you want to continue?",
-                options: [
-                    {
-                        value: "retry",
-                        label: "Try auto-create again",
-                        hint: "Run the same local agent again on the Source Folder",
-                    },
-                    {
-                        value: "manual",
-                        label: "Add readiness checks manually",
-                        hint: "Write the checks yourself instead",
-                    },
-                    {
-                        value: "skip",
-                        label: "Skip for now",
-                        hint: "Save this Preparation without readiness checks",
-                    },
-                ],
-            });
-            if (p.isCancel(retryMode))
-                return null;
-            if (retryMode === "retry")
-                continue;
-            return retryMode === "manual" ? "manual" : [];
-        }
-        printDraftReadinessChecks(drafted.checks);
-        const nextStep = await p.select({
-            message: "Use these readiness checks?",
-            options: [
-                {
-                    value: "use",
-                    label: "Use this draft (Recommended)",
-                    hint: "Save these checks and edit them later if needed",
-                },
-                {
-                    value: "retry",
-                    label: "Draft again",
-                    hint: "Run the same local agent again on the Source Folder",
-                },
-                {
-                    value: "manual",
-                    label: "Add readiness checks manually instead",
-                    hint: "Discard this draft and write the checks yourself",
-                },
-                {
-                    value: "skip",
-                    label: "Skip for now",
-                    hint: "Save this Preparation without readiness checks",
-                },
-            ],
-        });
-        if (p.isCancel(nextStep))
-            return null;
-        if (nextStep === "retry")
-            continue;
-        if (nextStep === "manual")
-            return "manual";
-        if (nextStep === "skip")
-            return [];
-        return drafted.checks;
-    }
-}
-async function promptCompiledChecks(options) {
-    if (!options.initialChecks?.length) {
-        if (options.initialAbout) {
-            p.log.info(`About: ${options.initialAbout}`);
-        }
-        p.log.info("Readiness checks are small agent-work-critical checks from your files that define when this data is ready for agent work.");
-        const mode = await p.select({
-            message: "How should Interf create them?",
-            options: [
-                {
-                    value: "draft",
-                    label: "Auto-create readiness checks (Recommended)",
-                    hint: "Let your chosen local agent recommend a few clear, verifiable checks from this Source Folder",
-                },
-                {
-                    value: "manual",
-                    label: "Add readiness checks manually",
-                    hint: "Write the checks and expected answers yourself",
-                },
-                {
-                    value: "skip",
-                    label: "Skip for now",
-                    hint: "You can save the Preparation first and add readiness checks later",
-                },
-            ],
-        });
-        if (p.isCancel(mode))
-            return null;
-        if (mode === "skip")
-            return [];
-        if (mode === "draft") {
-            const drafted = await promptDraftReadinessChecks({
-                projectPath: options.projectPath,
-                preparationName: options.preparationName,
-                sourceFolderPath: options.sourceFolderPath,
-                about: options.initialAbout,
-            });
-            if (drafted === null)
-                return null;
-            if (drafted === "manual") {
-                return promptCheckCases({
-                    heading: "Readiness checks",
-                    questionMessage: "Check 1?",
-                    questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
-                    answerMessage: "Expected answer 1?",
-                    answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-                    addAnotherMessage: "Add another readiness check?",
-                });
-            }
-            return drafted;
-        }
-        return promptCheckCases({
-            heading: "Readiness checks",
-            questionMessage: "Check 1?",
-            questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
-            answerMessage: "Expected answer 1?",
-            answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-            addAnotherMessage: "Add another readiness check?",
-        });
-    }
-    if (options.initialAbout) {
-        p.log.info(`About: ${options.initialAbout}`);
-    }
-    p.log.info(`Current readiness checks: ${options.initialChecks.length}`);
-    const mode = await p.select({
-        message: "What do you want to do with them?",
-        options: [
-            {
-                value: "keep",
-                label: "Keep them",
-                hint: "Leave the current readiness checks as-is",
-            },
-            {
-                value: "add",
-                label: "Add more",
-                hint: "Append more readiness checks",
-            },
-            {
-                value: "replace",
-                label: "Replace all",
-                hint: "Rewrite the readiness checks from scratch",
-            },
-            {
-                value: "redraft",
-                label: "Replace with auto-created draft",
-                hint: "Let a local agent rewrite the readiness checks from the Preparation files",
-            },
-            {
-                value: "clear",
-                label: "Clear them for now",
-                hint: "Keep this Preparation without readiness checks",
-            },
-        ],
-    });
-    if (p.isCancel(mode))
-        return null;
-    if (mode === "keep") {
-        return options.initialChecks;
-    }
-    if (mode === "clear") {
-        return [];
-    }
-    if (mode === "redraft") {
-        const drafted = await promptDraftReadinessChecks({
-            projectPath: options.projectPath,
-            preparationName: options.preparationName,
-            sourceFolderPath: options.sourceFolderPath,
-            about: options.initialAbout,
-        });
-        if (drafted === null)
-            return null;
-        if (drafted === "manual") {
-            return promptCheckCases({
-                heading: "Replace readiness checks",
-                questionMessage: "Check 1?",
-                questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
-                answerMessage: "Expected answer 1?",
-                answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-                addAnotherMessage: "Add another readiness check?",
-            });
-        }
-        return drafted;
-    }
-    const nextChecks = await promptCheckCases({
-        heading: mode === "add" ? "Add more readiness checks" : "Replace readiness checks",
-        questionMessage: mode === "add"
-            ? `Check ${options.initialChecks.length + 1}?`
-            : "Check 1?",
-        questionPlaceholder: DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER,
-        answerMessage: mode === "add"
-            ? `Expected answer ${options.initialChecks.length + 1}?`
-            : "Expected answer 1?",
-        answerPlaceholder: DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER,
-        addAnotherMessage: "Add another readiness check?",
-        startIndex: mode === "add" ? options.initialChecks.length + 1 : 1,
-    });
-    if (nextChecks === null)
-        return null;
-    return mode === "add" ? [...options.initialChecks, ...nextChecks] : nextChecks;
-}
-async function promptSelfImprovingLoops(options) {
-    const maxLoops = await p.text({
-        message: options.message,
-        placeholder: String(DEFAULT_SELF_IMPROVING_LOOPS),
-        initialValue: String(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS),
-        validate: (value) => {
-            const parsed = Number.parseInt(value.trim(), 10);
-            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 3) {
-                return "Enter a whole number from 1 to 3";
-            }
-            return undefined;
-        },
-    });
-    if (p.isCancel(maxLoops))
-        return null;
-    return projectSourceConfig.compiledMaxLoops(Number.parseInt(String(maxLoops).trim(), 10))
-        ?? DEFAULT_SELF_IMPROVING_LOOPS;
-}
-export async function promptCompileLoopSelection(options) {
-    if (!options.hasChecks) {
-        return {};
-    }
-    const currentMode = resolveCompileLoopMode(options.initialMaxAttempts, options.initialMaxLoops);
-    const currentPromptMode = currentMode;
-    const recommendedMode = options.recommendedMode ?? "once";
-    const includeCompileOnce = options.includeCompileOnce !== false;
-    const hasSavedPolicy = typeof options.initialMaxAttempts === "number" ||
-        typeof options.initialMaxLoops === "number";
-    for (const line of options.intro ?? []) {
-        p.log.info(line);
-    }
-    p.log.info(`Current mode: ${describeCompileLoopSelection({
-        maxAttempts: options.initialMaxAttempts,
-        maxLoops: options.initialMaxLoops,
-    })}`);
-    const optionsByMode = {
-        once: {
-            value: "once",
-            label: "Prepare once",
-            hint: "Run the selected Method once and write Portable Context",
-        },
-        "self-improving": {
-            value: "self-improving",
-            label: recommendedMode === "self-improving"
-                ? "Self-improving loops (Recommended)"
-                : "Self-improving loops",
-            hint: `Let Interf revise the Method and retry up to ${options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS} time${(options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS) === 1 ? "" : "s"}`,
-        },
-        retry: {
-            value: "retry",
-            label: "Retry same Method",
-            hint: `Retry the same Method and readiness checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the Method`,
-        },
-    };
-    const orderedModes = (hasSavedPolicy
-        ? [
-            currentPromptMode,
-            ...(recommendedMode !== currentPromptMode ? [recommendedMode] : []),
-            "retry",
-            "once",
-        ]
-        : [
-            recommendedMode,
-            "retry",
-            "once",
-        ]).filter((mode, index, list) => list.indexOf(mode) === index)
-        .filter((mode) => includeCompileOnce || mode !== "once");
-    const selectedMode = await p.select({
-        message: options.message ?? "How should this prepare run work?",
-        options: orderedModes.map((mode) => optionsByMode[mode]),
-    });
-    if (p.isCancel(selectedMode))
-        return null;
-    if (selectedMode === "once") {
-        return {};
-    }
-    if (selectedMode === "retry") {
-        const maxAttempts = await promptCompileRetryAttempts({
-            initialMaxAttempts: options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
-            message: "How many total attempts should Interf try before stopping?",
-        });
-        if (maxAttempts === null)
-            return null;
-        return {
-            max_attempts: maxAttempts,
-        };
-    }
-    const maxLoops = await promptSelfImprovingLoops({
-        initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
-        message: "How many Method revisions should Interf try?",
-    });
-    if (maxLoops === null)
-        return null;
-    return {
-        max_attempts: DEFAULT_SELF_IMPROVING_ATTEMPTS,
-        max_loops: maxLoops,
-    };
-}
-export async function promptSingleCompiledConfig(options = {}) {
-    const initial = options.initial;
-    const introStyle = options.introStyle ?? "first";
-    if (introStyle === "first") {
-        if (options.fixedPath) {
-            p.log.info("Describe the agent work this Preparation should help with and review the recommended readiness checks.");
-        }
-        else {
-            p.log.info("Pick the Source Folder for this Preparation.");
-            p.log.info("Then say what agent work this Preparation should help with and review the recommended readiness checks.");
-        }
-    }
-    else if (introStyle === "additional") {
-        p.log.info("Add another Preparation only if this Source Folder needs a separate folder, agent-work focus, or readiness-check set.");
-    }
-    const fixedName = options.fixedName ? slugify(String(options.fixedName)) : undefined;
-    if (options.fixedName && !fixedName) {
-        p.log.error("Current Preparation name needs letters, numbers, or dashes.");
-        return null;
-    }
-    let name = fixedName;
-    if (name && options.fixedName) {
-        p.log.info(`Editing readiness checks for Preparation "${name}".`);
-    }
-    let about = normalizeOptionalPromptText(initial?.about);
-    const projectPath = options.projectPath ?? process.cwd();
-    const defaultNameSeed = slugify(String(initial?.name ?? DEFAULT_PREPARATION_NAME)) || DEFAULT_PREPARATION_NAME;
-    const defaultSourceFolderPath = initial?.path ?? defaultSourceFolderPathForPrompt(defaultNameSeed, introStyle, projectPath);
-    const normalizedSourceFolderPath = options.fixedPath
-        ? (() => {
-            try {
-                return normalizeSourceFolderPathForConfig(projectPath, options.fixedPath);
-            }
-            catch (error) {
-                p.log.error(error instanceof Error ? error.message : String(error));
-                return null;
-            }
-        })()
-        : await promptSourceFolderPath({
-            projectPath,
-            initialPath: defaultSourceFolderPath,
-        });
-    if (!normalizedSourceFolderPath)
-        return null;
-    if (options.fixedPath) {
-        p.log.info(`Source Folder: ${normalizedSourceFolderPath}`);
-    }
-    if (!name) {
-        const suggestedName = defaultPreparationNameForPath(normalizedSourceFolderPath);
-        const rawName = await p.text({
-            message: "Preparation name?",
-            placeholder: suggestedName,
-            initialValue: suggestedName,
-            validate: (value) => (value.trim().length === 0 ? "Preparation name is required" : undefined),
-        });
-        if (p.isCancel(rawName))
-            return null;
-        name = slugify(String(rawName));
-        if (!name) {
-            p.log.error("Preparation name needs letters, numbers, or dashes.");
-            return null;
-        }
-        if (name !== rawName) {
-            p.log.info(`Preparation name: ${name}`);
-        }
-    }
-    let compileLoopSelection = {
-        ...(typeof initial?.max_attempts === "number" ? { max_attempts: initial.max_attempts } : {}),
-        ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
-    };
-    if (!(options.skipAboutPrompt && initial?.about)) {
-        const aboutInput = await p.text({
-            message: preparationAboutPromptMessage(introStyle),
-            placeholder: DEFAULT_COMPILED_ABOUT_PLACEHOLDER,
-            initialValue: about ?? "",
-        });
-        if (p.isCancel(aboutInput))
-            return null;
-        about = normalizeOptionalPromptText(aboutInput);
-    }
-    const checks = await promptCompiledChecks({
-        projectPath: options.projectPath ?? process.cwd(),
-        preparationName: name,
-        sourceFolderPath: normalizedSourceFolderPath,
-        initialAbout: about,
-        initialChecks: initial?.checks,
-    });
-    if (checks === null)
-        return null;
-    if (introStyle === "edit") {
-        compileLoopSelection = await promptCompileLoopSelection({
-            initialMaxAttempts: initial?.max_attempts,
-            initialMaxLoops: initial?.max_loops,
-            hasChecks: checks.length > 0,
-            intro: [
-                "Prepare mode",
-                "Choose whether Interf should prepare once, retry the same Method, or try self-improving Method variations against the same readiness checks.",
-            ],
-        });
-        if (compileLoopSelection === null)
-            return null;
-    }
-    return {
-        name,
-        path: normalizedSourceFolderPath,
-        ...(about ? { about } : {}),
-        ...(typeof compileLoopSelection.max_attempts === "number"
-            ? { max_attempts: compileLoopSelection.max_attempts }
-            : {}),
-        ...(typeof compileLoopSelection.max_loops === "number"
-            ? { max_loops: compileLoopSelection.max_loops }
-            : {}),
-        checks,
-    };
-}