mepcli 0.6.1 → 1.0.0-beta.2

package/dist/index.js

@@ -20,3 +20,39 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
+__exportStar(require("./prompts/map"), exports);
+__exportStar(require("./prompts/semver"), exports);
+__exportStar(require("./prompts/ip"), exports);
+__exportStar(require("./prompts/kanban"), exports);
+__exportStar(require("./prompts/time"), exports);
+__exportStar(require("./prompts/heatmap"), exports);
+__exportStar(require("./prompts/byte"), exports);
+__exportStar(require("./prompts/slot"), exports);
+__exportStar(require("./prompts/gauge"), exports);
+__exportStar(require("./prompts/calculator"), exports);
+__exportStar(require("./prompts/emoji"), exports);
+__exportStar(require("./prompts/match"), exports);
+__exportStar(require("./prompts/diff"), exports);
+__exportStar(require("./prompts/dial"), exports);
+__exportStar(require("./prompts/draw"), exports);
+__exportStar(require("./prompts/multi-column-select"), exports);
+__exportStar(require("./prompts/fuzzy"), exports);
+__exportStar(require("./prompts/miller"), exports);
+__exportStar(require("./prompts/pattern"), exports);
+__exportStar(require("./prompts/region"), exports);
+__exportStar(require("./prompts/spreadsheet"), exports);
+__exportStar(require("./prompts/scroll"), exports);
+__exportStar(require("./prompts/breadcrumb"), exports);
+__exportStar(require("./prompts/schedule"), exports);
+__exportStar(require("./prompts/data-inspector"), exports);
+__exportStar(require("./prompts/exec"), exports);
+__exportStar(require("./prompts/shortcut"), exports);
+__exportStar(require("./prompts/seat"), exports);
+__exportStar(require("./prompts/select-range"), exports);
+__exportStar(require("./prompts/sort-grid"), exports);
+__exportStar(require("./prompts/dependency"), exports);
+__exportStar(require("./prompts/license"), exports);
+__exportStar(require("./prompts/regex"), exports);
+__exportStar(require("./prompts/box"), exports);
+__exportStar(require("./prompts/connection-string"), exports);
+__exportStar(require("./prompts/curl"), exports);

package/dist/input.js

@@ -146,9 +146,6 @@ class InputParser extends events_1.EventEmitter {
         // Normalize Enter
         if (key === '\r')
             key = '\n';
-        // We emit both the raw sequence and a normalized representation if needed,
-        // but existing prompt logic handles raw strings like \x1b[A.
-        // So we just emit the reconstructed sequence.
         this.emit('keypress', key, Buffer.from(key));
     }
 }

package/dist/prompts/box.d.ts

