mepcli 0.2.1 → 0.2.5

package/dist/prompts/multi-select.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiSelectPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: MultiSelect Prompt ---
+class MultiSelectPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.searchBuffer = '';
+        this.scrollTop = 0;
+        this.pageSize = 7;
+        this.errorMsg = '';
+        this.checkedState = options.choices.map(c => !!c.selected);
+        this.selectedIndex = 0;
+    }
+    getFilteredChoices() {
+        if (!this.searchBuffer)
+            return this.options.choices.map((c, i) => ({ ...c, originalIndex: i }));
+        return this.options.choices
+            .map((c, i) => ({ ...c, originalIndex: i }))
+            .filter(c => c.title.toLowerCase().includes(this.searchBuffer.toLowerCase()));
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        // This is tricky because height changes with filter.
+        // Simplified clearing:
+        if (!firstRender) {
+            this.print(ansi_1.ANSI.ERASE_DOWN); // Clear everything below cursor
+            // But we need to move cursor up to start of prompt
+            // We can store last height?
+        }
+        // Wait, standard render loop usually assumes fixed position or we manually handle it.
+        // Let's use ERASE_LINE + UP loop like SelectPrompt but simpler since we have full screen control in a way
+        // Actually, let's just clear screen? No, that's bad.
+        // Let's stick to SelectPrompt's strategy.
+        if (!firstRender) {
+            // Hack: Just clear last 10 lines to be safe? No.
+            // We will implement proper tracking later if needed, for now standard clear
+            // Let's re-use SelectPrompt logic structure if possible, but distinct implementation here.
+            // Simplest: Always move to top of prompt and erase down.
+            // Assuming we track how many lines we printed.
+        }
+        // ... Implementation detail: use a simpler clear strategy:
+        // Move to start of prompt line (we need to track lines printed in previous frame)
+        if (this.lastRenderLines) {
+            this.print(`\x1b[${this.lastRenderLines}A`);
+            this.print(ansi_1.ANSI.ERASE_DOWN);
+        }
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Adjust Scroll
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        if (this.scrollTop > choices.length - 1) {
+            this.scrollTop = Math.max(0, choices.length - this.pageSize);
+        }
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            const visible = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visible.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                const cursor = actualIndex === this.selectedIndex ? `${theme_1.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
+                const isChecked = this.checkedState[choice.originalIndex];
+                const checkbox = isChecked
+                    ? `${theme_1.theme.success}◉${ansi_1.ANSI.RESET}`
+                    : `${theme_1.theme.muted}◯${ansi_1.ANSI.RESET}`;
+                output += `${cursor} ${checkbox} ${choice.title}\n`;
+            });
+        }
+        if (this.errorMsg) {
+            output += `${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}\n`;
+        }
+        this.print(output);
+        // Count lines
+        const lines = 1 + (choices.length === 0 ? 1 : Math.min(choices.length, this.pageSize)) + (this.errorMsg ? 1 : 0);
+        this.lastRenderLines = lines;
+    }
+    handleInput(char) {
+        const choices = this.getFilteredChoices();
+        if (char === '\r' || char === '\n') {
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { min = 0, max } = this.options;
+            if (selectedCount < min) {
+                this.errorMsg = `Select at least ${min}.`;
+                this.render(false);
+                return;
+            }
+            if (max && selectedCount > max) {
+                this.errorMsg = `Max ${max} allowed.`;
+                this.render(false);
+                return;
+            }
+            const results = this.options.choices
+                .filter((_, i) => this.checkedState[i])
+                .map(c => c.value);
+            this.submit(results);
+            return;
+        }
+        if (char === ' ') {
+            if (choices.length > 0) {
+                const choice = choices[this.selectedIndex];
+                const originalIndex = choice.originalIndex;
+                this.checkedState[originalIndex] = !this.checkedState[originalIndex];
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isUp(char)) { // Up
+            if (choices.length > 0) {
+                this.selectedIndex = (this.selectedIndex - 1 + choices.length) % choices.length;
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isDown(char)) { // Down
+            if (choices.length > 0) {
+                this.selectedIndex = (this.selectedIndex + 1) % choices.length;
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.selectedIndex = 0;
+                this.render(false);
+            }
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.searchBuffer += char;
+            this.selectedIndex = 0;
+            this.render(false);
+        }
+    }
+}
+exports.MultiSelectPrompt = MultiSelectPrompt;

package/dist/prompts/number.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { NumberOptions } from '../types';
+export declare class NumberPrompt extends Prompt<number, NumberOptions> {
+    private cursor;
+    private stringValue;
+    private errorMsg;
+    constructor(options: NumberOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/number.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Number Prompt ---
+class NumberPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.errorMsg = '';
+        this.value = options.initial ?? 0;
+        this.stringValue = this.value.toString();
+        this.cursor = this.stringValue.length;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.SHOW_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);
+            }
+        }
+        // 1. Render the Prompt Message
+        this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+        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} `);
+        // 2. Render the Value
+        this.print(`${theme_1.theme.main}${this.stringValue}${ansi_1.ANSI.RESET}`);
+        // 3. Handle Error Message
+        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);
+            const promptLen = this.options.message.length + 3;
+            const valLen = this.stringValue.length;
+            this.print(`\x1b[1000D\x1b[${promptLen + valLen}C`);
+        }
+        // 4. Position Cursor
+        const diff = this.stringValue.length - this.cursor;
+        if (diff > 0) {
+            this.print(`\x1b[${diff}D`);
+        }
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            const num = parseFloat(this.stringValue);
+            if (isNaN(num)) {
+                this.errorMsg = 'Please enter a valid number.';
+                this.render(false);
+                return;
+            }
+            if (this.options.min !== undefined && num < this.options.min) {
+                this.errorMsg = `Minimum value is ${this.options.min}`;
+                this.render(false);
+                return;
+            }
+            if (this.options.max !== undefined && num > this.options.max) {
+                this.errorMsg = `Maximum value is ${this.options.max}`;
+                this.render(false);
+                return;
+            }
+            if (this.errorMsg) {
+                this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
+            }
+            this.submit(num);
+            return;
+        }
+        // Up Arrow (Increment)
+        if (this.isUp(char)) {
+            let num = parseFloat(this.stringValue) || 0;
+            num += (this.options.step ?? 1);
+            if (this.options.max !== undefined && num > this.options.max)
+                num = this.options.max;
+            this.stringValue = num.toString();
+            this.cursor = this.stringValue.length;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Down Arrow (Decrement)
+        if (this.isDown(char)) {
+            let num = parseFloat(this.stringValue) || 0;
+            num -= (this.options.step ?? 1);
+            if (this.options.min !== undefined && num < this.options.min)
+                num = this.options.min;
+            this.stringValue = num.toString();
+            this.cursor = this.stringValue.length;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.cursor > 0) {
+                this.stringValue = this.stringValue.slice(0, this.cursor - 1) + this.stringValue.slice(this.cursor);
+                this.cursor--;
+                this.errorMsg = '';
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Left
+        if (this.isLeft(char)) {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Right
+        if (this.isRight(char)) {
+            if (this.cursor < this.stringValue.length) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+        // Numeric Input (and . and -)
+        // Simple paste support for numbers is also good
+        if (/^[0-9.\-]+$/.test(char)) {
+            // Basic validation for pasted content
+            if (char.includes('-') && (this.cursor !== 0 || this.stringValue.includes('-') || char.lastIndexOf('-') > 0)) {
+                // If complex paste fails simple checks, ignore or let user correct
+                // For now, strict check on single char logic is preserved if we want, 
+                // but let's allow pasting valid number strings
+            }
+            // Allow if it looks like a number part
+            this.stringValue = this.stringValue.slice(0, this.cursor) + char + this.stringValue.slice(this.cursor);
+            this.cursor += char.length;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
+exports.NumberPrompt = NumberPrompt;

package/dist/prompts/select.d.ts

@@ -0,0 +1,16 @@
+import { Prompt } from '../base';
+import { SelectOptions } from '../types';
+export declare class SelectPrompt extends Prompt<any, SelectOptions> {
+    private selectedIndex;
+    private searchBuffer;
+    private scrollTop;
+    private readonly pageSize;
+    constructor(options: SelectOptions);
+    private isSeparator;
+    private findNextSelectableIndex;
+    private getFilteredChoices;
+    private lastRenderHeight;
+    protected renderWrapper(firstRender: boolean): void;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/select.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Select Prompt ---
+class SelectPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.searchBuffer = '';
+        this.scrollTop = 0;
+        this.pageSize = 7;
+        // Custom render to handle variable height clearing
+        this.lastRenderHeight = 0;
+        // Find first non-separator index
+        this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+    }
+    isSeparator(item) {
+        return item && item.separator === true;
+    }
+    findNextSelectableIndex(currentIndex, direction) {
+        let nextIndex = currentIndex + direction;
+        const choices = this.getFilteredChoices();
+        // Loop around logic
+        if (nextIndex < 0)
+            nextIndex = choices.length - 1;
+        if (nextIndex >= choices.length)
+            nextIndex = 0;
+        if (choices.length === 0)
+            return 0;
+        // Safety check to prevent infinite loop if all are separators (shouldn't happen in practice)
+        let count = 0;
+        while (this.isSeparator(choices[nextIndex]) && count < choices.length) {
+            nextIndex += direction;
+            if (nextIndex < 0)
+                nextIndex = choices.length - 1;
+            if (nextIndex >= choices.length)
+                nextIndex = 0;
+            count++;
+        }
+        return nextIndex;
+    }
+    getFilteredChoices() {
+        if (!this.searchBuffer)
+            return this.options.choices;
+        return this.options.choices.filter(c => {
+            if (this.isSeparator(c))
+                return false; // Hide separators when searching
+            return c.title.toLowerCase().includes(this.searchBuffer.toLowerCase());
+        });
+    }
+    renderWrapper(firstRender) {
+        if (!firstRender && this.lastRenderHeight > 0) {
+            this.print(`\x1b[${this.lastRenderHeight}A`);
+        }
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        // Handle Filtering Edge Case: if list shrinks, scrollTop might be too high
+        if (this.scrollTop > choices.length - 1) {
+            this.scrollTop = Math.max(0, choices.length - this.pageSize);
+        }
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleChoices.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`;
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || '────────'}${ansi_1.ANSI.RESET}\n`;
+                }
+                else {
+                    if (actualIndex === this.selectedIndex) {
+                        output += `${theme_1.theme.main}❯ ${choice.title}${ansi_1.ANSI.RESET}\n`;
+                    }
+                    else {
+                        output += `  ${choice.title}\n`;
+                    }
+                }
+            });
+        }
+        this.print(output);
+        // Clear remaining lines if list shrunk
+        const visibleCount = Math.min(choices.length, this.pageSize);
+        const currentHeight = visibleCount + 1 + (choices.length === 0 ? 1 : 0);
+        const linesToClear = this.lastRenderHeight - currentHeight;
+        if (linesToClear > 0) {
+            for (let i = 0; i < linesToClear; i++) {
+                this.print(`${ansi_1.ANSI.ERASE_LINE}\n`);
+            }
+            this.print(`\x1b[${linesToClear}A`); // Move back up
+        }
+        this.lastRenderHeight = currentHeight;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        this.renderWrapper(firstRender);
+    }
+    handleInput(char) {
+        const choices = this.getFilteredChoices();
+        if (char === '\r' || char === '\n') {
+            if (choices.length === 0) {
+                this.searchBuffer = '';
+                this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+                this.render(false);
+                return;
+            }
+            if (this.isSeparator(choices[this.selectedIndex]))
+                return;
+            this.cleanup();
+            this.print(ansi_1.ANSI.SHOW_CURSOR);
+            if (this._resolve)
+                this._resolve(choices[this.selectedIndex].value);
+            return;
+        }
+        if (this.isUp(char)) { // Up
+            if (choices.length > 0) {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, -1);
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isDown(char)) { // Down
+            if (choices.length > 0) {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, 1);
+                this.render(false);
+            }
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.selectedIndex = 0; // Reset selection
+                this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+                this.render(false);
+            }
+            return;
+        }
+        // Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char)) {
+            this.searchBuffer += char;
+            this.selectedIndex = 0; // Reset selection
+            this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+            this.render(false);
+        }
+    }
+}
+exports.SelectPrompt = SelectPrompt;

