mepcli 0.2.1 → 0.2.6

package/dist/prompts/list.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: List Prompt ---
+class ListPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.currentInput = '';
+        this.errorMsg = '';
+        this.value = options.initial || [];
+    }
+    render(firstRender) {
+        // Prepare content
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        let mainLine = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        // Render Tags
+        if (this.value.length > 0) {
+            this.value.forEach((tag) => {
+                mainLine += `${theme_1.theme.main}[${tag}]${ansi_1.ANSI.RESET} `;
+            });
+        }
+        // Render Current Input
+        mainLine += `${this.currentInput}`;
+        let output = mainLine;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        // Use Double Buffering
+        this.renderFrame(output);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        // If we printed an error, the cursor is at the end of the error line.
+        // We need to move it back to the end of the input line.
+        if (this.errorMsg) {
+            // Move up one line (since error is always on the next line in this simple implementation)
+            this.print(ansi_1.ANSI.UP);
+            // Move to the correct column.
+            // We need to calculate visual length of mainLine to place cursor correctly.
+            // stripAnsi is available in base class now.
+            const visualLength = this.stripAnsi(mainLine).length;
+            this.print(ansi_1.ANSI.CURSOR_LEFT); // Go to start
+            if (visualLength > 0) {
+                this.print(`\x1b[${visualLength}C`);
+            }
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            if (this.currentInput.trim()) {
+                this.value.push(this.currentInput.trim());
+                this.currentInput = '';
+                this.errorMsg = '';
+                this.render(false);
+            }
+            else {
+                // Done if input is empty
+                if (this.options.validate) {
+                    const result = this.options.validate(this.value);
+                    if (result !== true) {
+                        this.errorMsg = typeof result === 'string' ? result : 'Invalid input';
+                        this.render(false);
+                        return;
+                    }
+                }
+                this.submit(this.value);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.currentInput.length > 0) {
+                this.currentInput = this.currentInput.slice(0, -1);
+                this.render(false);
+            }
+            else if (this.value.length > 0) {
+                this.value.pop();
+                this.render(false);
+            }
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.currentInput += char;
+            this.render(false);
+        }
+    }
+}
+exports.ListPrompt = ListPrompt;

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

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { MultiSelectOptions } from '../types';
+export declare class MultiSelectPrompt extends Prompt<any[], MultiSelectOptions> {
+    private selectedIndex;
+    private checkedState;
+    private searchBuffer;
+    private scrollTop;
+    private readonly pageSize;
+    private errorMsg;
+    constructor(options: MultiSelectOptions);
+    private getFilteredChoices;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/multi-select.js

@@ -0,0 +1,123 @@
+"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) {
+        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}`; // No newline at end
+        }
+        else {
+            const visible = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visible.forEach((choice, index) => {
+                if (index > 0)
+                    output += '\n';
+                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}`;
+            });
+        }
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    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 stringValue;
+    private cursor;
+    private errorMsg;
+    constructor(options: NumberOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/number.js

@@ -0,0 +1,133 @@
+"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.stringValue = '';
+        this.cursor = 0;
+        this.errorMsg = '';
+        // We work with string for editing, but value property stores the parsed number ultimately
+        // Initialize stringValue from initial
+        this.stringValue = options.initial !== undefined ? options.initial.toString() : '';
+        this.cursor = this.stringValue.length;
+    }
+    render(firstRender) {
+        // Prepare content
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        // Prefix
+        let output = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        // Value
+        output += `${theme_1.theme.main}${this.stringValue}${ansi_1.ANSI.RESET}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        // Restore cursor position
+        // If errorMsg, we are on the line below the input.
+        if (this.errorMsg) {
+            this.print(ansi_1.ANSI.UP);
+        }
+        // Calculate visual offset
+        const prefix = `${icon} ${theme_1.theme.title}${this.options.message} `;
+        const prefixLen = this.stripAnsi(prefix).length;
+        const targetCol = prefixLen + this.cursor;
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (targetCol > 0) {
+            this.print(`\x1b[${targetCol}C`);
+        }
+    }
+    handleInput(char) {
+        // Enter
+        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;
+            }
+            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;
+            }
+            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;
+            // Round to avoid float errors
+            num = Math.round(num * 10000) / 10000;
+            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;
+            // Round to avoid float errors
+            num = Math.round(num * 10000) / 10000;
+            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 -)
+        if (/^[0-9.\-]+$/.test(char)) {
+            // 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,14 @@
+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;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/select.js

@@ -0,0 +1,148 @@
+"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;
+        // 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());
+        });
+    }
+    render(firstRender) {
+        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}` : '';
+        // Note: We avoid ERASE_LINE here because renderFrame handles full redraw
+        output += `${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 += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
+            // We can omit newline at the very end if we want, but usually it's better to be consistent.
+            // renderFrame adds newline via truncate logic? No, it joins.
+            // So if I want a line break, I must add it.
+        }
+        else {
+            const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleChoices.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                if (index > 0)
+                    output += '\n'; // Separator between items
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || '────────'}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    if (actualIndex === this.selectedIndex) {
+                        output += `${theme_1.theme.main}❯ ${choice.title}${ansi_1.ANSI.RESET}`;
+                    }
+                    else {
+                        output += `  ${choice.title}`;
+                    }
+                }
+            });
+        }
+        // No manual printing. Pass to renderFrame.
+        this.renderFrame(output);
+    }
+    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();
+            // Cursor is shown by cleanup
+            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,49 @@
+"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) {
+        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 || '';
+        const output = `${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}`;
+        this.renderFrame(output);
+    }
+    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);
+            // Round to avoid float errors
+            this.value = Math.round(this.value * 10000) / 10000;
+            this.render(false);
+        }
+        if (this.isRight(char)) { // Right
+            this.value = Math.min(this.options.max, this.value + step);
+            // Round to avoid float errors
+            this.value = Math.round(this.value * 10000) / 10000;
+            this.render(false);
+        }
+    }
+}
+exports.SliderPrompt = SliderPrompt;

package/dist/prompts/text.d.ts

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