mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/scroll.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+class ScrollPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.scrollTop = 0;
+        this.hasReachedBottom = false;
+        this.showError = false;
+        // Normalize newlines and split content
+        this.lines = (options.content || '').replace(/\r\n/g, '\n').split('\n');
+        this.height = options.height || 15;
+        // Initial check if content fits without scrolling
+        if (this.lines.length <= this.height) {
+            this.hasReachedBottom = true;
+        }
+    }
+    render(_firstRender) {
+        const width = this.stdout.columns || 80;
+        const contentWidth = width - 4; // Border (2) + Padding (2)
+        // 1. Header & Progress
+        const percent = Math.min(100, Math.round(((this.scrollTop + this.height) / Math.max(this.height, this.lines.length)) * 100));
+        const header = `${theme_1.theme.title}${symbols_1.symbols.pointer} ${ansi_1.ANSI.BOLD}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}[${percent}%]${ansi_1.ANSI.RESET}`;
+        // 2. Viewport
+        const visibleLines = this.lines.slice(this.scrollTop, this.scrollTop + this.height);
+        // Fill empty lines if content is shorter than height
+        while (visibleLines.length < this.height) {
+            visibleLines.push('');
+        }
+        const borderTop = `${theme_1.theme.muted}${symbols_1.symbols.topLeft}${symbols_1.symbols.horizontal.repeat(width - 2)}${symbols_1.symbols.topRight}${ansi_1.ANSI.RESET}`;
+        const borderBottom = `${theme_1.theme.muted}${symbols_1.symbols.bottomLeft}${symbols_1.symbols.horizontal.repeat(width - 2)}${symbols_1.symbols.bottomRight}${ansi_1.ANSI.RESET}`;
+        const contentRows = visibleLines.map(line => {
+            let displayLine = line;
+            const len = (0, utils_1.stringWidth)(displayLine);
+            if (len > contentWidth) {
+                // Truncate
+                displayLine = this.truncate(displayLine, contentWidth);
+            }
+            else {
+                // Pad
+                displayLine += ' '.repeat(contentWidth - len);
+            }
+            return `${theme_1.theme.muted}${symbols_1.symbols.vertical}${ansi_1.ANSI.RESET} ${displayLine} ${theme_1.theme.muted}${symbols_1.symbols.vertical}${ansi_1.ANSI.RESET}`;
+        });
+        // 3. Footer / Status
+        let footer = '';
+        if (this.showError) {
+            footer = `${theme_1.theme.error}>> Please scroll to the bottom before proceeding.${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.options.requireScrollToBottom && !this.hasReachedBottom) {
+            footer = `${theme_1.theme.muted}(Scroll down to read more)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            footer = `${theme_1.theme.success}>> Press Enter to accept${ansi_1.ANSI.RESET}`;
+        }
+        const output = [
+            header,
+            borderTop,
+            ...contentRows,
+            borderBottom,
+            footer
+        ].join('\n');
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.options.requireScrollToBottom && !this.hasReachedBottom) {
+                this.showError = true;
+                this.render(false);
+                return;
+            }
+            this.submit(true);
+            return;
+        }
+        let didScroll = false;
+        // Up / k
+        if (this.isUp(char) || char === 'k') {
+            if (this.scrollTop > 0) {
+                this.scrollTop--;
+                didScroll = true;
+            }
+        }
+        // Down / j
+        else if (this.isDown(char) || char === 'j') {
+            if (this.scrollTop + this.height < this.lines.length) {
+                this.scrollTop++;
+                didScroll = true;
+            }
+        }
+        // PageUp
+        else if (key.toString('hex') === '1b5b357e') { // Standard PageUp sequence
+            this.scrollTop = Math.max(0, this.scrollTop - this.height);
+            didScroll = true;
+        }
+        // PageDown / Space
+        else if (char === ' ' || key.toString('hex') === '1b5b367e') { // Standard PageDown sequence
+            this.scrollTop = Math.min(this.lines.length - this.height, this.scrollTop + this.height);
+            if (this.scrollTop < 0)
+                this.scrollTop = 0; // Fix if content < height
+            didScroll = true;
+        }
+        // Home
+        else if (key.toString('hex') === '1b5b48') {
+            this.scrollTop = 0;
+            didScroll = true;
+        }
+        // End
+        else if (key.toString('hex') === '1b5b46') {
+            this.scrollTop = Math.max(0, this.lines.length - this.height);
+            didScroll = true;
+        }
+        if (didScroll) {
+            this.showError = false;
+            // Check if reached bottom
+            if (this.scrollTop + this.height >= this.lines.length) {
+                this.hasReachedBottom = true;
+            }
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            let didScroll = false;
+            if (event.scroll === 'up') {
+                if (this.scrollTop > 0) {
+                    this.scrollTop--;
+                    didScroll = true;
+                }
+            }
+            else if (event.scroll === 'down') {
+                if (this.scrollTop + this.height < this.lines.length) {
+                    this.scrollTop++;
+                    didScroll = true;
+                }
+            }
+            if (didScroll) {
+                this.showError = false;
+                if (this.scrollTop + this.height >= this.lines.length) {
+                    this.hasReachedBottom = true;
+                }
+                this.render(false);
+            }
+        }
+    }
+}
+exports.ScrollPrompt = ScrollPrompt;

