terminal-pilot 0.0.30 → 0.0.32

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.d.ts

@@ -0,0 +1,20 @@
+import type { PromptStateName } from "./core.js";
+export declare const UNICODE: boolean;
+export declare const GLYPHS: {
+    readonly stepActive: string;
+    readonly stepCancel: string;
+    readonly stepError: string;
+    readonly stepSubmit: string;
+    readonly barStart: string;
+    readonly bar: string;
+    readonly barEnd: string;
+    readonly radioActive: string;
+    readonly radioInactive: string;
+    readonly checkboxActive: string;
+    readonly checkboxSelected: string;
+    readonly checkboxInactive: string;
+    readonly passwordMask: string;
+    readonly ellipsis: "...";
+};
+export declare function symbol(state: PromptStateName): string;
+export declare function symbolBar(state: PromptStateName): string;

package/node_modules/toolcraft-design/dist/prompts/interactive/glyphs.js

@@ -0,0 +1,53 @@
+import { color } from "../../components/color.js";
+function supportsUnicode() {
+    if (!process.platform.startsWith("win")) {
+        return process.env.TERM !== "linux";
+    }
+    return Boolean(process.env.CI ||
+        process.env.WT_SESSION ||
+        process.env.TERMINUS_SUBLIME ||
+        process.env.ConEmuTask === "{cmd::Cmder}" ||
+        process.env.TERM_PROGRAM === "Terminus-Sublime" ||
+        process.env.TERM_PROGRAM === "vscode" ||
+        process.env.TERM === "xterm-256color" ||
+        process.env.TERM === "alacritty" ||
+        process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+export const UNICODE = supportsUnicode();
+function glyph(unicode, ascii) {
+    return UNICODE ? unicode : ascii;
+}
+export const GLYPHS = {
+    stepActive: glyph("◆", "*"),
+    stepCancel: glyph("■", "x"),
+    stepError: glyph("▲", "x"),
+    stepSubmit: glyph("◇", "o"),
+    barStart: glyph("┌", "T"),
+    bar: glyph("│", "|"),
+    barEnd: glyph("└", "-"),
+    radioActive: glyph("●", ">"),
+    radioInactive: glyph("○", " "),
+    checkboxActive: glyph("◻", "[ ]"),
+    checkboxSelected: glyph("◼", "[+]"),
+    checkboxInactive: glyph("◻", "[ ]"),
+    passwordMask: glyph("•", "*"),
+    ellipsis: "..."
+};
+export function symbol(state) {
+    if (state === "cancel")
+        return color.red(GLYPHS.stepCancel);
+    if (state === "error")
+        return color.yellow(GLYPHS.stepError);
+    if (state === "submit")
+        return color.green(GLYPHS.stepSubmit);
+    return color.cyan(GLYPHS.stepActive);
+}
+export function symbolBar(state) {
+    if (state === "cancel")
+        return color.red(GLYPHS.bar);
+    if (state === "error")
+        return color.yellow(GLYPHS.bar);
+    if (state === "submit")
+        return color.green(GLYPHS.bar);
+    return color.cyan(GLYPHS.bar);
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/index.d.ts

@@ -0,0 +1,6 @@
+export { CANCEL, isCancel } from "./cancel-symbol.js";
+export { textPrompt, type TextOptions } from "./text.js";
+export { passwordPrompt, type PasswordOptions } from "./password.js";
+export { confirmPrompt, type ConfirmOptions } from "./confirm.js";
+export { selectPrompt, type SelectOption, type SelectOptions } from "./select.js";
+export { multiselectPrompt, type MultiselectOptions } from "./multiselect.js";

package/node_modules/toolcraft-design/dist/prompts/interactive/index.js

@@ -0,0 +1,6 @@
+export { CANCEL, isCancel } from "./cancel-symbol.js";
+export { textPrompt } from "./text.js";
+export { passwordPrompt } from "./password.js";
+export { confirmPrompt } from "./confirm.js";
+export { selectPrompt } from "./select.js";
+export { multiselectPrompt } from "./multiselect.js";

package/node_modules/toolcraft-design/dist/prompts/interactive/keys.d.ts

@@ -0,0 +1,2 @@
+export type Action = "up" | "down" | "left" | "right" | "space" | "enter" | "cancel";
+export declare function mapKey(name: string | undefined, char: string | undefined): Action | undefined;

package/node_modules/toolcraft-design/dist/prompts/interactive/keys.js

@@ -0,0 +1,28 @@
+const aliases = {
+    k: "up",
+    j: "down",
+    h: "left",
+    l: "right"
+};
+const keyActions = {
+    up: "up",
+    down: "down",
+    left: "left",
+    right: "right",
+    space: "space",
+    return: "enter",
+    enter: "enter",
+    escape: "cancel"
+};
+export function mapKey(name, char) {
+    if (char === "\x03") {
+        return "cancel";
+    }
+    if (char === " ") {
+        return "space";
+    }
+    if (!name) {
+        return undefined;
+    }
+    return keyActions[name] ?? aliases[name];
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/multiselect.d.ts

@@ -0,0 +1,13 @@
+import { CANCEL } from "./cancel-symbol.js";
+import { type SelectOption } from "./select.js";
+export interface MultiselectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValues?: Value[];
+    required?: boolean;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function multiselectPrompt<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/multiselect.js

@@ -0,0 +1,131 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol } from "./glyphs.js";
+import { Prompt } from "./core.js";
+import { limitOptions } from "./pagination.js";
+import { findNonDisabled } from "./select.js";
+class MultiselectPrompt extends Prompt {
+    options;
+    constructor(opts) {
+        if (opts.options.length === 0) {
+            throw new Error("Multiselect prompt requires at least one option.");
+        }
+        if (opts.options.every((option) => option.disabled)) {
+            throw new Error("Multiselect prompt requires at least one enabled option.");
+        }
+        const cursor = findNonDisabled(0, 1, opts.options);
+        super({
+            ...opts,
+            initialValue: [...(opts.initialValues ?? [])],
+            validate: (value) => {
+                if (opts.required && (!value || value.length === 0)) {
+                    return "Please select at least one option.\nPress SPACE to select, ENTER to submit";
+                }
+                return undefined;
+            },
+            render: (prompt) => renderMultiselectPrompt(prompt, opts)
+        }, false);
+        this.options = opts.options;
+        this._cursor = cursor;
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "left") {
+                this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+            }
+            else if (action === "down" || action === "right") {
+                this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+            }
+            else if (action === "space") {
+                this.toggleFocused();
+            }
+        });
+        this.on("key", (key) => {
+            if (key === "a") {
+                this.toggleAll();
+            }
+            else if (key === "i") {
+                this.invert();
+            }
+        });
+    }
+    get visibleOptions() {
+        return this.options;
+    }
+    enabledOptions() {
+        return this.options.filter((option) => !option.disabled);
+    }
+    toggleFocused() {
+        const option = this.options[this.cursor];
+        if (!option || option.disabled) {
+            return;
+        }
+        this.toggleValue(option.value);
+    }
+    toggleValue(value) {
+        const current = this.value ?? [];
+        this.setValue(current.includes(value)
+            ? current.filter((item) => item !== value)
+            : [...current, value]);
+    }
+    toggleAll() {
+        const enabledValues = this.enabledOptions().map((option) => option.value);
+        const current = this.value ?? [];
+        const allSelected = enabledValues.every((value) => current.includes(value));
+        this.setValue(allSelected ? [] : enabledValues);
+    }
+    invert() {
+        const current = this.value ?? [];
+        this.setValue(this.enabledOptions().map((option) => option.value).filter((value) => !current.includes(value)));
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value ?? []);
+        }
+        return super.promptNonTty();
+    }
+}
+function hasValue(values, value) {
+    return (values ?? []).includes(value);
+}
+function renderOption(option, values, active, submitted, cancelled) {
+    const selected = hasValue(values, option.value);
+    const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+    if (submitted)
+        return color.dim(option.label);
+    if (cancelled)
+        return color.dim.strikethrough(option.label);
+    if (option.disabled)
+        return `${color.gray(GLYPHS.checkboxInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+    if (selected)
+        return `${color.green(GLYPHS.checkboxSelected)} ${active ? option.label : color.dim(option.label)}${hint}`;
+    if (active)
+        return `${color.cyan(GLYPHS.checkboxActive)} ${option.label}${hint}`;
+    return `${color.dim(GLYPHS.checkboxInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderMultiselectPrompt(prompt, opts) {
+    if (prompt.state === "submit" || prompt.state === "cancel") {
+        const labels = prompt.visibleOptions
+            .filter((option) => hasValue(prompt.value, option.value))
+            .map((option) => prompt.state === "submit" ? color.dim(option.label) : color.dim.strikethrough(option.label))
+            .join(", ");
+        const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${labels}\n${end}`;
+    }
+    const lines = limitOptions({
+        cursor: prompt.cursor,
+        options: prompt.visibleOptions,
+        output: opts.output ?? process.stdout,
+        maxItems: opts.maxItems,
+        columnPadding: 3,
+        style: (option, active) => renderOption(option, prompt.value, active, false, false)
+    }).map((line) => `${prompt.state === "error" ? color.yellow(GLYPHS.bar) : color.cyan(GLYPHS.bar)}  ${line}`);
+    const body = [`${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}`, ...lines];
+    if (prompt.state === "error") {
+        body.push(`${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`);
+    }
+    else {
+        body.push(color.cyan(GLYPHS.barEnd));
+    }
+    return body.join("\n");
+}
+export function multiselectPrompt(opts) {
+    return new MultiselectPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/pagination.d.ts

@@ -0,0 +1,10 @@
+export interface PaginationOptions<Option> {
+    cursor: number;
+    options: Option[];
+    style: (option: Option, active: boolean) => string;
+    output: NodeJS.WritableStream;
+    maxItems?: number;
+    columnPadding?: number;
+    rowPadding?: number;
+}
+export declare function limitOptions<Option>(opts: PaginationOptions<Option>): string[];

package/node_modules/toolcraft-design/dist/prompts/interactive/pagination.js

@@ -0,0 +1,52 @@
+import { color } from "../../components/color.js";
+import { GLYPHS } from "./glyphs.js";
+import { getColumns, getRows } from "./wrap.js";
+import { wrapAnsi } from "fast-wrap-ansi";
+function countLines(values) {
+    return values.reduce((sum, value) => sum + value.split("\n").length, 0);
+}
+function trimToRows(values, cursorOffset, rows, hasTop, hasBottom) {
+    const output = [...values];
+    while (countLines(output) > rows && output.length > 1) {
+        const removeFromTop = hasTop && cursorOffset > 0;
+        const removeFromBottom = hasBottom && cursorOffset < output.length - 1;
+        if (removeFromTop) {
+            output.shift();
+            cursorOffset -= 1;
+        }
+        else if (removeFromBottom) {
+            output.pop();
+        }
+        else {
+            output.pop();
+        }
+    }
+    return output;
+}
+export function limitOptions(opts) {
+    const { cursor, options, style, output, maxItems = Number.POSITIVE_INFINITY, columnPadding = 0, rowPadding = 4 } = opts;
+    if (options.length === 0) {
+        return [];
+    }
+    const columns = Math.max(1, getColumns(output) - columnPadding);
+    const rowBudget = Math.max(getRows(output) - rowPadding, 0);
+    const visibleCount = Math.max(Math.min(maxItems, rowBudget), 5);
+    const cappedVisibleCount = Math.min(visibleCount, options.length);
+    let start = 0;
+    if (cursor >= cappedVisibleCount - 3) {
+        start = Math.max(Math.min(cursor - cappedVisibleCount + 3, options.length - cappedVisibleCount), 0);
+    }
+    const hasTopMarker = cappedVisibleCount < options.length && start > 0;
+    const hasBottomMarker = cappedVisibleCount < options.length && start + cappedVisibleCount < options.length;
+    const visible = options
+        .slice(start, start + cappedVisibleCount)
+        .map((option, index) => wrapAnsi(style(option, start + index === cursor), columns, { hard: true, trim: false }));
+    const trimmed = trimToRows(visible, Math.max(cursor - start, 0), Math.max(rowBudget - Number(hasTopMarker) - Number(hasBottomMarker), 1), hasTopMarker, hasBottomMarker);
+    if (hasTopMarker) {
+        trimmed.unshift(color.dim(GLYPHS.ellipsis));
+    }
+    if (hasBottomMarker) {
+        trimmed.push(color.dim(GLYPHS.ellipsis));
+    }
+    return trimmed;
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/password.d.ts

@@ -0,0 +1,10 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function passwordPrompt(opts: PasswordOptions): Promise<string | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/password.js

@@ -0,0 +1,55 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class PasswordPrompt extends Prompt {
+    mask;
+    constructor(opts) {
+        super({
+            ...opts,
+            initialValue: "",
+            initialUserInput: "",
+            render: (prompt) => renderPasswordPrompt(prompt, opts),
+            validate: opts.validate
+        });
+        this.mask = opts.mask ?? GLYPHS.passwordMask;
+        this.on("userInput", (value) => this.setValue(value));
+    }
+    get masked() {
+        return this.mask.repeat(this.userInput.length);
+    }
+    get userInputWithCursor() {
+        if (this.state === "submit") {
+            return this.masked;
+        }
+        const masked = this.masked;
+        const before = masked.slice(0, this.cursor);
+        const current = masked[this.cursor];
+        const after = masked.slice(this.cursor + 1);
+        if (current) {
+            return `${before}${color.inverse(current)}${after}`;
+        }
+        return `${before}${color.inverse("█")}`;
+    }
+    promptNonTty() {
+        return this.readNonTtyLine();
+    }
+}
+function renderHeader(prompt, message) {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message}`;
+}
+function renderPasswordPrompt(prompt, opts) {
+    const value = prompt.masked;
+    if (prompt.state === "submit") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim(value)}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "error") {
+        return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${prompt.userInputWithCursor}\n${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+    }
+    return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${prompt.userInputWithCursor}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function passwordPrompt(opts) {
+    return new PasswordPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/select.d.ts

@@ -0,0 +1,18 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface SelectOption<Value> {
+    value: Value;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+export interface SelectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function findNonDisabled<Value>(start: number, direction: 1 | -1, options: Array<SelectOption<Value>>): number;
+export declare function selectPrompt<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/select.js

@@ -0,0 +1,89 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol } from "./glyphs.js";
+import { Prompt } from "./core.js";
+import { limitOptions } from "./pagination.js";
+class SelectPrompt extends Prompt {
+    options;
+    constructor(opts) {
+        if (opts.options.length === 0) {
+            throw new Error("Select prompt requires at least one option.");
+        }
+        if (opts.options.every((option) => option.disabled)) {
+            throw new Error("Select prompt requires at least one enabled option.");
+        }
+        const initialIndex = Math.max(opts.options.findIndex((option) => option.value === opts.initialValue), 0);
+        const cursor = findNonDisabled(initialIndex, 1, opts.options);
+        super({
+            ...opts,
+            initialValue: opts.options[cursor]?.value,
+            render: (prompt) => renderSelectPrompt(prompt, opts)
+        }, false);
+        this.options = opts.options;
+        this._cursor = cursor;
+        this.setValue(this.options[this._cursor]?.value);
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "left") {
+                this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+            }
+            else if (action === "down" || action === "right") {
+                this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+            }
+            this.setValue(this.options[this._cursor]?.value);
+        });
+    }
+    get visibleOptions() {
+        return this.options;
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value);
+        }
+        return super.promptNonTty();
+    }
+}
+export function findNonDisabled(start, direction, options) {
+    if (options.every((option) => option.disabled)) {
+        return start;
+    }
+    let index = start;
+    for (let checked = 0; checked < options.length; checked += 1) {
+        index = (index + options.length) % options.length;
+        if (!options[index]?.disabled) {
+            return index;
+        }
+        index += direction;
+    }
+    return start;
+}
+function renderOption(option, active, submitted, cancelled) {
+    const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+    if (submitted)
+        return color.dim(option.label);
+    if (cancelled)
+        return color.dim.strikethrough(option.label);
+    if (option.disabled)
+        return `${color.gray(GLYPHS.radioInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+    if (active)
+        return `${color.green(GLYPHS.radioActive)} ${option.label}${hint}`;
+    return `${color.dim(GLYPHS.radioInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderSelectPrompt(prompt, opts) {
+    if (prompt.state === "submit" || prompt.state === "cancel") {
+        const option = prompt.visibleOptions[prompt.cursor];
+        const rendered = option ? renderOption(option, false, prompt.state === "submit", prompt.state === "cancel") : "";
+        const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${rendered}\n${end}`;
+    }
+    const lines = limitOptions({
+        cursor: prompt.cursor,
+        options: prompt.visibleOptions,
+        output: opts.output ?? process.stdout,
+        maxItems: opts.maxItems,
+        columnPadding: 3,
+        style: (option, active) => renderOption(option, active, false, false)
+    }).map((line) => `${color.cyan(GLYPHS.bar)}  ${line}`);
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${lines.join("\n")}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function selectPrompt(opts) {
+    return new SelectPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.d.ts

@@ -0,0 +1,21 @@
+import { PassThrough, Writable } from "node:stream";
+export interface PromptHarness {
+    input: PassThrough & {
+        isTTY?: boolean;
+        setRawMode?: (enabled: boolean) => void;
+    };
+    output: Writable & {
+        columns?: number;
+        rows?: number;
+        isTTY?: boolean;
+        frames: string[];
+    };
+    rawModes: boolean[];
+    getOutput: () => string;
+}
+export declare function createPromptHarness(options?: {
+    tty?: boolean;
+    columns?: number;
+    rows?: number;
+}): PromptHarness;
+export declare function tick(): Promise<void>;

package/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.js

@@ -0,0 +1,32 @@
+import { PassThrough, Writable } from "node:stream";
+export function createPromptHarness(options = {}) {
+    const chunks = [];
+    const frames = [];
+    const rawModes = [];
+    const input = new PassThrough();
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            const value = String(chunk);
+            chunks.push(value);
+            frames.push(value);
+            callback();
+        }
+    });
+    input.isTTY = options.tty ?? true;
+    input.setRawMode = (enabled) => {
+        rawModes.push(enabled);
+    };
+    output.isTTY = options.tty ?? true;
+    output.columns = options.columns ?? 80;
+    output.rows = options.rows ?? 20;
+    output.frames = frames;
+    return {
+        input,
+        output,
+        rawModes,
+        getOutput: () => chunks.join("")
+    };
+}
+export async function tick() {
+    await new Promise((resolve) => setImmediate(resolve));
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/text.d.ts

@@ -0,0 +1,12 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function textPrompt(opts: TextOptions): Promise<string | typeof CANCEL>;

package/node_modules/toolcraft-design/dist/prompts/interactive/text.js

@@ -0,0 +1,60 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class TextPrompt extends Prompt {
+    constructor(opts) {
+        const initialUserInput = opts.initialValue ?? "";
+        super({
+            ...opts,
+            initialValue: initialUserInput,
+            initialUserInput,
+            render: (prompt) => renderTextPrompt(prompt, opts),
+            validate: opts.validate
+        });
+        this.on("userInput", (value) => this.setValue(value));
+        this.on("finalize", () => {
+            if (this.state === "submit") {
+                this.setValue(this.value || opts.defaultValue || "");
+            }
+        });
+    }
+    get userInputWithCursor() {
+        if (this.state === "submit") {
+            return this.userInput;
+        }
+        const before = this.userInput.slice(0, this.cursor);
+        const current = this.userInput[this.cursor];
+        const after = this.userInput.slice(this.cursor + 1);
+        if (current) {
+            return `${before}${color.inverse(current)}${after}`;
+        }
+        return `${before}${color.inverse("█")}`;
+    }
+    promptNonTty() {
+        return this.readNonTtyLine();
+    }
+}
+function renderHeader(prompt, message) {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message}`;
+}
+function renderTextPrompt(prompt, opts) {
+    const value = prompt.value ?? "";
+    if (prompt.state === "submit") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim(value)}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    const input = prompt.userInput.length > 0
+        ? prompt.userInputWithCursor
+        : opts.placeholder
+            ? `${color.inverse(opts.placeholder[0] ?? " ")}${color.dim(opts.placeholder.slice(1))}`
+            : color.inverse("_");
+    if (prompt.state === "error") {
+        return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+    }
+    return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function textPrompt(opts) {
+    return new TextPrompt(opts).prompt();
+}

package/node_modules/toolcraft-design/dist/prompts/interactive/wrap.d.ts

@@ -0,0 +1,4 @@
+export declare function getColumns(output: NodeJS.WritableStream): number;
+export declare function getRows(output: NodeJS.WritableStream): number;
+export declare function wrapTextWithPrefix(output: NodeJS.WritableStream, text: string, prefix: string, startPrefix?: string): string;
+export declare function wrapFrame(output: NodeJS.WritableStream, frame: string): string;

package/node_modules/toolcraft-design/dist/prompts/interactive/wrap.js

@@ -0,0 +1,18 @@
+import { wrapAnsi } from "fast-wrap-ansi";
+import stringWidth from "fast-string-width";
+export function getColumns(output) {
+    return Math.max(1, output.columns ?? 80);
+}
+export function getRows(output) {
+    return Math.max(1, output.rows ?? 20);
+}
+export function wrapTextWithPrefix(output, text, prefix, startPrefix = prefix) {
+    const width = Math.max(1, getColumns(output) - stringWidth(prefix));
+    return wrapAnsi(text, width, { hard: true, trim: false })
+        .split("\n")
+        .map((line, index) => `${index === 0 ? startPrefix : prefix}${line}`)
+        .join("\n");
+}
+export function wrapFrame(output, frame) {
+    return wrapAnsi(frame, getColumns(output), { hard: true, trim: false });
+}

package/node_modules/toolcraft-design/dist/prompts/primitives/cancel.d.ts

@@ -0,0 +1,2 @@
+export { isCancel } from "../interactive/cancel-symbol.js";
+export declare function cancel(msg?: string): void;