@levu/snap 0.1.0 → 0.1.1

package/dist/dx/terminal/output.js

@@ -0,0 +1,18 @@
+const writeLine = (stream, message) => {
+    stream.write(`${message}\n`);
+};
+export const createTerminalOutput = (stdout = process.stdout, stderr = process.stderr) => {
+    return {
+        line(message) {
+            writeLine(stdout, message);
+        },
+        lines(messages) {
+            for (const message of messages) {
+                writeLine(stdout, message);
+            }
+        },
+        error(message) {
+            writeLine(stderr, message);
+        }
+    };
+};

package/dist/dx/tui/components.d.ts

@@ -0,0 +1,6 @@
+import type { TuiComponentContract, TuiCustomComponentContract, TuiOptionContract, TuiStepContract } from '../../core/contracts/tui-contract.js';
+export declare const defineTuiOptions: <TOption extends TuiOptionContract>(options: readonly TOption[]) => TOption[];
+export declare const defineTuiComponent: <TComponent extends TuiComponentContract>(component: TComponent) => TComponent;
+export declare const defineCustomTuiComponent: <TConfig extends Record<string, unknown> = Record<string, unknown>>(component: Omit<TuiCustomComponentContract<TConfig>, "type">) => TuiCustomComponentContract<TConfig>;
+export declare const defineTuiStep: <TStep extends TuiStepContract>(step: TStep) => TStep;
+export declare const isCustomTuiComponent: (component: TuiComponentContract) => component is TuiCustomComponentContract;

package/dist/dx/tui/components.js

@@ -0,0 +1,40 @@
+export const defineTuiOptions = (options) => {
+    if (options.length === 0) {
+        throw new Error('TUI select options cannot be empty.');
+    }
+    return [...options];
+};
+export const defineTuiComponent = (component) => {
+    if (!component.componentId.trim()) {
+        throw new Error('TUI componentId cannot be empty.');
+    }
+    if (!component.label.trim()) {
+        throw new Error(`TUI component label cannot be empty: ${component.componentId}`);
+    }
+    if (component.type === 'select' || component.type === 'multiselect') {
+        if (!component.options || component.options.length === 0) {
+            throw new Error(`TUI component options required for ${component.componentId}.`);
+        }
+    }
+    if (component.type === 'custom' && !component.renderer.trim()) {
+        throw new Error(`Custom TUI component renderer is required: ${component.componentId}.`);
+    }
+    return component;
+};
+export const defineCustomTuiComponent = (component) => defineTuiComponent({
+    ...component,
+    type: 'custom'
+});
+export const defineTuiStep = (step) => {
+    if (!step.stepId.trim()) {
+        throw new Error('TUI stepId cannot be empty.');
+    }
+    if (!step.title.trim()) {
+        throw new Error(`TUI step title cannot be empty: ${step.stepId}`);
+    }
+    if (step.components) {
+        step.components.forEach((component) => defineTuiComponent(component));
+    }
+    return step;
+};
+export const isCustomTuiComponent = (component) => component.type === 'custom';

package/dist/dx/tui/flow.d.ts

@@ -0,0 +1,2 @@
+import type { TuiFlowContract } from '../../core/contracts/tui-contract.js';
+export declare const defineTuiFlow: <TFlow extends TuiFlowContract>(flow: TFlow) => TFlow;

package/dist/dx/tui/flow.js

@@ -0,0 +1,14 @@
+import { defineTuiStep } from './components.js';
+export const defineTuiFlow = (flow) => {
+    if (!flow.steps || flow.steps.length === 0) {
+        throw new Error('TUI flow must include at least one step.');
+    }
+    const steps = flow.steps.map((step) => defineTuiStep(step));
+    if (flow.entryStepId && !steps.some((step) => step.stepId === flow.entryStepId)) {
+        throw new Error(`TUI flow entry step does not exist: ${flow.entryStepId}`);
+    }
+    return {
+        ...flow,
+        steps
+    };
+};

package/dist/dx/tui/index.d.ts

@@ -0,0 +1,4 @@
+export { defineTuiOptions, defineTuiComponent, defineCustomTuiComponent, defineTuiStep, isCustomTuiComponent } from './components.js';
+export { defineTuiFlow } from './flow.js';
+export { backToPreviousOnNoResult, formatNoResultMessage } from './no-result.js';
+export type { NoResultBackContext, NoResultBackInput } from './no-result.js';

package/dist/dx/tui/index.js

