@felan-ai/felan 0.28.4 → 0.31.0

package/dist/tui/renderers/ask-user.js

@@ -0,0 +1,1348 @@
+import { decodeUiMarkdown } from '../../client/ui.js';
+import { createRequire } from 'node:module';
+import { Container, decodeKittyPrintable, Editor, fuzzyFilter, Key, matchesKey, Spacer, Text, truncateToWidth, wrapTextWithAnsi, } from '@earendil-works/pi-tui';
+import { normalizeAskUserOption } from '@felan-ai/ext-ask-user/data';
+import { renderSingleSelectRows } from './ask-user/single-select-layout.js';
+import { DEFAULT_ASK_USER_CONFIG, normalizeAskUserShortcut } from '../ask-user-preferences.js';
+export { ASK_USER_FORM_HINT } from '@felan-ai/ext-ask-user/data';
+const VERSION = createRequire(import.meta.url)('../../../package.json').version;
+const BOX_LEFT = '│ ';
+const BOX_RIGHT = ' │';
+const BOX_OVERHEAD = BOX_LEFT.length + BOX_RIGHT.length;
+const OVERLAY_MAX_HEIGHT_RATIO = 0.85;
+const OVERLAY_MIN_RENDER_LINES = 8;
+const OVERLAY_WIDTH = '92%';
+const OVERLAY_MAX_HEIGHT = '85%';
+const OVERLAY_MIN_WIDTH = 40;
+const SPLIT_PANE_MIN_WIDTH = 84;
+const SPLIT_LEFT_MIN_WIDTH = 32;
+const SPLIT_RIGHT_MIN_WIDTH = 28;
+const SPLIT_SEPARATOR = ' │ ';
+const COMMENT_LABEL = 'Add extra context after selection';
+const DEFAULT_OVERLAY_TOGGLE = 'alt+o';
+const DEFAULT_COMMENT_TOGGLE = 'ctrl+g';
+const CONTEXT_TOGGLE_KEY = Key.ctrl('e');
+const INLINE_CONTEXT_MAX_ROWS = 3;
+const FREEFORM_SENTINEL = 'Type custom response...';
+const DISABLED_SHORTCUT = {
+    disabled: true,
+    spec: null,
+    matches: (_data) => false,
+};
+export function createTuiAskUserPresenter(config = {}) {
+    const defaults = { ...DEFAULT_ASK_USER_CONFIG, ...config };
+    return { present: (request, context) => presentAskUser(request, {
+            ...context, mode: 'tui', hasUI: true, reportProgress: context.reportProgress ?? (() => { }),
+        }, defaults) };
+}
+export async function presentAskUserForm(form, context, config = {}) {
+    const ids = [...new Set(form.input.fields.map(field => field.id.replace(/\.(mode|selection|text|comment)$/u, '')))];
+    const sections = form.markdown?.split(/^## Question \d+: /mu).slice(1) ?? [];
+    const questions = ids.map((id, index) => {
+        const selection = form.input.fields.find(field => field.id === `${id}.selection`);
+        const section = sections[index] ?? '';
+        const newline = section.indexOf('\n');
+        const header = newline < 0 ? `Q${index + 1}` : section.slice(0, newline);
+        const body = section.slice(newline + 1).trim();
+        const choicesAt = body.indexOf('\n\n- ');
+        const skipAt = body.lastIndexOf('\n\nChoose an answer type.');
+        const content = choicesAt >= 0 ? body.slice(0, choicesAt) : skipAt >= 0 ? body.slice(0, skipAt) : body;
+        const [question, ...context] = content.split('\n\n');
+        const choices = choicesAt < 0 ? [] : body.slice(choicesAt + 4, body.lastIndexOf('\n\nSelect ')).split('\n- ').map(formLiteral);
+        const options = selection?.kind === 'enum' || selection?.kind === 'multi_select' ? selection.options : [];
+        const numbered = new Set(options.map(option => option.label)).size !== options.length;
+        return {
+            id, header: formLiteral(header), question: formLiteral(question || form.title),
+            ...(context.length ? { context: formLiteral(context.join('\n\n')) } : {}),
+            options: options.map((option, index) => {
+                const title = option.label.replace(/[\u0000-\u001f\u007f-\u009f]/gu, '');
+                const choice = choices[index];
+                const description = choice?.startsWith(`${option.label}: `) ? choice.slice(option.label.length + 2) : undefined;
+                return { title: numbered ? `${index + 1}. ${title}` : title, ...(description === undefined ? {} : { description }) };
+            }),
+            allowMultiple: selection?.kind === 'multi_select',
+            allowFreeform: form.input.fields.some(field => field.id === `${id}.text` && field.kind === 'string'),
+            allowComment: form.input.fields.some(field => field.id === `${id}.comment` && field.kind === 'string'),
+        };
+    });
+    const result = await createTuiAskUserPresenter(config).present({ questions }, context);
+    if (context.signal.aborted)
+        return undefined;
+    const action = form.actions.find(action => action.id === (result.status === 'answered' ? 'submit' : 'cancel'));
+    if (!action)
+        throw new Error('Ask-user form is missing its response action.');
+    const values = {};
+    if (result.status === 'answered')
+        for (const question of questions) {
+            const response = result.answers.find(answer => answer.questionId === question.id)?.response;
+            const mode = response?.kind ?? 'skip';
+            if (form.input.fields.some(field => field.id === `${question.id}.mode`))
+                values[`${question.id}.mode`] = mode;
+            if (response?.kind === 'freeform')
+                values[`${question.id}.text`] = response.text;
+            if (response?.kind === 'selection') {
+                const field = form.input.fields.find(field => field.id === `${question.id}.selection`);
+                if (field?.kind !== 'enum' && field?.kind !== 'multi_select')
+                    throw new Error('Ask-user selection field is missing.');
+                const selected = response.selections.map(title => {
+                    const option = field.options[question.options.findIndex(option => option.title === title)];
+                    if (!option)
+                        throw new Error('Ask-user returned an undeclared selection.');
+                    return option.id;
+                });
+                values[field.id] = field.kind === 'multi_select' ? selected : selected[0];
+                if (response.comment !== undefined)
+                    values[`${question.id}.comment`] = response.comment;
+            }
+        }
+    return { kind: 'form', actionId: action.id, outcome: action.outcome, values };
+}
+function formLiteral(value) {
+    return decodeUiMarkdown(value, { plainText: true }).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu, '');
+}
+async function presentAskUser(request, execution, config) {
+    if (execution.signal.aborted)
+        return { status: 'cancelled', reason: 'abort' };
+    const ctx = execution;
+    if (!ctx.hasUI || (ctx.mode !== 'tui' && ctx.mode !== 'rpc')) {
+        return {
+            status: 'cancelled',
+            reason: 'unavailable',
+            message: `ask_user requires TUI or RPC dialog mode; current mode is ${ctx.mode}`,
+        };
+    }
+    const displayMode = request.displayMode ?? config.displayMode;
+    const singleSelectLayout = request.singleSelectLayout ?? config.singleSelectLayout;
+    const shortcuts = {
+        overlayToggle: resolveShortcut(request.overlayToggleKey, config.overlayToggleKey, DEFAULT_OVERLAY_TOGGLE),
+        commentToggle: resolveShortcut(request.commentToggleKey, config.commentToggleKey, DEFAULT_COMMENT_TOGGLE),
+    };
+    let timedOut = false;
+    let aborted = false;
+    if (ctx.mode === 'rpc') {
+        const dialogResult = await askQuestionsViaDialogs(ctx.ui, request.questions, request.timeout, execution.signal);
+        if (dialogResult.cancelled)
+            return { status: 'cancelled', reason: dialogResult.cancelled };
+        return dialogResult.answers.some((answer) => answer.response !== null)
+            ? { status: 'answered', answers: dialogResult.answers }
+            : { status: 'cancelled', reason: 'user' };
+    }
+    let overlayHandle;
+    let removeOverlayListener;
+    let removeAbortListener;
+    let timeoutHandle;
+    let announcedHidden = false;
+    try {
+        const overlayToggle = shortcuts.overlayToggle;
+        if (displayMode === 'overlay' && !overlayToggle.disabled && typeof ctx.ui.onTerminalInput === 'function') {
+            removeOverlayListener = ctx.ui.onTerminalInput((data) => {
+                if (!overlayHandle || !overlayToggle.matches(data))
+                    return undefined;
+                const hidden = !overlayHandle.isHidden();
+                overlayHandle.setHidden(hidden);
+                if (hidden && !announcedHidden) {
+                    announcedHidden = true;
+                    ctx.ui.notify?.(`ask_user hidden — press ${overlayToggle.spec} to reopen`, 'info');
+                }
+                return { consume: true };
+            });
+        }
+        const result = await ctx.ui.custom((tui, theme, keybindings, done) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                done(value);
+            };
+            const onAbort = () => {
+                aborted = true;
+                finish(null);
+            };
+            execution.signal.addEventListener('abort', onAbort, { once: true });
+            removeAbortListener = () => execution.signal.removeEventListener('abort', onAbort);
+            if (request.timeout !== undefined) {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    finish(null);
+                }, request.timeout);
+            }
+            if (request.questions.length === 1) {
+                const question = request.questions[0];
+                return new AskPrompt(question, displayMode, singleSelectLayout, tui, theme, keybindings, shortcuts, (response) => finish(response === null ? null : [{ questionId: question.id, response }]));
+            }
+            return new AskWizard(request.questions, displayMode, singleSelectLayout, tui, theme, keybindings, shortcuts, execution.reportProgress, finish);
+        }, customUIOptions(displayMode, (handle) => {
+            overlayHandle = handle;
+        }));
+        if (result === undefined) {
+            const dialogResult = await askQuestionsViaDialogs(ctx.ui, request.questions, request.timeout, execution.signal);
+            if (dialogResult.cancelled)
+                return { status: 'cancelled', reason: dialogResult.cancelled };
+            return dialogResult.answers.some((answer) => answer.response !== null)
+                ? { status: 'answered', answers: dialogResult.answers }
+                : { status: 'cancelled', reason: 'user' };
+        }
+        if (result === null) {
+            return {
+                status: 'cancelled',
+                reason: timedOut ? 'timeout' : aborted || execution.signal.aborted ? 'abort' : 'user',
+            };
+        }
+        return { status: 'answered', answers: result };
+    }
+    finally {
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+        removeAbortListener?.();
+        removeOverlayListener?.();
+    }
+}
+function resolveShortcut(parameter, configuredDefault, fallback) {
+    for (const value of [parameter, configuredDefault, fallback]) {
+        if (value === undefined)
+            continue;
+        if (value === null)
+            return DISABLED_SHORTCUT;
+        const normalized = normalizeAskUserShortcut(value);
+        if (normalized === undefined)
+            continue;
+        if (normalized === null)
+            return DISABLED_SHORTCUT;
+        return { disabled: false, spec: normalized, matches: (data) => matchesKey(data, normalized) };
+    }
+    return DISABLED_SHORTCUT;
+}
+function customUIOptions(displayMode, onHandle) {
+    if (displayMode === 'inline')
+        return undefined;
+    return {
+        overlay: true,
+        overlayOptions: {
+            anchor: 'center',
+            width: OVERLAY_WIDTH,
+            minWidth: OVERLAY_MIN_WIDTH,
+            maxHeight: OVERLAY_MAX_HEIGHT,
+            margin: 1,
+        },
+        onHandle,
+    };
+}
+function overlayMaxRenderLines(terminalRows) {
+    const rows = Number.isFinite(terminalRows) ? Math.max(1, Math.floor(terminalRows)) : 24;
+    const availableRows = Math.max(1, rows - 2);
+    const ratioRows = Math.max(1, Math.floor(rows * OVERLAY_MAX_HEIGHT_RATIO));
+    const minimumRows = Math.min(OVERLAY_MIN_RENDER_LINES, availableRows);
+    return Math.min(availableRows, Math.max(minimumRows, ratioRows));
+}
+class BorderTop {
+    color;
+    title;
+    titleColor;
+    constructor(color, title, titleColor) {
+        this.color = color;
+        this.title = title;
+        this.titleColor = titleColor;
+    }
+    invalidate() { }
+    render(width) {
+        const inner = Math.max(0, width - 2);
+        if (inner < this.title.length + 4)
+            return [this.color(`╭${'─'.repeat(inner)}╮`)];
+        const label = ` ${this.title} `;
+        return [
+            this.color('╭─')
+                + this.titleColor(label)
+                + this.color(`${'─'.repeat(Math.max(0, inner - label.length - 1))}╮`),
+        ];
+    }
+}
+class BorderBottom {
+    color;
+    label;
+    labelColor;
+    constructor(color, label, labelColor) {
+        this.color = color;
+        this.label = label;
+        this.labelColor = labelColor;
+    }
+    invalidate() { }
+    render(width) {
+        const inner = Math.max(0, width - 2);
+        if (inner < this.label.length + 4)
+            return [this.color(`╰${'─'.repeat(inner)}╯`)];
+        const tag = ` ${this.label} `;
+        return [
+            this.color(`╰${'─'.repeat(Math.max(0, inner - tag.length - 1))}`)
+                + this.labelColor(tag)
+                + this.color('─╯'),
+        ];
+    }
+}
+function createEditorTheme(theme) {
+    return {
+        borderColor: (text) => theme.fg('accent', text),
+        selectList: {
+            selectedPrefix: (text) => theme.fg('accent', text),
+            selectedText: (text) => theme.fg('accent', text),
+            description: (text) => theme.fg('muted', text),
+            scrollInfo: (text) => theme.fg('dim', text),
+            noMatch: (text) => theme.fg('warning', text),
+        },
+    };
+}
+function keyHint(theme, keybindings, binding, description) {
+    return `${theme.fg('dim', keybindings.getKeys(binding).join('/'))}${theme.fg('muted', ` ${description}`)}`;
+}
+function literalHint(theme, key, description) {
+    return `${theme.fg('dim', key)}${theme.fg('muted', ` ${description}`)}`;
+}
+function matchesUp(data, keybindings) {
+    return keybindings.matches(data, 'tui.select.up')
+        || matchesKey(data, Key.shift('tab'))
+        || matchesKey(data, Key.ctrl('k'));
+}
+function matchesDown(data, keybindings) {
+    return keybindings.matches(data, 'tui.select.down')
+        || matchesKey(data, Key.tab)
+        || matchesKey(data, Key.ctrl('j'));
+}
+function matchesSubmit(data, keybindings) {
+    return keybindings.matches(data, 'tui.select.confirm')
+        || keybindings.matches(data, 'tui.input.submit')
+        || matchesKey(data, Key.enter)
+        || matchesKey(data, Key.return);
+}
+class MultiSelectList {
+    options;
+    allowFreeform;
+    allowComment;
+    theme;
+    keybindings;
+    commentToggle;
+    selectedIndex = 0;
+    checked = new Set();
+    commentEnabled = false;
+    maxVisibleRows = 10;
+    cachedWidth;
+    cachedLines;
+    onCancel;
+    onSubmit;
+    onEnterFreeform;
+    constructor(options, allowFreeform, allowComment, theme, keybindings, commentToggle) {
+        this.options = options;
+        this.allowFreeform = allowFreeform;
+        this.allowComment = allowComment;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.commentToggle = commentToggle;
+    }
+    setMaxVisibleRows(rows) {
+        const normalized = Math.max(1, Math.floor(rows));
+        if (normalized !== this.maxVisibleRows) {
+            this.maxVisibleRows = normalized;
+            this.invalidate();
+        }
+    }
+    invalidate() {
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    handleInput(data) {
+        if (this.keybindings.matches(data, 'tui.select.cancel'))
+            return this.onCancel?.();
+        const count = this.itemCount();
+        if (count === 0)
+            return this.onCancel?.();
+        if (this.allowComment && !this.commentToggle.disabled && this.commentToggle.matches(data)) {
+            this.toggleComment();
+            return;
+        }
+        if (matchesUp(data, this.keybindings)) {
+            this.selectedIndex = this.selectedIndex === 0 ? count - 1 : this.selectedIndex - 1;
+            this.invalidate();
+            return;
+        }
+        if (matchesDown(data, this.keybindings)) {
+            this.selectedIndex = this.selectedIndex === count - 1 ? 0 : this.selectedIndex + 1;
+            this.invalidate();
+            return;
+        }
+        const number = data.match(/^[1-9]$/);
+        if (number) {
+            const index = Number(number[0]) - 1;
+            if (index < this.options.length) {
+                this.toggle(index);
+                this.selectedIndex = index;
+                this.invalidate();
+            }
+            return;
+        }
+        if (matchesKey(data, Key.space)) {
+            if (this.isCommentRow(this.selectedIndex))
+                return this.toggleComment();
+            if (this.isFreeformRow(this.selectedIndex))
+                return this.onEnterFreeform?.();
+            this.toggle(this.selectedIndex);
+            this.invalidate();
+            return;
+        }
+        if (!matchesSubmit(data, this.keybindings))
+            return;
+        if (this.isCommentRow(this.selectedIndex))
+            return this.toggleComment();
+        if (this.isFreeformRow(this.selectedIndex))
+            return this.onEnterFreeform?.();
+        const selections = [...this.checked]
+            .sort((left, right) => left - right)
+            .map((index) => this.options[index]?.title)
+            .filter((title) => title !== undefined);
+        const fallback = this.options[this.selectedIndex]?.title;
+        const result = selections.length > 0 ? selections : fallback ? [fallback] : [];
+        if (result.length > 0)
+            this.onSubmit?.(result, this.commentEnabled);
+        else
+            this.onCancel?.();
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width)
+            return this.cachedLines;
+        const count = this.itemCount();
+        if (count === 0)
+            return [this.theme.fg('warning', 'No options')];
+        const blocks = [];
+        for (let index = 0; index < count; index += 1) {
+            const active = index === this.selectedIndex;
+            const pointer = active ? this.theme.fg('accent', '→') : ' ';
+            const block = [];
+            if (this.isCommentRow(index)) {
+                const check = this.commentEnabled ? this.theme.fg('success', '[✓]') : this.theme.fg('dim', '[ ]');
+                block.push(truncateToWidth(`${pointer}   ${check} ${this.theme.fg(active ? 'accent' : 'text', COMMENT_LABEL)}`, width, ''));
+                blocks.push(block);
+                continue;
+            }
+            if (this.isFreeformRow(index)) {
+                block.push(truncateToWidth(`${pointer}   ${this.theme.fg(active ? 'accent' : 'text', 'Type something.')} ${this.theme.fg('muted', '— Enter a custom response')}`, width, ''));
+                blocks.push(block);
+                continue;
+            }
+            const option = this.options[index];
+            const check = this.checked.has(index) ? this.theme.fg('success', '[✓]') : this.theme.fg('dim', '[ ]');
+            block.push(truncateToWidth(`${pointer} ${this.theme.fg('dim', `${index + 1}.`)} ${check} ${this.theme.fg(active ? 'accent' : 'text', this.theme.bold(option.title))}`, width, ''));
+            if (option.description) {
+                for (const line of wrapTextWithAnsi(option.description, Math.max(10, width - 6))) {
+                    block.push(truncateToWidth(`      ${this.theme.fg('muted', line)}`, width, ''));
+                }
+            }
+            blocks.push(block);
+        }
+        const totalRows = blocks.reduce((sum, block) => sum + block.length, 0);
+        let lines;
+        if (totalRows <= this.maxVisibleRows) {
+            lines = blocks.flat();
+        }
+        else {
+            const availableRows = this.maxVisibleRows > 1 ? this.maxVisibleRows - 1 : 1;
+            const selectedBlock = blocks[this.selectedIndex] ?? blocks[0] ?? [];
+            if (selectedBlock.length >= availableRows) {
+                lines = selectedBlock.slice(0, availableRows);
+            }
+            else {
+                let start = this.selectedIndex;
+                let end = this.selectedIndex + 1;
+                let usedRows = selectedBlock.length;
+                while (true) {
+                    const next = blocks[end];
+                    if (next && usedRows + next.length <= availableRows) {
+                        usedRows += next.length;
+                        end += 1;
+                        continue;
+                    }
+                    const previous = blocks[start - 1];
+                    if (previous && usedRows + previous.length <= availableRows) {
+                        start -= 1;
+                        usedRows += previous.length;
+                        continue;
+                    }
+                    break;
+                }
+                lines = blocks.slice(start, end).flat();
+            }
+            if (this.maxVisibleRows > 1) {
+                lines.push(this.theme.fg('dim', truncateToWidth(`  (${this.selectedIndex + 1}/${count})`, width, '')));
+            }
+        }
+        this.cachedWidth = width;
+        this.cachedLines = lines;
+        return lines;
+    }
+    itemCount() {
+        return this.options.length + (this.allowComment ? 1 : 0) + (this.allowFreeform ? 1 : 0);
+    }
+    isCommentRow(index) {
+        return this.allowComment && index === this.options.length;
+    }
+    isFreeformRow(index) {
+        return this.allowFreeform && index === this.options.length + (this.allowComment ? 1 : 0);
+    }
+    toggle(index) {
+        if (index < 0 || index >= this.options.length)
+            return;
+        if (this.checked.has(index))
+            this.checked.delete(index);
+        else
+            this.checked.add(index);
+    }
+    toggleComment() {
+        if (!this.allowComment)
+            return;
+        this.commentEnabled = !this.commentEnabled;
+        this.invalidate();
+    }
+}
+class SearchableSingleSelect {
+    options;
+    allowFreeform;
+    allowComment;
+    theme;
+    singleSelectLayout;
+    keybindings;
+    commentToggle;
+    selectedIndex = 0;
+    searchQuery = '';
+    commentEnabled = false;
+    maxVisibleRows = 12;
+    cachedWidth;
+    cachedLines;
+    onCancel;
+    onSubmit;
+    onEnterFreeform;
+    constructor(options, allowFreeform, allowComment, theme, singleSelectLayout, keybindings, commentToggle) {
+        this.options = options;
+        this.allowFreeform = allowFreeform;
+        this.allowComment = allowComment;
+        this.theme = theme;
+        this.singleSelectLayout = singleSelectLayout;
+        this.keybindings = keybindings;
+        this.commentToggle = commentToggle;
+    }
+    setMaxVisibleRows(rows) {
+        const normalized = Math.max(1, Math.floor(rows));
+        if (normalized !== this.maxVisibleRows) {
+            this.maxVisibleRows = normalized;
+            this.invalidate();
+        }
+    }
+    invalidate() {
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    handleInput(data) {
+        if (this.searchQuery && matchesKey(data, Key.escape)) {
+            this.setSearch('');
+            return;
+        }
+        if (this.keybindings.matches(data, 'tui.select.cancel'))
+            return this.onCancel?.();
+        if (this.allowComment && !this.commentToggle.disabled && this.commentToggle.matches(data)) {
+            this.toggleComment();
+            return;
+        }
+        const filtered = this.filtered();
+        const count = this.itemCount(filtered);
+        if (matchesUp(data, this.keybindings) && count > 0) {
+            this.selectedIndex = this.selectedIndex === 0 ? count - 1 : this.selectedIndex - 1;
+            this.invalidate();
+            return;
+        }
+        if (matchesDown(data, this.keybindings) && count > 0) {
+            this.selectedIndex = this.selectedIndex === count - 1 ? 0 : this.selectedIndex + 1;
+            this.invalidate();
+            return;
+        }
+        const number = data.match(/^[1-9]$/);
+        if (number && Number(number[0]) <= filtered.length) {
+            this.selectedIndex = Number(number[0]) - 1;
+            this.invalidate();
+            return;
+        }
+        if (matchesKey(data, Key.space) && this.isCommentRow(this.selectedIndex, filtered)) {
+            this.toggleComment();
+            return;
+        }
+        if (matchesSubmit(data, this.keybindings) && count > 0) {
+            if (this.isCommentRow(this.selectedIndex, filtered))
+                return this.toggleComment();
+            if (this.isFreeformRow(this.selectedIndex, filtered))
+                return this.onEnterFreeform?.();
+            const selected = filtered[this.selectedIndex]?.title;
+            if (selected)
+                this.onSubmit?.(selected, this.commentEnabled);
+            else
+                this.onCancel?.();
+            return;
+        }
+        if (this.keybindings.matches(data, 'tui.editor.deleteCharBackward') || matchesKey(data, Key.backspace)) {
+            const characters = [...this.searchQuery];
+            characters.pop();
+            this.setSearch(characters.join(''));
+            return;
+        }
+        const printable = printableInput(data);
+        if (printable)
+            this.setSearch(this.searchQuery + printable);
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width)
+            return this.cachedLines;
+        const filtered = this.filtered();
+        const count = this.itemCount(filtered);
+        this.selectedIndex = count > 0 ? Math.min(this.selectedIndex, count - 1) : 0;
+        const split = this.singleSelectLayout === 'list' ? null : splitPaneWidths(width);
+        const lines = split
+            ? this.renderSplit(split.left, split.right, filtered)
+            : this.renderList(width, filtered, false);
+        this.cachedWidth = width;
+        this.cachedLines = lines;
+        return lines;
+    }
+    renderList(width, filtered, hideDescriptions) {
+        const query = this.searchQuery ? this.theme.fg('text', this.searchQuery) : this.theme.fg('dim', 'type to filter');
+        const header = [truncateToWidth(`${this.theme.fg('accent', 'Filter:')} ${query}`, width, '')];
+        if (this.searchQuery && filtered.length === 0)
+            header.push(this.theme.fg('warning', 'No matching options'));
+        const rows = renderSingleSelectRows({
+            options: filtered,
+            selectedIndex: this.selectedIndex,
+            width,
+            allowFreeform: this.allowFreeform,
+            allowComment: this.allowComment,
+            commentEnabled: this.commentEnabled,
+            maxRows: Math.max(1, this.maxVisibleRows - header.length),
+            hideDescriptions,
+        });
+        const renderedRows = rows.map((row) => this.styleLine(row.line, width, row.selected));
+        if (this.maxVisibleRows === 1)
+            return renderedRows.length > 0 ? [renderedRows[0]] : header.slice(-1);
+        return [...header, ...renderedRows].slice(0, this.maxVisibleRows);
+    }
+    renderSplit(leftWidth, rightWidth, filtered) {
+        const left = this.renderList(leftWidth, filtered, true);
+        const right = this.preview(rightWidth, filtered);
+        const rows = Math.min(this.maxVisibleRows, Math.max(left.length, right.length));
+        return Array.from({ length: rows }, (_, index) => (`${truncateToWidth(left[index] ?? '', leftWidth, '', true)}${this.theme.fg('dim', SPLIT_SEPARATOR)}${truncateToWidth(right[index] ?? '', rightWidth, '')}`));
+    }
+    preview(width, filtered) {
+        let title;
+        let description;
+        if (this.isCommentRow(this.selectedIndex, filtered)) {
+            title = 'Additional context';
+            description = `Currently ${this.commentEnabled ? 'enabled' : 'disabled'}. Add an explanation after selecting.`;
+        }
+        else if (this.isFreeformRow(this.selectedIndex, filtered)) {
+            title = 'Custom response';
+            description = 'Open the editor to write an answer when none of the listed options fit.';
+        }
+        else {
+            const selected = filtered[this.selectedIndex];
+            title = selected?.title ?? 'No option selected';
+            description = selected?.description ?? 'No additional details provided for this option.';
+        }
+        const lines = [this.theme.fg('accent', this.theme.bold(title)), ''];
+        lines.push(...wrapTextWithAnsi(description, Math.max(10, width)).map((line) => this.theme.fg('muted', line)));
+        return lines.slice(0, this.maxVisibleRows);
+    }
+    styleLine(line, width, selected) {
+        if (selected)
+            return truncateToWidth(this.theme.fg('accent', this.theme.bold(line)), width, '');
+        if (line.startsWith('      '))
+            return truncateToWidth(this.theme.fg('muted', line), width, '');
+        if (line.trim().startsWith('('))
+            return truncateToWidth(this.theme.fg('dim', line), width, '');
+        return truncateToWidth(this.theme.fg('text', line), width, '');
+    }
+    filtered() {
+        return fuzzyFilter([...this.options], this.searchQuery, (option) => `${option.title} ${option.description ?? ''}`);
+    }
+    itemCount(filtered) {
+        return filtered.length + (this.allowComment ? 1 : 0) + (this.allowFreeform ? 1 : 0);
+    }
+    isCommentRow(index, filtered) {
+        return this.allowComment && index === filtered.length;
+    }
+    isFreeformRow(index, filtered) {
+        return this.allowFreeform && index === filtered.length + (this.allowComment ? 1 : 0);
+    }
+    setSearch(value) {
+        this.searchQuery = value;
+        this.selectedIndex = 0;
+        this.invalidate();
+    }
+    toggleComment() {
+        this.commentEnabled = !this.commentEnabled;
+        this.invalidate();
+    }
+}
+function printableInput(data) {
+    const kitty = decodeKittyPrintable(data);
+    if (kitty !== undefined)
+        return kitty;
+    const characters = [...data];
+    if (characters.length !== 1)
+        return null;
+    const character = characters[0];
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f) ? null : character;
+}
+function splitPaneWidths(width) {
+    if (width < SPLIT_PANE_MIN_WIDTH)
+        return null;
+    const available = width - SPLIT_SEPARATOR.length;
+    if (available < SPLIT_LEFT_MIN_WIDTH + SPLIT_RIGHT_MIN_WIDTH)
+        return null;
+    const left = Math.max(SPLIT_LEFT_MIN_WIDTH, Math.min(Math.floor(available * 0.42), available - SPLIT_RIGHT_MIN_WIDTH));
+    const right = available - left;
+    return right < SPLIT_RIGHT_MIN_WIDTH ? null : { left, right };
+}
+class AskPrompt extends Container {
+    question;
+    displayMode;
+    singleSelectLayout;
+    tui;
+    theme;
+    keybindings;
+    shortcuts;
+    onDone;
+    mode = 'select';
+    pendingSelections = [];
+    freeformDraft = '';
+    commentDraft = '';
+    modeContainer = new Container();
+    titleText = new Text('', 1, 0);
+    helpText = new Text('', 1, 0);
+    contextText;
+    contextIsCollapsible = false;
+    contextExpanded = false;
+    singleSelect;
+    multiSelect;
+    editor;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (this.editor && this.mode !== 'select')
+            this.editor.focused = value;
+    }
+    constructor(question, displayMode, singleSelectLayout, tui, theme, keybindings, shortcuts, onDone) {
+        super();
+        this.question = question;
+        this.displayMode = displayMode;
+        this.singleSelectLayout = singleSelectLayout;
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.shortcuts = shortcuts;
+        this.onDone = onDone;
+        this.addChild(new BorderTop((text) => theme.fg('accent', text), 'ask_user', (text) => theme.fg('dim', theme.bold(text))));
+        this.addChild(new Spacer(1));
+        this.addChild(this.titleText);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg('text', theme.bold(question.question)), 1, 0));
+        if (question.context) {
+            this.addChild(new Spacer(1));
+            this.contextText = new Text('', 1, 0);
+            this.addChild(this.contextText);
+        }
+        this.addChild(new Spacer(1));
+        this.addChild(this.modeContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(this.helpText);
+        this.addChild(new Spacer(1));
+        this.addChild(new BorderBottom((text) => theme.fg('accent', text), `v${VERSION}`, (text) => theme.fg('dim', text)));
+        this.showSelect();
+    }
+    invalidate() {
+        super.invalidate();
+        this.updateText();
+    }
+    render(width) {
+        const innerWidth = Math.max(1, width - (this.displayMode === 'overlay' ? BOX_OVERHEAD : 0));
+        const maxHeight = this.displayMode === 'overlay'
+            ? overlayMaxRenderLines(this.tui.terminal.rows)
+            : undefined;
+        this.updateContext(innerWidth, maxHeight);
+        if (this.mode === 'select') {
+            const questionRows = wrapTextWithAnsi(this.question.question, Math.max(10, innerWidth - 2)).length;
+            const contextRows = this.contextText?.render(innerWidth).length ?? 0;
+            const staticLines = 10 + questionRows + (contextRows > 0 ? contextRows + 1 : 0);
+            const visibleRows = maxHeight === undefined
+                ? (this.question.allowMultiple ? 10 : 12)
+                : Math.max(1, maxHeight - staticLines);
+            if (this.question.allowMultiple)
+                this.ensureMulti().setMaxVisibleRows(visibleRows);
+            else
+                this.ensureSingle().setMaxVisibleRows(visibleRows);
+        }
+        const lines = super.render(innerWidth);
+        if (maxHeight !== undefined && lines.length > maxHeight) {
+            if (maxHeight <= 1)
+                return [this.renderTopBorder(width)];
+            if (maxHeight === 2)
+                return [this.renderTopBorder(width), this.renderBottomBorder(width)];
+            const bodyCapacity = maxHeight - 2;
+            const renderedModeLines = this.modeContainer.render(innerWidth);
+            let prioritizedModeLines = renderedModeLines;
+            if (this.mode !== 'select' && renderedModeLines.length > 1) {
+                prioritizedModeLines = renderedModeLines.slice(0, -1);
+            }
+            else if (!this.question.allowMultiple && renderedModeLines.length > 1) {
+                prioritizedModeLines = renderedModeLines.slice(1);
+            }
+            const modeLines = prioritizedModeLines.slice(-bodyCapacity);
+            const promptBudget = Math.max(0, bodyCapacity - modeLines.length);
+            const promptLines = [
+                ...new Text(this.theme.fg('text', this.theme.bold(this.question.question)), 1, 0).render(innerWidth),
+                ...(this.contextText?.render(innerWidth) ?? []),
+            ].slice(0, promptBudget);
+            return this.frameBody([...promptLines, ...modeLines], width, innerWidth);
+        }
+        return lines.map((line, index) => {
+            if (index === 0)
+                return this.renderTopBorder(width);
+            if (index === lines.length - 1)
+                return this.renderBottomBorder(width);
+            return this.displayMode === 'overlay'
+                ? this.boxLine(line, innerWidth)
+                : truncateToWidth(line, width, '', true);
+        });
+    }
+    handleInput(data) {
+        if (this.contextIsCollapsible && matchesKey(data, CONTEXT_TOGGLE_KEY)) {
+            this.contextExpanded = !this.contextExpanded;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        if (this.mode !== 'select') {
+            if (matchesKey(data, Key.escape)) {
+                this.showSelect();
+                return;
+            }
+            if (this.keybindings.matches(data, 'tui.select.cancel')) {
+                this.onDone(null);
+                return;
+            }
+            this.ensureEditor().handleInput(data);
+            this.tui.requestRender();
+            return;
+        }
+        if (this.question.allowMultiple)
+            this.ensureMulti().handleInput(data);
+        else
+            this.ensureSingle().handleInput(data);
+        this.tui.requestRender();
+    }
+    isTextInputMode() {
+        return this.mode !== 'select';
+    }
+    ensureSingle() {
+        if (this.singleSelect)
+            return this.singleSelect;
+        const list = new SearchableSingleSelect(this.question.options, this.question.allowFreeform, this.question.allowComment, this.theme, this.singleSelectLayout, this.keybindings, this.shortcuts.commentToggle);
+        list.onCancel = () => this.onDone(null);
+        list.onEnterFreeform = () => this.showFreeform();
+        list.onSubmit = (selection, comment) => this.handleSelection([selection], comment);
+        this.singleSelect = list;
+        return list;
+    }
+    ensureMulti() {
+        if (this.multiSelect)
+            return this.multiSelect;
+        const list = new MultiSelectList(this.question.options, this.question.allowFreeform, this.question.allowComment, this.theme, this.keybindings, this.shortcuts.commentToggle);
+        list.onCancel = () => this.onDone(null);
+        list.onEnterFreeform = () => this.showFreeform();
+        list.onSubmit = (selections, comment) => this.handleSelection(selections, comment);
+        this.multiSelect = list;
+        return list;
+    }
+    ensureEditor() {
+        if (this.editor)
+            return this.editor;
+        const editor = new Editor(this.tui, createEditorTheme(this.theme));
+        editor.disableSubmit = false;
+        editor.onSubmit = (text) => {
+            if (this.mode === 'freeform')
+                this.onDone(freeformResponse(text));
+            else
+                this.onDone(selectionResponse(this.pendingSelections, text));
+        };
+        editor.focused = this._focused;
+        this.editor = editor;
+        return editor;
+    }
+    handleSelection(selections, wantsComment) {
+        if (this.question.allowComment && wantsComment) {
+            this.pendingSelections = selections;
+            this.commentDraft = '';
+            this.showComment();
+            return;
+        }
+        this.onDone(selectionResponse(selections));
+    }
+    showSelect() {
+        this.saveDraft();
+        this.mode = 'select';
+        this.pendingSelections = [];
+        this.modeContainer.clear();
+        this.modeContainer.addChild(this.question.allowMultiple ? this.ensureMulti() : this.ensureSingle());
+        this.updateText();
+        this.invalidate();
+        this.tui.requestRender();
+    }
+    showFreeform() {
+        this.saveDraft();
+        this.mode = 'freeform';
+        this.modeContainer.clear();
+        this.setEditorText(this.freeformDraft);
+        this.modeContainer.addChild(new Text(this.theme.fg('accent', this.theme.bold('Custom response')), 1, 0));
+        this.modeContainer.addChild(new Spacer(1));
+        this.modeContainer.addChild(this.ensureEditor());
+        this.updateText();
+        this.invalidate();
+        this.tui.requestRender();
+    }
+    showComment() {
+        this.saveDraft();
+        this.mode = 'comment';
+        this.modeContainer.clear();
+        this.setEditorText(this.commentDraft);
+        this.modeContainer.addChild(new Text(this.theme.fg('accent', this.theme.bold('Selected:')), 1, 0));
+        this.modeContainer.addChild(new Text(this.pendingSelections.join(', '), 1, 0));
+        this.modeContainer.addChild(new Spacer(1));
+        this.modeContainer.addChild(this.ensureEditor());
+        this.updateText();
+        this.invalidate();
+        this.tui.requestRender();
+    }
+    saveDraft() {
+        if (!this.editor || this.mode === 'select')
+            return;
+        const text = this.editor.getText();
+        if (this.mode === 'freeform')
+            this.freeformDraft = text;
+        else
+            this.commentDraft = text;
+    }
+    setEditorText(text) {
+        this.ensureEditor().setText(text);
+    }
+    updateText() {
+        this.titleText.setText(this.theme.fg('accent', this.theme.bold(this.mode === 'comment' ? 'Optional comment' : 'Question')));
+        const overlay = this.displayMode === 'overlay' && !this.shortcuts.overlayToggle.disabled
+            ? literalHint(this.theme, this.shortcuts.overlayToggle.spec, 'hide')
+            : undefined;
+        const context = this.contextIsCollapsible
+            ? literalHint(this.theme, CONTEXT_TOGGLE_KEY, this.contextExpanded ? 'collapse context' : 'expand context')
+            : undefined;
+        if (this.mode !== 'select') {
+            this.helpText.setText(this.theme.fg('dim', [
+                keyHint(this.theme, this.keybindings, 'tui.input.submit', this.mode === 'comment' ? 'submit/skip' : 'submit'),
+                literalHint(this.theme, 'esc', 'back'),
+                context,
+                overlay,
+            ].filter(Boolean).join(' • ')));
+            return;
+        }
+        const comment = this.question.allowComment && !this.shortcuts.commentToggle.disabled
+            ? literalHint(this.theme, this.shortcuts.commentToggle.spec, 'toggle context')
+            : undefined;
+        this.helpText.setText(this.theme.fg('dim', [
+            this.question.allowMultiple ? literalHint(this.theme, 'space', 'toggle') : literalHint(this.theme, 'type', 'filter'),
+            literalHint(this.theme, '↑↓', 'navigate'),
+            comment,
+            context,
+            overlay,
+            keyHint(this.theme, this.keybindings, 'tui.select.confirm', this.question.allowMultiple ? 'submit' : 'select'),
+            keyHint(this.theme, this.keybindings, 'tui.select.cancel', 'cancel'),
+        ].filter(Boolean).join(' • ')));
+    }
+    updateContext(width, maxHeight) {
+        if (!this.contextText || !this.question.context)
+            return;
+        const contentWidth = Math.max(10, width - 2);
+        const contextRows = wrapTextWithAnsi(this.question.context, contentWidth).length;
+        const questionRows = wrapTextWithAnsi(this.question.question, contentWidth).length;
+        const wouldCrowdChoices = maxHeight !== undefined && 11 + questionRows + contextRows + 1 > maxHeight;
+        const collapsible = contextRows > INLINE_CONTEXT_MAX_ROWS || wouldCrowdChoices;
+        if (this.contextIsCollapsible !== collapsible) {
+            this.contextIsCollapsible = collapsible;
+            if (!collapsible)
+                this.contextExpanded = false;
+            this.updateText();
+        }
+        if (this.contextIsCollapsible && !this.contextExpanded) {
+            this.contextText.setText(this.theme.fg('dim', `Context (${contextRows} lines) — ${CONTEXT_TOGGLE_KEY} expand`));
+            return;
+        }
+        this.contextText.setText(`${this.theme.fg('accent', this.theme.bold('Context:'))}\n${this.theme.fg('dim', this.question.context)}`);
+    }
+    frameBody(body, width, innerWidth) {
+        if (this.displayMode === 'inline') {
+            return [this.renderTopBorder(width), ...body.map((line) => truncateToWidth(line, width, '', true)), this.renderBottomBorder(width)];
+        }
+        return [
+            this.renderTopBorder(width),
+            ...body.map((line) => this.boxLine(line, innerWidth)),
+            this.renderBottomBorder(width),
+        ];
+    }
+    boxLine(line, innerWidth) {
+        const border = (text) => this.theme.fg('accent', text);
+        return `${border(BOX_LEFT)}${truncateToWidth(line, innerWidth, '', true)}${border(BOX_RIGHT)}`;
+    }
+    renderTopBorder(width) {
+        if (this.displayMode === 'inline')
+            return this.theme.fg('accent', '─'.repeat(Math.max(1, width)));
+        return new BorderTop((text) => this.theme.fg('accent', text), 'ask_user', (text) => this.theme.fg('dim', this.theme.bold(text))).render(width)[0];
+    }
+    renderBottomBorder(width) {
+        if (this.displayMode === 'inline')
+            return this.theme.fg('accent', '─'.repeat(Math.max(1, width)));
+        return new BorderBottom((text) => this.theme.fg('accent', text), `v${VERSION}`, (text) => this.theme.fg('dim', text)).render(width)[0];
+    }
+}
+class AskWizard {
+    questions;
+    displayMode;
+    singleSelectLayout;
+    tui;
+    theme;
+    keybindings;
+    shortcuts;
+    reportProgress;
+    onDone;
+    index = 0;
+    responses = new Map();
+    prompt;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (this.prompt)
+            this.prompt.focused = value;
+    }
+    constructor(questions, displayMode, singleSelectLayout, tui, theme, keybindings, shortcuts, reportProgress, onDone) {
+        this.questions = questions;
+        this.displayMode = displayMode;
+        this.singleSelectLayout = singleSelectLayout;
+        this.tui = tui;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.shortcuts = shortcuts;
+        this.reportProgress = reportProgress;
+        this.onDone = onDone;
+    }
+    invalidate() {
+        this.prompt?.invalidate();
+    }
+    handleInput(data) {
+        if (this.index === this.questions.length) {
+            if (this.navigate(data))
+                return;
+            if (matchesSubmit(data, this.keybindings)) {
+                const answers = this.answers();
+                this.onDone(answers.some((answer) => answer.response !== null) ? answers : null);
+            }
+            else if (this.keybindings.matches(data, 'tui.select.cancel')) {
+                this.onDone(null);
+            }
+            return;
+        }
+        const prompt = this.ensurePrompt();
+        if (!prompt.isTextInputMode() && this.navigate(data))
+            return;
+        prompt.handleInput(data);
+    }
+    render(width) {
+        const body = this.index === this.questions.length ? this.renderReview(width) : this.ensurePrompt().render(width);
+        if (body.length < 2)
+            return body;
+        const border = (text) => this.theme.fg('accent', text);
+        const inner = Math.max(1, width - (this.displayMode === 'overlay' ? BOX_OVERHEAD : 0));
+        const navigation = this.displayMode === 'overlay'
+            ? `${border(BOX_LEFT)}${truncateToWidth(this.navigation(), inner, '', true)}${border(BOX_RIGHT)}`
+            : truncateToWidth(this.navigation(), width, '', true);
+        const spacer = this.displayMode === 'overlay'
+            ? `${border(BOX_LEFT)}${truncateToWidth('', inner, '', true)}${border(BOX_RIGHT)}`
+            : ' '.repeat(width);
+        const decorated = [body[0], navigation, spacer, ...body.slice(1)];
+        if (this.displayMode !== 'overlay')
+            return decorated;
+        const maxHeight = overlayMaxRenderLines(this.tui.terminal.rows);
+        if (decorated.length <= maxHeight)
+            return decorated;
+        if (maxHeight <= 1)
+            return [body[0]];
+        if (maxHeight === 2)
+            return [body[0], body.at(-1)];
+        const contentCapacity = maxHeight - 2;
+        const promptContent = body.slice(1, -1);
+        const content = contentCapacity === 1
+            ? promptContent.slice(-1)
+            : [navigation, ...promptContent.slice(-(contentCapacity - 1))];
+        return [body[0], ...content, body.at(-1)];
+    }
+    ensurePrompt() {
+        if (this.prompt)
+            return this.prompt;
+        const question = this.questions[this.index];
+        this.prompt = new AskPrompt(question, this.displayMode, this.singleSelectLayout, this.tui, this.theme, this.keybindings, this.shortcuts, (response) => {
+            if (response === null) {
+                this.onDone(null);
+                return;
+            }
+            this.responses.set(question.id, response);
+            const answers = this.answers();
+            this.reportProgress(answers);
+            this.index = this.index < this.questions.length - 1 ? this.index + 1 : this.questions.length;
+            this.prompt = undefined;
+            this.invalidate();
+            this.tui.requestRender();
+        });
+        this.prompt.focused = this._focused;
+        return this.prompt;
+    }
+    navigate(data) {
+        if (matchesKey(data, Key.tab) || matchesKey(data, Key.right)) {
+            this.goTo((this.index + 1) % (this.questions.length + 1));
+            return true;
+        }
+        if (matchesKey(data, Key.shift('tab')) || matchesKey(data, Key.left)) {
+            this.goTo((this.index - 1 + this.questions.length + 1) % (this.questions.length + 1));
+            return true;
+        }
+        return false;
+    }
+    goTo(index) {
+        this.index = index;
+        this.prompt = undefined;
+        this.invalidate();
+        this.tui.requestRender();
+    }
+    answers() {
+        return this.questions.map((question) => ({
+            questionId: question.id,
+            response: this.responses.get(question.id) ?? null,
+        }));
+    }
+    navigation() {
+        const parts = [this.theme.fg('dim', '←')];
+        for (let index = 0; index < this.questions.length; index += 1) {
+            const question = this.questions[index];
+            const answered = this.responses.has(question.id);
+            const label = `${answered ? '✓' : '□'} ${question.header}`;
+            parts.push(index === this.index
+                ? this.theme.fg('accent', `[${label}]`)
+                : this.theme.fg(answered ? 'success' : 'muted', label));
+        }
+        const submit = `${this.responses.size > 0 ? '✓' : '□'} Submit`;
+        parts.push(this.index === this.questions.length
+            ? this.theme.fg('accent', `[${submit}]`)
+            : this.theme.fg(this.responses.size > 0 ? 'success' : 'muted', submit));
+        parts.push(this.theme.fg('dim', '→'));
+        return parts.join(' ');
+    }
+    renderReview(width) {
+        const border = (text) => this.theme.fg('accent', text);
+        const inner = Math.max(1, width - (this.displayMode === 'overlay' ? BOX_OVERHEAD : 0));
+        const body = [this.theme.fg('accent', this.theme.bold('Review answers')), ''];
+        for (const question of this.questions) {
+            body.push(`${this.theme.fg('muted', `${question.header}:`)} ${this.theme.fg('text', question.question)}`);
+            body.push(`  ${this.responses.has(question.id) ? formatResponse(this.responses.get(question.id)) : this.theme.fg('muted', 'Skipped')}`);
+        }
+        body.push('', this.theme.fg('dim', 'Enter submit • unanswered questions are skipped • Tab/←→ navigate • Esc cancel'));
+        const bodyLines = body.map((line) => this.displayMode === 'overlay'
+            ? this.boxLine(line, inner)
+            : truncateToWidth(line, width, '', true));
+        return [
+            this.displayMode === 'overlay'
+                ? new BorderTop(border, 'ask_user', (text) => this.theme.fg('dim', this.theme.bold(text))).render(width)[0]
+                : border('─'.repeat(Math.max(1, width))),
+            ...bodyLines,
+            this.displayMode === 'overlay'
+                ? new BorderBottom(border, `v${VERSION}`, (text) => this.theme.fg('dim', text)).render(width)[0]
+                : border('─'.repeat(Math.max(1, width))),
+        ];
+    }
+    boxLine(line, innerWidth) {
+        const border = (text) => this.theme.fg('accent', text);
+        return `${border(BOX_LEFT)}${truncateToWidth(line, innerWidth, '', true)}${border(BOX_RIGHT)}`;
+    }
+}
+async function askQuestionsViaDialogs(ui, questions, timeout, signal) {
+    const answers = [];
+    const deadline = timeout === undefined ? undefined : Date.now() + timeout;
+    for (const question of questions) {
+        if (signal?.aborted)
+            return { answers, cancelled: 'abort' };
+        const remaining = deadline === undefined ? undefined : deadline - Date.now();
+        if (remaining !== undefined && remaining <= 0)
+            return { answers, cancelled: 'timeout' };
+        const response = await raceDialogAbort(askViaDialogs(ui, question, remaining), signal);
+        if (response.aborted)
+            return { answers, cancelled: 'abort' };
+        if (response.value === null && deadline !== undefined && Date.now() >= deadline) {
+            return { answers, cancelled: 'timeout' };
+        }
+        answers.push({
+            questionId: question.id,
+            response: response.value,
+        });
+    }
+    return { answers };
+}
+async function raceDialogAbort(operation, signal) {
+    if (!signal)
+        return { aborted: false, value: await operation };
+    if (signal.aborted)
+        return { aborted: true };
+    // Pi dialogs have no abort option, so stop this host flow even if the RPC
+    // client dismisses its outstanding prompt later.
+    let removeListener = () => { };
+    const aborted = new Promise((resolve) => {
+        const onAbort = () => resolve({ aborted: true });
+        signal.addEventListener('abort', onAbort, { once: true });
+        removeListener = () => signal.removeEventListener('abort', onAbort);
+    });
+    try {
+        return await Promise.race([
+            operation.then((value) => ({ aborted: false, value })),
+            aborted,
+        ]);
+    }
+    finally {
+        removeListener();
+    }
+}
+async function askViaDialogs(ui, question, timeout) {
+    const dialogOptions = timeout === undefined ? undefined : { timeout };
+    const prompt = question.context
+        ? `${question.question}\n\nContext:\n${question.context}`
+        : question.question;
+    if (question.options.length === 0) {
+        const answer = await ui.input(prompt, 'Type your answer...', dialogOptions);
+        return answer === undefined ? null : freeformResponse(answer);
+    }
+    if (question.allowMultiple) {
+        const options = formatOptions(question.options);
+        const raw = await ui.input(`${prompt}\n\nOptions (select one or more):\n${options}`, 'Type option titles separated by commas...', dialogOptions);
+        if (raw === undefined)
+            return null;
+        const selections = raw.split(',').map((selection) => selection.trim()).filter(Boolean);
+        if (selections.length === 0)
+            return null;
+        if (!question.allowComment)
+            return selectionResponse(selections);
+        const comment = await ui.input(`${prompt}\n\nSelected:\n${selections.map((selection) => `- ${selection}`).join('\n')}`, 'Optional comment (press Enter to skip)...', dialogOptions);
+        return selectionResponse(selections, comment);
+    }
+    const options = question.options.map((option) => option.title);
+    if (question.allowFreeform)
+        options.push(FREEFORM_SENTINEL);
+    const selected = await ui.select(prompt, options, dialogOptions);
+    if (selected === undefined)
+        return null;
+    if (selected === FREEFORM_SENTINEL) {
+        const answer = await ui.input(prompt, 'Type your answer...', dialogOptions);
+        return answer === undefined ? null : freeformResponse(answer);
+    }
+    if (!question.allowComment)
+        return selectionResponse([selected]);
+    const comment = await ui.input(`${prompt}\n\nSelected option:\n- ${selected}`, 'Optional comment (press Enter to skip)...', dialogOptions);
+    return selectionResponse([selected], comment);
+}
+function selectionResponse(selections, comment) {
+    const normalizedSelections = selections.map((selection) => selection.trim()).filter(Boolean);
+    if (normalizedSelections.length === 0)
+        return null;
+    const normalizedComment = comment?.trim();
+    return {
+        kind: 'selection',
+        selections: normalizedSelections,
+        ...(normalizedComment ? { comment: normalizedComment } : {}),
+    };
+}
+function freeformResponse(text) {
+    const normalized = text.trim();
+    return normalized ? { kind: 'freeform', text: normalized } : null;
+}
+function formatOptions(options) {
+    return options.map((option, index) => (`${index + 1}. ${option.title}${option.description ? ` — ${option.description}` : ''}`)).join('\n');
+}
+function formatResponse(response) {
+    if (response.kind === 'freeform')
+        return response.text;
+    const selections = response.selections.join(', ');
+    return response.comment ? `${selections} — ${response.comment}` : selections;
+}
+export const askUserToolPresentation = {
+    renderCall(args, theme) {
+        const values = args;
+        if (Array.isArray(values.questions) && values.questions.length > 0) {
+            const labels = values.questions.map((question, index) => (question.header || question.question || `Q${index + 1}`));
+            return new Text(`${theme.fg('toolTitle', theme.bold('ask_user '))}${theme.fg('muted', `${values.questions.length} questions`)}\n${theme.fg('dim', `  ${truncateToWidth(labels.join(', '), 80)}`)}`, 0, 0);
+        }
+        const options = Array.isArray(values.options) ? values.options : [];
+        const labels = options.map((option) => normalizeAskUserOption(option)?.title ?? '<invalid>');
+        const optionLine = labels.length > 0
+            ? `\n${theme.fg('dim', `  ${labels.length} option(s): ${labels.join(', ')}`)}`
+            : '';
+        const modes = `${values.allowMultiple ? ' [multi-select]' : ''}${values.allowComment ? ' [optional comment]' : ''}`;
+        return new Text(`${theme.fg('toolTitle', theme.bold('ask_user '))}${theme.fg('muted', String(values.question ?? ''))}${optionLine}${theme.fg('dim', modes)}`, 0, 0);
+    },
+    renderResult(result, options, theme) {
+        const details = result.details;
+        if (details && 'error' in details)
+            return new Text(theme.fg('error', `✗ ${details.error}`), 0, 0);
+        if (options.isPartial) {
+            const waiting = result.content
+                .filter((part) => part.type === 'text')
+                .map((part) => part.text)
+                .join('\n') || 'Waiting for user input...';
+            return new Text(theme.fg('muted', waiting), 0, 0);
+        }
+        if (!details)
+            return new Text(theme.fg('warning', 'No result'), 0, 0);
+        if (details.status === 'cancelled')
+            return new Text(theme.fg('warning', details.message ?? 'Cancelled'), 0, 0);
+        if (details.status === 'deferred') {
+            const interaction = details.interactionId ? ` (interaction: ${details.interactionId})` : '';
+            return new Text(theme.fg('muted', `${details.message ?? 'Question sent'}${interaction}`), 0, 0);
+        }
+        if (details.status === 'pending')
+            return new Text(theme.fg('muted', 'Waiting for user input...'), 0, 0);
+        if (details.kind === 'single') {
+            if (!details.response)
+                return new Text(theme.fg('warning', 'Skipped'), 0, 0);
+            let text = `${theme.fg('success', '✓ ')}${theme.fg('accent', formatResponse(details.response))}`;
+            if (options.expanded) {
+                text += `\n${theme.fg('dim', `Q: ${details.question.question}`)}`;
+                if (details.question.context)
+                    text += `\n${theme.fg('dim', details.question.context)}`;
+            }
+            return new Text(text, 0, 0);
+        }
+        const lines = details.questions.map((question) => {
+            const response = details.responses[question.id];
+            return response
+                ? `${theme.fg('success', '✓ ')}${theme.fg('accent', question.header)}: ${formatResponse(response)}`
+                : `${theme.fg('muted', '○ ')}${theme.fg('muted', question.header)}: skipped`;
+        });
+        return new Text(lines.join('\n'), 0, 0);
+    },
+};
+//# sourceMappingURL=ask-user.js.map