mepcli 0.2.5 → 0.2.6

package/dist/base.d.ts

@@ -1,3 +1,4 @@
+import { detectCapabilities } from './utils';
 /**
  * Abstract base class for all prompts.
  * Handles common logic like stdin management, raw mode, and cleanup
@@ -10,7 +11,12 @@ export declare abstract class Prompt<T, O> {
     protected stdout: NodeJS.WriteStream;
     private _resolve?;
     private _reject?;
+    private _inputParser;
+    private _onKeyHandler?;
     private _onDataHandler?;
+    protected lastRenderHeight: number;
+    protected lastRenderLines: string[];
+    protected capabilities: ReturnType<typeof detectCapabilities>;
     constructor(options: O);
     /**
      * Renders the UI. Must be implemented by subclasses.
@@ -37,6 +43,13 @@ export declare abstract class Prompt<T, O> {
      * Submits the final value and resolves the promise.
      */
     protected submit(result: T): void;
+    /**
+     * Render Method with Diffing (Virtual DOM for CLI).
+     * Calculates new lines, compares with old lines, and updates only changed parts.
+     */
+    protected renderFrame(content: string): void;
+    protected stripAnsi(str: string): string;
+    protected truncate(str: string, width: number): string;
     protected isUp(char: string): boolean;
     protected isDown(char: string): boolean;
     protected isRight(char: string): boolean;

package/dist/base.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Prompt = void 0;
 const ansi_1 = require("./ansi");
