mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/number.js

@@ -48,8 +48,6 @@ class NumberPrompt extends base_1.Prompt {
         if (char === '\r' || char === '\n') {
             const num = parseFloat(this.stringValue);
             if (this.stringValue.trim() === '' || isNaN(num)) {
-                // Check if empty is allowed? 
-                // If not required? Assuming required for number prompt usually
                 this.errorMsg = 'Please enter a valid number.';
                 this.render(false);
                 return;

package/dist/prompts/otp.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { OTPOptions } from '../types';
+export declare class OTPPrompt extends Prompt<string, OTPOptions> {
+    private slots;
+    private cursor;
+    private readonly length;
+    constructor(options: OTPOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/otp.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTPPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class OTPPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.length = options.length || 6;
+        this.slots = new Array(this.length).fill('');
+    }
+    render(_firstRender) {
+        const mask = this.options.mask || '_';
+        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`;
+        output += '  '; // Indent
+        for (let i = 0; i < this.length; i++) {
+            const val = this.slots[i];
+            let charToDisplay = mask;
+            if (val) {
+                charToDisplay = this.options.secure ? '*' : val;
+            }
+            else {
+                // Use placeholder char if available at this index
+                if (this.options.placeholder && i < this.options.placeholder.length) {
+                    charToDisplay = this.options.placeholder[i];
+                }
+            }
+            if (i === this.cursor) {
+                output += `${ansi_1.ANSI.REVERSE}${charToDisplay}${ansi_1.ANSI.RESET} `;
+            }
+            else {
+                if (!val) {
+                    output += `${theme_1.theme.muted}${charToDisplay}${ansi_1.ANSI.RESET} `;
+                }
+                else {
+                    output += `${theme_1.theme.main}${charToDisplay}${ansi_1.ANSI.RESET} `;
+                }
+            }
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Digits
+        if (/^\d$/.test(char)) {
+            this.slots[this.cursor] = char;
+            // If we are at the last slot
+            if (this.cursor === this.length - 1) {
+                // Only submit if all slots are filled
+                if (this.slots.every(s => s !== '')) {
+                    this.render(false); // Update view first
+                    this.submit(this.slots.join(''));
+                    return;
+                }
+            }
+            this.cursor++;
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.slots[this.cursor] !== '') {
+                this.slots[this.cursor] = '';
+            }
+            else if (this.cursor > 0) {
+                this.cursor--;
+                this.slots[this.cursor] = '';
+            }
+            this.render(false);
+            return;
+        }
+        // Left Arrow
+        if (this.isLeft(char)) {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Right Arrow
+        if (this.isRight(char)) {
+            if (this.cursor < this.length - 1) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+    }
+}
+exports.OTPPrompt = OTPPrompt;

package/dist/prompts/pattern.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../base';
+import { PatternOptions, MouseEvent } from '../types';
+export declare class PatternPrompt extends Prompt<number[], PatternOptions> {
+    private path;
+    private cursor;
+    private isDragging;
+    private errorMsg;
+    private rows;
+    private cols;
+    private nodeChar;
+    private nodeSpacingX;
+    private nodeSpacingY;
+    private lastMouse;
+    constructor(options: PatternOptions);
+    private getIndex;
+    private getPoint;
+    protected render(firstRender: boolean): void;
+    private drawLine;
+    protected handleInput(char: string, _key: Buffer): void;
+    private addToPath;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/pattern.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class PatternPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.path = [];
+        this.cursor = { r: 0, c: 0 };
+        this.isDragging = false;
+        this.errorMsg = '';
+        // Layout
+        this.nodeSpacingX = 4;
+        this.nodeSpacingY = 2;
+        this.lastMouse = null;
+        this.rows = options.rows || 3;
+        this.cols = options.cols || 3;
+        this.nodeChar = options.nodeChar || '●';
+    }
+    getIndex(r, c) {
+        return r * this.cols + c;
+    }
+    getPoint(index) {
+        return {
+            r: Math.floor(index / this.cols),
+            c: index % this.cols
+        };
+    }
+    render(firstRender) {
+        let output = '';
+        // Title
+        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}\n`;
+        // Instructions
+        if (firstRender) {
+            output += `${ansi_1.ANSI.DIM}(Draw pattern with mouse or use Arrows + Space)${ansi_1.ANSI.RESET}\n`;
+        }
+        // Render Grid
+        // Initialize buffer with spaces
+        // Adjust height/width slightly to ensure we cover full lines
+        const bufferHeight = this.rows * this.nodeSpacingY + 1;
+        const bufferWidth = this.cols * this.nodeSpacingX + 1;
+        const buffer = Array(bufferHeight).fill(null).map(() => Array(bufferWidth).fill(' '));
+        // Draw connections
+        for (let i = 0; i < this.path.length - 1; i++) {
+            this.drawLine(buffer, this.path[i], this.path[i + 1]);
+        }
+        // Draw nodes
+        for (let r = 0; r < this.rows; r++) {
+            for (let c = 0; c < this.cols; c++) {
+                const index = this.getIndex(r, c);
+                const isSelected = this.path.includes(index);
+                // Calculate buffer position
+                const by = r * this.nodeSpacingY;
+                const bx = c * this.nodeSpacingX;
+                // Mark node in buffer (will be stylized later)
+                buffer[by][bx] = isSelected ? '●' : '○';
+            }
+        }
+        // Build string from buffer
+        // Limit loop to actual grid dimensions to avoid trailing empty lines
+        const displayHeight = (this.rows - 1) * this.nodeSpacingY + 1;
+        const displayWidth = (this.cols - 1) * this.nodeSpacingX + 1;
+        for (let y = 0; y < displayHeight; y++) {
+            output += '  '; // Indent
+            for (let x = 0; x < displayWidth; x++) {
+                const char = buffer[y][x];
+                // Determine coloring context
+                const isNodeRow = y % this.nodeSpacingY === 0;
+                const isNodeCol = x % this.nodeSpacingX === 0;
+                if (isNodeRow && isNodeCol) {
+                    const r = y / this.nodeSpacingY;
+                    const c = x / this.nodeSpacingX;
+                    const idx = this.getIndex(r, c);
+                    const isSelected = this.path.includes(idx);
+                    const isLast = this.path.length > 0 && this.path[this.path.length - 1] === idx;
+                    const isCursor = this.cursor.r === r && this.cursor.c === c;
+                    let styledChar = this.nodeChar;
+                    if (isSelected)
+                        styledChar = theme_1.theme.main + this.nodeChar + ansi_1.ANSI.RESET;
+                    if (isLast)
+                        styledChar = theme_1.theme.success + this.nodeChar + ansi_1.ANSI.RESET;
+                    if (isCursor) {
+                        styledChar = ansi_1.ANSI.REVERSE + styledChar + ansi_1.ANSI.RESET;
+                    }
+                    else if (!isSelected) {
+                        styledChar = theme_1.theme.muted + '○' + ansi_1.ANSI.RESET;
+                    }
+                    output += styledChar;
+                }
+                else {
+                    // It's a line or space
+                    if (char !== ' ' && char !== '○' && char !== '●') {
+                        output += theme_1.theme.main + char + ansi_1.ANSI.RESET;
+                    }
+                    else {
+                        output += ' ';
+                    }
+                }
+            }
+            output += '\n';
+        }
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    drawLine(buffer, fromIdx, toIdx) {
+        const p1 = this.getPoint(fromIdx);
+        const p2 = this.getPoint(toIdx);
+        const y1 = p1.r * this.nodeSpacingY;
+        const x1 = p1.c * this.nodeSpacingX;
+        const y2 = p2.r * this.nodeSpacingY;
+        const x2 = p2.c * this.nodeSpacingX;
+        const dy = y2 - y1;
+        const dx = x2 - x1;
+        const steps = Math.max(Math.abs(dx), Math.abs(dy));
+        if (steps === 0)
+            return;
+        const yInc = dy / steps;
+        const xInc = dx / steps;
+        let y = y1;
+        let x = x1;
+        for (let i = 0; i <= steps; i++) {
+            const ry = Math.round(y);
+            const rx = Math.round(x);
+            // Check bounds
+            if (ry >= 0 && ry < buffer.length && rx >= 0 && rx < buffer[0].length) {
+                const isNode = (ry % this.nodeSpacingY === 0) && (rx % this.nodeSpacingX === 0);
+                if (!isNode) {
+                    // Determine char based on slope
+                    // Flat horizontal
+                    if (dy === 0)
+                        buffer[ry][rx] = '─';
+                    // Flat vertical
+                    else if (dx === 0)
+                        buffer[ry][rx] = '│';
+                    // Diagonal
+                    else if ((dx > 0 && dy > 0) || (dx < 0 && dy < 0))
+                        buffer[ry][rx] = '╲';
+                    else
+                        buffer[ry][rx] = '╱';
+                }
+            }
+            y += yInc;
+            x += xInc;
+        }
+    }
+    handleInput(char, _key) {
+        // Navigation
+        if (this.isUp(char)) {
+            this.cursor.r = Math.max(0, this.cursor.r - 1);
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.cursor.r = Math.min(this.rows - 1, this.cursor.r + 1);
+            this.render(false);
+            return;
+        }
+        if (this.isLeft(char)) {
+            this.cursor.c = Math.max(0, this.cursor.c - 1);
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            this.cursor.c = Math.min(this.cols - 1, this.cursor.c + 1);
+            this.render(false);
+            return;
+        }
+        // Selection (Space)
+        if (char === ' ') {
+            const index = this.getIndex(this.cursor.r, this.cursor.c);
+            this.addToPath(index);
+            this.render(false);
+            return;
+        }
+        // Submit (Enter)
+        if (char === '\r' || char === '\n') {
+            if (this.path.length < 2) {
+                this.errorMsg = 'Pattern too short';
+                this.render(false);
+                return;
+            }
+            this.submit(this.path);
+            return;
+        }
+        // Backspace / Reset
+        if (char === '\x7f' || char === '\b') {
+            this.path.pop();
+            this.render(false);
+            return;
+        }
+    }
+    addToPath(index) {
+        if (this.path.includes(index)) {
+            return;
+        }
+        this.path.push(index);
+    }
+    handleMouse(event) {
+        if (event.action === 'release') {
+            this.isDragging = false;
+            this.lastMouse = null;
+            if (this.path.length >= 2) {
+                this.submit(this.path);
+            }
+            return;
+        }
+        if (this.lastMouse) {
+            const dx = event.x - this.lastMouse.x;
+            const dy = event.y - this.lastMouse.y;
+            // Sensitivity threshold
+            if (dx !== 0 || dy !== 0) {
+                if (Math.abs(dx) > Math.abs(dy)) {
+                    if (dx > 0)
+                        this.cursor.c = Math.min(this.cols - 1, this.cursor.c + 1);
+                    else if (dx < 0)
+                        this.cursor.c = Math.max(0, this.cursor.c - 1);
+                }
+                else {
+                    if (dy > 0)
+                        this.cursor.r = Math.min(this.rows - 1, this.cursor.r + 1);
+                    else if (dy < 0)
+                        this.cursor.r = Math.max(0, this.cursor.r - 1);
+                }
+                if (this.isDragging) {
+                    const idx = this.getIndex(this.cursor.r, this.cursor.c);
+                    this.addToPath(idx);
+                }
+                this.render(false);
+            }
+        }
+        else {
+            // Mouse Down
+            if (event.action === 'press' && event.button === 0) {
+                this.isDragging = true;
+                this.path = []; // Reset
+                const idx = this.getIndex(this.cursor.r, this.cursor.c);
+                this.addToPath(idx);
+                this.render(false);
+            }
+        }
+        this.lastMouse = { x: event.x, y: event.y };
+    }
+}
+exports.PatternPrompt = PatternPrompt;

package/dist/prompts/quiz-select.d.ts

@@ -0,0 +1,10 @@
+import { QuizSelectOptions } from '../types';
+import { SelectPrompt } from './select';
+export declare class QuizSelectPrompt<V> extends SelectPrompt<V, QuizSelectOptions<V>> {
+    private status;
+    private isCorrect;
+    private userSelectionIndex;
+    constructor(options: QuizSelectOptions<V>);
+    protected handleInput(char: string): void;
+    protected render(firstRender: boolean): void;
+}

package/dist/prompts/quiz-select.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuizSelectPrompt = void 0;
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const select_1 = require("./select");
+class QuizSelectPrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        super(options);
+        this.status = 'pending';
+        this.isCorrect = false;
+        this.userSelectionIndex = -1;
+    }
+    handleInput(char) {
+        if (this.status === 'revealed') {
+            // Wait for Enter to submit
+            if (char === '\r' || char === '\n') {
+                const choices = this.getFilteredChoices();
+                // Ensure index is valid, though it should be captured
+                const value = choices[this.userSelectionIndex]
+                    ? choices[this.userSelectionIndex].value
+                    : null;
+                this.submit(value);
+            }
+            return;
+        }
+        if (this.status === 'pending') {
+            // Intercept Enter
+            if (char === '\r' || char === '\n') {
+                const choices = this.getFilteredChoices();
+                if (choices.length === 0)
+                    return;
+                if (this.isSeparator(choices[this.selectedIndex]))
+                    return;
+                this.userSelectionIndex = this.selectedIndex;
+                const selectedChoice = choices[this.userSelectionIndex];
+                // Check correctness
+                this.isCorrect = selectedChoice.value === this.options.correctValue;
+                this.status = 'revealed';
+                this.render(false);
+                return;
+            }
+            // Delegate navigation to super
+            super.handleInput(char);
+        }
+    }
+    render(firstRender) {
+        if (this.status === 'pending') {
+            super.render(firstRender);
+            return;
+        }
+        // Revealed State
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Header
+        const icon = this.isCorrect ? `${theme_1.theme.success}${symbols_1.symbols.tick}` : `${theme_1.theme.error}${symbols_1.symbols.cross}`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleChoices.forEach((choice, index) => {
+            if (index > 0)
+                output += '\n';
+            if (this.isSeparator(choice)) {
+                output += `  ${ansi_1.ANSI.DIM}${choice.text || symbols_1.symbols.line.repeat(8)}${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                // Determine absolute index to match with user selection
+                const actualIndex = this.scrollTop + index;
+                const isSelected = actualIndex === this.userSelectionIndex;
+                const isCorrectAnswer = choice.value === this.options.correctValue;
+                let prefix = '  ';
+                let style = ansi_1.ANSI.RESET;
+                if (isSelected) {
+                    if (this.isCorrect) {
+                        prefix = `${theme_1.theme.success}${symbols_1.symbols.pointer} `;
+                        style = theme_1.theme.success;
+                    }
+                    else {
+                        prefix = `${theme_1.theme.error}${symbols_1.symbols.cross} `;
+                        style = theme_1.theme.error;
+                    }
+                }
+                else if (isCorrectAnswer) {
+                    prefix = `${theme_1.theme.success}${symbols_1.symbols.pointer} `;
+                    style = theme_1.theme.success;
+                }
+                output += `${prefix}${style}${choice.title}${ansi_1.ANSI.RESET}`;
+                if (isSelected && !this.isCorrect) {
+                    output += ` ${theme_1.theme.error}(Your Answer)${ansi_1.ANSI.RESET}`;
+                }
+                if (isCorrectAnswer && !isSelected) {
+                    output += ` ${theme_1.theme.success}(Correct)${ansi_1.ANSI.RESET}`;
+                }
+            }
+        });
+        // Explanation
+        if (this.options.explanation) {
+            output += `\n\n${ansi_1.ANSI.BOLD}Explanation:${ansi_1.ANSI.RESET}\n${theme_1.theme.muted}${this.options.explanation}${ansi_1.ANSI.RESET}`;
+        }
+        output += `\n\n${ansi_1.ANSI.DIM}(Press Enter to continue)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+}
+exports.QuizSelectPrompt = QuizSelectPrompt;

package/dist/prompts/quiz-text.d.ts

@@ -0,0 +1,11 @@
+import { QuizTextOptions } from '../types';
+import { TextPrompt } from './text';
+export declare class QuizTextPrompt extends TextPrompt<QuizTextOptions> {
+    private status;
+    private isCorrect;
+    constructor(options: QuizTextOptions);
+    protected handleInput(char: string): void;
+    protected submit(value: string): void;
+    private checkCorrectness;
+    protected render(firstRender: boolean): void;
+}

package/dist/prompts/quiz-text.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuizTextPrompt = void 0;
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const text_1 = require("./text");
+class QuizTextPrompt extends text_1.TextPrompt {
+    constructor(options) {
+        super(options);
+        this.status = 'pending';
+        this.isCorrect = false;
+    }
+    handleInput(char) {
+        if (this.status === 'revealed') {
+            if (char === '\r' || char === '\n') {
+                this.submit(this.value);
+            }
+            return;
+        }
+        super.handleInput(char);
+    }
+    submit(value) {
+        if (this.status === 'pending') {
+            // We caught the submission from TextPrompt logic.
+            // Now verify correctness.
+            this.checkCorrectness(value).then(correct => {
+                this.isCorrect = correct;
+                this.status = 'revealed';
+                this.render(false);
+            });
+        }
+        else {
+            // If revealed (or anything else), we proceed to final submission.
+            // This calls Prompt.submit
+            super.submit(value);
+        }
+    }
+    async checkCorrectness(value) {
+        try {
+            if (this.options.verify) {
+                return await this.options.verify(value);
+            }
+            if (this.options.correctAnswer) {
+                return value.trim().toLowerCase() === this.options.correctAnswer.trim().toLowerCase();
+            }
+            return false;
+        }
+        catch (_e) {
+            return false;
+        }
+    }
+    render(firstRender) {
+        if (this.status === 'pending') {
+            super.render(firstRender);
+            return;
+        }
+        // Revealed State
+        let output = '';
+        const icon = this.isCorrect ? `${theme_1.theme.success}${symbols_1.symbols.tick}` : `${theme_1.theme.error}${symbols_1.symbols.cross}`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        const userValue = this.segments.join('');
+        // Display user input
+        if (this.isCorrect) {
+            output += `  ${theme_1.theme.success}${userValue}${ansi_1.ANSI.RESET} ${theme_1.theme.success}(Correct)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += `  ${theme_1.theme.error}${userValue}${ansi_1.ANSI.RESET} ${theme_1.theme.error}(Wrong)${ansi_1.ANSI.RESET}`;
+        }
+        // Show correct answer if wrong
+        if (!this.isCorrect && this.options.correctAnswer) {
+            output += `\n  ${theme_1.theme.success}Correct Answer: ${this.options.correctAnswer}${ansi_1.ANSI.RESET}`;
+        }
+        // Explanation
+        if (this.options.explanation) {
+            output += `\n\n${ansi_1.ANSI.BOLD}Explanation:${ansi_1.ANSI.RESET}\n${theme_1.theme.muted}${this.options.explanation}${ansi_1.ANSI.RESET}`;
+        }
+        output += `\n\n${ansi_1.ANSI.DIM}(Press Enter to continue)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+}
+exports.QuizTextPrompt = QuizTextPrompt;

package/dist/prompts/regex.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { RegexOptions } from '../types';
+export declare class RegexPrompt extends Prompt<RegExp, RegexOptions> {
+    private input;
+    private cursor;
+    private segments;
+    private error;
+    private regex;
+    constructor(options: RegexOptions);
+    private validateRegex;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+}