package/dist/prompts/seat.d.ts

@@ -0,0 +1,17 @@
+import { Prompt } from '../base';
+import { SeatOptions, MouseEvent } from '../types';
+export declare class SeatPrompt extends Prompt<string[], SeatOptions> {
+    private grid;
+    private cursorX;
+    private cursorY;
+    private selected;
+    private height;
+    private width;
+    private initializedCursor;
+    constructor(options: SeatOptions);
+    private parseLayout;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+    private move;
+}

package/dist/prompts/seat.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeatPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+class SeatPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.grid = [];
+        this.cursorX = 0;
+        this.cursorY = 0;
+        this.selected = new Set();
+        this.height = 0;
+        this.width = 0;
+        this.initializedCursor = false;
+        this.parseLayout();
+        if (options.initial) {
+            options.initial.forEach(id => this.selected.add(id));
+        }
+        this.checkWindowsAttention();
+    }
+    parseLayout() {
+        this.height = this.options.layout.length;
+        this.width = 0;
+        this.grid = this.options.layout.map((line, y) => {
+            if (line.length > this.width)
+                this.width = line.length;
+            return line.split('').map((char, x) => {
+                const isGap = char === '_' || char === ' ';
+                // Convention: 'X' is occupied.
+                const isOccupied = char.toUpperCase() === 'X';
+                // Label generation: Rows (A, B...), Cols (1, 2...)
+                const rowLabel = this.options.rows ? (this.options.rows[y] || String(y + 1)) : String.fromCharCode(65 + y);
+                const colLabel = this.options.cols ? (this.options.cols[x] || String(x + 1)) : String(x + 1);
+                const label = `${rowLabel}${colLabel}`;
+                const selectable = !isGap;
+                let status = 'available';
+                if (isOccupied)
+                    status = 'occupied';
+                if (this.selected.has(label))
+                    status = 'selected'; // Though this is dynamic state
+                // Initialize cursor to first available seat
+                if (selectable && status !== 'occupied' && !this.initializedCursor) {
+                    this.cursorX = x;
+                    this.cursorY = y;
+                    this.initializedCursor = true;
+                }
+                return {
+                    x, y, char, label, selectable, status
+                };
+            });
+        });
+    }
+    render(_firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        output += `${theme_1.theme.muted}(Use arrows to move, Space to select, Enter to confirm)${ansi_1.ANSI.RESET}\n\n`;
+        this.grid.forEach((row, y) => {
+            let lineStr = '';
+            row.forEach((node, x) => {
+                const isCursor = x === this.cursorX && y === this.cursorY;
+                const isSelected = this.selected.has(node.label);
+                const charDisplay = node.char;
+                // If occupied, maybe show a different char or color
+                let style = ansi_1.ANSI.RESET;
+                if (node.status === 'occupied') {
+                    style = ansi_1.ANSI.FG_RED;
+                }
+                else if (!node.selectable) {
+                    style = theme_1.theme.muted;
+                }
+                else {
+                    style = theme_1.theme.main; // Available seats
+                }
+                if (isSelected) {
+                    style = ansi_1.ANSI.BG_GREEN + ansi_1.ANSI.FG_BLACK;
+                }
+                if (isCursor) {
+                    // Combine styles? Cursor overrides everything usually
+                    style = ansi_1.ANSI.BG_CYAN + ansi_1.ANSI.FG_BLACK;
+                }
+                lineStr += style + charDisplay + ansi_1.ANSI.RESET + ' ';
+            });
+            output += lineStr + '\n';
+        });
+        // Show Legend or Current Selection
+        if (this.selected.size > 0) {
+            output += `\n${theme_1.theme.success}Selected: ${Array.from(this.selected).join(', ')}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(Array.from(this.selected));
+            return;
+        }
+        if (char === ' ') {
+            const row = this.grid[this.cursorY];
+            if (!row)
+                return;
+            const node = row[this.cursorX];
+            if (node && node.selectable && node.status !== 'occupied') {
+                if (this.selected.has(node.label)) {
+                    this.selected.delete(node.label);
+                }
+                else {
+                    if (!this.options.multiple)
+                        this.selected.clear();
+                    this.selected.add(node.label);
+                }
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isUp(char))
+            this.move(0, -1);
+        else if (this.isDown(char))
+            this.move(0, 1);
+        else if (this.isLeft(char))
+            this.move(-1, 0);
+        else if (this.isRight(char))
+            this.move(1, 0);
+        // Tab / Shift+Tab
+        else if (char === '\t')
+            this.move(1, 0);
+        else if (char === '\u001b[Z')
+            this.move(-1, 0);
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up')
+                this.move(0, -1);
+            else if (event.scroll === 'down')
+                this.move(0, 1);
+        }
+    }
+    move(dx, dy) {
+        let nx = this.cursorX;
+        let ny = this.cursorY;
+        let limit = Math.max(this.width, this.height) + 10;
+        do {
+            nx += dx;
+            ny += dy;
+            limit--;
+            // Boundary Check
+            if (ny < 0 || ny >= this.height)
+                return;
+            const row = this.grid[ny];
+            if (!row)
+                return;
+            if (nx < 0 || nx >= row.length)
+                return;
+            const node = row[nx];
+            // Stop if node is selectable (seat or occupied seat)
+            // Skip gaps ('_' or ' ')
+            if (node.selectable) {
+                this.cursorX = nx;
+                this.cursorY = ny;
+                this.render(false);
+                return;
+            }
+        } while (limit > 0);
+    }
+}
+exports.SeatPrompt = SeatPrompt;

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

@@ -0,0 +1,8 @@
+import { SelectRangeOptions } from '../types';
+import { SelectPrompt } from './select';
+export declare class SelectRangePrompt<V> extends SelectPrompt<V, SelectRangeOptions<V>> {
+    protected anchorIndex: number | null;
+    constructor(options: SelectRangeOptions<V>);
+    protected handleInput(char: string, _key?: Buffer): void;
+    protected render(_firstRender: boolean): void;
+}

package/dist/prompts/select-range.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectRangePrompt = void 0;
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const select_1 = require("./select");
+class SelectRangePrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        super(options);
+        this.anchorIndex = null;
+        if (options.initial) {
+            const maxIdx = Math.max(0, options.choices.length - 1);
+            this.anchorIndex = Math.min(Math.max(0, options.initial[0]), maxIdx);
+            this.selectedIndex = Math.min(Math.max(0, options.initial[1]), maxIdx);
+        }
+    }
+    handleInput(char, _key) {
+        // Handle Enter (Submit)
+        if (char === '\r' || char === '\n') {
+            const choices = this.getFilteredChoices();
+            if (choices.length === 0)
+                return;
+            if (this.isSeparator(choices[this.selectedIndex]))
+                return;
+            let start = this.selectedIndex;
+            let end = this.selectedIndex;
+            if (this.anchorIndex !== null) {
+                start = Math.min(this.anchorIndex, this.selectedIndex);
+                end = Math.max(this.anchorIndex, this.selectedIndex);
+            }
+            const selectedItems = [];
+            for (let i = start; i <= end; i++) {
+                const choice = choices[i];
+                if (!this.isSeparator(choice)) {
+                    selectedItems.push(choice.value);
+                }
+            }
+            this.submit(selectedItems);
+            return;
+        }
+        // Handle Space (Anchor)
+        if (char === ' ') {
+            if (this.anchorIndex === null) {
+                this.anchorIndex = this.selectedIndex;
+            }
+            else {
+                this.anchorIndex = null;
+            }
+            this.render(false);
+            return;
+        }
+        // Delegate navigation and search to SelectPrompt
+        super.handleInput(char);
+        // Check bounds after navigation/filtering
+        const choices = this.getFilteredChoices();
+        if (this.anchorIndex !== null && this.anchorIndex >= choices.length) {
+            this.anchorIndex = null;
+        }
+    }
+    render(_firstRender) {
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Scroll Logic
+        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);
+        }
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        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}`;
+        }
+        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';
+                let isSelected = false;
+                if (this.anchorIndex !== null) {
+                    const min = Math.min(this.anchorIndex, this.selectedIndex);
+                    const max = Math.max(this.anchorIndex, this.selectedIndex);
+                    if (actualIndex >= min && actualIndex <= max) {
+                        isSelected = true;
+                    }
+                }
+                else if (actualIndex === this.selectedIndex) {
+                    isSelected = true;
+                }
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || symbols_1.symbols.line.repeat(8)}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    let prefix = '  ';
+                    const title = choice.title;
+                    let content = title;
+                    // Anchor Marker
+                    if (actualIndex === this.anchorIndex) {
+                        prefix = `${theme_1.theme.muted}> ${ansi_1.ANSI.RESET}`;
+                    }
+                    // Cursor Marker
+                    if (actualIndex === this.selectedIndex) {
+                        prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                    }
+                    // Combined Marker
+                    if (actualIndex === this.selectedIndex && actualIndex === this.anchorIndex) {
+                        prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer}>`;
+                    }
+                    // Highlighting
+                    if (isSelected) {
+                        // Inside the range (and not cursor/anchor which have their own prefixes)
+                        if (actualIndex !== this.selectedIndex && actualIndex !== this.anchorIndex) {
+                            prefix = `${theme_1.theme.success}* ${ansi_1.ANSI.RESET}`;
+                        }
+                        content = `${theme_1.theme.success}${title}${ansi_1.ANSI.RESET}`;
+                    }
+                    // Underline Cursor
+                    if (actualIndex === this.selectedIndex) {
+                        content = `${ansi_1.ANSI.UNDERLINE}${content}${ansi_1.ANSI.RESET}`;
+                    }
+                    output += `${prefix}${content}`;
+                }
+            });
+        }
+        output += `\n${theme_1.theme.muted}(Space to anchor, Enter to submit)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+}
+exports.SelectRangePrompt = SelectRangePrompt;

