mepcli 0.2.1 → 0.2.6

package/dist/input.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'events';
+export declare class InputParser extends EventEmitter {
+    private buffer;
+    private timeout;
+    private state;
+    constructor();
+    /**
+     * Feed data into the parser.
+     */
+    feed(data: Buffer): void;
+    private processChar;
+    private emitKey;
+}

package/dist/input.js

@@ -0,0 +1,89 @@
+"use strict";
+// src/input.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputParser = void 0;
+const events_1 = require("events");
+class InputParser extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.buffer = '';
+        this.timeout = null;
+        this.state = 'NORMAL';
+    }
+    /**
+     * Feed data into the parser.
+     */
+    feed(data) {
+        // Convert buffer to string.
+        // For partial multi-byte sequences at the chunk boundary,
+        // buffer.toString() might produce replacement chars.
+        // Ideally we should use StringDecoder, but since we are handling KeyPresses,
+        // and usually a keypress is complete, simple toString often works.
+        // However, the user mentioned fragmentation issues.
+        // But InputParser usually receives data from stdin.
+        // The core issue of fragmentation is splitting escape codes like \x1b [ A
+        const input = data.toString('utf-8');
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            this.processChar(char);
+        }
+    }
+    processChar(char) {
+        if (this.state === 'NORMAL') {
+            if (char === '\x1b') {
+                this.state = 'ESC';
+                this.buffer = char;
+                // Start a short timeout to detect bare ESC
+                this.timeout = setTimeout(() => {
+                    this.emitKey(this.buffer);
+                    this.buffer = '';
+                    this.state = 'NORMAL';
+                }, 20); // 20ms timeout
+            }
+            else {
+                this.emitKey(char);
+            }
+        }
+        else if (this.state === 'ESC') {
+            // Cancel timeout as we received more data
+            if (this.timeout)
+                clearTimeout(this.timeout);
+            this.timeout = null;
+            this.buffer += char;
+            if (char === '[') {
+                this.state = 'CSI';
+            }
+            else if (char === 'O') {
+                // SS3 sequence like \x1b O A (Application Cursor Keys)
+                // Treat as similar to CSI for collecting the next char
+                this.state = 'CSI';
+            }
+            else {
+                // Alt + Key or similar (\x1b + char)
+                this.emitKey(this.buffer);
+                this.buffer = '';
+                this.state = 'NORMAL';
+            }
+        }
+        else if (this.state === 'CSI') {
+            this.buffer += char;
+            // CSI sequences end with 0x40-0x7E
+            if (char >= '@' && char <= '~') {
+                this.emitKey(this.buffer);
+                this.buffer = '';
+                this.state = 'NORMAL';
+            }
+            // Otherwise, we keep buffering (params like 1;2)
+        }
+    }
+    emitKey(key) {
+        // Normalize Enter
+        if (key === '\r')
+            key = '\n';
+        // We emit both the raw sequence and a normalized representation if needed,
+        // but existing prompt logic handles raw strings like \x1b[A.
+        // So we just emit the reconstructed sequence.
+        this.emit('keypress', key, Buffer.from(key));
+    }
+}
+exports.InputParser = InputParser;

package/dist/prompts/checkbox.d.ts

