@nodeint/migent 0.0.0-stage → 0.1.2

package/dist/commands/config.js

@@ -0,0 +1,613 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { confirm as clackConfirm, isCancel, select as clackSelect, text as clackText } from "@clack/prompts";
+import { ConfigEditError, ConfigurationError, assignRoles, describeChange, diagnose, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, resolveStageSpec, setRoleOptions, upsertModel, whichSync, } from "@nodeint/migent-kernel";
+import { printError } from "../display.js";
+import { cliHooks } from "../hooks.js";
+import { requireCurrentSchema } from "../migrate.js";
+import { acceptedOptions, adapterMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireAdapter, runProviderCommand, } from "../provider.js";
+import { runDoctor } from "./doctor.js";
+const NEW = "__new__";
+const UNSET = Symbol("unset");
+export function runConfigShow(workspace) {
+    const text = readFileSync(path.join(workspace, ".migent", "config.yaml"), "utf8");
+    process.stdout.write(text);
+    return 0;
+}
+export async function runConfigModel(workspace, options = {}) {
+    try {
+        return await runModel(workspace, {
+            ...options,
+            adapters: options.adapters ?? adapterMap(),
+            which: options.which ?? cliHooks.which ?? whichSync,
+            prompter: options.prompter ?? new ClackConfigPrompter(),
+            runCommand: options.runCommand ?? runProviderCommand,
+        });
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError || error instanceof ConfigEditError || error instanceof Error) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
+}
+export async function runConfigRole(workspace, options = {}) {
+    try {
+        return await runRole(workspace, {
+            ...options,
+            adapters: options.adapters ?? adapterMap(),
+            which: options.which ?? cliHooks.which ?? whichSync,
+            prompter: options.prompter ?? new ClackConfigPrompter(),
+            runCommand: options.runCommand ?? runProviderCommand,
+        });
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError || error instanceof ConfigEditError || error instanceof Error) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
+}
+async function runModel(workspace, args) {
+    const key = args.key ?? null;
+    let provider = args.provider ?? null;
+    let model = args.model ?? null;
+    const asJson = args.asJson ?? false;
+    const interactive = args.interactive ?? false;
+    let optionUpdates = optionUpdatesOf(args.options ?? [], args.clearOptions ?? []);
+    if ((provider === null) !== (model === null)) {
+        throw new ConfigEditError("Pass both --provider and --model, or omit both.");
+    }
+    const [config, workflows, view] = loaded(workspace);
+    const mutating = provider !== null || optionUpdates !== UNSET;
+    if (key === null && !mutating) {
+        if (interactive) {
+            return interactiveModels(workspace, config, workflows, view, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+        }
+        emitView(view, asJson, true, false);
+        return 0;
+    }
+    if (key === null)
+        throw new ConfigEditError("Pass a name.");
+    if (!mutating) {
+        if (interactive) {
+            return editModel(workspace, config, workflows, view, key, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+        }
+        emitModels(selectedModels(view, [key]), asJson);
+        return 0;
+    }
+    let catalog = null;
+    if (provider !== null && model !== null) {
+        [provider, model, catalog] = await catalogModel(args.adapters, args.which, args.runCommand, provider, model);
+    }
+    if (optionUpdates !== UNSET) {
+        const currentProvider = provider ?? modelProvider(config, key);
+        const currentModel = model ?? loadModelTarget(config, key).model;
+        optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, currentProvider, currentModel, optionUpdates, provider !== null ? catalog : null);
+    }
+    const change = upsertModel(config, key, {
+        provider,
+        model,
+        ...(optionUpdates === UNSET ? {} : { options: optionUpdates }),
+        workflows,
+    });
+    validateChange(config, change.config, workflows, args.adapters);
+    return await commit(workspace, change, { asJson, which: args.which });
+}
+async function runRole(workspace, args) {
+    const roles = args.roles ?? [];
+    const modelName = args.modelName ?? null;
+    let provider = args.provider ?? null;
+    let model = args.model ?? null;
+    const asJson = args.asJson ?? false;
+    const interactive = args.interactive ?? false;
+    let optionUpdates = optionUpdatesOf(args.options ?? [], args.clearOptions ?? []);
+    if (modelName !== null && (provider !== null || model !== null)) {
+        throw new ConfigEditError("Pass --model-name or --provider and --model.");
+    }
+    if ((provider === null) !== (model === null)) {
+        throw new ConfigEditError("Pass both --provider and --model, or omit both.");
+    }
+    const [config, workflows, view] = loaded(workspace);
+    const mutating = modelName !== null || provider !== null || optionUpdates !== UNSET;
+    if (roles.length === 0 && !mutating) {
+        if (interactive) {
+            return interactiveRoles(workspace, config, workflows, view, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+        }
+        emitView(view, asJson, false, true);
+        return 0;
+    }
+    if (roles.length === 0)
+        throw new ConfigEditError("Pass a role.");
+    if (roles.length > 1 && (provider !== null || optionUpdates !== UNSET)) {
+        throw new ConfigEditError("Pass one role to set options or a provider model.");
+    }
+    if (!mutating) {
+        if (interactive && roles.length === 1) {
+            knownRole(view, roles[0] ?? "");
+            return pointRole(workspace, config, workflows, view, roles[0] ?? "", args.adapters, args.which, args.prompter, args.runCommand, asJson);
+        }
+        emitRoles(selectedRoles(view, roles), asJson);
+        return 0;
+    }
+    let change;
+    if (provider !== null && model !== null) {
+        let catalog;
+        [provider, model, catalog] = await catalogModel(args.adapters, args.which, args.runCommand, provider, model);
+        if (optionUpdates !== UNSET) {
+            optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, provider, model, optionUpdates, catalog);
+        }
+        change = placeRoleModel(config, roles[0] ?? "", {
+            provider,
+            model,
+            ...(optionUpdates === UNSET ? {} : { options: optionUpdates }),
+            workflows,
+        });
+    }
+    else if (modelName !== null) {
+        change = assignRoles(config, roles, modelName, { workflows });
+        if (optionUpdates !== UNSET) {
+            const target = loadModelTarget(change.config, modelName);
+            optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, target.provider, target.model, optionUpdates);
+            const follow = setRoleOptions(change.config, roles[0] ?? "", optionUpdates, { workflows });
+            change = describeChange(config, follow.config, workflows);
+        }
+    }
+    else {
+        const target = roleModel(config, roles[0] ?? "");
+        if (optionUpdates === UNSET)
+            throw new ConfigEditError("Pass a role.");
+        optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, target.provider, target.model, optionUpdates);
+        change = setRoleOptions(config, roles[0] ?? "", optionUpdates, { workflows });
+    }
+    validateChange(config, change.config, workflows, args.adapters);
+    return await commit(workspace, change, { asJson, which: args.which });
+}
+async function interactiveModels(workspace, config, workflows, view, adapters, which, prompter, runCommand, asJson) {
+    const choices = view.models.map((model) => [modelLabel(model), model.key]);
+    choices.push(["New model", NEW]);
+    const selected = await prompter.select("Model", choices, view.models[0]?.key ?? NEW);
+    if (selected === NEW)
+        return addModel(workspace, config, workflows, null, adapters, which, prompter, runCommand, asJson);
+    return editModel(workspace, config, workflows, view, selected, adapters, which, prompter, runCommand, asJson);
+}
+async function editModel(workspace, config, workflows, view, key, adapters, which, prompter, runCommand, asJson) {
+    const current = selectedModels(view, [key])[0];
+    if (current === undefined)
+        throw new ConfigEditError(`Unknown name: ${key}.`);
+    const provider = await selectProvider(prompter, adapters, which, "Provider", current.provider);
+    const adapter = requireAdapter(adapters, provider);
+    const catalog = await loadCatalog(adapter, which, runCommand);
+    const initial = catalog.ids.includes(current.model) ? current.model : (catalog.defaultId ?? undefined);
+    let modelId = knownModel(await prompter.select("Model", catalog.ids.map((item) => [item, item]), initial), catalog);
+    const stored = await promptedOptions(prompter, adapter, modelId, catalog, which, runCommand, current.options);
+    const change = upsertModel(config, key, { provider, model: modelId, options: stored, workflows });
+    validateChange(config, change.config, workflows, adapters);
+    return confirmAndCommit(workspace, change, prompter, asJson, which);
+}
+async function addModel(workspace, config, workflows, role, adapters, which, prompter, runCommand, asJson) {
+    const provider = await selectProvider(prompter, adapters, which, "Provider", null);
+    const adapter = requireAdapter(adapters, provider);
+    const catalog = await loadCatalog(adapter, which, runCommand);
+    const modelId = knownModel(await prompter.select("Model", catalog.ids.map((item) => [item, item]), catalog.defaultId), catalog);
+    const options = await promptedOptions(prompter, adapter, modelId, catalog, which, runCommand, {});
+    const present = presentOptions(options);
+    const existing = matchingModelName(config, { provider, model: modelId, options: present });
+    let change;
+    if (existing !== null) {
+        if (role === null) {
+            process.stdout.write(`Model ${existing} already has this provider and model.\n`);
+            return 0;
+        }
+        const assigned = assignRoles(config, [role], existing, { workflows });
+        change = describeChange(config, assigned.config, workflows, { reusedModel: existing });
+    }
+    else {
+        const key = (await prompter.text("Name")).trim();
+        if (key === "")
+            throw new ConfigEditError("Name is required.");
+        const models = config.models;
+        if (isRecord(models) && Object.hasOwn(models, key))
+            throw new ConfigEditError(`Name ${key} already exists.`);
+        const created = upsertModel(config, key, { provider, model: modelId, options, workflows });
+        if (role === null)
+            change = created;
+        else {
+            const assigned = assignRoles(created.config, [role], key, { workflows });
+            change = describeChange(config, assigned.config, workflows);
+        }
+    }
+    validateChange(config, change.config, workflows, adapters);
+    return confirmAndCommit(workspace, change, prompter, asJson, which);
+}
+async function interactiveRoles(workspace, config, workflows, view, adapters, which, prompter, runCommand, asJson) {
+    const choices = view.roles.map((role) => [roleLabel(role), role.role]);
+    choices.push(["New role", NEW]);
+    const selected = await prompter.select("Role", choices, view.roles[0]?.role ?? NEW);
+    if (selected === NEW) {
+        const name = (await prompter.text("Role name")).trim();
+        if (name === "")
+            throw new ConfigEditError("Role name is required.");
+        if (view.roles.some((role) => role.role === name))
+            throw new ConfigEditError(`Role ${name} already exists.`);
+        return pointRole(workspace, config, workflows, view, name, adapters, which, prompter, runCommand, asJson);
+    }
+    return pointRole(workspace, config, workflows, view, selected, adapters, which, prompter, runCommand, asJson);
+}
+async function pointRole(workspace, config, workflows, view, role, adapters, which, prompter, runCommand, asJson) {
+    const current = view.roles.find((item) => item.role === role) ?? null;
+    const choices = view.models.map((model) => [modelLabel(model), model.key]);
+    choices.push(["New model", NEW]);
+    const selected = await prompter.select("Model", choices, current?.modelName ?? NEW);
+    if (selected === NEW) {
+        return addModel(workspace, config, workflows, role, adapters, which, prompter, runCommand, asJson);
+    }
+    const change = assignRoles(config, [role], selected, { workflows });
+    validateChange(config, change.config, workflows, adapters);
+    return confirmAndCommit(workspace, change, prompter, asJson, which);
+}
+async function confirmAndCommit(workspace, change, prompter, asJson, which) {
+    printChange(change);
+    if (!(await prompter.confirm("Save this change?"))) {
+        process.stdout.write("Left unchanged.\n");
+        return 0;
+    }
+    return commit(workspace, change, { asJson, which, echo: false });
+}
+async function commit(workspace, change, args) {
+    const filePath = path.join(workspace, ".migent", "config.yaml");
+    const original = readFileSync(filePath, "utf8");
+    const updated = patchConfigText(original, change.config);
+    if (updated === original) {
+        if (args.asJson)
+            process.stdout.write(`${JSON.stringify(changePayload(change, false, null))}\n`);
+        else
+            process.stdout.write("Left unchanged.\n");
+        return 0;
+    }
+    writeFileSync(filePath, updated, "utf8");
+    if (args.asJson) {
+        const checks = diagnose(workspace, { adapters: adapterMap(), which: args.which });
+        const doctor = doctorPayload(checks);
+        process.stdout.write(`${JSON.stringify(changePayload(change, true, doctor))}\n`);
+        return doctor.ok ? 0 : 1;
+    }
+    if (args.echo !== false)
+        printChange(change);
+    return runDoctor(workspace, { which: args.which });
+}
+function validateChange(before, after, workflows, adapters) {
+    const beforeModels = isRecord(before.models) ? before.models : {};
+    const afterModels = isRecord(after.models) ? after.models : {};
+    const changed = new Set();
+    for (const key of Object.keys(afterModels)) {
+        if (!Object.hasOwn(beforeModels, key) || !sameTarget(safeTarget(before, key), safeTarget(after, key))) {
+            changed.add(key);
+        }
+    }
+    for (const key of changed) {
+        const target = loadModelTarget(after, key);
+        requireAdapter(adapters, target.provider).validateOptions(target.options);
+    }
+    const beforeRoles = isRecord(before.roles) ? before.roles : {};
+    const afterRoles = isRecord(after.roles) ? after.roles : {};
+    for (const [name, body] of Object.entries(afterRoles)) {
+        const usesChanged = isRecord(body) && typeof body.default_model === "string" && changed.has(body.default_model);
+        if (deepEqual(beforeRoles[name], body) && !usesChanged)
+            continue;
+        if (!isRecord(body) || typeof body.default_model !== "string")
+            continue;
+        const target = loadModelTarget(after, body.default_model);
+        const options = { ...target.options };
+        if (isRecord(body.options)) {
+            for (const [optionName, value] of Object.entries(body.options)) {
+                if (typeof value === "string" && value.trim() !== "")
+                    options[optionName] = value.trim();
+            }
+        }
+        requireAdapter(adapters, target.provider).validateOptions(options);
+    }
+    for (const document of workflows) {
+        for (const stage of Object.values(document.stages)) {
+            let beforeTarget;
+            let afterTarget;
+            try {
+                beforeTarget = resolveStageSpec(before, stage);
+                afterTarget = resolveStageSpec(after, stage);
+            }
+            catch (error) {
+                if (error instanceof ConfigurationError)
+                    continue;
+                throw error;
+            }
+            if (sameTarget(beforeTarget, afterTarget))
+                continue;
+            requireAdapter(adapters, afterTarget.provider).validateOptions(afterTarget.options);
+        }
+    }
+}
+async function catalogModel(adapters, which, runCommand, provider, model) {
+    const adapter = requireAdapter(adapters, provider);
+    const catalog = await loadCatalog(adapter, which, runCommand);
+    return [provider, knownModel(model, catalog), catalog];
+}
+async function checkedOptions(adapters, which, runCommand, provider, model, updates, catalog = null) {
+    const adapter = requireAdapter(adapters, provider);
+    const resolved = catalog ?? (await loadCatalog(adapter, which, runCommand));
+    const present = {};
+    for (const [key, value] of Object.entries(updates)) {
+        if (value !== null)
+            present[key] = value;
+    }
+    if (Object.keys(present).length > 0) {
+        await acceptedOptions(adapter, model, resolved, which, runCommand, present);
+    }
+    return { ...updates };
+}
+async function promptedOptions(prompter, adapter, model, catalog, which, runCommand, current) {
+    const stored = {};
+    const catalogAdapter = asCatalog(adapter);
+    for (const spec of catalogAdapter.providerOptions()) {
+        if (!spec.prompt)
+            continue;
+        const values = await loadOptionValues(adapter, spec.name, model, catalog, which, runCommand);
+        if (values === null || values.length === 0)
+            continue;
+        const choices = values.map((value) => [value, value]);
+        if (spec.allowDefault)
+            choices.unshift(["provider default", ""]);
+        const currentValue = current[spec.name] ?? "";
+        const picked = await prompter.select(spec.name, choices, values.includes(currentValue) ? currentValue : "");
+        stored[spec.name] = picked || null;
+    }
+    return stored;
+}
+function optionUpdatesOf(options, clearOptions) {
+    if (options.length === 0 && clearOptions.length === 0)
+        return UNSET;
+    const parsed = parseOptions(options);
+    const overlap = Object.keys(parsed).filter((name) => clearOptions.includes(name)).sort();
+    if (overlap.length > 0)
+        throw new ConfigEditError(`Pass either --option or --clear-option for ${overlap.join(", ")}.`);
+    const updates = { ...parsed };
+    for (const name of clearOptions) {
+        if (name.trim() === "")
+            throw new ConfigEditError("Option name is required.");
+        updates[name.trim()] = null;
+    }
+    return updates;
+}
+async function selectProvider(prompter, adapters, which, message, defaultValue) {
+    const rows = detected(adapters, which);
+    if (rows.length === 0)
+        throw new Error("No providers are available.");
+    const names = new Set(rows.map(([name]) => name));
+    return prompter.select(message, rows.map(([name, found]) => [`${name}  ${found ?? "not found"}`, name]), defaultValue !== null && names.has(defaultValue) ? defaultValue : rows[0]?.[0]);
+}
+function loaded(workspace) {
+    requireCurrentSchema(workspace);
+    const config = loadYamlMapping(path.join(workspace, ".migent", "config.yaml"));
+    const workflows = Object.values(loadWorkflowCatalog(workspace).documents);
+    return [config, workflows, inspectConfig(config, workflows)];
+}
+function modelProvider(config, key) {
+    return loadModelTarget(config, key).provider;
+}
+function roleModel(config, role) {
+    const roles = config.roles;
+    if (!isRecord(roles) || !isRecord(roles[role]))
+        throw new ConfigEditError(`Unknown role: ${role}.`);
+    const modelName = roles[role].default_model;
+    if (typeof modelName !== "string")
+        throw new ConfigurationError(`Missing or invalid roles.${role}.default_model.`);
+    return loadModelTarget(config, modelName);
+}
+function selectedModels(view, keys) {
+    const byKey = new Map(view.models.map((model) => [model.key, model]));
+    return keys.map((key) => {
+        const found = byKey.get(key);
+        if (found === undefined)
+            throw new ConfigEditError(`Unknown name: ${key}.`);
+        return found;
+    });
+}
+function selectedRoles(view, names) {
+    return names.map((name) => knownRole(view, name));
+}
+function knownRole(view, name) {
+    const found = view.roles.find((role) => role.role === name);
+    if (found === undefined)
+        throw new ConfigEditError(`Unknown role: ${name}.`);
+    return found;
+}
+function emitView(view, asJson, models, roles) {
+    if (asJson) {
+        const payload = {};
+        if (models)
+            payload.models = view.models.map(modelJson);
+        if (roles)
+            payload.roles = view.roles.map(roleJson);
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        return;
+    }
+    if (models)
+        emitModels(view.models, false);
+    if (roles)
+        emitRoles(view.roles, false);
+}
+function emitModels(models, asJson) {
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify({ models: models.map(modelJson) })}\n`);
+        return;
+    }
+    process.stdout.write("Models\n");
+    if (models.length === 0) {
+        process.stdout.write("  none\n");
+        return;
+    }
+    for (const model of models)
+        process.stdout.write(`  ${modelLabel(model)}\n`);
+}
+function emitRoles(roles, asJson) {
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify({ roles: roles.map(roleJson) })}\n`);
+        return;
+    }
+    process.stdout.write("Roles\n");
+    if (roles.length === 0) {
+        process.stdout.write("  none\n");
+        return;
+    }
+    for (const role of roles)
+        process.stdout.write(`  ${roleLabel(role)}\n`);
+}
+function modelLabel(model) {
+    return `${model.key} - ${model.model}`;
+}
+function roleLabel(role) {
+    return `${role.role} - ${role.model}`;
+}
+function modelJson(model) {
+    return {
+        key: model.key,
+        provider: model.provider,
+        model: model.model,
+        options: { ...model.options },
+        roles: [...model.roles],
+        stages: model.stages.map((stage) => ({ workflow: stage.workflow, stage: stage.stage })),
+    };
+}
+function roleJson(role) {
+    return {
+        role: role.role,
+        model_name: role.modelName,
+        provider: role.provider,
+        model: role.model,
+        options: { ...role.options },
+        shared_with: [...role.sharedWith],
+        stages: role.stages.map((stage) => ({
+            workflow: stage.workflow,
+            stage: stage.stage,
+            model_name: stage.modelName,
+            options: { ...stage.options },
+        })),
+    };
+}
+function printChange(change) {
+    if (change.createdModel)
+        process.stdout.write(`Created model ${change.createdModel}.\n`);
+    if (change.reusedModel)
+        process.stdout.write(`Reused model ${change.reusedModel}.\n`);
+    if (change.updatedModel)
+        process.stdout.write(`Updated model ${change.updatedModel}.\n`);
+    if (change.roles.length > 0)
+        process.stdout.write(`Roles: ${change.roles.join(", ")}\n`);
+    if (change.stagesUpdated.length > 0) {
+        process.stdout.write(`Stages: ${change.stagesUpdated.map(([workflow, stage]) => `${workflow}.${stage}`).join(", ")}\n`);
+    }
+    for (const stage of change.stagesUnchanged) {
+        process.stdout.write(`Unchanged: ${stage.workflow}.${stage.stage} (${stage.ignores.join(", ")})\n`);
+    }
+    if (change.orphanedModels.length > 0)
+        process.stdout.write(`Orphaned models: ${change.orphanedModels.join(", ")}\n`);
+}
+function changePayload(change, wrote, doctor) {
+    return {
+        wrote,
+        created_model: change.createdModel,
+        reused_model: change.reusedModel,
+        updated_model: change.updatedModel,
+        roles: [...change.roles],
+        stages_updated: change.stagesUpdated.map(([workflow, stage]) => ({ workflow, stage })),
+        stages_unchanged: change.stagesUnchanged.map((stage) => ({
+            workflow: stage.workflow,
+            stage: stage.stage,
+            ignores: [...stage.ignores],
+        })),
+        orphaned_models: [...change.orphanedModels],
+        doctor,
+    };
+}
+function doctorPayload(checks) {
+    return {
+        ok: checks.every((check) => check.ok),
+        checks: checks.map((check) => ({
+            name: check.name,
+            ok: check.ok,
+            items: [...check.items],
+            problems: [...check.problems],
+        })),
+    };
+}
+function presentOptions(options) {
+    const present = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== null)
+            present[key] = value;
+    }
+    return present;
+}
+function safeTarget(config, key) {
+    try {
+        return loadModelTarget(config, key);
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError)
+            return null;
+        throw error;
+    }
+}
+function sameTarget(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    return left.provider === right.provider && left.model === right.model && deepEqual(left.options, right.options);
+}
+function deepEqual(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((item, index) => deepEqual(item, right[index]));
+    }
+    if (!isRecord(left) || !isRecord(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length)
+        return false;
+    return leftKeys.every((key) => deepEqual(left[key], right[key]));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+class ClackConfigPrompter {
+    async select(message, choices, defaultValue) {
+        if (choices.length === 0)
+            throw new Error("Choose a value.");
+        const values = new Set(choices.map(([, value]) => value));
+        const initial = defaultValue != null && values.has(defaultValue) ? defaultValue : choices[0]?.[1];
+        const result = await clackSelect({
+            message,
+            options: choices.map(([label, value]) => ({ label, value })),
+            initialValue: initial,
+        });
+        if (isCancel(result) || typeof result !== "string" || !values.has(result))
+            throw new Error("Choose a value.");
+        return result;
+    }
+    async confirm(message) {
+        const result = await clackConfirm({ message, initialValue: true });
+        if (isCancel(result) || typeof result !== "boolean")
+            throw new Error("Answer yes or no.");
+        return result;
+    }
+    async text(message, defaultValue = "") {
+        const result = await clackText({ message, initialValue: defaultValue });
+        if (isCancel(result) || typeof result !== "string")
+            throw new Error("Enter a value.");
+        return result;
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+import { type Which } from "../provider.js";
+export declare function runDoctor(workspace: string, options?: {
+    asJson?: boolean;
+    which?: Which | null;
+}): Promise<number>;

package/dist/commands/doctor.js

@@ -0,0 +1,26 @@
+import { diagnose, whichSync } from "@nodeint/migent-kernel";
+import { printDoctor } from "../display.js";
+import { cliHooks } from "../hooks.js";
+import { requireCurrentSchema } from "../migrate.js";
+import { adapterMap } from "../provider.js";
+export async function runDoctor(workspace, options = {}) {
+    requireCurrentSchema(workspace);
+    const which = options.which ?? cliHooks.which ?? whichSync;
+    const checks = diagnose(workspace, { adapters: adapterMap(), which });
+    if (options.asJson)
+        process.stdout.write(`${JSON.stringify(payload(checks))}\n`);
+    else
+        printDoctor(checks);
+    return checks.every((check) => check.ok) ? 0 : 1;
+}
+function payload(checks) {
+    return {
+        ok: checks.every((check) => check.ok),
+        checks: checks.map((check) => ({
+            name: check.name,
+            ok: check.ok,
+            items: [...check.items],
+            problems: [...check.problems],
+        })),
+    };
+}

package/dist/commands/execute.d.ts

@@ -0,0 +1,12 @@
+import { AgentToolRunner } from "@nodeint/migent-kernel";
+export interface ExecuteWorkflowOptions {
+    action: string;
+    workflowId?: string | null;
+    task?: string | null;
+    sessionId?: string | null;
+    priorSessionId?: string | null;
+    maxAttempts?: number | null;
+    maxDispatches?: number | null;
+    runner?: AgentToolRunner | null;
+}
+export declare function executeWorkflow(workspace: string, options: ExecuteWorkflowOptions): Promise<number>;