@@ -0,0 +1,21 @@
+import { Prompt } from '../base';
+import { BoxOptions, MouseEvent } from '../types';
+interface BoxValues {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export declare class BoxPrompt extends Prompt<BoxValues, BoxOptions> {
+    private values;
+    private focus;
+    private inputBuffer;
+    constructor(options: BoxOptions);
+    private commitBuffer;
+    private changeFocus;
+    private increment;
+    protected render(_firstRender: boolean): void;
+    protected handleMouse(event: MouseEvent): void;
+    protected handleInput(char: string, _key: Buffer): void;
+}
+export {};

package/dist/prompts/box.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoxPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+class BoxPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.focus = 'top';
+        this.inputBuffer = '';
+        const initial = options.initial;
+        if (typeof initial === 'number') {
+            this.values = { top: initial, right: initial, bottom: initial, left: initial };
+        }
+        else if (typeof initial === 'object') {
+            this.values = {
+                top: initial.top ?? 0,
+                right: initial.right ?? 0,
+                bottom: initial.bottom ?? 0,
+                left: initial.left ?? 0
+            };
+        }
+        else {
+            this.values = { top: 0, right: 0, bottom: 0, left: 0 };
+        }
+        this.inputBuffer = this.values.top.toString();
+    }
+    commitBuffer() {
+        let val = parseInt(this.inputBuffer, 10);
+        if (isNaN(val))
+            val = 0;
+        // Apply constraints
+        if (this.options.min !== undefined && val < this.options.min)
+            val = this.options.min;
+        if (this.options.max !== undefined && val > this.options.max)
+            val = this.options.max;
+        this.values[this.focus] = val;
+        this.inputBuffer = val.toString(); // Normalize buffer
+    }
+    changeFocus(newFocus) {
+        this.commitBuffer(); // Save current
+        this.focus = newFocus;
+        this.inputBuffer = this.values[newFocus].toString();
+    }
+    increment(amount) {
+        let val = parseInt(this.inputBuffer, 10);
+        if (isNaN(val))
+            val = 0;
+        val += amount;
+        if (this.options.min !== undefined && val < this.options.min)
+            val = this.options.min;
+        if (this.options.max !== undefined && val > this.options.max)
+            val = this.options.max;
+        this.inputBuffer = val.toString();
+    }
+    render(_firstRender) {
+        const title = `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} (Arrows to navigate, Numbers to edit)`;
+        // Format value function
+        const formatVal = (side) => {
+            const isFocused = this.focus === side;
+            const text = isFocused ? this.inputBuffer : this.values[side].toString();
+            if (isFocused) {
+                return `${ansi_1.ANSI.FG_CYAN}${ansi_1.ANSI.BOLD}[ ${text} ]${ansi_1.ANSI.RESET}`;
+            }
+            return `  ${text}  `;
+        };
+        const vTop = formatVal('top');
+        const vRight = formatVal('right');
+        const vBottom = formatVal('bottom');
+        const vLeft = formatVal('left');
+        // Layout
+        //       [ Top ]
+        // [ Left ]   [ Right ]
+        //      [ Bottom ]
+        // We need to pad to align them nicely. 
+        // Simple manual padding for MVP.
+        // Calculate center padding based on longest string? 
+        // Keep it simple.
+        let output = title + '\n\n';
+        // Top Row (Centered)
+        output += `          ${vTop}\n`;
+        // Middle Row
+        output += `  ${vLeft}     ${vRight}\n`;
+        // Bottom Row
+        output += `          ${vBottom}\n`;
+        this.renderFrame(output);
+    }
+    handleMouse(event) {
+        if (event.name === 'mouse' && event.action === 'scroll') {
+            const order = ['top', 'right', 'bottom', 'left'];
+            const idx = order.indexOf(this.focus);
+            if (event.scroll === 'down') {
+                // Next (Down usually means going forward/down in list)
+                this.changeFocus(order[(idx + 1) % 4]);
+            }
+            else if (event.scroll === 'up') {
+                // Previous
+                this.changeFocus(order[(idx + 3) % 4]); // +3 is same as -1 in mod 4
+            }
+            this.render(false);
+        }
+    }
+    handleInput(char, _key) {
+        // Enter -> Submit
+        if (char === '\r' || char === '\n') {
+            this.commitBuffer();
+            this.submit(this.values);
+            return;
+        }
+        // Navigation
+        if (this.isUp(char)) {
+            if (this.focus === 'bottom' || this.focus === 'left' || this.focus === 'right') {
+                this.changeFocus('top');
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.focus === 'top' || this.focus === 'left' || this.focus === 'right') {
+                this.changeFocus('bottom');
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.focus === 'right' || this.focus === 'top' || this.focus === 'bottom') {
+                this.changeFocus('left');
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.focus === 'left' || this.focus === 'top' || this.focus === 'bottom') {
+                this.changeFocus('right');
+            }
+            this.render(false);
+            return;
+        }
+        // Tab Cycling
+        if (char === '\t') {
+            const order = ['top', 'right', 'bottom', 'left'];
+            const idx = order.indexOf(this.focus);
+            this.changeFocus(order[(idx + 1) % 4]);
+            this.render(false);
+            return;
+        }
+        // Shift+Tab Cycling (\u001b[Z)
+        if (char === '\u001b[Z') {
+            const order = ['top', 'right', 'bottom', 'left'];
+            const idx = order.indexOf(this.focus);
+            this.changeFocus(order[(idx + 3) % 4]); // (idx - 1) % 4 handling negative
+            this.render(false);
+            return;
+        }
+        // Increment/Decrement (+ / -)
+        const step = this.options.step || 1;
+        if (char === '+' || char === '=') { // = is usually unshifted +
+            this.increment(step);
+            this.render(false);
+            return;
+        }
+        if (char === '-' || char === '_') {
+            this.increment(-step);
+            this.render(false);
+            return;
+        }
+        // Typing Numbers
+        if (/^[0-9]$/.test(char)) {
+            // Special case: if buffer is "0", replace it unless we are appending
+            if (this.inputBuffer === '0') {
+                this.inputBuffer = char;
+            }
+            else {
+                this.inputBuffer += char;
+            }
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.inputBuffer.length > 0) {
+                this.inputBuffer = this.inputBuffer.slice(0, -1);
+                if (this.inputBuffer === '')
+                    this.inputBuffer = '0'; // default to 0
+            }
+            this.render(false);
+            return;
+        }
+    }
+}
+exports.BoxPrompt = BoxPrompt;