+const input_1 = require("./input");
+const utils_1 = require("./utils");
 /**
  * Abstract base class for all prompts.
  * Handles common logic like stdin management, raw mode, and cleanup
@@ -9,9 +11,14 @@ const ansi_1 = require("./ansi");
  */
 class Prompt {
     constructor(options) {
+        // Smart Cursor State
+        this.lastRenderHeight = 0;
+        this.lastRenderLines = [];
         this.options = options;
         this.stdin = process.stdin;
         this.stdout = process.stdout;
+        this._inputParser = new input_1.InputParser();
+        this.capabilities = (0, utils_1.detectCapabilities)();
     }
     print(text) {
         this.stdout.write(text);
@@ -31,10 +38,14 @@ class Prompt {
             this.stdin.setEncoding('utf8');
             // Initial render: Default to hidden cursor (good for menus)
             // Subclasses like TextPrompt will explicitly show it if needed.
+            if (this.capabilities.isCI) {
+                // In CI, maybe don't hide cursor or do nothing?
+                // But for now follow standard flow.
+            }
             this.print(ansi_1.ANSI.HIDE_CURSOR);
             this.render(true);
-            this._onDataHandler = (buffer) => {
-                const char = buffer.toString();
+            // Setup Input Parser Listeners
+            this._onKeyHandler = (char, buffer) => {
                 // Global Exit Handler (Ctrl+C)
                 if (char === '\u0003') {
                     this.cleanup();
@@ -45,6 +56,10 @@ class Prompt {
                 }
                 this.handleInput(char, buffer);
             };
+            this._inputParser.on('keypress', this._onKeyHandler);
+            this._onDataHandler = (buffer) => {
+                this._inputParser.feed(buffer);
+            };
             this.stdin.on('data', this._onDataHandler);
         });
     }
@@ -55,6 +70,9 @@ class Prompt {
         if (this._onDataHandler) {
             this.stdin.removeListener('data', this._onDataHandler);
         }
+        if (this._onKeyHandler) {
+            this._inputParser.removeListener('keypress', this._onKeyHandler);
+        }
         if (typeof this.stdin.setRawMode === 'function') {
             this.stdin.setRawMode(false);
         }
@@ -70,6 +88,242 @@ class Prompt {
         if (this._resolve)
             this._resolve(result);
     }
+    // --- Rendering Utilities ---
+    /**
+     * Render Method with Diffing (Virtual DOM for CLI).
+     * Calculates new lines, compares with old lines, and updates only changed parts.
+     */
+    renderFrame(content) {
+        // Ensure lines are truncated to terminal width
+        const width = this.stdout.columns || 80;
+        const rawLines = content.split('\n');
+        // Truncate each line and prepare the new buffer
+        const newLines = rawLines.map(line => this.truncate(line, width));
+        // Cursor logic:
+        // We assume the cursor is currently at the END of the last rendered frame.
+        // But to diff, it's easier to always reset to the top of the frame first.
+        // 1. Move Cursor to Top of the Frame
+        if (this.lastRenderHeight > 0) {
+            this.print(`\x1b[${this.lastRenderHeight}A`); // Move up N lines
+            // Actually, if last height was 1 (just one line), we move up 1 line?
+            // "A\n" -> 2 lines. Cursor at bottom.
+            // If we move up, we are at top.
+            // Wait, if lastRenderHeight includes the "current line" which is usually empty if we printed with newlines?
+            // Let's stick to: we printed N lines. Cursor is at line N+1 (start).
+            // To go to line 1, we move up N lines.
+            this.print(`\x1b[${this.lastRenderHeight}A`);
+        }
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        // 2. Diff and Render
+        // We iterate through newLines.
+        // For each line, check if it matches lastRenderLines[i].
+        for (let i = 0; i < newLines.length; i++) {
+            const newLine = newLines[i];
+            const oldLine = this.lastRenderLines[i];
+            if (newLine !== oldLine) {
+                // Move to this line if not already there?
+                // We are writing sequentially, so after writing line i-1 (or skipping it),
+                // the cursor might not be at the start of line i if we skipped.
+                // Strategy:
+                // If we skipped lines, we need to jump down.
+                // But simpler: just move cursor to line i relative to top.
+                // \x1b[<N>B moves down N lines.
+                // But we are processing sequentially.
+                // If we are at line 0 (Top).
+                // Process line 0. 
+                // If changed, write it + \n (or clear line + write).
+                // If unchanged, move cursor down 1 line.
+                // Wait, if we use \n at end of write, cursor moves down.
+                // If we skip writing, we must manually move down.
+                this.print(ansi_1.ANSI.ERASE_LINE); // Clear current line
+                this.print(newLine);
+            }
+            // Prepare for next line
+            if (i < newLines.length - 1) {
+                // If we wrote something, we are at end of line (maybe wrapped?).
+                // Since we truncate, we are not wrapped.
+                // But we didn't print \n yet if we just printed newLine.
+                // To move to next line start:
+                this.print('\n');
+            }
+        }
+        // 3. Clear remaining lines if new output is shorter
+        if (newLines.length < this.lastRenderLines.length) {
+            // We are at the last line of new output.
+            // BUG FIX: If the last line was unchanged, we skipped printing.
+            // The cursor is currently at the START of that line (or end of previous).
+            // We need to ensure we move to the NEXT line (or end of current) before clearing down.
+            // If we just finished loop `i = newLines.length - 1`, we are theoretically at the end of the content.
+            // However, since we might have skipped the last line, we need to be careful.
+            // Let's force move to the end of the visual content we just defined.
+            // Actually, simplest way: Just move cursor to start of line N (where N = newLines.length).
+            // Currently we are at line newLines.length - 1.
+            // We need to move down 1 line?
+            // If newLines has 1 line. Loop runs 0.
+            // If skipped, we are at start of line 0.
+            // We need to be at line 1 to clear from there down.
+            // But we didn't print \n.
+            // So: move cursor to (newLines.length) relative to top.
+            // We started at Top.
+            // We iterated newLines.
+            // We injected \n between lines.
+            // The cursor is implicitly tracking where we are.
+            // IF we skipped, we are physically at start of line `i`.
+            // We need to move over it.
+            // Fix: After the loop, explicitly move to the line AFTER the last line.
+            // Since we know where we started (Top), we can just jump to line `newLines.length`.
+            // But we are in relative movement land.
+            // Let's calculate where we *should* be: End of content.
+            // If we just rendered N lines, we want to be at line N+1 (conceptually) to clear below?
+            // Or just at the start of line N+1?
+            // If we have 2 lines. 
+            // Line 0. \n. Line 1.
+            // Cursor is at end of Line 1.
+            // If we skipped Line 1, cursor is at start of Line 1.
+            // We want to clear everything BELOW Line 1.
+            // So we should be at start of Line 2.
+            // Logic:
+            // 1. We are currently at the cursor position after processing `newLines`.
+            //    If last line was skipped, we are at start of last line.
+            //    If last line was written, we are at end of last line.
+            // 2. We want to erase from the line *following* the last valid line.
+            // We can just calculate the difference and move down if needed.
+            // But simpler: Move cursor to the conceptual "end" of the new frame.
+            // If we processed `newLines.length` lines.
+            // We want to be at row `newLines.length` (0-indexed) to start clearing?
+            // No, rows are 0 to N-1.
+            // We want to clear starting from row N.
+            // Since we can't easily query cursor pos, let's use the fact we reset to Top.
+            // We can move to row N relative to current? 
+            // Wait, `ERASE_DOWN` clears from cursor to end of screen.
+            // If we are at start of Line 1 (and it's valid), `ERASE_DOWN` deletes Line 1!
+            // So we MUST be past Line 1.
+            // If we skipped the last line, we must strictly move past it.
+            // How? `\x1b[1B` (Down).
+            // But we don't track if we skipped the last line explicitly outside the loop.
+            // Let's just track `currentLineIndex`.
+            // Alternate robust approach:
+            // After loop, we forcefully move cursor to `newLines.length` lines down from Top.
+            // We are currently at some unknown state (Start or End of last line).
+            // BUT we can just move UP to Top again and then move DOWN N lines.
+            // That feels safe.
+            // Reset to top of frame (which we are already inside/near).
+            // But we don't know exactly where we are relative to top anymore.
+            // Let's rely on the loop index.
+            // If loop finished, `i` was `newLines.length`.
+            // If `newLines.length > 0`.
+            // If we skipped the last line (index `len-1`), we are at start of it.
+            // If we wrote it, we are at end of it.
+            // If we skipped, we need `\x1b[1B`.
+            // If we wrote, we are at end. `ERASE_DOWN` from end of line clears rest of line + below.
+            // BUT we want to clear BELOW.
+            // `ERASE_DOWN` (J=0) clears from cursor to end of screen.
+            // If at end of line, it clears rest of that line (nothing) and lines below. Correct.
+            // So the issue is ONLY when we skipped the last line.
+            const lastLineIdx = newLines.length - 1;
+            if (lastLineIdx >= 0 && newLines[lastLineIdx] === this.lastRenderLines[lastLineIdx]) {
+                // We skipped the last line. Move down 1 line to ensure we don't delete it.
+                // Also move to start (CR) to be safe?
+                this.print('\n');
+                // Wait, \n moves down AND to start usually. 
+                // But strictly \n is Line Feed (Down). \r is Carriage Return (Left).
+                // Console usually treats \n as \r\n in cooked mode, but in raw mode?
+                // We are in raw mode.
+                // We likely need \r\n or explicit movement.
+                // Let's just use \x1b[1B (Down) and \r (Left).
+                // Actually, if we use `\n` in loop, we rely on it working.
+                // Let's assume `\x1b[1B` is safer for "just move down".
+                // But wait, if we are at start of line, `1B` puts us at start of next line.
+                // `ERASE_DOWN` there is perfect.
+                this.print('\x1b[1B');
+                this.print('\r'); // Move to start
+            }
+            else {
+                // We wrote the last line. We are at the end of it.
+                // `ERASE_DOWN` will clear lines below.
+                // BUT if we want to clear the REST of the screen cleanly starting from next line...
+                // It's mostly fine.
+                // However, there is a subtle case: 
+                // If we wrote the line, we are at the end of it.
+                // If we call ERASE_DOWN, it keeps current line intact (from cursor onwards, which is empty).
+                // And clears below.
+                // This is correct.
+                // EXCEPT: If the old screen had MORE lines, we want to clear them.
+                // If we are at end of Line N-1.
+                // Line N exists in old screen.
+                // ERASE_DOWN clears Line N etc.
+                // Correct.
+            }
+            this.print(ansi_1.ANSI.ERASE_DOWN);
+        }
+        // Update state
+        this.lastRenderLines = newLines;
+        this.lastRenderHeight = newLines.length;
+    }
+    stripAnsi(str) {
+        return (0, utils_1.stripAnsi)(str);
+    }
+    truncate(str, width) {
+        const visualWidth = (0, utils_1.stringWidth)(str);
+        if (visualWidth <= width) {
+            return str;
+        }
+        // Heuristic truncation using stringWidth
+        // We iterate and sum width until we hit limit - 3
+        let currentWidth = 0;
+        let cutIndex = 0;
+        // We need to iterate by Code Point or Grapheme to be safe?
+        // Let's use simple char iteration for speed, but respect ANSI.
+        // Actually, reusing the logic from stringWidth might be best but 
+        // we need the index.
+        let inAnsi = false;
+        for (let i = 0; i < str.length; i++) {
+            const code = str.charCodeAt(i);
+            if (str[i] === '\x1b') {
+                inAnsi = true;
+            }
+            if (inAnsi) {
+                if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
+                    inAnsi = false;
+                }
+            }
+            else {
+                // Width check
+                // Handle surrogates roughly (we don't need perfect width here during loop, just enough to stop)
+                // But wait, we imported `stringWidth`.
+                // We can't easily use `stringWidth` incrementally without re-parsing.
+                // Let's just trust the loop for cut index.
+                // Re-implement basic width logic here for the cut index finding
+                let charWidth = 1;
+                let cp = code;
+                if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
+                    const next = str.charCodeAt(i + 1);
+                    if (next >= 0xDC00 && next <= 0xDFFF) {
+                        cp = (code - 0xD800) * 0x400 + (next - 0xDC00) + 0x10000;
+                        // i is incremented in main loop but we need to skip next char
+                        // We'll handle i increment in the loop
+                    }
+                }
+                // Check range (simplified or call helper)
+                // We don't have isWideCodePoint exported. 
+                // But generally, we can just say:
+                if (cp >= 0x1100) { // Quick check for potentially wide
+                    // It's acceptable to be slightly aggressive on wide chars for truncation
+                    charWidth = 2;
+                }
+                if (currentWidth + charWidth > width - 3) {
+                    cutIndex = i;
+                    break;
+                }
+                currentWidth += charWidth;
+                if (cp > 0xFFFF) {
+                    i++; // Skip low surrogate
+                }
+            }
+            cutIndex = i + 1;
+        }
+        return str.substring(0, cutIndex) + '...' + ansi_1.ANSI.RESET;
+    }
     // Helper to check for arrow keys including application mode
     isUp(char) {
         return char === '\u001b[A' || char === '\u001bOA';

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

@@ -4,6 +4,8 @@ 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

@@ -10,36 +10,55 @@ class CheckboxPrompt extends base_1.Prompt {
         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) {
-        // Ensure cursor is HIDDEN for menus
-        this.print(ansi_1.ANSI.HIDE_CURSOR);
-        if (!firstRender) {
-            const extraLines = this.errorMsg ? 1 : 0;
-            this.print(`\x1b[${this.options.choices.length + 1 + extraLines}A`);
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
         }
-        this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
+        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}?`;
-        this.print(`${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}\n`);
-        this.options.choices.forEach((choice, index) => {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-            const cursor = index === this.selectedIndex ? `${theme_1.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
-            const isChecked = this.checkedState[index];
+        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 = index === this.selectedIndex
+            const title = actualIndex === this.selectedIndex
                 ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
                 : choice.title;
-            this.print(`${cursor} ${checkbox} ${title}\n`);
+            output += `${cursor} ${checkbox} ${title}`;
         });
-        if (this.errorMsg) {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+        // 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.
         }
-        else if (!firstRender) {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}`);
+        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') {
@@ -56,7 +75,10 @@ class CheckboxPrompt extends base_1.Prompt {
                 return;
             }
             this.cleanup();
-            this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
+            // 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);

package/dist/prompts/confirm.js

@@ -11,15 +11,12 @@ class ConfirmPrompt extends base_1.Prompt {
         this.value = options.initial ?? true;
     }
     render(firstRender) {
-        // Hide cursor for confirm, user just hits Y/N or Enter
-        this.print(ansi_1.ANSI.HIDE_CURSOR);
-        if (!firstRender) {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-        }
+        // 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}`;
-        this.print(`${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} `);
+        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';
-        this.print(`${theme_1.theme.main}${text}${ansi_1.ANSI.RESET}\x1b[${text.length}D`);
+        output += `${theme_1.theme.main}${text}${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
     }
     handleInput(char) {
         const c = char.toLowerCase();
@@ -35,6 +32,11 @@ class ConfirmPrompt extends base_1.Prompt {
             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.js

@@ -14,13 +14,7 @@ class DatePrompt extends base_1.Prompt {
         this.value = options.initial || new Date();
     }
     render(firstRender) {
-        this.print(ansi_1.ANSI.HIDE_CURSOR);
-        if (!firstRender) {
-            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
-            if (this.errorMsg) {
-                this.print(ansi_1.ANSI.UP + ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
-            }
-        }
+        // 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');
@@ -34,14 +28,11 @@ class DatePrompt extends base_1.Prompt {
         });
         const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
         const dateStr = `${display[0]}-${display[1]}-${display[2]} ${display[3]}:${display[4]}`;
-        this.print(`${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}`);
+        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) {
-            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
-            this.print(ansi_1.ANSI.UP);
-            // restore cursor pos logic isn't needed as we are on one line mostly, but for consistency:
-            const promptLen = this.options.message.length + 3; // roughly
-            this.print(`\x1b[1000D\x1b[${promptLen + 15}C`); // approx move back
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
         }
+        this.renderFrame(output);
     }
     handleInput(char) {
         if (char === '\r' || char === '\n') {
@@ -66,20 +57,11 @@ class DatePrompt extends base_1.Prompt {
         if (/^\d$/.test(char)) {
             const maxLen = this.selectedField === 0 ? 4 : 2;
             let nextBuffer = this.inputBuffer + char;
-            // If we exceed max length, reset to just the new char (assuming user is starting a new number)
-            // Or better: try to parse.
-            // Logic: 
-            // 1. Try appending.
-            // 2. Validate.
-            // 3. If valid, keep.
-            // 4. If invalid (e.g. Month 13), assume new start -> set buffer to just char.
-            // However, we must respect field limits first.
             if (nextBuffer.length > maxLen) {
                 nextBuffer = char;
             }
             const val = parseInt(nextBuffer, 10);
             let valid = true;
-            // Pre-validation to decide if we should append or reset
             if (this.selectedField === 1 && (val < 1 || val > 12))
                 valid = false; // Month
             if (this.selectedField === 2 && (val < 1 || val > 31))
@@ -89,15 +71,12 @@ class DatePrompt extends base_1.Prompt {
             if (this.selectedField === 4 && (val > 59))
                 valid = false; // Minute
             if (!valid) {
-                // If appending made it invalid (e.g. was '1', typed '3' -> '13' invalid month),
-                // treat '3' as the start of a new number.
                 nextBuffer = char;
             }
             this.inputBuffer = nextBuffer;
             const finalVal = parseInt(this.inputBuffer, 10);
             const d = new Date(this.value);
             if (this.selectedField === 0) {
-                // Year is special, we just set it. 
                 d.setFullYear(finalVal);
             }
             else if (this.selectedField === 1)