@@ -0,0 +1,3 @@
+export { defineTuiOptions, defineTuiComponent, defineCustomTuiComponent, defineTuiStep, isCustomTuiComponent } from './components.js';
+export { defineTuiFlow } from './flow.js';
+export { backToPreviousOnNoResult, formatNoResultMessage } from './no-result.js';

package/dist/dx/tui/no-result.d.ts

@@ -0,0 +1,13 @@
+import type { FlowController } from '../runtime/index.js';
+import type { TerminalOutput } from '../terminal/index.js';
+export interface NoResultBackContext {
+    flow: Pick<FlowController, 'back'>;
+    terminal: Pick<TerminalOutput, 'line'>;
+}
+export interface NoResultBackInput {
+    context: NoResultBackContext;
+    entityName?: string;
+    message?: string;
+}
+export declare const formatNoResultMessage: (entityName?: string) => string;
+export declare const backToPreviousOnNoResult: (input: NoResultBackInput) => void;

package/dist/dx/tui/no-result.js

@@ -0,0 +1,18 @@
+const DEFAULT_NO_RESULT_MESSAGE = 'No results found.';
+const normalizeEntityName = (entityName) => {
+    if (entityName === undefined)
+        return undefined;
+    const normalized = entityName.trim();
+    return normalized.length > 0 ? normalized : undefined;
+};
+export const formatNoResultMessage = (entityName) => {
+    const normalizedEntityName = normalizeEntityName(entityName);
+    if (!normalizedEntityName)
+        return DEFAULT_NO_RESULT_MESSAGE;
+    return `No ${normalizedEntityName} found.`;
+};
+export const backToPreviousOnNoResult = (input) => {
+    const message = input.message?.trim().length ? input.message.trim() : formatNoResultMessage(input.entityName);
+    input.context.terminal.line(message);
+    input.context.flow.back();
+};

package/dist/help/help-renderer.js

@@ -1,6 +1,10 @@
+const renderLine = (line) => line
+    .split('\n')
+    .map((part, index) => (index === 0 ? `- ${part}` : `  ${part}`))
+    .join('\n');
 const renderSection = (section) => {
     const header = `## ${section.title}`;
-    const lines = section.lines.length > 0 ? section.lines.map((line) => `- ${line}`).join('\n') : '- (none)';
+    const lines = section.lines.length > 0 ? section.lines.map(renderLine).join('\n') : '- (none)';
     return `${header}\n${lines}`;
 };
 export const renderHelp = (views) => views

package/dist/help/hierarchy-resolver.js

