mepcli 0.5.5 → 0.6.0

package/dist/prompts/color.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class ColorPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.activeChannel = 'r';
+        this.inputBuffer = '';
+        this.rgb = this.parseHex(options.initial || '#000000');
+    }
+    parseHex(hex) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : { r: 0, g: 0, b: 0 };
+    }
+    rgbToHex(r, g, b) {
+        return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase();
+    }
+    // Helper to format ANSI TrueColor background
+    getBgColorCode(r, g, b) {
+        return `\x1b[48;2;${r};${g};${b}m`;
+    }
+    render(_firstRender) {
+        const { r, g, b } = this.rgb;
+        const hex = this.rgbToHex(r, g, b);
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        output += `${ansi_1.ANSI.BOLD}${hex}${ansi_1.ANSI.RESET}\n\n`;
+        // Preview Block
+        if (this.capabilities.hasTrueColor) {
+            const bg = this.getBgColorCode(r, g, b);
+            const block = `${bg}        ${ansi_1.ANSI.RESET}`; // 8 spaces
+            output += `  ${block}\n`;
+            output += `  ${block}\n`;
+            output += `  ${block}\n\n`;
+        }
+        else {
+            // Fallback for no true color?
+            // Maybe just show text or use closest 256 color?
+            // For now, simpler fallback:
+            output += `  (Preview unavailable in this terminal)\n\n`;
+        }
+        // Sliders
+        const channels = ['r', 'g', 'b'];
+        const labels = { r: 'Red  ', g: 'Green', b: 'Blue ' };
+        channels.forEach(ch => {
+            const val = this.rgb[ch];
+            const isActive = this.activeChannel === ch;
+            // Render slider track
+            // Width 20 chars for 0-255
+            const width = 20;
+            const pos = Math.floor((val / 255) * width);
+            // Wait, '⚪' might be wide. using simpler char if needed. 'O' or ANSI reverse space.
+            // Let's use standard chars.
+            const trackSimple = '━'.repeat(pos) + (isActive ? '●' : '○') + '─'.repeat(width - pos);
+            let line = `${labels[ch]}: ${val.toString().padStart(3)} [${trackSimple}]`;
+            if (isActive) {
+                line = `${theme_1.theme.main}${ansi_1.ANSI.REVERSE} ${line} ${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                line = ` ${line} `;
+            }
+            output += line + '\n';
+        });
+        output += `\n${theme_1.theme.muted}Arrows: Adjust/Switch | Shift+Arrows: Adjust fast | Enter: 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);
+        // Detect Shift key for faster movement (generic check if possible, or mapping specific codes)
+        // \x1b[1;2C is Shift+Right usually. \x1b[1;2D is Shift+Left.
+        // It varies by terminal.
+        const isShiftRight = char === '\x1b[1;2C';
+        const isShiftLeft = char === '\x1b[1;2D';
+        // Channel Switching (Up/Down)
+        if (isUp) {
+            if (this.activeChannel === 'g')
+                this.activeChannel = 'r';
+            else if (this.activeChannel === 'b')
+                this.activeChannel = 'g';
+            this.render(false);
+            return;
+        }
+        if (isDown) {
+            if (this.activeChannel === 'r')
+                this.activeChannel = 'g';
+            else if (this.activeChannel === 'g')
+                this.activeChannel = 'b';
+            this.render(false);
+            return;
+        }
+        // Value Adjustment (Left/Right)
+        if (isLeft || isRight || isShiftLeft || isShiftRight) {
+            let change = 0;
+            if (isRight)
+                change = 1;
+            if (isLeft)
+                change = -1;
+            if (isShiftRight)
+                change = 10;
+            if (isShiftLeft)
+                change = -10;
+            const val = this.rgb[this.activeChannel] + change;
+            this.rgb[this.activeChannel] = Math.max(0, Math.min(255, val));
+            this.render(false);
+            return;
+        }
+        // Tab to cycle channels
+        if (char === '\t') {
+            if (this.activeChannel === 'r')
+                this.activeChannel = 'g';
+            else if (this.activeChannel === 'g')
+                this.activeChannel = 'b';
+            else
+                this.activeChannel = 'r';
+            this.render(false);
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            this.submit(this.rgbToHex(this.rgb.r, this.rgb.g, this.rgb.b));
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            // On scroll, adjust the currently active channel's value.
+            // If Ctrl is held, adjust by a larger step (fast adjust).
+            const fast = !!event.ctrl;
+            const step = fast ? 10 : 1;
+            const change = event.scroll === 'up' ? step : (event.scroll === 'down' ? -step : 0);
+            if (change !== 0) {
+                const val = this.rgb[this.activeChannel] + change;
+                this.rgb[this.activeChannel] = Math.max(0, Math.min(255, val));
+                this.render(false);
+            }
+        }
+    }
+}
+exports.ColorPrompt = ColorPrompt;

package/dist/prompts/confirm.d.ts

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

package/dist/prompts/confirm.js

@@ -10,7 +10,7 @@ class ConfirmPrompt extends base_1.Prompt {
         super(options);
         this.value = options.initial ?? true;
     }
-    render(firstRender) {
+    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} `;

package/dist/prompts/cron.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { CronOptions, MouseEvent } from '../types';
+export declare class CronPrompt extends Prompt<string, CronOptions> {
+    private fields;
+    private activeField;
+    private buffer;
+    constructor(options: CronOptions);
+    private get currentConfig();
+    protected render(_firstRender: boolean): void;
+    private validateCurrentField;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/cron.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const FIELDS = [
+    { label: 'Minute', min: 0, max: 59 },
+    { label: 'Hour', min: 0, max: 23 },
+    { label: 'Day', min: 1, max: 31 },
+    { label: 'Month', min: 1, max: 12 },
+    { label: 'Weekday', min: 0, max: 6 }
+];
+class CronPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.fields = ['*', '*', '*', '*', '*'];
+        this.activeField = 0;
+        this.buffer = '';
+        if (options.initial) {
+            const parts = options.initial.split(' ');
+            if (parts.length === 5) {
+                this.fields = parts;
+            }
+        }
+    }
+    get currentConfig() {
+        return FIELDS[this.activeField];
+    }
+    render(_firstRender) {
+        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}\n`;
+        // Render fields
+        let fieldsStr = '';
+        this.fields.forEach((val, index) => {
+            const isSelected = index === this.activeField;
+            const displayVal = val.padStart(2, ' ');
+            if (isSelected) {
+                fieldsStr += `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${displayVal}${ansi_1.ANSI.RESET} `;
+            }
+            else {
+                fieldsStr += `${ansi_1.ANSI.DIM}${displayVal}${ansi_1.ANSI.RESET} `;
+            }
+        });
+        output += `  ${fieldsStr}\n`;
+        // Render Label and Hints
+        const config = this.currentConfig;
+        output += `  ${theme_1.theme.muted}${config.label} (${config.min}-${config.max})${ansi_1.ANSI.RESET}\n`;
+        output += `  ${ansi_1.ANSI.DIM}(Arrows: Adjust | Space: Toggle * | 0-9: Type | Tab: Next)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    validateCurrentField() {
+        const config = this.currentConfig;
+        const val = this.fields[this.activeField];
+        if (val === '*')
+            return;
+        let num = parseInt(val);
+        if (isNaN(num)) {
+            this.fields[this.activeField] = config.min.toString();
+        }
+        else {
+            num = Math.max(config.min, Math.min(num, config.max));
+            this.fields[this.activeField] = num.toString();
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.validateCurrentField();
+            this.submit(this.fields.join(' '));
+            return;
+        }
+        if (char === '\t' || this.isRight(char)) {
+            this.validateCurrentField();
+            this.activeField = (this.activeField + 1) % 5;
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        // Shift+Tab detection is often '\x1b[Z'
+        if (char === '\x1b[Z' || this.isLeft(char)) {
+            this.validateCurrentField();
+            this.activeField = (this.activeField - 1 + 5) % 5;
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        const config = this.currentConfig;
+        const currentVal = this.fields[this.activeField];
+        let numVal = parseInt(currentVal);
+        if (this.isUp(char)) {
+            if (currentVal === '*') {
+                this.fields[this.activeField] = config.min.toString();
+            }
+            else if (!isNaN(numVal)) {
+                numVal++;
+                if (numVal > config.max)
+                    numVal = config.min;
+                this.fields[this.activeField] = numVal.toString();
+            }
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (currentVal === '*') {
+                this.fields[this.activeField] = config.max.toString();
+            }
+            else if (!isNaN(numVal)) {
+                numVal--;
+                if (numVal < config.min)
+                    numVal = config.max;
+                this.fields[this.activeField] = numVal.toString();
+            }
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        if (char === ' ' || char.toLowerCase() === 'x') {
+            this.fields[this.activeField] = '*';
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        // Direct Input
+        if (/^[0-9]$/.test(char)) {
+            const nextBuffer = this.buffer + char;
+            const nextNum = parseInt(nextBuffer);
+            // Check if valid
+            if (!isNaN(nextNum) && nextNum <= config.max) {
+                this.buffer = nextBuffer;
+                if (nextNum >= 0) { // Should be positive
+                    this.fields[this.activeField] = nextNum.toString();
+                }
+            }
+            else {
+                const freshNum = parseInt(char);
+                if (!isNaN(freshNum) && freshNum <= config.max) {
+                    this.buffer = char;
+                    this.fields[this.activeField] = freshNum.toString();
+                }
+            }
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const config = this.currentConfig;
+            const currentVal = this.fields[this.activeField];
+            let numVal = parseInt(currentVal);
+            if (event.scroll === 'up') { // Increase
+                if (currentVal === '*') {
+                    this.fields[this.activeField] = config.min.toString();
+                }
+                else if (!isNaN(numVal)) {
+                    numVal++;
+                    if (numVal > config.max)
+                        numVal = config.min;
+                    this.fields[this.activeField] = numVal.toString();
+                }
+            }
+            else { // Decrease
+                if (currentVal === '*') {
+                    this.fields[this.activeField] = config.max.toString();
+                }
+                else if (!isNaN(numVal)) {
+                    numVal--;
+                    if (numVal < config.min)
+                        numVal = config.max;
+                    this.fields[this.activeField] = numVal.toString();
+                }
+            }
+            this.buffer = '';
+            this.render(false);
+        }
+    }
+}
+exports.CronPrompt = CronPrompt;

package/dist/prompts/date.d.ts

@@ -5,7 +5,7 @@ export declare class DatePrompt extends Prompt<Date, DateOptions> {
     private errorMsg;
     private inputBuffer;
     constructor(options: DateOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
     private adjustDate;

package/dist/prompts/date.js

@@ -14,7 +14,7 @@ class DatePrompt extends base_1.Prompt {
         this.inputBuffer = '';
         this.value = options.initial || new Date();
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Date formatting
         const y = this.value.getFullYear();
         const m = (this.value.getMonth() + 1).toString().padStart(2, '0');
@@ -52,15 +52,25 @@ class DatePrompt extends base_1.Prompt {
             this.submit(this.value);
             return;
         }
-        if (this.isLeft(char)) { // Left
-            this.selectedField = Math.max(0, this.selectedField - 1);
+        if (char === '\t' || this.isRight(char)) { // Right / Tab
+            if (char === '\t') {
+                this.selectedField = (this.selectedField + 1) % 5;
+            }
+            else {
+                this.selectedField = Math.min(4, 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);
+        if (char === '\x1b[Z' || this.isLeft(char)) { // Left / Shift+Tab
+            if (char === '\x1b[Z') {
+                this.selectedField = (this.selectedField - 1 + 5) % 5;
+            }
+            else {
+                this.selectedField = Math.max(0, this.selectedField - 1);
+            }
             this.inputBuffer = ''; // Reset buffer on move
             this.errorMsg = '';
             this.render(false);

package/dist/prompts/editor.js

@@ -60,7 +60,7 @@ class EditorPrompt extends base_1.Prompt {
                     fs.unlinkSync(this.tempFilePath);
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // Ignore cleanup errors
             }
         }
@@ -168,7 +168,7 @@ class EditorPrompt extends base_1.Prompt {
                     this.tempFilePath = null; // Mark as cleaned
                 }
             }
-            catch (e) {
+            catch (_e) {
                 // Ignore read/delete errors
             }
             this.restoreMep();

package/dist/prompts/file.d.ts

@@ -1,12 +1,19 @@
 import { Prompt } from '../base';
 import { FileOptions } from '../types';
+/**
+ * Implementation of FilePrompt with autocomplete.
+ */
 export declare class FilePrompt extends Prompt<string, FileOptions> {
     private input;
     private cursor;
     private suggestions;
     private selectedSuggestion;
     private errorMsg;
+    private lastLinesUp;
     constructor(options: FileOptions);
+    /**
+     * Updates the suggestions list based on the current input path.
+     */
     private updateSuggestions;
     protected render(firstRender: boolean): void;
     protected handleInput(char: string): void;

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