mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/fuzzy.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzySelectPrompt = void 0;
+const select_1 = require("./select");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const utils_1 = require("../utils");
+const symbols_1 = require("../symbols");
+class FuzzySelectPrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        super(options);
+        this.filteredResults = [];
+        this.filteredResults = this.options.choices;
+    }
+    getFilteredChoices() {
+        // Safety check: this.filteredResults might be undefined if called from super() constructor
+        return this.filteredResults || this.options.choices;
+    }
+    handleInput(char) {
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.performSearch();
+            }
+            return;
+        }
+        // Intercept typing to add debounce
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.searchBuffer += char;
+            // Check if debounce is needed
+            if (this.options.choices.length > 1000) {
+                if (this.debounceTimer)
+                    clearTimeout(this.debounceTimer);
+                this.debounceTimer = setTimeout(() => {
+                    this.performSearch();
+                }, 150); // 150ms debounce
+            }
+            else {
+                this.performSearch();
+            }
+            return; // Skip super.handleInput for typing
+        }
+        super.handleInput(char);
+    }
+    performSearch() {
+        if (!this.searchBuffer) {
+            this.filteredResults = this.options.choices;
+        }
+        else {
+            const results = this.options.choices.map(c => {
+                if (this.isSeparator(c))
+                    return null;
+                const match = (0, utils_1.fuzzyMatch)(this.searchBuffer, c.title);
+                return { choice: c, match };
+            }).filter(item => item && item.match !== null)
+                // Sort by score descending
+                .sort((a, b) => b.match.score - a.match.score);
+            this.filteredResults = results.map(r => {
+                r.choice._match = r.match;
+                return r.choice;
+            });
+        }
+        this.selectedIndex = 0;
+        this.render(false);
+    }
+    highlight(text, indices, isSelected) {
+        let output = '';
+        const indexSet = new Set(indices);
+        for (let i = 0; i < text.length; i++) {
+            if (indexSet.has(i)) {
+                if (isSelected) {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_WHITE}${text[i]}${theme_1.theme.main}`; // Reset to main theme
+                }
+                else {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_CYAN}${text[i]}${ansi_1.ANSI.RESET}`;
+                }
+            }
+            else {
+                output += text[i];
+            }
+        }
+        return output;
+    }
+    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;
+        }
+        if (this.scrollTop > choices.length - 1) {
+            this.scrollTop = Math.max(0, choices.length - this.pageSize);
+        }
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Fuzzy: ${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';
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || symbols_1.symbols.line.repeat(8)}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    let title = choice.title;
+                    const match = choice._match;
+                    const isSelected = actualIndex === this.selectedIndex;
+                    if (match && this.searchBuffer) {
+                        title = this.highlight(title, match.indices, isSelected);
+                    }
+                    if (isSelected) {
+                        output += `${theme_1.theme.main}${symbols_1.symbols.pointer} ${title}${ansi_1.ANSI.RESET}`;
+                        if (match && this.searchBuffer) {
+                            // Show score
+                            // output += ` ${theme.muted}(${Math.round(match.score)})${ANSI.RESET}`;
+                        }
+                    }
+                    else {
+                        output += `  ${title}`;
+                    }
+                }
+            });
+        }
+        this.renderFrame(output);
+    }
+}
+exports.FuzzySelectPrompt = FuzzySelectPrompt;

package/dist/prompts/gauge.d.ts

@@ -0,0 +1,21 @@
+import { Prompt } from '../base';
+import { GaugeOptions } from '../types';
+export declare class GaugePrompt extends Prompt<string, GaugeOptions> {
+    private cursor;
+    private direction;
+    private running;
+    private timer?;
+    private readonly width;
+    private readonly safeZoneHalf;
+    private readonly warnZoneHalf;
+    private result;
+    private resultColor;
+    constructor(options: GaugeOptions);
+    run(): Promise<string>;
+    private startLoop;
+    private tick;
+    private stop;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected render(_firstRender: boolean): void;
+    protected cleanup(): void;
+}

