@levu/snap 0.1.0 → 0.2.0

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/note.d.ts

@@ -0,0 +1,7 @@
+import type { Writable } from 'node:stream';
+export interface NoteInput {
+    message: string;
+    title?: string;
+    format?: (line: string) => string;
+}
+export declare const note: (input: NoteInput, stdout?: Writable) => void;

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

@@ -0,0 +1,23 @@
+const boxChars = {
+    topLeft: '╮',
+    topRight: '╯',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│'
+};
+export const note = (input, stdout = process.stdout) => {
+    const { message, title = '', format } = input;
+    const lines = message.split('\n');
+    const formattedLines = format ? lines.map(format) : lines;
+    const maxLength = Math.max(...formattedLines.map((line) => line.length), title.length);
+    const padding = 2;
+    // Top line
+    stdout.write(`${boxChars.vertical} ${title.padEnd(maxLength + padding)} ${boxChars.topLeft}${boxChars.horizontal.repeat(maxLength + padding * 2)}${boxChars.horizontal}\n`);
+    // Message lines
+    for (const line of formattedLines) {
+        stdout.write(`${boxChars.vertical} ${' '.repeat(maxLength + padding)} ${boxChars.vertical} ${line.padEnd(maxLength + padding)} ${boxChars.vertical}\n`);
+    }
+    // Bottom line
+    stdout.write(`${boxChars.horizontal}${boxChars.horizontal.repeat(maxLength + padding * 2)}${boxChars.horizontal}${boxChars.horizontal.repeat(maxLength + padding * 2)}${boxChars.vertical}\n`);
+};

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

@@ -0,0 +1,7 @@
+export interface PasswordPromptInput {
+    message: string;
+    required?: boolean;
+    validate?: (value: string) => string | Error | undefined;
+    mask?: string;
+}
+export declare const runPasswordPrompt: (input: PasswordPromptInput) => Promise<string>;

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

@@ -0,0 +1,24 @@
+import { password as clackPassword } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+import { unwrapClackResult } from './cancel.js';
+export const runPasswordPrompt = async (input) => {
+    if (!isInteractiveTerminal()) {
+        // For non-interactive terminals, read from stdin in a secure way
+        // or return empty/throw error
+        if (input.required) {
+            throw new Error(`Password required: ${input.message}`);
+        }
+        return '';
+    }
+    const value = await clackPassword({
+        message: input.message,
+        mask: input.mask ?? '•',
+        validate: (raw) => {
+            if (input.required && (!raw || raw.trim().length === 0)) {
+                return `Password is required`;
+            }
+            return input.validate?.(raw ?? '');
+        }
+    });
+    return unwrapClackResult(value);
+};

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

@@ -0,0 +1,7 @@
+export interface Progress {
+    start(message: string): void;
+    message(message: string): void;
+    stop(message?: string): void;
+}
+export declare const createProgress: () => Progress;
+export declare const progress: () => Progress;

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

@@ -0,0 +1,44 @@
+import { isInteractiveTerminal } from './readline-utils.js';
+export const createProgress = () => {
+    // Non-interactive fallback
+    if (!isInteractiveTerminal()) {
+        let currentMessage = '';
+        return {
+            start(message) {
+                currentMessage = message;
+                process.stdout.write(`${message}...\n`);
+            },
+            message(newMessage) {
+                currentMessage = newMessage;
+                process.stdout.write(`${newMessage}\n`);
+            },
+            stop(finalMessage) {
+                if (finalMessage) {
+                    process.stdout.write(`${finalMessage}\n`);
+                }
+            }
+        };
+    }
+    // Interactive progress using @clack/prompts
+    let progressInstance = null;
+    return {
+        start(message) {
+            // Lazy load progress
+            import('@clack/prompts').then(({ progress }) => {
+                progressInstance = progress();
+                progressInstance.start(message);
+            });
+        },
+        message(newMessage) {
+            if (progressInstance) {
+                progressInstance.message(newMessage);
+            }
+        },
+        stop(finalMessage) {
+            if (progressInstance) {
+                progressInstance.stop(finalMessage);
+            }
+        }
+    };
+};
+export const progress = createProgress;

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/spinner.d.ts

@@ -0,0 +1,10 @@
+export interface SpinnerOptions {
+    message?: string;
+}
+export interface Spinner {
+    start(message?: string): void;
+    stop(message?: string): void;
+    message(message: string): void;
+}
+export declare const createSpinner: (options?: SpinnerOptions) => Spinner;
+export declare const spinner: (options?: SpinnerOptions) => Spinner;

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

@@ -0,0 +1,48 @@
+import { spinner as clackSpinner } from '@clack/prompts';
+import { isInteractiveTerminal } from './readline-utils.js';
+export const createSpinner = (options = {}) => {
+    // Non-interactive fallback
+    if (!isInteractiveTerminal()) {
+        let currentMessage = options.message ?? '';
+        return {
+            start(message) {
+                currentMessage = message ?? currentMessage;
+                if (currentMessage) {
+                    process.stdout.write(`${currentMessage}...\n`);
+                }
+            },
+            stop(message) {
+                if (message) {
+                    process.stdout.write(`${message}\n`);
+                }
+            },
+            message(newMessage) {
+                currentMessage = newMessage;
+            }
+        };
+    }
+    // Interactive spinner using @clack/prompts
+    const internalSpinner = clackSpinner();
+    return {
+        start(message) {
+            if (message) {
+                internalSpinner.start(message);
+            }
+            else if (options.message) {
+                internalSpinner.start(options.message);
+            }
+        },
+        stop(message) {
+            if (message) {
+                internalSpinner.stop(message);
+            }
+            else {
+                internalSpinner.stop();
+            }
+        },
+        message(newMessage) {
+            internalSpinner.message(newMessage);
+        }
+    };
+};
+export const spinner = createSpinner;

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

@@ -0,0 +1,9 @@
+export interface Task {
+    title: string;
+    task: (message: (msg: string) => void) => Promise<string>;
+}
+export interface TasksOptions {
+    /** Called when a task is cancelled */
+    onCancel?: (results: Record<string, string>) => void;
+}
+export declare const tasks: (taskList: Task[], options?: TasksOptions) => Promise<Record<string, string>>;

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

@@ -0,0 +1,31 @@
+import { isInteractiveTerminal } from './readline-utils.js';
+export const tasks = async (taskList, options = {}) => {
+    const results = {};
+    if (!isInteractiveTerminal()) {
+        // Non-interactive: just run tasks without spinner
+        for (const taskItem of taskList) {
+            try {
+                const result = await taskItem.task(() => { });
+                results[taskItem.title] = result;
+                process.stdout.write(`${taskItem.title}: ${result}\n`);
+            }
+            catch (error) {
+                results[taskItem.title] = error instanceof Error ? error.message : String(error);
+            }
+        }
+        return results;
+    }
+    // Import clack dynamically for interactive mode
+    const { tasks: clackTasks } = await import('@clack/prompts');
+    // Wrap tasks to collect results
+    const wrappedTasks = taskList.map((task) => ({
+        ...task,
+        task: async (message) => {
+            const result = await task.task(message);
+            results[task.title] = result;
+            return result;
+        }
+    }));
+    await clackTasks(wrappedTasks, options);
+    return results;
+};

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
+    };
+};