mepcli 0.5.0 → 0.6.0

package/dist/prompts/calendar.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class CalendarPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selection = null;
+        this.selectingRange = false; // Internal state for range selection
+        // Normalize initial value
+        if (Array.isArray(options.initial)) {
+            this.selection = [new Date(options.initial[0]), new Date(options.initial[1])];
+            this.cursor = new Date(options.initial[1]); // Cursor at end of range
+        }
+        else if (options.initial) {
+            this.selection = new Date(options.initial);
+            this.cursor = new Date(options.initial);
+        }
+        else {
+            this.cursor = new Date();
+            // If range mode but no initial, selection remains null until user picks
+            if (this.options.mode !== 'range') {
+                this.selection = new Date();
+            }
+        }
+        // Clone cursor to viewDate to track month view independently
+        this.viewDate = new Date(this.cursor);
+        this.viewDate.setDate(1);
+    }
+    getDaysInMonth(year, month) {
+        return new Date(year, month + 1, 0).getDate();
+    }
+    getDayOfWeek(year, month, day) {
+        return new Date(year, month, day).getDay();
+    }
+    generateMonthGrid(year, month) {
+        const days = [];
+        const firstDayOfMonth = new Date(year, month, 1);
+        const startDayOfWeek = firstDayOfMonth.getDay(); // 0 (Sun) to 6 (Sat)
+        const weekStart = this.options.weekStart || 0;
+        // Calculate days from previous month to fill the first row
+        // If startDayOfWeek is 2 (Tue) and weekStart is 0 (Sun), we need 2 days from prev month.
+        // If startDayOfWeek is 0 (Sun) and weekStart is 1 (Mon), we need 6 days from prev month.
+        const daysFromPrevMonth = (startDayOfWeek - weekStart + 7) % 7;
+        if (daysFromPrevMonth === 0 && startDayOfWeek !== weekStart) {
+            // Logic check: if starts on same day, 0. 
+        }
+        const prevMonthDate = new Date(year, month, 0); // Last day of prev month
+        const prevMonthDaysCount = prevMonthDate.getDate();
+        // Add previous month days
+        for (let i = daysFromPrevMonth - 1; i >= 0; i--) {
+            days.push({
+                date: new Date(year, month - 1, prevMonthDaysCount - i),
+                inMonth: false
+            });
+        }
+        // Add current month days
+        const daysInMonth = this.getDaysInMonth(year, month);
+        for (let i = 1; i <= daysInMonth; i++) {
+            days.push({
+                date: new Date(year, month, i),
+                inMonth: true
+            });
+        }
+        // Add next month days to fill 42 cells (6 rows * 7 cols)
+        let nextMonthDay = 1;
+        while (days.length < 42) {
+            days.push({
+                date: new Date(year, month + 1, nextMonthDay++),
+                inMonth: false
+            });
+        }
+        return days;
+    }
+    isSameDay(d1, d2) {
+        return d1.getFullYear() === d2.getFullYear() &&
+            d1.getMonth() === d2.getMonth() &&
+            d1.getDate() === d2.getDate();
+    }
+    isSelected(d) {
+        if (!this.selection)
+            return false;
+        if (this.options.mode === 'range') {
+            if (Array.isArray(this.selection)) {
+                const [start, end] = this.selection;
+                // If the range is complete, highlight everything in between
+                // Sort to ensure valid range check even if start > end (though we should normalize)
+                const s = start < end ? start : end;
+                const e = start < end ? end : start;
+                // Set times to midnight for comparison
+                const dTime = new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+                const sTime = new Date(s.getFullYear(), s.getMonth(), s.getDate()).getTime();
+                const eTime = new Date(e.getFullYear(), e.getMonth(), e.getDate()).getTime();
+                return dTime >= sTime && dTime <= eTime;
+            }
+            else {
+                // Selecting range, but only first point picked?
+                // Usually when picking range, first click sets start, moving cursor highlights?
+                // For now, if selection is single date in range mode, just highlight it
+                return this.isSameDay(d, this.selection);
+            }
+        }
+        else {
+            return this.isSameDay(d, this.selection);
+        }
+    }
+    // Helper to check if selection is 'in progress' (only one end picked) for visual feedback
+    isRangeStart(d) {
+        if (this.options.mode !== 'range' || !this.selection)
+            return false;
+        if (Array.isArray(this.selection)) {
+            return this.isSameDay(d, this.selection[0]) || this.isSameDay(d, this.selection[1]);
+        }
+        return this.isSameDay(d, this.selection);
+    }
+    render(_firstRender) {
+        const monthNames = ["January", "February", "March", "April", "May", "June",
+            "July", "August", "September", "October", "November", "December"
+        ];
+        const year = this.viewDate.getFullYear();
+        const month = this.viewDate.getMonth();
+        const header = `${ansi_1.ANSI.BOLD}${monthNames[month]} ${year}${ansi_1.ANSI.RESET}`;
+        // Centered header roughly
+        // 20 is approx width of calendar (3 chars * 7 cols - 1 space = 20)
+        // Actually grid width: 7 columns. Each cell is usually "DD ". Last col "DD".
+        // Let's say cell width is 3 chars (2 digits + 1 space). Total 21 chars.
+        const weekDays = this.options.weekStart === 1
+            ? ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"]
+            : ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
+        const grid = this.generateMonthGrid(year, month);
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Controls hint
+        output += `${theme_1.theme.muted}< ${header} >${ansi_1.ANSI.RESET}\n`;
+        // Weekday Header
+        output += weekDays.map(d => `${theme_1.theme.muted}${d}${ansi_1.ANSI.RESET}`).join(' ') + '\n';
+        // Grid
+        let rowLine = '';
+        for (let i = 0; i < grid.length; i++) {
+            const cell = grid[i];
+            const dateStr = cell.date.getDate().toString().padStart(2, ' ');
+            let style = '';
+            const isCursor = this.isSameDay(cell.date, this.cursor);
+            const isSel = this.isSelected(cell.date);
+            const isToday = this.isSameDay(cell.date, new Date());
+            // Base style
+            if (!cell.inMonth) {
+                style = theme_1.theme.muted;
+            }
+            if (isSel) {
+                // If it is selected, use main color
+                style = theme_1.theme.main;
+            }
+            if (isToday && !isSel) {
+                style += ansi_1.ANSI.UNDERLINE;
+            }
+            if (isCursor) {
+                style += ansi_1.ANSI.REVERSE; // Invert colors for cursor
+            }
+            // Apply
+            // Reset must be applied after each cell to prevent bleeding
+            rowLine += `${style}${dateStr}${ansi_1.ANSI.RESET}`;
+            if ((i + 1) % 7 === 0) {
+                output += rowLine + '\n';
+                rowLine = '';
+            }
+            else {
+                rowLine += ' ';
+            }
+        }
+        // Helper text
+        const help = this.options.mode === 'range'
+            ? 'Enter: Select start/end'
+            : 'Enter: Select';
+        output += `${theme_1.theme.muted}${help}${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    syncViewDate() {
+        if (this.cursor.getMonth() !== this.viewDate.getMonth() || this.cursor.getFullYear() !== this.viewDate.getFullYear()) {
+            this.viewDate = new Date(this.cursor);
+            this.viewDate.setDate(1);
+        }
+    }
+    // When the user navigates the visible month independently (mouse scroll or
+    // '<'/'>'), keep the cursor in the newly viewed month so subsequent
+    // cursor movements don't snap the view back to the old month.
+    alignCursorToViewDate() {
+        const day = this.cursor.getDate();
+        const year = this.viewDate.getFullYear();
+        const month = this.viewDate.getMonth();
+        const daysInTarget = this.getDaysInMonth(year, month);
+        const newDay = Math.min(day, daysInTarget);
+        this.cursor = new Date(year, month, newDay);
+    }
+    handleInput(char, _key) {
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        const isLeft = this.isLeft(char);
+        const isRight = this.isRight(char);
+        // Navigation
+        if (isUp || isDown || isLeft || isRight) {
+            const d = new Date(this.cursor);
+            if (isUp)
+                d.setDate(d.getDate() - 7);
+            if (isDown)
+                d.setDate(d.getDate() + 7);
+            if (isLeft)
+                d.setDate(d.getDate() - 1);
+            if (isRight)
+                d.setDate(d.getDate() + 1);
+            this.cursor = d;
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // PageUp (Month - 1)
+        if (char === '\x1b[5~') {
+            this.cursor.setMonth(this.cursor.getMonth() - 1);
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // PageDown (Month + 1)
+        if (char === '\x1b[6~') {
+            this.cursor.setMonth(this.cursor.getMonth() + 1);
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // Ctrl+Up (Year - 1)
+        if (char === '\x1b[1;5A') {
+            this.cursor.setFullYear(this.cursor.getFullYear() - 1);
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // Ctrl+Down (Year + 1)
+        if (char === '\x1b[1;5B') {
+            this.cursor.setFullYear(this.cursor.getFullYear() + 1);
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // Home (First Day of Month)
+        if (char === '\x1b[H' || char === '\x1b[1~') {
+            this.cursor.setDate(1);
+            this.render(false);
+            return;
+        }
+        // End (Last Day of Month)
+        if (char === '\x1b[F' || char === '\x1b[4~') {
+            this.cursor.setMonth(this.cursor.getMonth() + 1);
+            this.cursor.setDate(0);
+            this.render(false);
+            return;
+        }
+        // t (Today)
+        if (char === 't') {
+            this.cursor = new Date();
+            this.syncViewDate();
+            this.render(false);
+            return;
+        }
+        // Month Navigation with < and > (shift+, shift+.)
+        if (char === '<' || char === ',') {
+            this.viewDate.setMonth(this.viewDate.getMonth() - 1);
+            this.alignCursorToViewDate();
+            this.render(false);
+            return;
+        }
+        if (char === '>' || char === '.') {
+            this.viewDate.setMonth(this.viewDate.getMonth() + 1);
+            this.alignCursorToViewDate();
+            this.render(false);
+            return;
+        }
+        // Selection
+        if (char === '\r' || char === '\n' || char === ' ') {
+            if (this.options.mode === 'range') {
+                if (!this.selectingRange) {
+                    // Start new range selection
+                    this.selection = this.cursor; // First point (single date temporary)
+                    this.selectingRange = true;
+                }
+                else {
+                    // Finish range selection
+                    const start = this.selection;
+                    const end = this.cursor;
+                    // Order them
+                    if (start > end) {
+                        this.selection = [end, start];
+                    }
+                    else {
+                        this.selection = [start, end];
+                    }
+                    this.selectingRange = false;
+                    this.submit(this.selection);
+                    return;
+                }
+            }
+            else {
+                // Single mode
+                this.selection = this.cursor;
+                this.submit(this.selection);
+                return;
+            }
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const direction = event.scroll === 'up' ? -1 : 1;
+            if (event.ctrl) {
+                // Ctrl+Scroll: Day (Cursor)
+                this.cursor.setDate(this.cursor.getDate() + direction);
+                this.syncViewDate();
+            }
+            else {
+                // Normal Scroll: Month
+                this.viewDate.setMonth(this.viewDate.getMonth() + direction);
+                this.alignCursorToViewDate();
+            }
+            this.render(false);
+        }
+    }
+}
+exports.CalendarPrompt = CalendarPrompt;

package/dist/prompts/checkbox.d.ts

@@ -7,7 +7,7 @@ export declare class CheckboxPrompt<V> extends Prompt<any[], CheckboxOptions<V>>
     private scrollTop;
     private readonly pageSize;
     constructor(options: CheckboxOptions<V>);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/checkbox.js

@@ -11,12 +11,12 @@ class CheckboxPrompt extends base_1.Prompt {
         super(options);
         this.selectedIndex = 0;
         this.errorMsg = '';
-        // Pagination state (added for consistency and performance)
+        // Pagination state
         this.scrollTop = 0;
         this.pageSize = 10;
         this.checkedState = options.choices.map(c => !!c.selected);
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Adjust Scroll Top
         if (this.selectedIndex < this.scrollTop) {
             this.scrollTop = this.selectedIndex;
@@ -31,7 +31,7 @@ class CheckboxPrompt extends base_1.Prompt {
         let output = '';
         // Header
         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} ${theme_1.theme.muted}(Press <space> to select, <enter> to confirm)${ansi_1.ANSI.RESET}`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(Space: toggle, a: all, x: none, Enter: submit)${ansi_1.ANSI.RESET}`;
         // List
         const choices = this.options.choices;
         const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
@@ -50,7 +50,7 @@ class CheckboxPrompt extends base_1.Prompt {
         });
         // Indication of more items
         if (choices.length > this.pageSize) {
-            const progress = ` ${this.scrollTop + 1}-${Math.min(this.scrollTop + this.pageSize, choices.length)} of ${choices.length}`;
+            // const progress = ` ${this.scrollTop + 1}-${Math.min(this.scrollTop + this.pageSize, choices.length)} of ${choices.length}`;
         }
         if (this.errorMsg) {
             output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
@@ -72,10 +72,6 @@ class CheckboxPrompt extends base_1.Prompt {
                 return;
             }
             this.cleanup();
-            // renderFrame cleans up lines, but doesn't print the final state "persisted" if we want to show the result?
-            // Usually we clear the prompt or show a summary.
-            // MepCLI seems to submit and let the caller decide or just print newline.
-            // Base `submit` prints newline.
             const results = this.options.choices
                 .filter((_, i) => this.checkedState[i])
                 .map(c => c.value);
@@ -83,6 +79,40 @@ class CheckboxPrompt extends base_1.Prompt {
                 this._resolve(results);
             return;
         }
+        // --- Batch Shortcuts ---
+        // 'a': Select All
+        if (char === 'a') {
+            if (this.options.max && this.options.choices.length > this.options.max) {
+                this.errorMsg = `Cannot select all: Max limit is ${this.options.max}`;
+            }
+            else {
+                this.checkedState.fill(true);
+                this.errorMsg = '';
+            }
+            this.render(false);
+            return;
+        }
+        // 'x' or 'n': Select None
+        if (char === 'x' || char === 'n') {
+            this.checkedState.fill(false);
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // 'i': Invert Selection
+        if (char === 'i') {
+            const potentialCount = this.checkedState.filter(s => !s).length;
+            if (this.options.max && potentialCount > this.options.max) {
+                this.errorMsg = `Cannot invert: Result exceeds max limit ${this.options.max}`;
+            }
+            else {
+                this.checkedState = this.checkedState.map(s => !s);
+                this.errorMsg = '';
+            }
+            this.render(false);
+            return;
+        }
+        // Space Toggle
         if (char === ' ') {
             const currentChecked = this.checkedState[this.selectedIndex];
             const selectedCount = this.checkedState.filter(Boolean).length;

package/dist/prompts/code.d.ts

@@ -0,0 +1,17 @@
+import { Prompt } from '../base';
+import { CodeOptions, MouseEvent } from '../types';
+export declare class CodePrompt extends Prompt<string, CodeOptions> {
+    private tokens;
+    private variableTokens;
+    private values;
+    private activeVarIndex;
+    private cursor;
+    private lastLinesUp;
+    constructor(options: CodeOptions);
+    private parseTemplate;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+    private moveFocus;
+    private submitCode;
+}

package/dist/prompts/code.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const highlight_1 = require("../highlight");
+class CodePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.tokens = [];
+        this.variableTokens = [];
+        this.values = {};
+        this.activeVarIndex = 0;
+        this.cursor = 0;
+        this.lastLinesUp = 0;
+        this.parseTemplate();
+        // Init values
+        this.variableTokens.forEach(idx => {
+            const name = this.tokens[idx].value;
+            this.values[name] = '';
+        });
+        // Init cursor at end of first var
+        if (this.variableTokens.length > 0) {
+            this.cursor = 0; // Start empty
+        }
+    }
+    parseTemplate() {
+        const regex = /\$\{([a-zA-Z0-9_]+)\}/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(this.options.template)) !== null) {
+            if (match.index > lastIndex) {
+                this.tokens.push({ type: 'static', value: this.options.template.substring(lastIndex, match.index) });
+            }
+            this.tokens.push({ type: 'variable', value: match[1] });
+            this.variableTokens.push(this.tokens.length - 1);
+            lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < this.options.template.length) {
+            this.tokens.push({ type: 'static', value: this.options.template.substring(lastIndex) });
+        }
+    }
+    render(firstRender) {
+        // Reset cursor from previous render relative position
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        // 1. Construct Raw String for Highlighting
+        const ACTIVE_PLACEHOLDER = '___ACTIVE___';
+        let rawWithPlaceholder = '';
+        this.tokens.forEach((token, idx) => {
+            if (token.type === 'static') {
+                rawWithPlaceholder += token.value;
+            }
+            else {
+                if (this.variableTokens[this.activeVarIndex] === idx) {
+                    rawWithPlaceholder += ACTIVE_PLACEHOLDER;
+                }
+                else {
+                    rawWithPlaceholder += this.values[token.value] || '';
+                }
+            }
+        });
+        // 2. Highlight
+        let highlighted = '';
+        const shouldHighlight = this.options.highlight !== false; // Default true
+        if (shouldHighlight) {
+            highlighted = (0, highlight_1.highlightJson)(rawWithPlaceholder);
+        }
+        else {
+            highlighted = rawWithPlaceholder;
+        }
+        // 3. Replace Placeholder with Styled Active Value
+        const activeVarName = this.tokens[this.variableTokens[this.activeVarIndex]].value;
+        const activeVal = this.values[activeVarName] || '';
+        // Use Main color + Underline. RESET restores default.
+        const styledActive = `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${activeVal}${ansi_1.ANSI.RESET}`;
+        highlighted = highlighted.replace(ACTIVE_PLACEHOLDER, styledActive);
+        // 4. Output
+        const prefix = `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        const suffix = `\n${theme_1.theme.muted}(Tab to next, Enter to submit)${ansi_1.ANSI.RESET}`;
+        const fullOutput = prefix + highlighted + suffix;
+        this.renderFrame(fullOutput);
+        // 5. Cursor Calculation
+        // Calculate (row, col) relative to start of snippet
+        let textBeforeCursor = '';
+        for (let i = 0; i < this.tokens.length; i++) {
+            const token = this.tokens[i];
+            if (token.type === 'static') {
+                textBeforeCursor += token.value;
+            }
+            else {
+                if (this.variableTokens[this.activeVarIndex] === i) {
+                    textBeforeCursor += activeVal.substring(0, this.cursor);
+                    break;
+                }
+                else {
+                    textBeforeCursor += this.values[token.value] || '';
+                }
+            }
+        }
+        const rowsBefore = textBeforeCursor.split('\n');
+        const cursorRow = rowsBefore.length - 1;
+        const cursorCol = rowsBefore[rowsBefore.length - 1].length;
+        // Calculate total lines in snippet
+        let fullRaw = '';
+        this.tokens.forEach(token => {
+            fullRaw += (token.type === 'static' ? token.value : (this.values[token.value] || ''));
+        });
+        const totalSnippetLines = fullRaw.split('\n').length;
+        // Calculate linesUp from the bottom of snippet
+        // Suffix is 1 line.
+        // CursorRow is 0-based index from top of snippet.
+        // If cursorRow is at bottom (totalSnippetLines-1), linesUp = 1 (Suffix).
+        // If cursorRow is at top (0), linesUp = 1 + (totalSnippetLines - 1).
+        const linesUp = 1 + (totalSnippetLines - 1 - cursorRow);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+            this.lastLinesUp = linesUp;
+        }
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (cursorCol > 0) {
+            this.print(`\x1b[${cursorCol}C`);
+        }
+    }
+    handleInput(char, _key) {
+        // Nav
+        if (char === '\u001b[Z') { // Shift Tab
+            this.moveFocus(-1);
+            return;
+        }
+        if (char === '\t') {
+            this.moveFocus(1);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.submitCode();
+            return;
+        }
+        const activeTokenIdx = this.variableTokens[this.activeVarIndex];
+        const varName = this.tokens[activeTokenIdx].value;
+        const val = this.values[varName] || '';
+        // Editing
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.cursor > 0) {
+                const pre = val.slice(0, this.cursor - 1);
+                const post = val.slice(this.cursor);
+                this.values[varName] = pre + post;
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.cursor > 0)
+                this.cursor--;
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.cursor < val.length)
+                this.cursor++;
+            this.render(false);
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            const pre = val.slice(0, this.cursor);
+            const post = val.slice(this.cursor);
+            this.values[varName] = pre + char + post;
+            this.cursor += char.length;
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.moveFocus(-1);
+            }
+            else if (event.scroll === 'down') {
+                this.moveFocus(1);
+            }
+        }
+    }
+    moveFocus(direction) {
+        const nextIndex = this.activeVarIndex + direction;
+        if (nextIndex >= 0 && nextIndex < this.variableTokens.length) {
+            this.activeVarIndex = nextIndex;
+            const varName = this.tokens[this.variableTokens[this.activeVarIndex]].value;
+            this.cursor = (this.values[varName] || '').length; // Move cursor to end
+            this.render(false);
+        }
+    }
+    submitCode() {
+        let result = '';
+        this.tokens.forEach(token => {
+            if (token.type === 'static') {
+                result += token.value;
+            }
+            else {
+                result += this.values[token.value] || '';
+            }
+        });
+        this.submit(result);
+    }
+}
+exports.CodePrompt = CodePrompt;

package/dist/prompts/color.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { ColorOptions, MouseEvent } from '../types';
+export declare class ColorPrompt extends Prompt<string, ColorOptions> {
+    private rgb;
+    private activeChannel;
+    private inputBuffer;
+    constructor(options: ColorOptions);
+    private parseHex;
+    private rgbToHex;
+    private getBgColorCode;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+}