package/dist/prompts/gauge.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GaugePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class GaugePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0; // 0 to 100
+        this.direction = 1;
+        this.running = true;
+        this.result = null;
+        this.resultColor = '';
+        this.width = options.width || 40;
+        // Calculate safe zone logic (0-100 scale)
+        // Default safe width: 20% ( +/- 10%)
+        const safeParam = options.safeZone ?? 0.2;
+        // Convert to percentage (0-100)
+        let safeWidthPct;
+        if (safeParam <= 1) {
+            safeWidthPct = safeParam * 100;
+        }
+        else {
+            safeWidthPct = (safeParam / this.width) * 100;
+        }
+        this.safeZoneHalf = safeWidthPct / 2;
+        // Arbitrary "Good" zone is 3x the safe zone (or until limits)
+        this.warnZoneHalf = Math.max(this.safeZoneHalf * 3, 30);
+    }
+    run() {
+        // Start the loop when run is called (after initial render)
+        const p = super.run();
+        this.startLoop();
+        return p;
+    }
+    startLoop() {
+        if (!this.running)
+            return;
+        this.timer = setTimeout(() => {
+            this.tick();
+            this.startLoop();
+        }, 30); // ~33 FPS
+    }
+    tick() {
+        this.cursor += this.direction * 2; // Speed multiplier
+        if (this.cursor >= 100) {
+            this.cursor = 100;
+            this.direction = -1;
+        }
+        else if (this.cursor <= 0) {
+            this.cursor = 0;
+            this.direction = 1;
+        }
+        this.render(false);
+    }
+    stop() {
+        this.running = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        // Calculate score
+        const center = 50;
+        const distance = Math.abs(this.cursor - center);
+        if (distance <= this.safeZoneHalf) {
+            this.result = 'PERFECT!';
+            this.resultColor = theme_1.theme.success;
+        }
+        else if (distance <= this.warnZoneHalf) {
+            this.result = 'GOOD';
+            this.resultColor = ansi_1.ANSI.FG_YELLOW;
+        }
+        else {
+            this.result = 'MISS';
+            this.resultColor = theme_1.theme.error;
+        }
+        this.render(false);
+        // Wait a moment to show result, then submit
+        setTimeout(() => {
+            this.submit(this.result); // Force non-null
+        }, 800);
+    }
+    handleInput(char, _key) {
+        if (!this.running)
+            return;
+        if (char === ' ') {
+            this.stop();
+        }
+    }
+    render(_firstRender) {
+        let output = '';
+        // Header
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Draw Gauge Bar
+        let barStr = '';
+        const center = 50;
+        for (let i = 0; i < this.width; i++) {
+            const pct = (i / this.width) * 100;
+            const dist = Math.abs(pct - center);
+            let charColor = theme_1.theme.error; // Default Miss (Red)
+            if (dist <= this.safeZoneHalf) {
+                charColor = theme_1.theme.success; // Perfect (Green)
+            }
+            else if (dist <= this.warnZoneHalf) {
+                charColor = ansi_1.ANSI.FG_YELLOW; // Good (Yellow)
+            }
+            // Using block characters for the bar
+            barStr += `${charColor}━${ansi_1.ANSI.RESET}`;
+        }
+        output += `  ${barStr}\n`;
+        // Draw Cursor
+        // Position relative to width
+        const pos = Math.floor((this.cursor / 100) * (this.width - 1));
+        const padding = ' '.repeat(pos);
+        output += `  ${padding}${theme_1.theme.main}▲${ansi_1.ANSI.RESET}\n`;
+        // Instructions or Result
+        if (this.running) {
+            output += `${theme_1.theme.muted}(Press Space to Stop)${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += `${ansi_1.ANSI.BOLD}${this.resultColor}${this.result}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    cleanup() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        super.cleanup();
+    }
+}
+exports.GaugePrompt = GaugePrompt;

package/dist/prompts/heatmap.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { HeatmapOptions, MouseEvent } from '../types';
+export declare class HeatmapPrompt extends Prompt<number[][], HeatmapOptions> {
+    private grid;
+    private cursorRow;
+    private cursorCol;
+    private validValues;
+    constructor(options: HeatmapOptions);
+    protected render(_firstRender: boolean): void;
+    private getLegend;
+    protected handleMouse(event: MouseEvent): void;
+    protected handleInput(char: string, _key: Buffer): void;
+}

