mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/kanban.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KanbanPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const utils_1 = require("../utils");
+class KanbanPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.activeCol = 0;
+        this.activeRow = 0;
+        this.grabbed = false;
+        // Deep copy columns to avoid mutating original options during drag/drop
+        this.columns = JSON.parse(JSON.stringify(options.columns));
+        this.scrollStates = new Array(this.columns.length).fill(0);
+    }
+    render(_firstRender) {
+        const { columns } = this.stdout; // terminal width
+        const colCount = this.columns.length;
+        const colWidth = Math.floor(columns / colCount);
+        let output = '';
+        // Render Title
+        output += `${ansi_1.ANSI.FG_CYAN}${ansi_1.ANSI.BOLD}? ${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        if (this.grabbed) {
+            output += `${ansi_1.ANSI.FG_YELLOW}(Grabbed) Move with arrows, Space to Drop${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            output += `${ansi_1.ANSI.FG_GRAY}(Normal) Space to Grab, Arrows to Navigate, Enter to Submit${ansi_1.ANSI.RESET}\n`;
+        }
+        // Render Headers
+        const headers = this.columns.map((col, i) => {
+            const isSelected = i === this.activeCol;
+            const title = this.truncate(col.title, colWidth - 4);
+            const style = isSelected ? `${ansi_1.ANSI.FG_BLUE}${ansi_1.ANSI.BOLD}` : ansi_1.ANSI.BOLD;
+            return this.padCenter(title, colWidth, style);
+        });
+        output += headers.join('') + '\n';
+        // Render Separator
+        output += ansi_1.ANSI.FG_GRAY + '─'.repeat(columns) + ansi_1.ANSI.RESET + '\n';
+        // Render Rows
+        const viewportHeight = 10;
+        for (let r = 0; r < viewportHeight; r++) {
+            const rowLine = this.columns.map((col, cIndex) => {
+                const scrollTop = this.scrollStates[cIndex];
+                const itemIndex = r + scrollTop;
+                const item = col.items[itemIndex];
+                let content = '';
+                if (item) {
+                    const isCursor = cIndex === this.activeCol && itemIndex === this.activeRow;
+                    let prefix = ' ';
+                    const suffix = ' ';
+                    let style = '';
+                    if (isCursor) {
+                        if (this.grabbed) {
+                            style = ansi_1.ANSI.BG_YELLOW + ansi_1.ANSI.FG_BLACK;
+                            prefix = '>';
+                        }
+                        else {
+                            style = ansi_1.ANSI.FG_CYAN + ansi_1.ANSI.BOLD;
+                            prefix = '>';
+                        }
+                    }
+                    const title = this.truncate(item.title, colWidth - 4);
+                    content = `${prefix} ${title}${suffix}`;
+                    content = content.padEnd(colWidth);
+                    const plain = `${prefix} ${title}${suffix}`.padEnd(colWidth);
+                    if (style) {
+                        content = style + plain + ansi_1.ANSI.RESET;
+                    }
+                    else {
+                        content = plain;
+                    }
+                }
+                else {
+                    // Empty slot
+                    content = ' '.repeat(colWidth);
+                }
+                return content;
+            }).join('');
+            output += rowLine + '\n';
+        }
+        this.renderFrame(output);
+    }
+    padCenter(str, width, style = '') {
+        const visibleLen = (0, utils_1.stringWidth)(str);
+        if (visibleLen >= width)
+            return style + str + ansi_1.ANSI.RESET;
+        const left = Math.floor((width - visibleLen) / 2);
+        const right = width - visibleLen - left;
+        return ' '.repeat(left) + style + str + ansi_1.ANSI.RESET + ' '.repeat(right);
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (this.grabbed) {
+                // Grabbed: Scroll moves Left/Right
+                if (event.scroll === 'up') {
+                    // Up/Left
+                    if (this.activeCol > 0) {
+                        this.moveItemHorizontal(-1);
+                        this.activeCol--;
+                        this.clampRow();
+                        this.ensureVisible();
+                    }
+                }
+                else if (event.scroll === 'down') {
+                    // Down/Right
+                    if (this.activeCol < this.columns.length - 1) {
+                        this.moveItemHorizontal(1);
+                        this.activeCol++;
+                        this.clampRow();
+                        this.ensureVisible();
+                    }
+                }
+            }
+            else {
+                // Normal: Scroll moves Up/Down
+                if (event.scroll === 'up') {
+                    if (this.activeRow > 0) {
+                        this.activeRow--;
+                        this.ensureVisible();
+                    }
+                }
+                else if (event.scroll === 'down') {
+                    const colLen = this.columns[this.activeCol].items.length;
+                    if (this.activeRow < colLen - 1) {
+                        this.activeRow++;
+                        this.ensureVisible();
+                    }
+                }
+            }
+            this.render(false);
+        }
+    }
+    handleInput(char, _key) {
+        if (char === '\r' || char === '\n') { // Enter
+            const result = {};
+            this.columns.forEach(c => {
+                result[c.id] = c.items;
+            });
+            this.submit(result);
+            return;
+        }
+        if (char === ' ') { // Space
+            this.grabbed = !this.grabbed;
+            this.render(false);
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.activeCol > 0) {
+                if (this.grabbed) {
+                    this.moveItemHorizontal(-1);
+                }
+                this.activeCol--;
+                this.clampRow();
+                this.ensureVisible();
+            }
+        }
+        else if (this.isRight(char)) {
+            if (this.activeCol < this.columns.length - 1) {
+                if (this.grabbed) {
+                    this.moveItemHorizontal(1);
+                }
+                this.activeCol++;
+                this.clampRow();
+                this.ensureVisible();
+            }
+        }
+        else if (this.isUp(char)) {
+            if (this.activeRow > 0) {
+                if (this.grabbed) {
+                    // Swap with prev
+                    const col = this.columns[this.activeCol];
+                    const temp = col.items[this.activeRow];
+                    col.items[this.activeRow] = col.items[this.activeRow - 1];
+                    col.items[this.activeRow - 1] = temp;
+                }
+                this.activeRow--;
+                this.ensureVisible();
+            }
+        }
+        else if (this.isDown(char)) {
+            const colLen = this.columns[this.activeCol].items.length;
+            if (this.activeRow < colLen - 1) {
+                if (this.grabbed) {
+                    // Swap with next
+                    const col = this.columns[this.activeCol];
+                    const temp = col.items[this.activeRow];
+                    col.items[this.activeRow] = col.items[this.activeRow + 1];
+                    col.items[this.activeRow + 1] = temp;
+                }
+                this.activeRow++;
+                this.ensureVisible();
+            }
+        }
+        this.render(false);
+    }
+    moveItemHorizontal(direction) {
+        const sourceCol = this.columns[this.activeCol];
+        const targetCol = this.columns[this.activeCol + direction];
+        const item = sourceCol.items.splice(this.activeRow, 1)[0];
+        let targetIndex = this.activeRow;
+        if (targetIndex > targetCol.items.length) {
+            targetIndex = targetCol.items.length;
+        }
+        targetCol.items.splice(targetIndex, 0, item);
+        this.activeRow = targetIndex;
+    }
+    clampRow() {
+        const len = this.columns[this.activeCol].items.length;
+        if (len === 0) {
+            this.activeRow = 0;
+        }
+        else if (this.activeRow >= len) {
+            this.activeRow = len - 1;
+        }
+    }
+    ensureVisible() {
+        const scrollTop = this.scrollStates[this.activeCol];
+        const viewportHeight = 10;
+        if (this.activeRow < scrollTop) {
+            this.scrollStates[this.activeCol] = this.activeRow;
+        }
+        else if (this.activeRow >= scrollTop + viewportHeight) {
+            this.scrollStates[this.activeCol] = this.activeRow - viewportHeight + 1;
+        }
+    }
+}
+exports.KanbanPrompt = KanbanPrompt;

