@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/create-method-wizard.js

@@ -1,434 +0,0 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { resolve } from "node:path";
-import { listCompiledMethodChoices, getCompiledMethod, } from "../../packages/method-package/method-definitions.js";
-import { loadMethodDefinitionFromDir, } from "../../packages/method-package/local-methods.js";
-import { listSourcePreparationConfigs, loadSourceFolderConfig, resolveSourcePreparationPath, } from "../../packages/project-model/source-config.js";
-import { MethodChangeCreateRequestSchema, submitMethodAuthoringRunToLocalService, submitMethodChangeToLocalService, } from "../../packages/local-service/index.js";
-import { MethodAuthoringActionValuesSchema, buildCreateMethodActionDefinition, buildMethodChangeActionDefinition, methodAuthoringTaskPrompt, } from "../../packages/local-service/action-definitions.js";
-import { DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER, listSourceFolderChoices, normalizeSourceFolderPathForConfig, } from "./source-config-wizard.js";
-import { promptActionInputValues } from "./action-input-cli.js";
-export const clackMethodPrompts = {
-    intro: p.intro,
-    select: (options) => p.select(options),
-    text: (options) => p.text(options),
-    isCancel: p.isCancel,
-    log: {
-        info: p.log.info,
-        error: p.log.error,
-    },
-};
-function normalizeMethodCreationMode(mode) {
-    if (mode === "draft")
-        return "draft-from-scratch";
-    if (mode === "manual")
-        return "fork-existing";
-    return mode;
-}
-function findMatchingPreparationConfig(sourcePath, sourceFolderPath) {
-    const config = loadSourceFolderConfig(sourcePath);
-    for (const preparation of listSourcePreparationConfigs(config)) {
-        if (resolveSourcePreparationPath(sourcePath, preparation) === sourceFolderPath) {
-            return preparation;
-        }
-    }
-    return null;
-}
-function describeSavedPreparation(preparation) {
-    return preparation.about
-        ? `${preparation.path} · ${preparation.about}`
-        : `${preparation.path} · ${preparation.checks.length} readiness check${preparation.checks.length === 1 ? "" : "s"}`;
-}
-async function promptMethodSourceFolder(sourcePath, prompts) {
-    const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
-    const folderChoices = listSourceFolderChoices(sourcePath);
-    if (folderChoices.length > 0) {
-        const selected = await prompts.select({
-            message: "Which Source Folder should shape this Method?",
-            options: [
-                ...savedPreparations.map((preparation) => ({
-                    value: preparation.name,
-                    label: preparation.name,
-                    hint: describeSavedPreparation(preparation),
-                })),
-                ...folderChoices,
-                {
-                    value: "__manual__",
-                    label: "Enter a different path",
-                    hint: "Use a relative path if the Source Folder is not listed here",
-                },
-            ],
-        });
-        if (prompts.isCancel(selected))
-            return selected;
-        if (selected !== "__manual__") {
-            const savedPreparation = savedPreparations.find((preparation) => preparation.name === selected);
-            if (savedPreparation) {
-                return resolveSourcePreparationPath(sourcePath, savedPreparation);
-            }
-            return resolve(sourcePath, normalizeSourceFolderPathForConfig(sourcePath, String(selected)));
-        }
-    }
-    const sourceFolderPrompt = await prompts.text({
-        message: "Which Source Folder should shape this Method?",
-        placeholder: DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER,
-        initialValue: folderChoices.length === 1 ? folderChoices[0]?.value : undefined,
-        validate: (value) => {
-            const trimmed = value.trim();
-            if (trimmed.length === 0)
-                return "Source Folder is required";
-            try {
-                normalizeSourceFolderPathForConfig(sourcePath, trimmed);
-                return undefined;
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : String(error);
-            }
-        },
-    });
-    if (prompts.isCancel(sourceFolderPrompt))
-        return sourceFolderPrompt;
-    return resolve(sourcePath, normalizeSourceFolderPathForConfig(sourcePath, String(sourceFolderPrompt)));
-}
-export function formatMethodLabel(method) {
-    return {
-        value: method.id,
-        label: method.scope === "local" ? `${method.label} (Local)` : method.label,
-        hint: method.hint,
-    };
-}
-export function buildCompiledMethodOptions(sourcePath) {
-    return listCompiledMethodChoices(sourcePath).map(formatMethodLabel);
-}
-function methodUseLabel(method) {
-    if (method.value === "interf-default") {
-        return "built-in Method";
-    }
-    return method.label.replace(/ \(Local\)$/, "");
-}
-function methodForkLabel(method) {
-    return `Fork ${methodUseLabel(method)}`;
-}
-async function promptMethodAuthoringValues(options) {
-    const existingMethodIds = listCompiledMethodChoices(options.sourcePath).map((method) => method.id);
-    const definition = buildCreateMethodActionDefinition({
-        defaultPreparation: options.defaultPreparation ?? "",
-        existingMethodIds,
-        suggestedMethodId: options.defaultPreparation ? `${options.defaultPreparation}-method` : "custom-method",
-    });
-    const values = await promptActionInputValues(definition, {
-        prompts: options.prompts,
-        omitFields: options.includeOutputFields
-            ? undefined
-            : new Set(["portable_output", "readiness_notes"]),
-    });
-    if (!values)
-        return null;
-    const parsed = MethodAuthoringActionValuesSchema.parse(values);
-    const methodId = parsed.method_id;
-    const label = parsed.label;
-    const hint = parsed.hint;
-    if (!methodId || !label || !hint) {
-        throw new Error("Create Method action did not produce complete Method metadata.");
-    }
-    return {
-        methodId,
-        label,
-        hint,
-        taskPrompt: methodAuthoringTaskPrompt(parsed),
-    };
-}
-export async function chooseCompiledMethod(sourcePath, options = {}) {
-    const currentMethodId = options.currentMethodId;
-    const methodOptions = buildCompiledMethodOptions(sourcePath);
-    const orderedOptions = methodOptions
-        .map((option) => option.value === currentMethodId
-        ? {
-            ...option,
-            label: `${option.label} (Current)`,
-            hint: option.hint,
-        }
-        : option)
-        .sort((left, right) => {
-        if (left.value === currentMethodId)
-            return -1;
-        if (right.value === currentMethodId)
-            return 1;
-        return 0;
-    });
-    if (orderedOptions.length === 1) {
-        return orderedOptions[0]?.value ?? "interf-default";
-    }
-    return p.select({
-        message: options.message ?? "Preparation Method?",
-        options: orderedOptions,
-    });
-}
-export async function chooseOrCreateCompiledMethodForPreparation(sourcePath, preparationConfig, options = {}, prompts = clackMethodPrompts) {
-    const currentMethodId = options.currentMethodId ?? preparationConfig.method ?? "interf-default";
-    const methodOptions = buildCompiledMethodOptions(sourcePath);
-    const currentMethod = methodOptions.find((method) => method.value === currentMethodId) ??
-        methodOptions.find((method) => method.value === "interf-default") ??
-        methodOptions[0];
-    const selected = await prompts.select({
-        message: "Which Method should Interf use for this Preparation?",
-        options: [
-            {
-                value: "__draft_from_scratch__",
-                label: "Draft a new Method from scratch (Recommended)",
-                hint: "Start from a neutral scaffold; an agent designs stages, outputs, and proof for this Preparation",
-            },
-            ...(currentMethod
-                ? [{
-                        value: "__current__",
-                        label: `Use ${methodUseLabel(currentMethod)}`,
-                        hint: currentMethod.value === "interf-default"
-                            ? "Use the built-in Method without drafting a custom package"
-                            : currentMethod.hint,
-                    }]
-                : []),
-            ...(currentMethod
-                ? [{
-                        value: "__fork_existing__",
-                        label: methodForkLabel(currentMethod),
-                        hint: "Copy its existing stage topology, then write the per-stage guidance yourself",
-                    }]
-                : []),
-            ...methodOptions
-                .filter((method) => method.value !== currentMethod?.value)
-                .map((method) => ({
-                ...method,
-                label: `Use ${methodUseLabel(method)}`,
-            })),
-        ],
-    });
-    if (prompts.isCancel(selected))
-        return selected;
-    if (selected === "__current__") {
-        return currentMethod?.value ?? currentMethodId;
-    }
-    if (selected === "__draft_from_scratch__" || selected === "__fork_existing__") {
-        const methodId = await createMethodWizard({
-            intro: false,
-            sourcePath,
-            baseMethodId: selected === "__fork_existing__"
-                ? currentMethod?.value ?? currentMethodId
-                : undefined,
-            creationMode: selected === "__draft_from_scratch__" ? "draft-from-scratch" : "fork-existing",
-            preparationContext: {
-                config: preparationConfig,
-                sourceFolderPath: resolveSourcePreparationPath(sourcePath, preparationConfig),
-            },
-        }, prompts);
-        return methodId;
-    }
-    return String(selected);
-}
-export async function createMethodWizard(options = {}, prompts = clackMethodPrompts) {
-    if (options.intro !== false) {
-        prompts.intro(chalk.bold("Create a Method"));
-    }
-    const sourcePath = options.sourcePath ?? process.cwd();
-    return createCompiledMethodWizard(sourcePath, prompts, {
-        baseMethodId: options.baseMethodId,
-        creationMode: options.creationMode,
-        preparationContext: options.preparationContext,
-    });
-}
-export async function createCompiledMethodWizard(sourcePath, prompts = clackMethodPrompts, options = {}) {
-    const creationMode = options.creationMode ?? await prompts.select({
-        message: "How do you want to create it?",
-        options: [
-            {
-                value: "draft-from-scratch",
-                label: "Draft a new Method from scratch (Recommended)",
-                hint: "Start from a neutral scaffold and let a local agent design a reusable Method for this kind of agent work",
-            },
-            {
-                value: "fork-existing",
-                label: "Fork an existing Method and edit stage guidance",
-                hint: "Copy an existing topology; choose this when the stages are right but their emphasis should change",
-            },
-        ],
-    });
-    if (prompts.isCancel(creationMode))
-        return creationMode;
-    const creationModeValue = normalizeMethodCreationMode(creationMode);
-    const baseMethod = creationModeValue === "fork-existing"
-        ? options.baseMethodId ?? await prompts.select({
-            message: "Which existing Method should Interf fork?",
-            options: listCompiledMethodChoices(sourcePath).map(formatMethodLabel),
-        })
-        : null;
-    if (prompts.isCancel(baseMethod))
-        return baseMethod;
-    const baseMethodId = typeof baseMethod === "string" ? baseMethod : null;
-    const resolvedBaseMethod = baseMethodId
-        ? getCompiledMethod(baseMethodId, { sourcePath })
-        : null;
-    if (creationModeValue === "draft-from-scratch") {
-        let sourceFolderPath = options.preparationContext?.sourceFolderPath ?? null;
-        let matchedPreparation = options.preparationContext?.config ?? null;
-        if (!sourceFolderPath) {
-            const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
-            if (savedPreparations.length > 0) {
-                const preparationChoice = await prompts.select({
-                    message: "Which saved Preparation should shape this Method?",
-                    options: [
-                        ...savedPreparations.map((preparation) => ({
-                            value: preparation.name,
-                            label: preparation.name,
-                            hint: describeSavedPreparation(preparation),
-                        })),
-                        {
-                            value: "__manual__",
-                            label: "Enter folder path manually",
-                            hint: "Use a folder that is not saved as a Preparation yet",
-                        },
-                    ],
-                });
-                if (prompts.isCancel(preparationChoice))
-                    return preparationChoice;
-                if (preparationChoice !== "__manual__") {
-                    matchedPreparation = savedPreparations.find((preparation) => preparation.name === preparationChoice) ?? null;
-                    sourceFolderPath = matchedPreparation
-                        ? resolveSourcePreparationPath(sourcePath, matchedPreparation)
-                        : null;
-                }
-            }
-        }
-        if (!sourceFolderPath) {
-            const sourceFolderPrompt = await promptMethodSourceFolder(sourcePath, prompts);
-            if (prompts.isCancel(sourceFolderPrompt))
-                return sourceFolderPrompt;
-            if (!sourceFolderPrompt)
-                return null;
-            sourceFolderPath = String(sourceFolderPrompt);
-            matchedPreparation = matchedPreparation ?? findMatchingPreparationConfig(sourcePath, sourceFolderPath);
-        }
-        const methodValues = await promptMethodAuthoringValues({
-            defaultPreparation: matchedPreparation?.name ?? options.preparationContext?.config.name,
-            includeOutputFields: true,
-            prompts,
-            sourcePath,
-        });
-        if (prompts.isCancel(methodValues))
-            return methodValues;
-        if (!methodValues)
-            return null;
-        if (matchedPreparation) {
-            prompts.log.info(`Shaping this Method from Preparation "${matchedPreparation.name}".`);
-        }
-        if (matchedPreparation?.checks.length) {
-            prompts.log.info(`Using ${matchedPreparation.checks.length} saved readiness check${matchedPreparation.checks.length === 1 ? "" : "s"} from Preparation "${matchedPreparation.name}" as authoring context.`);
-        }
-        prompts.log.info("Preparing a Method-authoring shell from the Source Folder, then drafting the package.");
-        let lastServiceStatus = "";
-        const serviceRun = await submitMethodAuthoringRunToLocalService({
-            projectPath: sourcePath,
-            request: {
-                preparation: matchedPreparation?.name ?? null,
-                source_folder_path: sourceFolderPath,
-                method_id: methodValues.methodId,
-                label: methodValues.label,
-                hint: methodValues.hint,
-                task_prompt: methodValues.taskPrompt,
-                checks: matchedPreparation?.checks ?? [],
-            },
-            onSubmitted: (submission) => {
-                prompts.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;
-                prompts.log.info(activeStep
-                    ? `${activeStep.label}: ${activeStep.status}`
-                    : `Method draft run: ${job.status}`);
-            },
-        });
-        if (!serviceRun) {
-            process.exitCode = 1;
-            (prompts.log.error ?? prompts.log.info)("Interf local service is not running. Start `interf web`, then rerun Method creation so the draft run is visible in Interf.");
-            return null;
-        }
-        const result = serviceRun.result
-            ? {
-                status: serviceRun.result.status,
-                changed: serviceRun.result.changed,
-                summary: serviceRun.result.summary,
-                validation: serviceRun.result.validation ?? null,
-                methodPath: serviceRun.result.method_path,
-                shellPath: serviceRun.result.shell_path,
-            }
-            : {
-                status: "executor-failed",
-                changed: false,
-                summary: serviceRun.error ?? "Method authoring failed in the local Interf service.",
-                validation: null,
-                methodPath: resolve(sourcePath, "interf", "methods", methodValues.methodId),
-                shellPath: resolve(sourcePath, "interf", "methods", methodValues.methodId),
-            };
-        if (!result)
-            return null;
-        if (result.status === "updated") {
-            const draft = loadMethodDefinitionFromDir(result.methodPath);
-            const stageList = draft?.stages?.map((stage) => stage.id).join(" -> ") ?? "-";
-            prompts.log.info(`Draft ready at ${result.methodPath}`);
-            prompts.log.info(`  Name: ${draft?.label ?? methodValues.label}`);
-            prompts.log.info(`  Description: ${draft?.hint ?? methodValues.hint}`);
-            if (draft?.purpose)
-                prompts.log.info(`  Purpose: ${draft.purpose}`);
-            prompts.log.info(`  Stages: ${stageList}`);
-            const confirmChoice = await prompts.select({
-                message: "Save this Method?",
-                options: [
-                    { value: "save", label: "Save", hint: "Keep the draft as your new Method package" },
-                    { value: "cancel", label: "Close", hint: "Leave the service-created draft in place for review" },
-                ],
-            });
-            if (prompts.isCancel(confirmChoice) || confirmChoice === "cancel") {
-                prompts.log.info(`Draft kept at ${result.methodPath}`);
-                return null;
-            }
-            prompts.log.info(`Saved local Method: ${result.methodPath}`);
-            return methodValues.methodId;
-        }
-        process.exitCode = 1;
-        (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
-            ? `${result.summary} Draft mode only succeeds when it produces an agent-work-specific package change.`
-            : result.summary);
-        prompts.log.info(`Method shell kept at: ${result.shellPath}`);
-        return null;
-    }
-    if (!baseMethodId || !resolvedBaseMethod) {
-        throw new Error("Fork-existing Method creation needs a base Method.");
-    }
-    const duplicateDefinition = buildMethodChangeActionDefinition({
-        action: "duplicate",
-        existingMethodIds: listCompiledMethodChoices(sourcePath).map((method) => method.id),
-        hint: resolvedBaseMethod.hint ?? null,
-        label: resolvedBaseMethod.label ?? baseMethodId,
-        methodId: baseMethodId,
-        preparation: options.preparationContext?.config.name ?? "",
-    });
-    const duplicateValues = await promptActionInputValues(duplicateDefinition, { prompts });
-    if (!duplicateValues)
-        return null;
-    const duplicateDraft = duplicateDefinition.buildDraft(duplicateValues);
-    const result = await submitMethodChangeToLocalService({
-        projectPath: sourcePath,
-        request: MethodChangeCreateRequestSchema.parse(duplicateDraft.values),
-    });
-    if (!result) {
-        process.exitCode = 1;
-        (prompts.log.error ?? prompts.log.info)("Interf local service is not running. Start `interf web`, then rerun Method creation so the Method change is visible in Interf.");
-        return null;
-    }
-    prompts.log.info(`Saved local Method: ${result.method_path}`);
-    return result.new_method_id ?? null;
-}

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