package/dist/prompts/breadcrumb.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../base';
+import { BreadcrumbOptions, MouseEvent } from '../types';
+export declare class BreadcrumbPrompt extends Prompt<string, BreadcrumbOptions> {
+    private stack;
+    private currentEntries;
+    private cursor;
+    private scrollTop;
+    private root;
+    private currentPath;
+    private separator;
+    private showHidden;
+    private isLoading;
+    private error;
+    private readonly pageSize;
+    constructor(options: BreadcrumbOptions);
+    private loadDirectory;
+    private drillDown;
+    private goUp;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(_event: MouseEvent): void;
+}

package/dist/prompts/breadcrumb.js

@@ -0,0 +1,302 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreadcrumbPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class BreadcrumbPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.stack = [];
+        this.currentEntries = [];
+        this.cursor = 0;
+        this.scrollTop = 0;
+        this.isLoading = false;
+        this.error = null;
+        this.pageSize = 10;
+        this.root = path.resolve(options.root || process.cwd());
+        this.currentPath = this.root;
+        this.separator = options.separator || ' › ';
+        this.showHidden = options.showHidden || false;
+        this.loadDirectory(this.currentPath);
+    }
+    async loadDirectory(dir) {
+        this.isLoading = true;
+        this.error = null;
+        this.render(false);
+        try {
+            await fs.access(dir);
+            const dirents = await fs.readdir(dir, { withFileTypes: true });
+            let entries = dirents.map(d => ({
+                name: d.name,
+                isDirectory: d.isDirectory()
+            }));
+            if (!this.showHidden) {
+                entries = entries.filter(e => !e.name.startsWith('.'));
+            }
+            entries.sort((a, b) => {
+                if (a.isDirectory === b.isDirectory) {
+                    return a.name.localeCompare(b.name);
+                }
+                return a.isDirectory ? -1 : 1;
+            });
+            this.currentEntries = entries;
+            if (this.currentEntries.length === 0) {
+                this.cursor = 0;
+            }
+            else if (this.cursor >= this.currentEntries.length) {
+                this.cursor = this.currentEntries.length - 1;
+            }
+        }
+        catch (err) {
+            this.error = err.message || 'Error reading directory';
+            this.currentEntries = [];
+        }
+        finally {
+            this.isLoading = false;
+            this.render(false);
+        }
+    }
+    async drillDown() {
+        const entry = this.currentEntries[this.cursor];
+        if (!entry || !entry.isDirectory)
+            return;
+        const nextPath = path.join(this.currentPath, entry.name);
+        this.stack.push({
+            path: this.currentPath,
+            cursor: this.cursor,
+            scrollTop: this.scrollTop
+        });
+        this.currentPath = nextPath;
+        this.cursor = 0;
+        this.scrollTop = 0;
+        await this.loadDirectory(nextPath);
+    }
+    async goUp() {
+        if (this.stack.length === 0)
+            return;
+        const prevState = this.stack.pop();
+        if (prevState) {
+            this.currentPath = prevState.path;
+            this.cursor = prevState.cursor;
+            this.scrollTop = prevState.scrollTop;
+            await this.loadDirectory(this.currentPath);
+        }
+    }
+    render(_firstRender) {
+        const width = this.stdout.columns || 80;
+        let output = '';
+        // --- Breadcrumb Line Construction ---
+        const relative = path.relative(this.root, this.currentPath);
+        const parts = relative ? relative.split(path.sep) : [];
+        const rootName = path.basename(this.root);
+        const segments = [rootName, ...parts];
+        // Calculate available space for path
+        // Prefix: "? Message: "
+        const prefix = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        const prefixWidth = this.stripAnsi(prefix).length;
+        const availableWidth = Math.max(20, width - prefixWidth - 5); // Reserve 5 chars buffer
+        let breadcrumbStr = segments.join(this.separator);
+        if (breadcrumbStr.length > availableWidth) {
+            // Truncate logic: Keep root and tail segments that fit
+            // e.g., root > ... > folder > subfolder
+            let suffix = segments[segments.length - 1];
+            for (let i = segments.length - 2; i >= 1; i--) { // Stop before root (index 0)
+                const next = segments[i] + this.separator + suffix;
+                if (next.length + 4 > availableWidth)
+                    break; // +4 for "... "
+                suffix = next;
+            }
+            breadcrumbStr = `${segments[0]}${this.separator}...${this.separator}${suffix}`;
+            // If even that is too long (extreme case), just truncate tail
+            if (breadcrumbStr.length > availableWidth) {
+                breadcrumbStr = '...' + breadcrumbStr.slice(-(availableWidth - 3));
+            }
+        }
+        output += `${prefix}${breadcrumbStr}\n`;
+        // --- Content / List ---
+        if (this.isLoading) {
+            output += `  ${theme_1.theme.muted}Loading...${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.error) {
+            output += `  ${theme_1.theme.error}${this.error}${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.currentEntries.length === 0) {
+            output += `  ${theme_1.theme.muted}(Empty directory)${ansi_1.ANSI.RESET}\n  ${theme_1.theme.muted}(Backspace to go back)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            // Adjust Scroll Top
+            if (this.cursor < this.scrollTop) {
+                this.scrollTop = this.cursor;
+            }
+            else if (this.cursor >= this.scrollTop + this.pageSize) {
+                this.scrollTop = this.cursor - this.pageSize + 1;
+            }
+            // Sanity check
+            if (this.scrollTop > this.currentEntries.length - 1) {
+                this.scrollTop = Math.max(0, this.currentEntries.length - this.pageSize);
+            }
+            const visibleEntries = this.currentEntries.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleEntries.forEach((entry, index) => {
+                const absoluteIndex = this.scrollTop + index;
+                const isSelected = absoluteIndex === this.cursor;
+                const icon = entry.isDirectory ? '📂' : '📄';
+                let line = '';
+                if (isSelected) {
+                    line += `${theme_1.theme.main}${symbols_1.symbols.pointer} ${icon} ${entry.name}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    line += `  ${icon} ${entry.name}`;
+                }
+                if (index > 0 || index === 0)
+                    output += line;
+                if (index < visibleEntries.length - 1)
+                    output += '\n';
+            });
+            // Add a hint about navigation if plenty of space? 
+            // Optional: output += `\n${theme.muted}(Use Arrow Keys, Enter to Select, Backspace to Up)${ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (this.isLoading)
+            return;
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.currentEntries.length === 0)
+                return;
+            const entry = this.currentEntries[this.cursor];
+            if (entry.isDirectory) {
+                this.drillDown();
+            }
+            else {
+                const fullPath = path.join(this.currentPath, entry.name);
+                this.submit(fullPath);
+            }
+            return;
+        }
+        // Backspace or Left Arrow
+        if (char === '\x7f' || char === '\x08' || this.isLeft(char)) {
+            this.goUp();
+            return;
+        }
+        // Right Arrow
+        if (this.isRight(char)) {
+            const entry = this.currentEntries[this.cursor];
+            if (entry && entry.isDirectory) {
+                this.drillDown();
+            }
+            return;
+        }
+        // Tab (Next)
+        if (char === '\t') {
+            if (this.currentEntries.length === 0)
+                return;
+            this.cursor = (this.cursor + 1) % this.currentEntries.length;
+            this.render(false);
+            return;
+        }
+        // Shift+Tab (Prev)
+        if (char === '\x1b[Z') {
+            if (this.currentEntries.length === 0)
+                return;
+            this.cursor = (this.cursor - 1 + this.currentEntries.length) % this.currentEntries.length;
+            this.render(false);
+            return;
+        }
+        // Up
+        if (this.isUp(char)) {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            else if (this.currentEntries.length > 0) {
+                // Cycle to bottom?
+                this.cursor = this.currentEntries.length - 1;
+                this.render(false);
+            }
+            return;
+        }
+        // Down
+        if (this.isDown(char)) {
+            if (this.cursor < this.currentEntries.length - 1) {
+                this.cursor++;
+                this.render(false);
+            }
+            else if (this.currentEntries.length > 0) {
+                // Cycle to top?
+                this.cursor = 0;
+                this.render(false);
+            }
+            return;
+        }
+        // Page Up
+        if (char === '\x1b[5~') {
+            this.cursor = Math.max(0, this.cursor - this.pageSize);
+            this.render(false);
+            return;
+        }
+        // Page Down
+        if (char === '\x1b[6~') {
+            this.cursor = Math.min(this.currentEntries.length - 1, this.cursor + this.pageSize);
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(_event) {
+        // Scroll up and down
+        if (this.isLoading)
+            return;
+        if (_event.action === 'scroll') {
+            if (_event.scroll === 'up') {
+                if (this.cursor > 0) {
+                    this.cursor--;
+                    this.render(false);
+                }
+            }
+            else if (_event.scroll === 'down') {
+                if (this.cursor < this.currentEntries.length - 1) {
+                    this.cursor++;
+                    this.render(false);
+                }
+            }
+        }
+    }
+}
+exports.BreadcrumbPrompt = BreadcrumbPrompt;

package/dist/prompts/byte.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { ByteOptions, MouseEvent } from '../types';
+export declare class BytePrompt extends Prompt<number, ByteOptions> {
+    private inputValue;
+    private buffer;
+    private unitIndex;
+    private errorMsg;
+    constructor(options: ByteOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    private formatBytes;
+    protected handleMouse(event: MouseEvent): void;
+}