@@ -31,7 +31,7 @@ const toActionHelp = (moduleId, action) => ({
         { title: 'SUMMARY', lines: [action.help.summary] },
         {
             title: 'ARGS',
-            lines: action.help.args.map((arg) => `${arg.required ? '*' : '-'} ${arg.name}: ${arg.description}`)
+            lines: action.help.args.map((arg) => `${arg.name} (${arg.required ? 'required' : 'optional'}): ${arg.description}`)
         },
         { title: 'EXAMPLES', lines: action.help.examples },
         {

package/dist/index.d.ts

@@ -1,3 +1,15 @@
 import { ActionRegistry } from './core/registry/action-registry.js';
 import type { ModuleContract } from './core/contracts/module-contract.js';
+export { parseCliInput, runMultiModuleCli, runSingleModuleCli } from './cli/cli-runner.js';
+export type { SubmoduleRoute } from './cli/cli-runner.js';
+export { runSubmoduleCli } from './cli/cli-runner.js';
+export * as SnapArgs from './dx/args/index.js';
+export * as SnapHelp from './dx/help/index.js';
+export * as SnapRuntime from './dx/runtime/index.js';
+export * as SnapTerminal from './dx/terminal/index.js';
+export * as SnapTui from './dx/tui/index.js';
+export { createPromptToolkit } from './tui/prompt-toolkit.js';
+export type { PromptToolkit } from './tui/prompt-toolkit.js';
+export { runCustomPrompt, createCustomPromptRunner } from './tui/custom/index.js';
+export type { CustomPromptInput, CustomPromptRunner } from './tui/custom/index.js';
 export declare const createRegistry: (modules: ModuleContract[]) => ActionRegistry;

package/dist/index.js

@@ -1,4 +1,13 @@
 import { ActionRegistry } from './core/registry/action-registry.js';
+export { parseCliInput, runMultiModuleCli, runSingleModuleCli } from './cli/cli-runner.js';
+export { runSubmoduleCli } from './cli/cli-runner.js';
+export * as SnapArgs from './dx/args/index.js';
+export * as SnapHelp from './dx/help/index.js';
+export * as SnapRuntime from './dx/runtime/index.js';
+export * as SnapTerminal from './dx/terminal/index.js';
+export * as SnapTui from './dx/tui/index.js';
+export { createPromptToolkit } from './tui/prompt-toolkit.js';
+export { runCustomPrompt, createCustomPromptRunner } from './tui/custom/index.js';
 export const createRegistry = (modules) => {
     const registry = new ActionRegistry();
     for (const moduleContract of modules) {

package/dist/runtime/dispatch.d.ts

@@ -1,10 +1,11 @@
 import type { ActionResultEnvelope } from '../core/contracts/action-contract.js';
 import type { ActionRegistry } from '../core/registry/action-registry.js';
+import type { CliArgs } from '../dx/args/index.js';
 export interface DispatchInput {
     registry: ActionRegistry;
     moduleId: string;
     actionId: string;
-    args: Record<string, string | boolean>;
+    args: CliArgs;
     isTTY: boolean;
     resumeFilePath?: string;
 }

package/dist/runtime/engine.d.ts

@@ -1,11 +1,12 @@
 import type { ActionContract, ActionResultEnvelope, RuntimeMode } from '../core/contracts/action-contract.js';
+import type { CliArgs } from '../dx/args/index.js';
 import { ResumeStore } from './resume-store.js';
 import { type WorkflowNode } from './state-machine.js';
 export interface EngineInput {
     moduleId: string;
     action: ActionContract;
     mode: RuntimeMode;
-    args: Record<string, string | boolean>;
+    args: CliArgs;
     workflowId?: string;
     workflowNodes?: WorkflowNode[];
     resumeStore?: ResumeStore;

package/dist/runtime/engine.js

@@ -1,7 +1,22 @@
 import { ExitCode } from '../core/errors/framework-errors.js';
+import { createFlowController } from '../dx/runtime/index.js';
+import { createTerminalOutput } from '../dx/terminal/index.js';
+import { createPromptToolkit } from '../tui/prompt-toolkit.js';
 import { StateMachine } from './state-machine.js';
+const resolveWorkflowNodes = (action) => {
+    if (action.tui.flow?.steps && action.tui.flow.steps.length > 0) {
+        return action.tui.flow.steps.map((step) => ({
+            id: step.stepId,
+            label: step.title
+        }));
+    }
+    if (action.tui.steps && action.tui.steps.length > 0) {
+        return action.tui.steps.map((step) => ({ id: step, label: step }));
+    }
+    return [{ id: 'default', label: 'default' }];
+};
 export const executeAction = async (input) => {
-    const nodes = input.workflowNodes ?? input.action.tui.steps.map((step) => ({ id: step, label: step }));
+    const nodes = input.workflowNodes ?? resolveWorkflowNodes(input.action);
     const workflowId = input.workflowId ?? `${input.moduleId}.${input.action.actionId}`;
     let initialNodeId;
     if (input.resumeStore) {
@@ -10,12 +25,18 @@ export const executeAction = async (input) => {
             initialNodeId = checkpoint.nodeId;
         }
     }
+    if (!initialNodeId && input.action.tui.flow?.entryStepId) {
+        initialNodeId = input.action.tui.flow.entryStepId;
+    }
     const stateMachine = new StateMachine(workflowId, nodes, initialNodeId);
     const context = {
         moduleId: input.moduleId,
         actionId: input.action.actionId,
         mode: input.mode,
         args: input.args,
+        flow: createFlowController(stateMachine),
+        terminal: createTerminalOutput(),
+        prompts: createPromptToolkit(),
         stateMachine
     };
     try {

package/dist/runtime/mode-resolver.d.ts

@@ -1,8 +1,9 @@
 import type { CommandlineContract, RuntimeMode } from '../core/contracts/action-contract.js';
+import type { CliArgs } from '../dx/args/index.js';
 export interface RuntimeResolutionInput {
     isTTY: boolean;
-    providedArgs: Record<string, string | boolean>;
+    providedArgs: CliArgs;
     commandline: CommandlineContract;
 }
-export declare const hasRequiredArgs: (requiredArgs: string[], providedArgs: Record<string, string | boolean>) => boolean;
+export declare const hasRequiredArgs: (requiredArgs: string[], providedArgs: CliArgs) => boolean;
 export declare const resolveRuntimeMode: (input: RuntimeResolutionInput) => RuntimeMode;

package/dist/runtime/runtime-context.d.ts

@@ -1,9 +1,16 @@
 import type { RuntimeMode } from '../core/contracts/action-contract.js';
+import type { CliArgs } from '../dx/args/index.js';
+import type { FlowController } from '../dx/runtime/index.js';
+import type { TerminalOutput } from '../dx/terminal/index.js';
 import type { StateMachine } from './state-machine.js';
+import type { PromptToolkit } from '../tui/prompt-toolkit.js';
 export interface RuntimeContext {
     moduleId: string;
     actionId: string;
     mode: RuntimeMode;
-    args: Record<string, string | boolean>;
+    args: CliArgs;
+    flow: FlowController;
+    terminal: TerminalOutput;
+    prompts: PromptToolkit;
     stateMachine?: StateMachine;
 }

package/dist/tui/component-adapters/cancel.d.ts

@@ -0,0 +1,6 @@
+export declare class PromptCancelledError extends Error {
+    readonly isPromptCancelled = true;
+    constructor(message?: string);
+}
+export declare const isPromptCancelledError: (error: unknown) => error is PromptCancelledError;
+export declare const unwrapClackResult: <T>(value: T | symbol, cancelMessage?: string) => T;

package/dist/tui/component-adapters/cancel.js

@@ -0,0 +1,20 @@
+import { isCancel } from '@clack/prompts';
+export class PromptCancelledError extends Error {
+    isPromptCancelled = true;
+    constructor(message = 'Cancelled by user.') {
+        super(message);
+        this.name = 'PromptCancelledError';
+    }
+}
+export const isPromptCancelledError = (error) => {
+    return error instanceof PromptCancelledError || (typeof error === 'object' &&
+        error !== null &&
+        'isPromptCancelled' in error &&
+        error.isPromptCancelled === true);
+};
+export const unwrapClackResult = (value, cancelMessage = 'Cancelled by user.') => {
+    if (isCancel(value)) {
+        throw new PromptCancelledError(cancelMessage);
+    }
+    return value;
+};

package/dist/tui/component-adapters/confirm.d.ts

@@ -1,5 +1,7 @@
 export interface ConfirmPromptInput {
     message: string;
     initialValue?: boolean;
+    active?: string;
+    inactive?: string;
 }
 export declare const runConfirmPrompt: (input: ConfirmPromptInput) => Promise<boolean>;

package/dist/tui/component-adapters/confirm.js

@@ -1,3 +1,15 @@
+import { confirm } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+import { unwrapClackResult } from './cancel.js';
 export const runConfirmPrompt = async (input) => {
-    return input.initialValue ?? true;
+    const fallback = input.initialValue ?? true;
+    if (!isInteractiveTerminal())
+        return fallback;
+    const value = await confirm({
+        message: input.message,
+        initialValue: fallback,
+        active: input.active,
+        inactive: input.inactive
+    });
+    return unwrapClackResult(value);
 };

package/dist/tui/component-adapters/multiselect.d.ts

@@ -1,10 +1,14 @@
 export interface MultiSelectOption {
     value: string;
     label: string;
+    hint?: string;
+    disabled?: boolean;
 }
 export interface MultiSelectPromptInput {
     message: string;
     options: MultiSelectOption[];
     initialValues?: string[];
+    required?: boolean;
+    showInstructions?: boolean;
 }
 export declare const runMultiSelectPrompt: (input: MultiSelectPromptInput) => Promise<string[]>;

package/dist/tui/component-adapters/multiselect.js

@@ -1,9 +1,29 @@
+import { multiselect } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+import { unwrapClackResult } from './cancel.js';
 export const runMultiSelectPrompt = async (input) => {
     if (input.options.length === 0) {
         throw new Error(`No options available for multiselect prompt: ${input.message}`);
     }
-    if (input.initialValues && input.initialValues.length > 0) {
-        return input.initialValues.filter((value) => input.options.some((option) => option.value === value));
+    const defaultValues = input.initialValues && input.initialValues.length > 0
+        ? input.initialValues.filter((value) => input.options.some((option) => option.value === value))
+        : [input.options[0].value];
+    if (!isInteractiveTerminal()) {
+        return defaultValues;
     }
-    return [input.options[0].value];
+    const message = input.showInstructions === false
+        ? input.message
+        : `${input.message} (space to toggle, a to select all)`;
+    const selected = await multiselect({
+        message,
+        options: input.options.map((option) => ({
+            value: option.value,
+            label: option.label,
+            hint: option.hint,
+            disabled: option.disabled
+        })),
+        initialValues: defaultValues,
+        required: input.required ?? false
+    });
+    return unwrapClackResult(selected);
 };

package/dist/tui/component-adapters/readline-utils.d.ts

@@ -0,0 +1 @@
+export declare const isInteractiveTerminal: () => boolean;

package/dist/tui/component-adapters/readline-utils.js

@@ -0,0 +1,2 @@
+import { stdin as input, stdout as output } from 'node:process';
+export const isInteractiveTerminal = () => Boolean(input.isTTY && output.isTTY);

package/dist/tui/component-adapters/select.d.ts

@@ -1,6 +1,8 @@
 export interface SelectOption {
     value: string;
     label: string;
+    hint?: string;
+    disabled?: boolean;
 }
 export interface SelectPromptInput {
     message: string;

package/dist/tui/component-adapters/select.js

@@ -1,7 +1,29 @@
+import { select } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+import { unwrapClackResult } from './cancel.js';
 export const runSelectPrompt = async (input) => {
-    const selected = input.initialValue ?? input.options[0]?.value;
-    if (!selected) {
+    if (input.options.length === 0) {
         throw new Error(`No options available for select prompt: ${input.message}`);
     }
-    return selected;
+    const initialValue = input.initialValue && input.options.some((option) => option.value === input.initialValue)
+        ? input.initialValue
+        : undefined;
+    const defaultValue = initialValue ?? input.options[0]?.value;
+    if (!defaultValue) {
+        throw new Error(`No options available for select prompt: ${input.message}`);
+    }
+    if (!isInteractiveTerminal()) {
+        return defaultValue;
+    }
+    const selection = await select({
+        message: input.message,
+        options: input.options.map((option) => ({
+            value: option.value,
+            label: option.label,
+            hint: option.hint,
+            disabled: option.disabled
+        })),
+        initialValue: defaultValue
+    });
+    return unwrapClackResult(selection);
 };

package/dist/tui/component-adapters/text.d.ts

@@ -2,5 +2,7 @@ export interface TextPromptInput {
     message: string;
     initialValue?: string;
     required?: boolean;
+    placeholder?: string;
+    validate?: (value: string) => string | Error | undefined;
 }
 export declare const runTextPrompt: (input: TextPromptInput) => Promise<string>;

package/dist/tui/component-adapters/text.js

@@ -1,7 +1,24 @@
+import { text } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+import { unwrapClackResult } from './cancel.js';
 export const runTextPrompt = async (input) => {
-    const value = input.initialValue ?? '';
-    if (input.required && value.trim().length === 0) {
-        throw new Error(`Required text value missing: ${input.message}`);
+    const fallbackValue = input.initialValue ?? '';
+    if (!isInteractiveTerminal()) {
+        if (input.required && fallbackValue.trim().length === 0) {
+            throw new Error(`Required text value missing: ${input.message}`);
+        }
+        return fallbackValue;
     }
-    return value;
+    const value = await text({
+        message: input.message,
+        initialValue: input.initialValue,
+        placeholder: input.placeholder,
+        validate: (raw) => {
+            if (input.required && (!raw || raw.trim().length === 0)) {
+                return `Required text value missing: ${input.message}`;
+            }
+            return input.validate?.(raw ?? '');
+        }
+    });
+    return unwrapClackResult(value);
 };

package/dist/tui/custom/custom-prompt.d.ts

@@ -0,0 +1,16 @@
+export interface CustomPromptInput<TValue = string> {
+    message: string;
+    defaultValue?: string;
+    required?: boolean;
+    signal?: AbortSignal;
+    parse?: (raw: string) => TValue;
+    validate?: (value: TValue) => string | undefined;
+    onValue?: (value: TValue) => void;
+    onSubmit?: (value: TValue) => void;
+    onCancel?: () => void;
+}
+export interface CustomPromptRunner {
+    run<TValue = string>(input: CustomPromptInput<TValue>): Promise<TValue>;
+}
+export declare const runCustomPrompt: <TValue = string>(input: CustomPromptInput<TValue>) => Promise<TValue>;
+export declare const createCustomPromptRunner: () => CustomPromptRunner;

package/dist/tui/custom/custom-prompt.js

@@ -0,0 +1,72 @@
+import { text } from '@clack/prompts';
+import { isInteractiveTerminal } from '../component-adapters/readline-utils.js';
+import { unwrapClackResult } from '../component-adapters/cancel.js';
+const toAbortError = () => {
+    const error = new Error('Prompt aborted.');
+    error.name = 'AbortError';
+    return error;
+};
+const assertNotAborted = (signal) => {
+    if (signal?.aborted) {
+        throw toAbortError();
+    }
+};
+const defaultParse = (raw) => raw;
+export const runCustomPrompt = async (input) => {
+    const parse = input.parse ?? (defaultParse);
+    const fallback = input.defaultValue ?? '';
+    const validateValue = (value) => {
+        const message = input.validate?.(value);
+        if (message)
+            throw new Error(message);
+    };
+    const parseAndValidate = (raw) => {
+        const parsed = parse(raw);
+        validateValue(parsed);
+        input.onValue?.(parsed);
+        return parsed;
+    };
+    assertNotAborted(input.signal);
+    if (!isInteractiveTerminal()) {
+        if (input.required && fallback.trim().length === 0) {
+            throw new Error(`Required value missing: ${input.message}`);
+        }
+        const value = parseAndValidate(fallback);
+        input.onSubmit?.(value);
+        return value;
+    }
+    const onAbort = () => {
+        input.onCancel?.();
+    };
+    input.signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+        const rawValue = await text({
+            message: input.message,
+            initialValue: input.defaultValue,
+            validate: (value) => {
+                if ((!value || value.length === 0) && input.required && fallback.trim().length === 0) {
+                    return `Required value missing: ${input.message}`;
+                }
+                try {
+                    parseAndValidate(value && value.length > 0 ? value : fallback);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : 'Invalid value';
+                }
+            },
+            signal: input.signal
+        });
+        assertNotAborted(input.signal);
+        const resolved = unwrapClackResult(rawValue);
+        const value = parseAndValidate(resolved.length > 0 ? resolved : fallback);
+        input.onSubmit?.(value);
+        return value;
+    }
+    finally {
+        input.signal?.removeEventListener('abort', onAbort);
+    }
+};
+export const createCustomPromptRunner = () => ({
+    run: runCustomPrompt
+});

package/dist/tui/custom/index.d.ts

@@ -0,0 +1,2 @@
+export type { CustomPromptInput, CustomPromptRunner } from './custom-prompt.js';
+export { runCustomPrompt, createCustomPromptRunner } from './custom-prompt.js';

package/dist/tui/custom/index.js

@@ -0,0 +1 @@
+export { runCustomPrompt, createCustomPromptRunner } from './custom-prompt.js';

package/dist/tui/prompt-toolkit.d.ts

@@ -0,0 +1,15 @@
+import type { ConfirmPromptInput } from './component-adapters/confirm.js';
+import type { GroupStep } from './component-adapters/group.js';
+import type { MultiSelectPromptInput } from './component-adapters/multiselect.js';
+import type { SelectPromptInput } from './component-adapters/select.js';
+import type { TextPromptInput } from './component-adapters/text.js';
+import { type CustomPromptInput } from './custom/custom-prompt.js';
+export interface PromptToolkit {
+    text(input: TextPromptInput): Promise<string>;
+    confirm(input: ConfirmPromptInput): Promise<boolean>;
+    select(input: SelectPromptInput): Promise<string>;
+    multiselect(input: MultiSelectPromptInput): Promise<string[]>;
+    group<T = unknown>(steps: GroupStep<T>[]): Promise<Record<string, T>>;
+    custom<T>(input: CustomPromptInput<T>): Promise<T>;
+}
+export declare const createPromptToolkit: () => PromptToolkit;

package/dist/tui/prompt-toolkit.js

@@ -0,0 +1,17 @@
+import { runConfirmPrompt } from './component-adapters/confirm.js';
+import { runGroupPrompt } from './component-adapters/group.js';
+import { runMultiSelectPrompt } from './component-adapters/multiselect.js';
+import { runSelectPrompt } from './component-adapters/select.js';
+import { runTextPrompt } from './component-adapters/text.js';
+import { createCustomPromptRunner } from './custom/custom-prompt.js';
+export const createPromptToolkit = () => {
+    const customRunner = createCustomPromptRunner();
+    return {
+        text: runTextPrompt,
+        confirm: runConfirmPrompt,
+        select: runSelectPrompt,
+        multiselect: runMultiSelectPrompt,
+        group: runGroupPrompt,
+        custom: customRunner.run
+    };
+};