@@ -1,6 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare const createCommand: CommandModule;
-export declare function createCompiledWizard(options?: {
-    intro?: boolean;
-}): Promise<void>;
-export { type MethodWizardPrompts, formatMethodLabel, createMethodWizard, createCompiledMethodWizard, } from "./create-method-wizard.js";

package/dist/cli/commands/create.js

@@ -1,183 +0,0 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_PATH, listSourcePreparationConfigs, loadSourceFolderConfig, } from "../../packages/project-model/source-config.js";
-import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
-import { findBuiltPortableContextPath, } from "../../packages/project-model/preparation-entries.js";
-import { DEFAULT_PREPARATION_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
-import { resolveCommandControlPath, resolveInterfInstanceContext, } from "./control-path.js";
-import { savePreparationThroughServiceAction } from "./preparation-action.js";
-function normalizeCreateTarget(value) {
-    if (!value)
-        return null;
-    switch (value) {
-        case "preparation":
-            return "preparation";
-        case "method":
-            return "method";
-        default:
-            return null;
-    }
-}
-async function selectCreateTarget() {
-    return p.select({
-        message: "Create what?",
-        options: [
-            {
-                value: "preparation",
-                label: "Preparation (Recommended)",
-                hint: "Add one Preparation for this Source Folder",
-            },
-            {
-                value: "method",
-                label: "Method",
-                hint: "Create a reusable local Method",
-            },
-        ],
-    });
-}
-async function maybeAssignMethodToPreparation(sourcePath, methodId) {
-    const config = loadSourceFolderConfig(sourcePath);
-    const preparations = listSourcePreparationConfigs(config);
-    if (preparations.length === 0) {
-        p.log.info(`Created Method "${methodId}".`);
-        p.log.info(`Next: run \`interf\`, add a Preparation, then assign Method "${methodId}" from that menu.`);
-        return;
-    }
-    const assignNow = await p.confirm({
-        message: "Assign this Method to a Preparation now? (Recommended)",
-        initialValue: true,
-    });
-    if (p.isCancel(assignNow) || !assignNow) {
-        p.log.info(`Created Method "${methodId}".`);
-        p.log.info(`Next: run \`interf\`, open a saved Preparation, and assign Method "${methodId}" from that menu.`);
-        return;
-    }
-    let targetPreparation = preparations[0] ?? null;
-    if (preparations.length > 1) {
-        const selected = await p.select({
-            message: "Which saved Preparation should use this Method?",
-            options: preparations.map((preparation) => ({
-                value: preparation.name,
-                label: preparation.name,
-                hint: `${preparation.path} · ${preparation.about ?? `${preparation.checks.length} readiness check${preparation.checks.length === 1 ? "" : "s"}`}`,
-            })),
-        });
-        if (p.isCancel(selected))
-            return;
-        targetPreparation = preparations.find((preparation) => preparation.name === selected) ?? null;
-    }
-    if (!targetPreparation)
-        return;
-    const nextConfig = {
-        ...targetPreparation,
-        method: methodId,
-    };
-    await savePreparationThroughServiceAction({
-        sourcePath,
-        preparation: nextConfig,
-        setupMode: "select-method",
-    });
-    const builtCompiledPath = findBuiltPortableContextPath(sourcePath, targetPreparation.name);
-    p.log.info(`Assigned Method "${methodId}" to Preparation "${targetPreparation.name}".`);
-    if (builtCompiledPath) {
-        p.log.info("The active local Method copy for that Portable Context lives under `.interf/method/`.");
-    }
-    p.log.info("Next: run `interf compile`, then `interf test`.");
-}
-export const createCommand = {
-    command: "create [type]",
-    describe: "Create a Preparation or reusable Method",
-    builder: (yargs) => yargs.positional("type", {
-        type: "string",
-        describe: "Type to create (`preparation` or `method`)",
-        default: undefined,
-    }),
-    handler: async (argv) => {
-        const rawType = argv.type;
-        let type = normalizeCreateTarget(rawType);
-        if (rawType && !type) {
-            process.exitCode = 1;
-            p.log.error(`Unknown create target: ${rawType}`);
-            return;
-        }
-        if (!type) {
-            const selected = await selectCreateTarget();
-            if (p.isCancel(selected))
-                return;
-            type = selected;
-        }
-        if (type === "method") {
-            const detected = detectInterf(process.cwd());
-            const sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
-            const methodId = await createMethodWizard({
-                sourcePath,
-            });
-            if (typeof methodId === "string") {
-                await maybeAssignMethodToPreparation(sourcePath, methodId);
-            }
-            return;
-        }
-        await createCompiledWizard();
-    },
-};
-export async function createCompiledWizard(options = {}) {
-    if (options.intro !== false) {
-        p.intro(chalk.bold("Add a Preparation"));
-    }
-    const cwd = process.cwd();
-    const detected = detectInterf(cwd);
-    if (detected) {
-        process.exitCode = 1;
-        p.log.error("You are already inside Portable Context.");
-        return;
-    }
-    const initContext = resolveInterfInstanceContext(cwd);
-    const sourcePath = initContext.controlPath;
-    const savedPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
-    if (savedPreparations.length > 0) {
-        p.log.info(`This Source Folder already has ${savedPreparations.length} saved Preparation${savedPreparations.length === 1 ? "" : "s"} in ${SOURCE_FOLDER_CONFIG_PATH}. Add another only when you need a separate Source Folder, agent-work focus, or readiness-check set.`);
-    }
-    if (sourcePath !== cwd) {
-        p.log.info(`Interf Workspace: ${sourcePath}`);
-    }
-    p.log.info("Interf works one Preparation at a time. Start with the agent work, the relevant files, and a few readiness checks, then build Portable Context when you need evidence that the data is ready for agents.");
-    const existingConfig = loadSourceFolderConfig(sourcePath);
-    const initialConfig = initContext.defaultSourceFolderPath && initContext.defaultPreparationPath
-        ? {
-            name: defaultPreparationNameForPath(initContext.defaultSourceFolderPath),
-            path: initContext.defaultPreparationPath,
-        }
-        : { name: DEFAULT_PREPARATION_NAME };
-    const draft = await promptSingleCompiledConfig({
-        projectPath: sourcePath,
-        initial: initialConfig,
-        introStyle: existingConfig ? "additional" : "first",
-    });
-    if (!draft)
-        return;
-    const existingNames = new Set(listSourcePreparationConfigs(existingConfig).map((preparation) => preparation.name));
-    if (existingNames.has(draft.name)) {
-        process.exitCode = 1;
-        p.log.error(`Preparation "${draft.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
-        return;
-    }
-    const methodChoice = await chooseOrCreateCompiledMethodForPreparation(sourcePath, draft, {
-        currentMethodId: "interf-default",
-    });
-    if (!methodChoice || p.isCancel(methodChoice))
-        return;
-    const configToSave = {
-        ...draft,
-        method: String(methodChoice),
-    };
-    await savePreparationThroughServiceAction({
-        sourcePath,
-        preparation: configToSave,
-    });
-    p.outro(configToSave.checks.length > 0
-        ? "Saved Preparation.\nNext:\n  interf compile\n  interf test"
-        : "Saved Preparation.\nNext:\n  interf or interf init");
-}
-export { formatMethodLabel, createMethodWizard, createCompiledMethodWizard, } from "./create-method-wizard.js";

package/dist/cli/commands/default.d.ts

@@ -1,2 +0,0 @@
-import type { CommandModule } from "yargs";
-export declare const defaultCommand: CommandModule;

package/dist/cli/commands/default.js

@@ -1,39 +0,0 @@
-import chalk from "chalk";
-import { userConfig } from "../../packages/agents/index.js";
-import { runInitCommand } from "./init.js";
-function printStaticLanding() {
-    const config = userConfig.loadUserConfig();
-    console.log();
-    console.log(chalk.bold("  Interf"));
-    console.log(chalk.dim("  Prepare data for agent work."));
-    console.log(chalk.dim("  Run locally, process files, show evidence that your data is ready, and write verifiable outputs as Portable Context for agents."));
-    console.log();
-    if (config) {
-        console.log(chalk.dim(`  Agent: ${config.agent}`));
-        console.log();
-    }
-    console.log(chalk.dim("  Suggested flow:"));
-    console.log(chalk.dim("    interf"));
-    console.log(chalk.dim("    interf web      # optional local UI/API"));
-    console.log(chalk.dim("    interf compile"));
-    console.log(chalk.dim("    interf test"));
-    console.log(chalk.dim("    interf test --target source-files   # optional baseline before compile"));
-    console.log();
-    console.log(chalk.dim("  More:"));
-    console.log(chalk.dim("    interf init"));
-    console.log(chalk.dim("    interf create method"));
-    console.log(chalk.dim("    interf doctor --live"));
-    console.log(chalk.dim("    interf --help"));
-    console.log();
-}
-export const defaultCommand = {
-    command: "$0",
-    describe: false,
-    handler: async () => {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) {
-            printStaticLanding();
-            return;
-        }
-        await runInitCommand();
-    },
-};