package/dist/prompts/slider.d.ts

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

package/dist/prompts/slider.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliderPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Slider Prompt ---
+class SliderPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? options.min;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+        }
+        const width = 20;
+        const range = this.options.max - this.options.min;
+        const ratio = (this.value - this.options.min) / range;
+        const pos = Math.round(ratio * width);
+        let bar = '';
+        for (let i = 0; i <= width; i++) {
+            if (i === pos)
+                bar += `${theme_1.theme.main}O${ansi_1.ANSI.RESET}`;
+            else
+                bar += '─';
+        }
+        const unit = this.options.unit || '';
+        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} [${bar}] ${this.value}${unit}`);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        const step = this.options.step || 1;
+        if (this.isLeft(char)) { // Left
+            this.value = Math.max(this.options.min, this.value - step);
+            this.render(false);
+        }
+        if (this.isRight(char)) { // Right
+            this.value = Math.min(this.options.max, this.value + step);
+            this.render(false);
+        }
+    }
+}
+exports.SliderPrompt = SliderPrompt;

package/dist/prompts/text.d.ts

@@ -0,0 +1,12 @@
+import { Prompt } from '../base';
+import { TextOptions } from '../types';
+export declare class TextPrompt extends Prompt<string, TextOptions> {
+    private errorMsg;
+    private cursor;
+    private hasTyped;
+    private renderLines;
+    constructor(options: TextOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    private validateAndSubmit;
+}