package/dist/prompts/select.d.ts

@@ -1,14 +1,14 @@
 import { Prompt } from '../base';
 import { SelectOptions, MouseEvent } from '../types';
-export declare class SelectPrompt<V> extends Prompt<any, SelectOptions<V>> {
-    private selectedIndex;
-    private searchBuffer;
-    private scrollTop;
-    private readonly pageSize;
-    constructor(options: SelectOptions<V>);
-    private isSeparator;
-    private findNextSelectableIndex;
-    private getFilteredChoices;
+export declare class SelectPrompt<V, O extends SelectOptions<V> = SelectOptions<V>> extends Prompt<any, O> {
+    protected selectedIndex: number;
+    protected searchBuffer: string;
+    protected scrollTop: number;
+    protected readonly pageSize: number;
+    constructor(options: O);
+    protected isSeparator(item: any): boolean;
+    protected findNextSelectableIndex(currentIndex: number, direction: 1 | -1): number;
+    protected getFilteredChoices(): (import("../types").Separator | import("../types").SelectChoice<V>)[];
     protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;

package/dist/prompts/semver.d.ts

@@ -0,0 +1,6 @@
+import { SelectPrompt } from './select';
+import { SemVerOptions } from '../types';
+export declare class SemVerPrompt extends SelectPrompt<string> {
+    constructor(options: SemVerOptions);
+    private static parseVersion;
+}

package/dist/prompts/semver.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemVerPrompt = void 0;
+const select_1 = require("./select");
+class SemVerPrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        const { currentVersion, ...baseOptions } = options;
+        const validVersion = SemVerPrompt.parseVersion(currentVersion) || '0.0.1';
+        const [major, minor, patch] = validVersion.split('.').map(Number);
+        const choices = [
+            {
+                title: `Patch (${validVersion} -> ${major}.${minor}.${patch + 1})`,
+                value: `${major}.${minor}.${patch + 1}`
+            },
+            {
+                title: `Minor (${validVersion} -> ${major}.${minor + 1}.0)`,
+                value: `${major}.${minor + 1}.0`
+            },
+            {
+                title: `Major (${validVersion} -> ${major + 1}.0.0)`,
+                value: `${major + 1}.0.0`
+            }
+        ];
+        super({ ...baseOptions, choices });
+    }
+    static parseVersion(version) {
+        // Simple SemVer regex: x.y.z
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+        return match ? match[0] : null;
+    }
+}
+exports.SemVerPrompt = SemVerPrompt;

package/dist/prompts/shortcut.d.ts

@@ -0,0 +1,9 @@
+import { Prompt } from '../base';
+import { ShortcutOptions, ShortcutResult } from '../types';
+export declare class ShortcutPrompt extends Prompt<ShortcutResult, ShortcutOptions> {
+    private currentKey?;
+    constructor(options: ShortcutOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, buffer: Buffer): void;
+    private parseKey;
+}