package/dist/prompts/keypress.js

@@ -18,8 +18,6 @@ class KeypressPrompt extends base_1.Prompt {
                     return 'space';
                 return k;
             }).join('/');
-            // Only show hint if it's short enough to be helpful, or always?
-            // Let's always show it if provided, or maybe just dimmed.
             output += ` ${theme_1.theme.muted}(${hint})${ansi_1.ANSI.RESET}`;
         }
         else {

package/dist/prompts/license.d.ts

@@ -0,0 +1,9 @@
+import { SelectPrompt } from './select';
+import { LicenseOptions } from '../types';
+export declare class LicensePrompt extends SelectPrompt<string> {
+    private licenses;
+    constructor(options: LicenseOptions);
+    protected render(_firstRender: boolean): void;
+    private renderList;
+    private renderDetails;
+}

package/dist/prompts/license.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicensePrompt = void 0;
+const ansi_1 = require("../ansi");
+const select_1 = require("./select");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+const licenses_1 = require("../data/licenses");
+class LicensePrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        // Map licenses to choices expected by SelectPrompt
+        const choices = licenses_1.POPULAR_LICENSES.map(l => ({
+            title: l.id,
+            value: l.id,
+            description: l.name
+        }));
+        super({
+            ...options,
+            choices
+        });
+        this.licenses = licenses_1.POPULAR_LICENSES;
+        // Set initial selection if provided
+        if (options.defaultLicense) {
+            const idx = this.licenses.findIndex(l => l.id === options.defaultLicense);
+            if (idx !== -1) {
+                this.selectedIndex = idx;
+            }
+        }
+    }
+    render(_firstRender) {
+        const width = this.stdout.columns || 80;
+        const gap = 2;
+        const ratio = 0.3;
+        // Calculate dimensions
+        // Left column: 30% or min 20 chars
+        // Right column: rest
+        const leftWidth = Math.floor((width - gap) * ratio);
+        const rightWidth = width - leftWidth - gap;
+        const leftContent = this.renderList();
+        const rightContent = this.renderDetails(rightWidth);
+        const content = utils_1.Layout.split(leftContent, rightContent, width, { ratio, gap });
+        // Header
+        const header = `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(Use arrows to navigate, Enter to select)${ansi_1.ANSI.RESET}`;
+        // Combine
+        this.renderFrame(`${header}\n${content}`);
+    }
+    renderList() {
+        const selectedIndex = this.selectedIndex;
+        const scrollTop = this.scrollTop;
+        const pageSize = this.pageSize;
+        const choices = this.options.choices; // from super
+        let output = '';
+        const visibleChoices = choices.slice(scrollTop, scrollTop + pageSize);
+        visibleChoices.forEach((choice, index) => {
+            const actualIndex = scrollTop + index;
+            const isSelected = actualIndex === selectedIndex;
+            const cursor = isSelected ? `${theme_1.theme.main}${symbols_1.symbols.pointer}` : ' ';
+            // Handle Separator type safety
+            if ('separator' in choice) {
+                output += `${theme_1.theme.muted}${choice.text || '---'}${ansi_1.ANSI.RESET}\n`;
+                return;
+            }
+            const title = isSelected ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}` : choice.title;
+            output += `${cursor} ${title}\n`;
+        });
+        // Fill remaining lines to maintain height
+        const filledLines = visibleChoices.length;
+        if (filledLines < pageSize) {
+            output += '\n'.repeat(pageSize - filledLines);
+        }
+        return output;
+    }
+    renderDetails(maxWidth) {
+        const selectedIndex = this.selectedIndex;
+        const license = this.licenses[selectedIndex];
+        if (!license)
+            return '';
+        let output = '';
+        output += `${ansi_1.ANSI.BOLD}${license.name}${ansi_1.ANSI.RESET}\n`;
+        const wrappedDesc = utils_1.Layout.wrap(license.description, maxWidth);
+        const coloredDesc = wrappedDesc.split('\n').map(line => `${theme_1.theme.muted}${line}${ansi_1.ANSI.RESET}`).join('\n');
+        output += `${coloredDesc}\n\n`;
+        // Permissions
+        if (license.permissions.length > 0) {
+            output += `${ansi_1.ANSI.FG_GREEN}Permissions:${ansi_1.ANSI.RESET}\n`;
+            license.permissions.forEach(p => output += ` ${theme_1.theme.success}${symbols_1.symbols.checked} ${p}${ansi_1.ANSI.RESET}\n`);
+            output += '\n';
+        }
+        // Conditions
+        if (license.conditions.length > 0) {
+            output += `${ansi_1.ANSI.FG_BLUE}Conditions:${ansi_1.ANSI.RESET}\n`;
+            // symbols.info doesn't exist, use 'i' or similar
+            license.conditions.forEach(c => output += ` ${ansi_1.ANSI.FG_BLUE}ℹ ${c}${ansi_1.ANSI.RESET}\n`);
+            output += '\n';
+        }
+        // Limitations
+        if (license.limitations.length > 0) {
+            output += `${ansi_1.ANSI.FG_RED}Limitations:${ansi_1.ANSI.RESET}\n`;
+            license.limitations.forEach(l => output += ` ${theme_1.theme.error}${symbols_1.symbols.cross} ${l}${ansi_1.ANSI.RESET}\n`);
+        }
+        return output;
+    }
+}
+exports.LicensePrompt = LicensePrompt;

package/dist/prompts/map.d.ts

@@ -0,0 +1,15 @@
+import { Prompt } from '../base';
+import { MapOptions, MouseEvent } from '../types';
+export declare class MapPrompt extends Prompt<Record<string, string>, MapOptions> {
+    private items;
+    private rowIndex;
+    private colIndex;
+    private scrollTop;
+    private readonly pageSize;
+    private errorMsg;
+    constructor(options: MapOptions);
+    protected render(_firstRender: boolean): void;
+    private pad;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/map.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+class MapPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.items = [];
+        this.rowIndex = 0;
+        this.colIndex = 0; // 0: Key, 1: Value
+        this.scrollTop = 0;
+        this.pageSize = 7;
+        this.errorMsg = '';
+        if (options.initial) {
+            this.items = Object.entries(options.initial).map(([key, value]) => ({ key, value }));
+        }
+        if (this.items.length === 0) {
+            this.items.push({ key: '', value: '' });
+        }
+    }
+    render(_firstRender) {
+        let output = '';
+        // Title
+        const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Layout Calculation
+        const maxKeyWidth = Math.max(5, // Minimum width
+        ...this.items.map(item => (0, utils_1.stringWidth)(item.key))) + 2; // Padding
+        // Scrolling Logic
+        if (this.rowIndex < this.scrollTop) {
+            this.scrollTop = this.rowIndex;
+        }
+        else if (this.rowIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.rowIndex - this.pageSize + 1;
+        }
+        // Clamping
+        const maxScroll = Math.max(0, this.items.length - this.pageSize);
+        this.scrollTop = Math.min(this.scrollTop, maxScroll);
+        // Header
+        const keyHeader = this.pad('Key', maxKeyWidth);
+        output += `  ${ansi_1.ANSI.BOLD}${keyHeader}Value${ansi_1.ANSI.RESET}\n`;
+        // Rows
+        const visibleItems = this.items.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleItems.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            if (index > 0)
+                output += '\n';
+            const isRowActive = actualIndex === this.rowIndex;
+            const pointer = isRowActive ? `${theme_1.theme.main}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET} ` : '  ';
+            // Render Key
+            let keyStr = item.key;
+            if (isRowActive && this.colIndex === 0) {
+                keyStr = `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${keyStr}${ansi_1.ANSI.RESET}`;
+            }
+            // Adjust padding manually because ANSI codes mess up simple padEnd
+            const keyVisualWidth = (0, utils_1.stringWidth)(item.key);
+            const padding = ' '.repeat(Math.max(0, maxKeyWidth - keyVisualWidth));
+            // Render Value
+            let valStr = item.value;
+            if (isRowActive && this.colIndex === 1) {
+                valStr = `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${valStr || ' '}${ansi_1.ANSI.RESET}`;
+            }
+            output += `${pointer}${keyStr}${padding}${valStr}`;
+        });
+        // Instructions
+        output += `\n${ansi_1.ANSI.DIM}(Ctrl+N: Add, Ctrl+D: Del)${ansi_1.ANSI.RESET}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    pad(str, width) {
+        const len = (0, utils_1.stringWidth)(str);
+        if (len >= width)
+            return str;
+        return str + ' '.repeat(width - len);
+    }
+    handleInput(char) {
+        this.errorMsg = '';
+        // Navigation
+        if (this.isUp(char)) {
+            if (this.rowIndex > 0)
+                this.rowIndex--;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.rowIndex < this.items.length - 1) {
+                this.rowIndex++;
+            }
+            else {
+                // Down at last row adds new row
+                this.items.push({ key: '', value: '' });
+                this.rowIndex++;
+                this.colIndex = 0; // Optional: Reset to Key col when creating new row
+            }
+            this.render(false);
+            return;
+        }
+        if (char === '\t' || this.isRight(char) || this.isLeft(char)) {
+            // Toggle column
+            this.colIndex = this.colIndex === 0 ? 1 : 0;
+            this.render(false);
+            return;
+        }
+        // CRUD
+        // Ctrl+N (Standard ASCII for Ctrl+N is \x0e)
+        if (char === '\x0e') {
+            this.items.push({ key: '', value: '' });
+            this.rowIndex = this.items.length - 1;
+            this.colIndex = 0;
+            this.render(false);
+            return;
+        }
+        // Ctrl+D (Standard ASCII for Ctrl+D is \x04)
+        if (char === '\x04') {
+            if (this.items.length > 1) {
+                this.items.splice(this.rowIndex, 1);
+                if (this.rowIndex >= this.items.length) {
+                    this.rowIndex = this.items.length - 1;
+                }
+            }
+            else {
+                // Clear the last remaining item instead of deleting it
+                this.items[0] = { key: '', value: '' };
+            }
+            this.render(false);
+            return;
+        }
+        // Submit
+        if (char === '\r' || char === '\n') {
+            // Validate duplicates
+            const keys = this.items.map(i => i.key);
+            const duplicates = keys.filter((item, index) => keys.indexOf(item) !== index && item !== '');
+            if (duplicates.length > 0) {
+                this.errorMsg = `Duplicate keys found: ${duplicates.join(', ')}`;
+                this.render(false);
+                return;
+            }
+            if (keys.some(k => k === '')) {
+                this.errorMsg = 'Keys cannot be empty';
+                this.render(false);
+                return;
+            }
+            const result = {};
+            this.items.forEach(item => {
+                result[item.key] = item.value;
+            });
+            this.submit(result);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            const item = this.items[this.rowIndex];
+            if (this.colIndex === 0) {
+                if (item.key.length > 0)
+                    item.key = item.key.slice(0, -1);
+            }
+            else {
+                if (item.value.length > 0)
+                    item.value = item.value.slice(0, -1);
+            }
+            this.render(false);
+            return;
+        }
+        // Typing
+        if (!/^[\x00-\x1F]/.test(char)) {
+            const item = this.items[this.rowIndex];
+            if (this.colIndex === 0) {
+                item.key += char;
+            }
+            else {
+                item.value += char;
+            }
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.rowIndex > 0) {
+                    this.rowIndex--;
+                    this.render(false);
+                }
+            }
+            else if (event.scroll === 'down') {
+                if (this.rowIndex < this.items.length - 1) {
+                    this.rowIndex++;
+                    this.render(false);
+                }
+            }
+        }
+    }
+}
+exports.MapPrompt = MapPrompt;

package/dist/prompts/match.d.ts

@@ -0,0 +1,19 @@
+import { Prompt } from '../base';
+import { MatchOptions, MouseEvent } from '../types';
+export declare class MatchPrompt extends Prompt<Record<string, any[]>, MatchOptions> {
+    private source;
+    private target;
+    private links;
+    private cursorSource;
+    private cursorTarget;
+    private scrollTopSource;
+    private scrollTopTarget;
+    private activeSide;
+    private pickedSourceIndex;
+    private readonly pageSize;
+    constructor(options: MatchOptions);
+    private normalize;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}