mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/shortcut.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShortcutPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+class ShortcutPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.currentKey = options.initial;
+    }
+    render(_firstRender) {
+        let text = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        if (this.currentKey) {
+            const parts = [];
+            if (this.currentKey.ctrl)
+                parts.push(`${ansi_1.ANSI.REVERSE} Ctrl ${ansi_1.ANSI.RESET}`);
+            if (this.currentKey.meta)
+                parts.push(`${ansi_1.ANSI.REVERSE} Alt ${ansi_1.ANSI.RESET}`);
+            if (this.currentKey.shift)
+                parts.push(`${ansi_1.ANSI.REVERSE} Shift ${ansi_1.ANSI.RESET}`);
+            if (this.currentKey.name) {
+                parts.push(`${ansi_1.ANSI.FG_CYAN}[${this.currentKey.name}]${ansi_1.ANSI.RESET}`);
+            }
+            text += parts.join(' + ');
+            text += ` ${theme_1.theme.muted}(Press Enter to confirm)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            text += `${theme_1.theme.muted}Press any key combination...${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(text);
+    }
+    handleInput(char, buffer) {
+        const raw = buffer.toString();
+        // Enter to confirm
+        if (char === '\r' || char === '\n') {
+            if (this.currentKey) {
+                this.submit(this.currentKey);
+            }
+            return;
+        }
+        // Parse the key
+        const parsed = this.parseKey(char, raw);
+        if (parsed) {
+            this.currentKey = parsed;
+            this.render(false);
+        }
+    }
+    parseKey(char, raw) {
+        let name = '';
+        let ctrl = false;
+        let meta = false;
+        let shift = false;
+        const code = raw.charCodeAt(0);
+        // Control Keys (1-26, except Backspace, Tab, Enter, Esc)
+        if (code >= 1 && code <= 26) {
+            // Exclude special control codes
+            if (char === '\t') { // Ctrl+I
+                name = 'Tab';
+            }
+            else if (char === '\n' || char === '\r') { // Ctrl+J / Ctrl+M
+                name = 'Enter';
+            }
+            else if (char === '\b') { // Ctrl+H
+                name = 'Backspace';
+            }
+            else {
+                ctrl = true;
+                name = String.fromCharCode(code + 64); // 1 -> 'A'
+            }
+        }
+        else if (code === 27) { // Escape
+            if (raw.length === 1) {
+                name = 'Escape';
+            }
+            else {
+                // Sequence starting with ESC
+                meta = true; // Assume Alt for ESC+Char
+                if (raw.length === 2) {
+                    // Alt + Char
+                    name = raw[1].toUpperCase();
+                    // Check shift for Alt+Shift+Char logic?
+                    if (raw[1] >= 'A' && raw[1] <= 'Z')
+                        shift = true;
+                }
+                else {
+                    // CSI sequences
+                    meta = false; // Usually these are navigation
+                    if (raw === '\u001b[A')
+                        name = 'Up';
+                    else if (raw === '\u001b[B')
+                        name = 'Down';
+                    else if (raw === '\u001b[C')
+                        name = 'Right';
+                    else if (raw === '\u001b[D')
+                        name = 'Left';
+                    else if (raw === '\u001b[H')
+                        name = 'Home';
+                    else if (raw === '\u001b[F')
+                        name = 'End';
+                    else if (raw === '\u001b[3~')
+                        name = 'Delete';
+                    else if (raw === '\u001b[Z') {
+                        name = 'Tab';
+                        shift = true;
+                    } // Shift+Tab
+                    else {
+                        name = 'Unknown';
+                    }
+                }
+            }
+        }
+        else if (code === 127) {
+            name = 'Backspace';
+        }
+        else {
+            // Regular char
+            name = char.toUpperCase();
+            if (char >= 'A' && char <= 'Z')
+                shift = true;
+            if (char === ' ')
+                name = 'Space';
+            // Special Symbols map? 
+            // Keep it simple for now.
+        }
+        return {
+            name,
+            ctrl,
+            shift,
+            meta,
+            sequence: raw
+        };
+    }
+}
+exports.ShortcutPrompt = ShortcutPrompt;

package/dist/prompts/slot.d.ts

@@ -0,0 +1,16 @@
+import { Prompt } from '../base';
+import { SlotOptions } from '../types';
+export declare class SlotPrompt extends Prompt<string, SlotOptions> {
+    private selectedIndex;
+    private isSpinning;
+    private isStopping;
+    private spinSpeed;
+    private spinTimer?;
+    private rows;
+    constructor(options: SlotOptions);
+    private spin;
+    private finish;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected render(_firstRender: boolean): void;
+    protected cleanup(): void;
+}

package/dist/prompts/slot.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotPrompt = 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 SlotPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.isSpinning = false;
+        this.isStopping = false;
+        this.spinSpeed = 50; // Initial speed (ms)
+        this.rows = options.rows || 3;
+        // Ensure rows is odd to have a center
+        if (this.rows % 2 === 0)
+            this.rows++;
+        this.selectedIndex = options.initial || 0;
+    }
+    spin() {
+        if (!this.isSpinning)
+            return;
+        this.selectedIndex = (this.selectedIndex + 1) % this.options.choices.length;
+        this.render(false);
+        if (this.isStopping) {
+            // Deceleration physics
+            this.spinSpeed = Math.floor(this.spinSpeed * 1.1);
+            if (this.spinSpeed > 400) {
+                this.isSpinning = false;
+                this.finish();
+                return;
+            }
+        }
+        this.spinTimer = setTimeout(() => this.spin(), this.spinSpeed);
+    }
+    finish() {
+        if (this.spinTimer)
+            clearTimeout(this.spinTimer);
+        this.submit(this.options.choices[this.selectedIndex]);
+    }
+    handleInput(char, _key) {
+        if (char === ' ' || char === '\r' || char === '\n') {
+            if (!this.isSpinning) {
+                // Start spinning
+                this.isSpinning = true;
+                this.isStopping = false;
+                this.spinSpeed = 50; // Reset speed
+                this.spin();
+            }
+            else if (!this.isStopping) {
+                // Initiate stop sequence
+                this.isStopping = true;
+            }
+        }
+    }
+    render(_firstRender) {
+        let output = '';
+        // Header
+        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`;
+        // Calculate dynamic width
+        const maxLen = Math.max(...this.options.choices.map(c => (0, utils_1.stringWidth)(c)));
+        const boxWidth = Math.max(20, maxLen + 6);
+        const border = symbols_1.symbols.line.repeat(boxWidth - 2);
+        output += `┌${border}┐\n`;
+        const centerRow = Math.floor(this.rows / 2);
+        for (let i = 0; i < this.rows; i++) {
+            const offset = i - centerRow;
+            let index = (this.selectedIndex + offset) % this.options.choices.length;
+            if (index < 0)
+                index += this.options.choices.length;
+            const item = this.options.choices[index];
+            const content = this.truncate(item, boxWidth - 4);
+            const contentWidth = (0, utils_1.stringWidth)(content);
+            const padding = boxWidth - 4 - contentWidth;
+            const leftPad = ' '.repeat(Math.floor(padding / 2));
+            const rightPad = ' '.repeat(Math.ceil(padding / 2));
+            const lineContent = `${leftPad}${content}${rightPad}`;
+            if (i === centerRow) {
+                // Highlight
+                output += `│ ${theme_1.theme.main}${ansi_1.ANSI.REVERSE} ${lineContent} ${ansi_1.ANSI.RESET} │ ${theme_1.theme.main}◄${ansi_1.ANSI.RESET}\n`;
+            }
+            else {
+                output += `│  ${lineContent}  │\n`;
+            }
+        }
+        output += `└${border}┘`;
+        // Instructions
+        if (!this.isSpinning) {
+            output += `\n${theme_1.theme.muted}(Press Space/Enter to Spin)${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.isStopping) {
+            output += `\n${theme_1.theme.muted}(Stopping...)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += `\n${theme_1.theme.muted}(Press Space/Enter to Stop)${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    // Override cleanup to ensure timer is cleared if user Ctrl+C
+    cleanup() {
+        if (this.spinTimer)
+            clearTimeout(this.spinTimer);
+        super.cleanup();
+    }
+}
+exports.SlotPrompt = SlotPrompt;

package/dist/prompts/snippet.js

@@ -59,9 +59,6 @@ class SnippetPrompt extends base_1.Prompt {
         // Prefix/Message
         const prefix = `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message || 'Fill snippet'}${ansi_1.ANSI.RESET}\n`;
         output += prefix;
-        // cursorVisualIndex should start after prefix?
-        // Actually renderFrame handles newlines.
-        // We will construct the snippet line.
         let snippetLine = '';
         this.tokens.forEach((token, index) => {
             if (token.type === 'static') {

package/dist/prompts/sort-grid.d.ts

@@ -0,0 +1,16 @@
+import { Prompt } from '../base';
+import { SortGridOptions, MouseEvent } from '../types';
+export declare class SortGridPrompt extends Prompt<string[][], SortGridOptions> {
+    protected cursorX: number;
+    protected cursorY: number;
+    protected grabbedX: number | null;
+    protected grabbedY: number | null;
+    private gridData;
+    private columnWidths;
+    constructor(options: SortGridOptions);
+    private calculateLayout;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+    protected move(direction: 'up' | 'down' | 'left' | 'right'): void;
+}

package/dist/prompts/sort-grid.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortGridPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+class SortGridPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursorX = 0;
+        this.cursorY = 0;
+        this.grabbedX = null;
+        this.grabbedY = null;
+        this.columnWidths = [];
+        // Deep copy grid data
+        this.gridData = options.data.map(row => [...row]);
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        const rows = this.gridData.length;
+        if (rows === 0)
+            return;
+        // Assume consistent column count, use max found if ragged
+        const cols = this.gridData.reduce((max, row) => Math.max(max, row.length), 0);
+        this.columnWidths = new Array(cols).fill(0);
+        for (let r = 0; r < rows; r++) {
+            for (let c = 0; c < this.gridData[r].length; c++) {
+                const cell = this.gridData[r][c] || '';
+                this.columnWidths[c] = Math.max(this.columnWidths[c], (0, utils_1.stringWidth)(cell) + 2); // +2 padding
+            }
+        }
+    }
+    render(_firstRender) {
+        this.calculateLayout();
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        this.gridData.forEach((row, r) => {
+            const rowStr = row.map((cell, c) => {
+                const width = this.columnWidths[c] || (0, utils_1.stringWidth)(cell) + 2;
+                const content = cell || '';
+                // Padding
+                const padding = Math.max(0, width - (0, utils_1.stringWidth)(content));
+                const leftPad = Math.floor(padding / 2);
+                const rightPad = padding - leftPad;
+                let cellStr = ' '.repeat(leftPad) + content + ' '.repeat(rightPad);
+                // Styling
+                const isFocused = (r === this.cursorY && c === this.cursorX);
+                const isGrabbed = (r === this.grabbedY && c === this.grabbedX);
+                if (isGrabbed) {
+                    // Grabbed item style
+                    cellStr = `${ansi_1.ANSI.BG_RED}${ansi_1.ANSI.FG_WHITE}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                else if (isFocused) {
+                    // Focused item style
+                    cellStr = `${ansi_1.ANSI.REVERSE}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                return cellStr;
+            }).join(' '); // Space between columns
+            output += rowStr + '\n';
+        });
+        output += `${theme_1.theme.muted}Arrows to move, Space to grab/drop, Enter to submit${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (char === '\r' || char === '\n') {
+            if (this.grabbedX !== null) {
+                this.grabbedX = null;
+                this.grabbedY = null;
+            }
+            this.submit(this.gridData);
+            return;
+        }
+        if (char === ' ') {
+            if (this.grabbedX === null) {
+                // Grab
+                this.grabbedX = this.cursorX;
+                this.grabbedY = this.cursorY;
+            }
+            else {
+                // Drop
+                this.grabbedX = null;
+                this.grabbedY = null;
+            }
+            this.render(false);
+            return;
+        }
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        const isLeft = this.isLeft(char);
+        const isRight = this.isRight(char);
+        const isTab = char === '\t';
+        const isShiftTab = char === '\u001b[Z';
+        if (isUp)
+            this.move('up');
+        if (isDown)
+            this.move('down');
+        if (isLeft || isShiftTab)
+            this.move('left');
+        if (isRight || isTab)
+            this.move('right');
+    }
+    handleMouse(event) {
+        if (event.scroll === 'up') {
+            this.move('up');
+        }
+        else if (event.scroll === 'down') {
+            this.move('down');
+        }
+    }
+    move(direction) {
+        if (this.gridData.length === 0)
+            return;
+        const oldX = this.cursorX;
+        const oldY = this.cursorY;
+        if (direction === 'up')
+            this.cursorY = Math.max(0, this.cursorY - 1);
+        if (direction === 'down')
+            this.cursorY = Math.min(this.gridData.length - 1, this.cursorY + 1);
+        // Clamp cursorX if we moved to a shorter row
+        if (this.gridData.length > 0) {
+            const rowLen = this.gridData[this.cursorY] ? this.gridData[this.cursorY].length : 0;
+            if (this.cursorX >= rowLen)
+                this.cursorX = Math.max(0, rowLen - 1);
+        }
+        if (direction === 'left')
+            this.cursorX = Math.max(0, this.cursorX - 1);
+        if (direction === 'right') {
+            const rowLen = this.gridData.length > 0 && this.gridData[this.cursorY] ? this.gridData[this.cursorY].length : 0;
+            this.cursorX = Math.min(rowLen - 1, this.cursorX + 1);
+        }
+        // If Grabbed, swap content
+        if (this.grabbedX !== null) {
+            // If we moved
+            if (oldX !== this.cursorX || oldY !== this.cursorY) {
+                const valA = this.gridData[oldY][oldX];
+                const valB = this.gridData[this.cursorY][this.cursorX];
+                this.gridData[oldY][oldX] = valB;
+                this.gridData[this.cursorY][this.cursorX] = valA;
+                this.grabbedX = this.cursorX;
+                this.grabbedY = this.cursorY;
+            }
+        }
+        this.render(false);
+    }
+}
+exports.SortGridPrompt = SortGridPrompt;

package/dist/prompts/sort.js

@@ -58,7 +58,6 @@ class SortPrompt extends base_1.Prompt {
             else if (isSelected) {
                 content = `${theme_1.theme.main}${content}${ansi_1.ANSI.RESET}`;
             }
-            // Index indicator? Maybe not needed, minimalist.
             output += `${prefix}${content}`;
         });
         this.renderFrame(output);

package/dist/prompts/spreadsheet.d.ts

@@ -0,0 +1,21 @@
+import { Prompt } from '../base';
+import { SpreadsheetOptions, MouseEvent } from '../types';
+export declare class SpreadsheetPrompt extends Prompt<Record<string, any>[], SpreadsheetOptions> {
+    private cursorRow;
+    private cursorCol;
+    private scrollRow;
+    private scrollCol;
+    private editMode;
+    private tempValue;
+    private colWidths;
+    private viewportHeight;
+    constructor(options: SpreadsheetOptions);
+    private calculateColWidths;
+    protected render(_firstRender: boolean): void;
+    private pad;
+    protected handleInput(char: string, _key: Buffer): void;
+    private handleNavInput;
+    private startEditing;
+    private handleEditInput;
+    protected handleMouse(event: MouseEvent): void;
+}