package/dist/prompts/heatmap.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeatmapPrompt = void 0;
+const base_1 = require("../base");
+const ansi_1 = require("../ansi");
+class HeatmapPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        // Initialize grid
+        const rows = options.rows.length;
+        const cols = options.columns.length;
+        if (options.initial) {
+            this.grid = options.initial.map(row => [...row]);
+        }
+        else {
+            this.grid = Array.from({ length: rows }, () => Array(cols).fill(0));
+        }
+        // Get sorted valid values for cycling
+        this.validValues = options.legend.map(l => l.value).sort((a, b) => a - b);
+    }
+    render(_firstRender) {
+        let output = `${ansi_1.ANSI.FG_CYAN}? ${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Render Column Headers
+        output += '     '; // Offset for row labels
+        this.options.columns.forEach(col => {
+            // Show first 2 chars
+            const label = col.substring(0, 2).padEnd(2);
+            output += ` ${label} `;
+        });
+        output += '\n';
+        // Grid
+        for (let r = 0; r < this.options.rows.length; r++) {
+            const rowLabel = this.options.rows[r].substring(0, 4).padStart(4);
+            output += `${ansi_1.ANSI.FG_GRAY}${rowLabel} ${ansi_1.ANSI.RESET}`;
+            for (let c = 0; c < this.options.columns.length; c++) {
+                const val = this.grid[r][c];
+                const legend = this.getLegend(val);
+                const char = legend?.char || '?';
+                const color = legend?.color || ((s) => s);
+                const isCursor = r === this.cursorRow && c === this.cursorCol;
+                const cellContent = color(char);
+                if (isCursor) {
+                    output += `[${cellContent}]`; // Brackets around
+                }
+                else {
+                    output += ` ${cellContent} `;
+                }
+            }
+            output += '\n';
+        }
+        // Legend
+        output += '\nLegend: ';
+        this.options.legend.forEach(l => {
+            output += `${l.value}:${l.color(l.char)}  `;
+        });
+        output += '\n' + ansi_1.ANSI.FG_GRAY + "(Arrows to move, Space to cycle, 0-9 to set)" + ansi_1.ANSI.RESET;
+        this.renderFrame(output);
+    }
+    getLegend(val) {
+        return this.options.legend.find(l => l.value === val);
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.cursorRow > 0)
+                    this.cursorRow--;
+            }
+            else if (event.scroll === 'down') {
+                if (this.cursorRow < this.options.rows.length - 1)
+                    this.cursorRow++;
+            }
+            this.render(false);
+        }
+    }
+    handleInput(char, _key) {
+        if (char === '\r' || char === '\n') { // Enter
+            this.submit(this.grid);
+            return;
+        }
+        if (this.isUp(char)) {
+            if (this.cursorRow > 0)
+                this.cursorRow--;
+        }
+        else if (this.isDown(char)) {
+            if (this.cursorRow < this.options.rows.length - 1)
+                this.cursorRow++;
+        }
+        else if (this.isLeft(char)) {
+            if (this.cursorCol > 0)
+                this.cursorCol--;
+        }
+        else if (this.isRight(char)) {
+            if (this.cursorCol < this.options.columns.length - 1)
+                this.cursorCol++;
+        }
+        else if (char === '\t') { // Tab -> Right (Cycle)
+            this.cursorCol++;
+            if (this.cursorCol >= this.options.columns.length) {
+                this.cursorCol = 0;
+                this.cursorRow++;
+                if (this.cursorRow >= this.options.rows.length) {
+                    this.cursorRow = 0;
+                }
+            }
+        }
+        else if (char === '\u001b[Z') { // Shift+Tab -> Left (Cycle)
+            this.cursorCol--;
+            if (this.cursorCol < 0) {
+                this.cursorCol = this.options.columns.length - 1;
+                this.cursorRow--;
+                if (this.cursorRow < 0) {
+                    this.cursorRow = this.options.rows.length - 1;
+                }
+            }
+        }
+        else if (char === ' ') {
+            const val = this.grid[this.cursorRow][this.cursorCol];
+            const idx = this.validValues.indexOf(val);
+            let nextVal;
+            if (idx === -1) {
+                // If current val not in legend (maybe init with invalid), reset to first
+                nextVal = this.validValues[0];
+            }
+            else {
+                nextVal = this.validValues[(idx + 1) % this.validValues.length];
+            }
+            this.grid[this.cursorRow][this.cursorCol] = nextVal;
+        }
+        else if (/[0-9]/.test(char)) {
+            const num = parseInt(char, 10);
+            // Only set if valid in legend
+            if (this.validValues.includes(num)) {
+                this.grid[this.cursorRow][this.cursorCol] = num;
+            }
+        }
+        this.render(false);
+    }
+}
+exports.HeatmapPrompt = HeatmapPrompt;

package/dist/prompts/ip.d.ts

@@ -0,0 +1,11 @@
+import { Prompt } from '../base';
+import { IPOptions, MouseEvent } from '../types';
+export declare class IPPrompt extends Prompt<string, IPOptions> {
+    private octets;
+    private activeOctet;
+    private errorMsg;
+    constructor(options: IPOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/ip.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class IPPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.octets = ['', '', '', ''];
+        this.activeOctet = 0;
+        this.errorMsg = '';
+        if (options.initial) {
+            const parts = options.initial.split('.');
+            if (parts.length === 4) {
+                this.octets = parts.map(p => {
+                    const num = parseInt(p, 10);
+                    return !isNaN(num) && num >= 0 && num <= 255 ? p : '';
+                });
+            }
+        }
+    }
+    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`;
+        // IP Render
+        const partsDisplay = this.octets.map((octet, index) => {
+            const isEmpty = octet.length === 0;
+            let displayVal = isEmpty ? '_' : octet;
+            if (index === this.activeOctet) {
+                // Highlight active
+                displayVal = `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${displayVal}${ansi_1.ANSI.RESET}`;
+            }
+            return displayVal;
+        });
+        output += `  ${partsDisplay.join('.')}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        this.errorMsg = '';
+        if (char === '\r' || char === '\n') {
+            if (this.octets.every(o => o.length > 0)) {
+                this.submit(this.octets.join('.'));
+            }
+            else {
+                this.errorMsg = 'Invalid IP address';
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            const current = this.octets[this.activeOctet];
+            if (current.length > 0) {
+                this.octets[this.activeOctet] = current.slice(0, -1);
+            }
+            else if (this.activeOctet > 0) {
+                this.activeOctet--;
+            }
+            this.render(false);
+            return;
+        }
+        // Navigation
+        if (this.isLeft(char) && this.activeOctet > 0) {
+            this.activeOctet--;
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char) && this.activeOctet < 3) {
+            this.activeOctet++;
+            this.render(false);
+            return;
+        }
+        // Dot navigation
+        if (char === '.') {
+            if (this.activeOctet < 3) {
+                this.activeOctet++;
+                this.render(false);
+            }
+            return;
+        }
+        // Numbers
+        if (/^\d$/.test(char)) {
+            const current = this.octets[this.activeOctet];
+            const newValue = current + char;
+            if (parseInt(newValue, 10) <= 255) {
+                this.octets[this.activeOctet] = newValue;
+                // Auto-jump if 3 digits
+                if (newValue.length === 3 && this.activeOctet < 3) {
+                    this.activeOctet++;
+                }
+                this.render(false);
+            }
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.activeOctet > 0) {
+                    this.activeOctet--;
+                    this.render(false);
+                }
+            }
+            else if (event.scroll === 'down') {
+                if (this.activeOctet < 3) {
+                    this.activeOctet++;
+                    this.render(false);
+                }
+            }
+        }
+    }
+}
+exports.IPPrompt = IPPrompt;

package/dist/prompts/kanban.d.ts

@@ -0,0 +1,17 @@
+import { Prompt } from '../base';
+import { KanbanOptions, KanbanItem, MouseEvent } from '../types';
+export declare class KanbanPrompt<V extends KanbanItem> extends Prompt<Record<string, V[]>, KanbanOptions<V>> {
+    private columns;
+    private activeCol;
+    private activeRow;
+    private grabbed;
+    private scrollStates;
+    constructor(options: KanbanOptions<V>);
+    protected render(_firstRender: boolean): void;
+    private padCenter;
+    protected handleMouse(event: MouseEvent): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    private moveItemHorizontal;
+    private clampRow;
+    private ensureVisible;
+}