@@ -0,0 +1,12 @@
+import { Prompt } from '../base';
+import { CheckboxOptions } from '../types';
+export declare class CheckboxPrompt extends Prompt<any[], CheckboxOptions> {
+    private selectedIndex;
+    private checkedState;
+    private errorMsg;
+    private scrollTop;
+    private readonly pageSize;
+    constructor(options: CheckboxOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/checkbox.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckboxPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Checkbox Prompt ---
+class CheckboxPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.errorMsg = '';
+        // Pagination state (added for consistency and performance)
+        this.scrollTop = 0;
+        this.pageSize = 10;
+        this.checkedState = options.choices.map(c => !!c.selected);
+    }
+    render(firstRender) {
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        // Ensure we don't scroll past bounds if list is small
+        if (this.options.choices.length <= this.pageSize) {
+            this.scrollTop = 0;
+        }
+        let output = '';
+        // Header
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(Press <space> to select, <enter> to confirm)${ansi_1.ANSI.RESET}`;
+        // List
+        const choices = this.options.choices;
+        const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleChoices.forEach((choice, index) => {
+            const actualIndex = this.scrollTop + index;
+            output += '\n'; // New line for each item
+            const cursor = actualIndex === this.selectedIndex ? `${theme_1.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
+            const isChecked = this.checkedState[actualIndex];
+            const checkbox = isChecked
+                ? `${theme_1.theme.success}◉${ansi_1.ANSI.RESET}`
+                : `${theme_1.theme.muted}◯${ansi_1.ANSI.RESET}`;
+            const title = actualIndex === this.selectedIndex
+                ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
+                : choice.title;
+            output += `${cursor} ${checkbox} ${title}`;
+        });
+        // Indication of more items
+        if (choices.length > this.pageSize) {
+            const progress = ` ${this.scrollTop + 1}-${Math.min(this.scrollTop + this.pageSize, choices.length)} of ${choices.length}`;
+            // Maybe add this to the header or footer?
+            // Let's add it to footer or header. Adding to header is cleaner.
+            // But I already wrote header.
+            // Let's just append it at the bottom if I want, or ignore for now to keep UI minimal.
+        }
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { min = 0, max } = this.options;
+            if (selectedCount < min) {
+                this.errorMsg = `You must select at least ${min} options.`;
+                this.render(false);
+                return;
+            }
+            if (max && selectedCount > max) {
+                this.errorMsg = `You can only select up to ${max} options.`;
+                this.render(false);
+                return;
+            }
+            this.cleanup();
+            // renderFrame cleans up lines, but doesn't print the final state "persisted" if we want to show the result?
+            // Usually we clear the prompt or show a summary.
+            // MepCLI seems to submit and let the caller decide or just print newline.
+            // Base `submit` prints newline.
+            const results = this.options.choices
+                .filter((_, i) => this.checkedState[i])
+                .map(c => c.value);
+            if (this._resolve)
+                this._resolve(results);
+            return;
+        }
+        if (char === ' ') {
+            const currentChecked = this.checkedState[this.selectedIndex];
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { max } = this.options;
+            if (!currentChecked && max && selectedCount >= max) {
+                this.errorMsg = `Max ${max} selections allowed.`;
+            }
+            else {
+                this.checkedState[this.selectedIndex] = !currentChecked;
+                this.errorMsg = '';
+            }
+            this.render(false);
+        }
+        if (this.isUp(char)) { // Up
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+            this.errorMsg = '';
+            this.render(false);
+        }
+        if (this.isDown(char)) { // Down
+            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
+exports.CheckboxPrompt = CheckboxPrompt;

package/dist/prompts/confirm.d.ts

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

package/dist/prompts/confirm.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Confirm Prompt ---
+class ConfirmPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? true;
+    }
+    render(firstRender) {
+        // Prepare content
+        const hint = this.value ? `${ansi_1.ANSI.BOLD}Yes${ansi_1.ANSI.RESET}/no` : `yes/${ansi_1.ANSI.BOLD}No${ansi_1.ANSI.RESET}`;
+        let output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(${hint})${ansi_1.ANSI.RESET} `;
+        const text = this.value ? 'Yes' : 'No';
+        output += `${theme_1.theme.main}${text}${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        const c = char.toLowerCase();
+        if (c === '\r' || c === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (c === 'y') {
+            this.value = true;
+            this.render(false);
+        }
+        if (c === 'n') {
+            this.value = false;
+            this.render(false);
+        }
+        // Allow left/right to toggle as well for better UX
+        if (this.isLeft(char) || this.isRight(char)) {
+            this.value = !this.value;
+            this.render(false);
+        }
+    }
+}
+exports.ConfirmPrompt = ConfirmPrompt;

package/dist/prompts/date.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { DateOptions } from '../types';
+export declare class DatePrompt extends Prompt<Date, DateOptions> {
+    private selectedField;
+    private errorMsg;
+    private inputBuffer;
+    constructor(options: DateOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/date.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Date Prompt ---
+class DatePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedField = 0; // 0: Year, 1: Month, 2: Day, 3: Hour, 4: Minute
+        this.errorMsg = '';
+        this.inputBuffer = '';
+        this.value = options.initial || new Date();
+    }
+    render(firstRender) {
+        // Date formatting
+        const y = this.value.getFullYear();
+        const m = (this.value.getMonth() + 1).toString().padStart(2, '0');
+        const d = this.value.getDate().toString().padStart(2, '0');
+        const h = this.value.getHours().toString().padStart(2, '0');
+        const min = this.value.getMinutes().toString().padStart(2, '0');
+        const fields = [y, m, d, h, min];
+        const display = fields.map((val, i) => {
+            if (i === this.selectedField)
+                return `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${val}${ansi_1.ANSI.RESET}`;
+            return val;
+        });
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        const dateStr = `${display[0]}-${display[1]}-${display[2]} ${display[3]}:${display[4]}`;
+        let output = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${dateStr} ${theme_1.theme.muted}(Use arrows or type)${ansi_1.ANSI.RESET}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (this.isLeft(char)) { // Left
+            this.selectedField = Math.max(0, this.selectedField - 1);
+            this.inputBuffer = ''; // Reset buffer on move
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) { // Right
+            this.selectedField = Math.min(4, this.selectedField + 1);
+            this.inputBuffer = ''; // Reset buffer on move
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Support numeric input
+        if (/^\d$/.test(char)) {
+            const maxLen = this.selectedField === 0 ? 4 : 2;
+            let nextBuffer = this.inputBuffer + char;
+            if (nextBuffer.length > maxLen) {
+                nextBuffer = char;
+            }
+            const val = parseInt(nextBuffer, 10);
+            let valid = true;
+            if (this.selectedField === 1 && (val < 1 || val > 12))
+                valid = false; // Month
+            if (this.selectedField === 2 && (val < 1 || val > 31))
+                valid = false; // Day (rough check)
+            if (this.selectedField === 3 && (val > 23))
+                valid = false; // Hour
+            if (this.selectedField === 4 && (val > 59))
+                valid = false; // Minute
+            if (!valid) {
+                nextBuffer = char;
+            }
+            this.inputBuffer = nextBuffer;
+            const finalVal = parseInt(this.inputBuffer, 10);
+            const d = new Date(this.value);
+            if (this.selectedField === 0) {
+                d.setFullYear(finalVal);
+            }
+            else if (this.selectedField === 1)
+                d.setMonth(Math.max(0, Math.min(11, finalVal - 1)));
+            else if (this.selectedField === 2)
+                d.setDate(Math.max(1, Math.min(31, finalVal)));
+            else if (this.selectedField === 3)
+                d.setHours(Math.max(0, Math.min(23, finalVal)));
+            else if (this.selectedField === 4)
+                d.setMinutes(Math.max(0, Math.min(59, finalVal)));
+            this.value = d;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Support standard and application cursor keys
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        if (isUp || isDown) {
+            this.inputBuffer = ''; // Reset buffer on arrow move
+            const dir = isUp ? 1 : -1;
+            const d = new Date(this.value);
+            switch (this.selectedField) {
+                case 0:
+                    d.setFullYear(d.getFullYear() + dir);
+                    break;
+                case 1:
+                    d.setMonth(d.getMonth() + dir);
+                    break;
+                case 2:
+                    d.setDate(d.getDate() + dir);
+                    break;
+                case 3:
+                    d.setHours(d.getHours() + dir);
+                    break;
+                case 4:
+                    d.setMinutes(d.getMinutes() + dir);
+                    break;
+            }
+            let valid = true;
+            if (this.options.min && d < this.options.min) {
+                this.errorMsg = 'Date cannot be before minimum allowed.';
+                valid = false;
+            }
+            if (this.options.max && d > this.options.max) {
+                this.errorMsg = 'Date cannot be after maximum allowed.';
+                valid = false;
+            }
+            if (valid) {
+                this.value = d;
+                this.errorMsg = '';
+            }
+            this.render(false);
+        }
+    }
+}
+exports.DatePrompt = DatePrompt;

package/dist/prompts/file.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { FileOptions } from '../types';
+export declare class FilePrompt extends Prompt<string, FileOptions> {
+    private input;
+    private cursor;
+    private suggestions;
+    private selectedSuggestion;
+    private errorMsg;
+    constructor(options: FileOptions);
+    private updateSuggestions;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/file.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// --- Implementation: File Prompt ---
+class FilePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.input = '';
+        this.cursor = 0;
+        this.suggestions = [];
+        this.selectedSuggestion = -1;
+        this.errorMsg = '';
+        this.input = options.basePath || '';
+        this.cursor = this.input.length;
+    }
+    updateSuggestions() {
+        try {
+            const dir = path.dirname(this.input) || '.';
+            const partial = 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 => {
+                    const fullPath = path.join(dir, f);
+                    // Handle errors if file doesn't exist or permission denied
+                    try {
+                        const isDir = fs.statSync(fullPath).isDirectory();
+                        if (this.options.onlyDirectories && !isDir)
+                            return false;
+                        if (this.options.extensions && !isDir) {
+                            return this.options.extensions.some(ext => f.endsWith(ext));
+                        }
+                        return true;
+                    }
+                    catch (e) {
+                        return false;
+                    }
+                })
+                    .map(f => {
+                    const fullPath = path.join(dir, f);
+                    try {
+                        if (fs.statSync(fullPath).isDirectory())
+                            return f + '/';
+                    }
+                    catch (e) { /* ignore */ }
+                    return f;
+                });
+            }
+            else {
+                this.suggestions = [];
+            }
+        }
+        catch (e) {
+            this.suggestions = [];
+        }
+        this.selectedSuggestion = -1;
+    }
+    render(firstRender) {
+        // Construct string
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${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
+            const maxShow = 5;
+            const displayed = this.suggestions.slice(0, maxShow);
+            displayed.forEach((s, i) => {
+                if (i > 0)
+                    output += '\n';
+                if (i === this.selectedSuggestion) {
+                    output += `${theme_1.theme.main}❯ ${s}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    output += `  ${s}`;
+                }
+            });
+            if (this.suggestions.length > maxShow) {
+                output += `\n  ...and ${this.suggestions.length - maxShow} more`;
+            }
+        }
+        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
+        if (totalLines > 1) {
+            this.print(`\x1b[${totalLines - 1}A`);
+        }
+        // Move right
+        const prefix = `${icon} ${theme_1.theme.title}${this.options.message} `;
+        const prefixLen = this.stripAnsi(prefix).length;
+        // Cursor is usually at the end of input unless we add backspace support etc.
+        // The cursor property tracks it, but my handleInput simplified it.
+        // Let's rely on this.input.length for now since handleInput appends.
+        // Ah, handleInput logic below supports cursor pos theoretically but I only see appending?
+        // Actually handleInput doesn't support left/right in the original code, it supports down/up for suggestions.
+        // So cursor is always at end.
+        const targetCol = prefixLen + this.input.length;
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (targetCol > 0)
+            this.print(`\x1b[${targetCol}C`);
+    }
+    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]);
+                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 {
+                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);
+            }
+            return;
+        }
+        if (this.isDown(char)) { // Down
+            if (this.suggestions.length > 0) {
+                this.selectedSuggestion = (this.selectedSuggestion + 1) % Math.min(this.suggestions.length, 5);
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isUp(char)) { // Up
+            if (this.suggestions.length > 0) {
+                this.selectedSuggestion = (this.selectedSuggestion - 1 + Math.min(this.suggestions.length, 5)) % Math.min(this.suggestions.length, 5);
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.input.length > 0) {
+                this.input = this.input.slice(0, -1);
+                this.updateSuggestions();
+                this.render(false);
+            }
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.input += char;
+            this.updateSuggestions();
+            this.render(false);
+        }
+    }
+}
+exports.FilePrompt = FilePrompt;

package/dist/prompts/list.d.ts

@@ -0,0 +1,9 @@
+import { Prompt } from '../base';
+import { ListOptions } from '../types';
+export declare class ListPrompt extends Prompt<string[], ListOptions> {
+    private currentInput;
+    private errorMsg;
+    constructor(options: ListOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}