mepcli 0.5.0 → 0.6.0

package/dist/prompts/file.js

@@ -40,7 +40,9 @@ const theme_1 = require("../theme");
 const symbols_1 = require("../symbols");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// --- Implementation: File Prompt ---
+/**
+ * Implementation of FilePrompt with autocomplete.
+ */
 class FilePrompt extends base_1.Prompt {
     constructor(options) {
         super(options);
@@ -49,22 +51,29 @@ class FilePrompt extends base_1.Prompt {
         this.suggestions = [];
         this.selectedSuggestion = -1;
         this.errorMsg = '';
+        this.lastLinesUp = 0;
         this.input = options.basePath || '';
         this.cursor = this.input.length;
+        this.updateSuggestions();
     }
+    /**
+     * Updates the suggestions list based on the current input path.
+     */
     updateSuggestions() {
         try {
-            const dir = path.dirname(this.input) || '.';
-            const partial = path.basename(this.input);
+            // Determine the directory to scan and the partial file name
+            const isDirQuery = this.input.endsWith('/') || this.input.endsWith('\\');
+            const dir = isDirQuery ? this.input : (path.dirname(this.input) || '.');
+            const partial = isDirQuery ? '' : path.basename(this.input);
             if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
                 const files = fs.readdirSync(dir);
                 this.suggestions = files
-                    .filter(f => f.startsWith(partial))
+                    .filter(f => f.toLowerCase().startsWith(partial.toLowerCase()))
                     .filter(f => {
                     const fullPath = path.join(dir, f);
-                    // Handle errors if file doesn't exist or permission denied
                     try {
-                        const isDir = fs.statSync(fullPath).isDirectory();
+                        const stats = fs.statSync(fullPath);
+                        const isDir = stats.isDirectory();
                         if (this.options.onlyDirectories && !isDir)
                             return false;
                         if (this.options.extensions && !isDir) {
@@ -72,17 +81,18 @@ class FilePrompt extends base_1.Prompt {
                         }
                         return true;
                     }
-                    catch (e) {
+                    catch (_e) {
                         return false;
                     }
                 })
                     .map(f => {
                     const fullPath = path.join(dir, f);
                     try {
+                        // Append separator if the file is a directory
                         if (fs.statSync(fullPath).isDirectory())
-                            return f + '/';
+                            return f + path.sep;
                     }
-                    catch (e) { /* ignore */ }
+                    catch (_e) { /* ignore */ }
                     return f;
                 });
             }
@@ -90,18 +100,21 @@ class FilePrompt extends base_1.Prompt {
                 this.suggestions = [];
             }
         }
-        catch (e) {
+        catch (_e) {
             this.suggestions = [];
         }
         this.selectedSuggestion = -1;
     }
     render(firstRender) {
-        // Construct string
+        // Restore cursor position to the bottom before renderFrame clears the area
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+            this.lastLinesUp = 0;
+        }
         const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
         let output = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${this.input}`;
-        // Suggestions
         if (this.suggestions.length > 0) {
-            output += '\n'; // Separate input from suggestions
+            output += '\n';
             const maxShow = 5;
             const displayed = this.suggestions.slice(0, maxShow);
             displayed.forEach((s, i) => {
@@ -115,86 +128,69 @@ class FilePrompt extends base_1.Prompt {
                 }
             });
             if (this.suggestions.length > maxShow) {
-                output += `\n  ...and ${this.suggestions.length - maxShow} more`;
+                output += `\n  ${theme_1.theme.muted}...and ${this.suggestions.length - maxShow} more${ansi_1.ANSI.RESET}`;
             }
         }
         this.renderFrame(output);
-        this.print(ansi_1.ANSI.SHOW_CURSOR);
-        // Restore Cursor Logic
-        // We need to move up to the input line if we printed suggestions.
-        // The input line is always the first line (index 0).
-        // So we move up by (totalLines - 1).
-        const totalLines = this.lastRenderHeight; // renderFrame sets this
+        // Move cursor back up to the input line
+        const totalLines = this.lastRenderHeight;
         if (totalLines > 1) {
-            this.print(`\x1b[${totalLines - 1}A`);
+            this.lastLinesUp = totalLines - 1;
+            this.print(`\x1b[${this.lastLinesUp}A`);
         }
-        // Move right
+        // Calculate horizontal cursor position on the input line
         const prefix = `${icon} ${theme_1.theme.title}${this.options.message} `;
         const prefixLen = this.stripAnsi(prefix).length;
         const targetCol = prefixLen + this.input.length;
         this.print(ansi_1.ANSI.CURSOR_LEFT);
         if (targetCol > 0)
             this.print(`\x1b[${targetCol}C`);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
     }
     handleInput(char) {
-        if (char === '\t') { // Tab
-            if (this.suggestions.length === 1) {
-                const dir = path.dirname(this.input);
-                this.input = path.join(dir === '.' ? '' : dir, this.suggestions[0]);
+        if (char === '\t') {
+            if (this.suggestions.length > 0) {
+                // Use the selected suggestion or the first one available
+                const idx = this.selectedSuggestion === -1 ? 0 : this.selectedSuggestion;
+                const suggestion = this.suggestions[idx];
+                const isDir = this.input.endsWith('/') || this.input.endsWith('\\');
+                const dir = isDir ? this.input : path.dirname(this.input);
+                // Construct the new path accurately
+                const baseDir = (dir === '.' && !this.input.startsWith('.')) ? '' : dir;
+                this.input = path.join(baseDir, suggestion);
                 this.cursor = this.input.length;
-                this.suggestions = [];
-                this.render(false);
-            }
-            else if (this.suggestions.length > 1) {
-                // Cycle or show? For now cycle if selected
-                if (this.selectedSuggestion !== -1) {
-                    const dir = path.dirname(this.input);
-                    this.input = path.join(dir === '.' ? '' : dir, this.suggestions[this.selectedSuggestion]);
-                    this.cursor = this.input.length;
-                    this.suggestions = [];
-                    this.render(false);
-                }
-                else {
-                    // Just show suggestions (already done in render loop usually, but update logic ensures it)
-                    this.updateSuggestions();
-                    this.render(false);
-                }
-            }
-            else {
+                // Immediately refresh suggestions for the new path
                 this.updateSuggestions();
                 this.render(false);
             }
             return;
         }
         if (char === '\r' || char === '\n') {
-            if (this.selectedSuggestion !== -1) {
-                const dir = path.dirname(this.input);
-                this.input = path.join(dir === '.' ? '' : dir, this.suggestions[this.selectedSuggestion]);
-                this.cursor = this.input.length;
-                this.suggestions = [];
-                this.selectedSuggestion = -1;
-                this.render(false);
-            }
-            else {
-                this.submit(this.input);
+            // Move cursor to the bottom to ensure clean exit UI
+            if (this.lastLinesUp > 0) {
+                this.print(`\x1b[${this.lastLinesUp}B`);
+                this.lastLinesUp = 0;
             }
+            this.submit(this.input);
             return;
         }
-        if (this.isDown(char)) { // Down
+        if (this.isDown(char)) {
             if (this.suggestions.length > 0) {
-                this.selectedSuggestion = (this.selectedSuggestion + 1) % Math.min(this.suggestions.length, 5);
+                const count = Math.min(this.suggestions.length, 5);
+                this.selectedSuggestion = (this.selectedSuggestion + 1) % count;
                 this.render(false);
             }
             return;
         }
-        if (this.isUp(char)) { // Up
+        if (this.isUp(char)) {
             if (this.suggestions.length > 0) {
-                this.selectedSuggestion = (this.selectedSuggestion - 1 + Math.min(this.suggestions.length, 5)) % Math.min(this.suggestions.length, 5);
+                const count = Math.min(this.suggestions.length, 5);
+                this.selectedSuggestion = (this.selectedSuggestion - 1 + count) % count;
                 this.render(false);
             }
             return;
         }
-        if (char === '\u0008' || char === '\x7f') { // Backspace
+        if (char === '\u0008' || char === '\x7f') {
             if (this.input.length > 0) {
                 this.input = this.input.slice(0, -1);
                 this.updateSuggestions();

package/dist/prompts/form.d.ts

@@ -0,0 +1,17 @@
+import { Prompt } from '../base';
+import { FormOptions, MouseEvent } from '../types';
+export declare class FormPrompt extends Prompt<Record<string, string>, FormOptions> {
+    private values;
+    private activeIndex;
+    private fieldErrors;
+    private globalError;
+    private cursor;
+    private lastLinesUp;
+    constructor(options: FormOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string, key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+    private moveFocus;
+    private validateCurrentField;
+    private submitForm;
+}

package/dist/prompts/form.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+class FormPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.values = {};
+        this.activeIndex = 0;
+        this.fieldErrors = {};
+        this.globalError = '';
+        this.cursor = 0; // Cursor position for the ACTIVE field.
+        this.lastLinesUp = 0; // To track cursor position after render
+        this.options.fields.forEach(field => {
+            this.values[field.name] = field.initial || '';
+        });
+        this.cursor = this.values[this.options.fields[0].name].length;
+    }
+    render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        const outputLines = [];
+        // Title
+        outputLines.push(`${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`);
+        if (this.globalError) {
+            outputLines.push(`${theme_1.theme.error}>> ${this.globalError}${ansi_1.ANSI.RESET}`);
+        }
+        let cursorLineIndex = -1;
+        let cursorColIndex = 0;
+        this.options.fields.forEach((field, index) => {
+            const isActive = index === this.activeIndex;
+            const value = this.values[field.name];
+            const error = this.fieldErrors[field.name];
+            // Icon
+            let icon = '';
+            if (isActive) {
+                icon = `${theme_1.theme.main}${symbols_1.symbols.pointer}`; // >
+            }
+            else {
+                icon = ' '; // indent
+            }
+            // Label
+            const labelStyle = isActive ? `${theme_1.theme.main}${ansi_1.ANSI.BOLD}` : theme_1.theme.muted;
+            const label = `${labelStyle}${field.message}:${ansi_1.ANSI.RESET}`;
+            // Value
+            // Note: Use Secret/Password prompt for case sensitive input, Form prompt is for general text input
+            const displayValue = isActive ? value : `${theme_1.theme.muted}${value}${ansi_1.ANSI.RESET}`;
+            // Construct Line
+            const line = `${icon} ${label} ${displayValue}`;
+            outputLines.push(line);
+            if (isActive) {
+                // Determine cursor position
+                // We need visual length of "icon + label + value_up_to_cursor"
+                const prefix = `${icon} ${label} `;
+                const valuePrefix = value.substring(0, this.cursor);
+                cursorLineIndex = outputLines.length - 1;
+                cursorColIndex = (0, utils_1.stringWidth)(this.stripAnsi(prefix)) + (0, utils_1.stringWidth)(this.stripAnsi(valuePrefix));
+            }
+            // Error for this field
+            if (error) {
+                outputLines.push(`  ${theme_1.theme.error}>> ${error}${ansi_1.ANSI.RESET}`);
+            }
+        });
+        // Instructions
+        outputLines.push('');
+        outputLines.push(`${ansi_1.ANSI.RESET}${theme_1.theme.muted}(Use Up/Down/Tab to navigate, Enter to submit)${ansi_1.ANSI.RESET}`);
+        const output = outputLines.join('\n');
+        this.renderFrame(output);
+        // Position Cursor
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (cursorLineIndex !== -1) {
+            // Calculate lines up from bottom
+            const totalLines = outputLines.length;
+            const linesUp = (totalLines - 1) - cursorLineIndex;
+            if (linesUp > 0) {
+                this.print(`\x1b[${linesUp}A`);
+                this.lastLinesUp = linesUp;
+            }
+            this.print(ansi_1.ANSI.CURSOR_LEFT);
+            if (cursorColIndex > 0) {
+                this.print(`\x1b[${cursorColIndex}C`);
+            }
+        }
+    }
+    handleInput(char, key) {
+        // Navigation: Up / Shift+Tab
+        if (this.isUp(char) || (char === '\t' && key /* how to detect Shift+Tab? usually \u001b[Z */) || char === '\u001b[Z') {
+            this.validateCurrentField();
+            this.moveFocus(-1);
+            return;
+        }
+        // Navigation: Down / Tab
+        if (this.isDown(char) || char === '\t') {
+            this.validateCurrentField();
+            this.moveFocus(1);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.validateCurrentField().then(isValid => {
+                if (isValid) {
+                    if (this.activeIndex < this.options.fields.length - 1) {
+                        this.moveFocus(1);
+                    }
+                    else {
+                        // Submit
+                        this.submitForm();
+                    }
+                }
+            });
+            return;
+        }
+        // Editing Active Field
+        const activeField = this.options.fields[this.activeIndex];
+        const val = this.values[activeField.name];
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.cursor > 0) {
+                const pre = val.slice(0, this.cursor - 1);
+                const post = val.slice(this.cursor);
+                this.values[activeField.name] = pre + post;
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Left/Right arrow to move cursor within field
+        if (this.isLeft(char)) {
+            if (this.cursor > 0)
+                this.cursor--;
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.cursor < val.length)
+                this.cursor++;
+            this.render(false);
+            return;
+        }
+        // Typing
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            const pre = val.slice(0, this.cursor);
+            const post = val.slice(this.cursor);
+            this.values[activeField.name] = pre + char + post;
+            this.cursor += char.length;
+            this.fieldErrors[activeField.name] = ''; // Clear error on type
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.validateCurrentField();
+                this.moveFocus(-1);
+            }
+            else if (event.scroll === 'down') {
+                this.validateCurrentField();
+                this.moveFocus(1);
+            }
+        }
+    }
+    moveFocus(direction) {
+        const nextIndex = this.activeIndex + direction;
+        if (nextIndex >= 0 && nextIndex < this.options.fields.length) {
+            this.activeIndex = nextIndex;
+            // "cursor must jump to end of data"
+            this.cursor = this.values[this.options.fields[this.activeIndex].name].length;
+            this.render(false);
+        }
+    }
+    async validateCurrentField() {
+        const field = this.options.fields[this.activeIndex];
+        const val = this.values[field.name];
+        if (field.validate) {
+            try {
+                const res = await field.validate(val);
+                if (res !== true) {
+                    this.fieldErrors[field.name] = typeof res === 'string' ? res : 'Invalid value';
+                    this.render(false);
+                    return false;
+                }
+            }
+            catch (err) {
+                this.fieldErrors[field.name] = err.message || 'Validation failed';
+                this.render(false);
+                return false;
+            }
+        }
+        // Clear error if valid
+        delete this.fieldErrors[field.name];
+        this.render(false);
+        return true;
+    }
+    async submitForm() {
+        this.globalError = '';
+        // Validate all fields
+        let allValid = true;
+        for (const field of this.options.fields) {
+            const val = this.values[field.name];
+            if (field.validate) {
+                const res = await field.validate(val);
+                if (res !== true) {
+                    this.fieldErrors[field.name] = typeof res === 'string' ? res : 'Invalid value';
+                    allValid = false;
+                }
+                else {
+                    delete this.fieldErrors[field.name];
+                }
+            }
+        }
+        if (allValid) {
+            this.submit(this.values);
+        }
+        else {
+            this.globalError = 'Please fix errors before submitting.';
+            this.render(false);
+        }
+    }
+}
+exports.FormPrompt = FormPrompt;

package/dist/prompts/grid.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { GridOptions, MouseEvent } from '../types';
+export declare class GridPrompt extends Prompt<boolean[][], GridOptions> {
+    private cursorRow;
+    private cursorCol;
+    private selected;
+    private columnWidths;
+    private rowLabelWidth;
+    constructor(options: GridOptions);
+    private calculateLayout;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/grid.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+class GridPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        this.columnWidths = [];
+        this.rowLabelWidth = 0;
+        // Initialize selection matrix
+        if (options.initial) {
+            this.selected = options.initial.map(row => [...row]);
+        }
+        else {
+            this.selected = options.rows.map(() => new Array(options.columns.length).fill(false));
+        }
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        // Calculate max width for row labels
+        this.rowLabelWidth = 0;
+        for (const row of this.options.rows) {
+            this.rowLabelWidth = Math.max(this.rowLabelWidth, (0, utils_1.stringWidth)(row));
+        }
+        // Calculate width for each column
+        this.columnWidths = this.options.columns.map(col => {
+            // Header width vs Cell width (3 chars for "[ ]")
+            return Math.max((0, utils_1.stringWidth)(col), 3);
+        });
+    }
+    render(_firstRender) {
+        const { rows, columns } = this.options;
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Render Header
+        // Padding for the row label column
+        output += ' '.repeat(this.rowLabelWidth + 2); // +2 for spacing/border
+        output += columns.map((col, i) => {
+            const width = this.columnWidths[i];
+            const padding = width - (0, utils_1.stringWidth)(col);
+            const leftPad = Math.floor(padding / 2);
+            const rightPad = padding - leftPad;
+            return `${theme_1.theme.muted}${' '.repeat(leftPad)}${col}${' '.repeat(rightPad)}${ansi_1.ANSI.RESET}`;
+        }).join('  ') + '\n';
+        // Render Rows
+        for (let r = 0; r < rows.length; r++) {
+            const rowLabel = rows[r];
+            const labelPadding = this.rowLabelWidth - (0, utils_1.stringWidth)(rowLabel);
+            // Row Label
+            output += `${theme_1.theme.muted}${rowLabel}${' '.repeat(labelPadding)}${ansi_1.ANSI.RESET}  `;
+            // Cells
+            const cells = this.selected[r].map((isChecked, c) => {
+                const isFocused = (r === this.cursorRow && c === this.cursorCol);
+                const width = this.columnWidths[c];
+                const content = isChecked ? `[${theme_1.theme.success}x${ansi_1.ANSI.RESET}]` : '[ ]';
+                // content string width is 3 (ignoring ansi)
+                const padding = width - 3;
+                const leftPad = Math.floor(padding / 2);
+                const rightPad = padding - leftPad;
+                let cellStr = `${' '.repeat(leftPad)}${content}${' '.repeat(rightPad)}`;
+                if (isFocused) {
+                    // Highlight the focused cell
+                    // If we use ANSI.REVERSE on the whole cell including padding:
+                    cellStr = `${ansi_1.ANSI.REVERSE}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                return cellStr;
+            });
+            output += cells.join('  ') + '\n';
+        }
+        output += `${theme_1.theme.muted}Arrows to move, Space to toggle, Enter to submit${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        const isLeft = this.isLeft(char);
+        const isRight = this.isRight(char);
+        if (isUp || isDown || isLeft || isRight) {
+            if (isUp)
+                this.cursorRow = Math.max(0, this.cursorRow - 1);
+            if (isDown)
+                this.cursorRow = Math.min(this.options.rows.length - 1, this.cursorRow + 1);
+            if (isLeft)
+                this.cursorCol = Math.max(0, this.cursorCol - 1);
+            if (isRight)
+                this.cursorCol = Math.min(this.options.columns.length - 1, this.cursorCol + 1);
+            this.render(false);
+            return;
+        }
+        if (char === ' ') {
+            this.selected[this.cursorRow][this.cursorCol] = !this.selected[this.cursorRow][this.cursorCol];
+            this.render(false);
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            this.submit(this.selected);
+            return;
+        }
+        // PageUp (First Row)
+        if (char === '\x1b[5~') {
+            this.cursorRow = 0;
+            this.render(false);
+            return;
+        }
+        // PageDown (Last Row)
+        if (char === '\x1b[6~') {
+            this.cursorRow = this.options.rows.length - 1;
+            this.render(false);
+            return;
+        }
+        // Home (First Column)
+        if (char === '\x1b[H' || char === '\x1b[1~') {
+            this.cursorCol = 0;
+            this.render(false);
+            return;
+        }
+        // End (Last Column)
+        if (char === '\x1b[F' || char === '\x1b[4~') {
+            this.cursorCol = this.options.columns.length - 1;
+            this.render(false);
+            return;
+        }
+        // r: Toggle Row
+        if (char === 'r') {
+            const row = this.selected[this.cursorRow];
+            const allSelected = row.every(c => c);
+            this.selected[this.cursorRow] = row.map(() => !allSelected);
+            this.render(false);
+            return;
+        }
+        // c: Toggle Column
+        if (char === 'c') {
+            const colIdx = this.cursorCol;
+            const colValues = this.selected.map(row => row[colIdx]);
+            const allSelected = colValues.every(c => c);
+            this.selected.forEach(row => row[colIdx] = !allSelected);
+            this.render(false);
+            return;
+        }
+        // a: Select All
+        if (char === 'a') {
+            this.selected = this.selected.map(row => row.map(() => true));
+            this.render(false);
+            return;
+        }
+        // x: Deselect All
+        if (char === 'x') {
+            this.selected = this.selected.map(row => row.map(() => false));
+            this.render(false);
+            return;
+        }
+        // i: Invert
+        if (char === 'i') {
+            this.selected = this.selected.map(row => row.map(v => !v));
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const direction = event.scroll === 'up' ? -1 : 1;
+            if (event.shift) {
+                // Horizontal (Column)
+                this.cursorCol = Math.max(0, Math.min(this.options.columns.length - 1, this.cursorCol + direction));
+            }
+            else {
+                // Vertical (Row)
+                this.cursorRow = Math.max(0, Math.min(this.options.rows.length - 1, this.cursorRow + direction));
+            }
+            this.render(false);
+        }
+    }
+}
+exports.GridPrompt = GridPrompt;

package/dist/prompts/keypress.d.ts

@@ -0,0 +1,7 @@
+import { Prompt } from '../base';
+import { KeypressOptions } from '../types';
+export declare class KeypressPrompt extends Prompt<string, KeypressOptions> {
+    constructor(options: KeypressOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+}