mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/byte.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+class BytePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.inputValue = 0;
+        this.buffer = '';
+        this.unitIndex = 0;
+        this.errorMsg = '';
+        // Parse initial bytes to best unit
+        // e.g. 1073741824 -> 1.00 GB
+        let val = options.initial || 0;
+        let idx = 0;
+        while (val >= 1024 && idx < UNITS.length - 1) {
+            val /= 1024;
+            idx++;
+        }
+        // Round to 2 decimals for display if float
+        this.inputValue = Math.round(val * 100) / 100;
+        this.buffer = this.inputValue.toString();
+        this.unitIndex = idx;
+    }
+    render(_firstRender) {
+        const unitStr = UNITS[this.unitIndex];
+        // 1. Render Question & Input
+        const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
+        let output = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        // Value part
+        output += `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${this.buffer}${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${unitStr}${ansi_1.ANSI.RESET}\n`;
+        // 2. Render Unit Bar
+        // (Unit: B > KB > [MB] > GB)
+        let bar = '  ';
+        UNITS.forEach((u, i) => {
+            if (i === this.unitIndex) {
+                bar += `${theme_1.theme.main}${ansi_1.ANSI.REVERSE} ${u} ${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                bar += `${theme_1.theme.muted} ${u} ${ansi_1.ANSI.RESET}`;
+            }
+            if (i < UNITS.length - 1) {
+                bar += ` ${theme_1.theme.muted}›${ansi_1.ANSI.RESET} `;
+            }
+        });
+        output += `\n${bar}\n`;
+        // 3. Hints & Errors
+        output += `${theme_1.theme.muted}  (Arrows: Adjust | Tab: Switch Unit | Enter: Submit)${ansi_1.ANSI.RESET}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        this.errorMsg = '';
+        // Enter
+        if (char === '\r' || char === '\n') {
+            const finalVal = parseFloat(this.buffer);
+            if (isNaN(finalVal)) {
+                this.errorMsg = 'Invalid number';
+                this.render(false);
+                return;
+            }
+            // Calculate Bytes: value * 1024^index
+            const bytes = finalVal * Math.pow(1024, this.unitIndex);
+            // Min/Max Validation (in bytes)
+            if (this.options.min !== undefined && bytes < this.options.min) {
+                this.errorMsg = `Minimum value is ${this.formatBytes(this.options.min)}`;
+                this.render(false);
+                return;
+            }
+            if (this.options.max !== undefined && bytes > this.options.max) {
+                this.errorMsg = `Maximum value is ${this.formatBytes(this.options.max)}`;
+                this.render(false);
+                return;
+            }
+            this.submit(Math.round(bytes)); // Return integer bytes? Or float? Usually bytes are int.
+            return;
+        }
+        // Tab / Shift+Tab -> Switch Unit
+        if (char === '\t' || this.isRight(char)) {
+            if (this.unitIndex < UNITS.length - 1) {
+                this.unitIndex++;
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\x1b[Z' || this.isLeft(char)) { // Shift+Tab or Left
+            if (this.unitIndex > 0) {
+                this.unitIndex--;
+                this.render(false);
+            }
+            return;
+        }
+        // Arrows -> Adjust Value
+        if (this.isUp(char) || this.isDown(char)) {
+            let val = parseFloat(this.buffer) || 0;
+            // Adaptive step: 1 if integer, 0.1 if float
+            const step = this.buffer.includes('.') ? 0.1 : 1;
+            if (this.isUp(char))
+                val += step;
+            if (this.isDown(char))
+                val -= step;
+            // Fix Float Precision
+            val = Math.round(val * 100) / 100;
+            if (val < 0)
+                val = 0; // No negative bytes usually
+            this.buffer = val.toString();
+            this.render(false);
+            return;
+        }
+        // Typing / Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.buffer.length > 0) {
+                this.buffer = this.buffer.slice(0, -1);
+                this.render(false);
+            }
+            return;
+        }
+        // Digits & Dot
+        if (/^[0-9.]$/.test(char)) {
+            // Prevent multiple dots
+            if (char === '.' && this.buffer.includes('.'))
+                return;
+            this.buffer += char;
+            this.render(false);
+        }
+    }
+    // Helper for error messages
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const i = Math.floor(Math.log(bytes) / Math.log(1024));
+        return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + ' ' + UNITS[i];
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                // Scroll up -> Increase Value
+                let val = parseFloat(this.buffer) || 0;
+                val += 1;
+                this.buffer = val.toString();
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                // Scroll down -> Decrease Value
+                let val = parseFloat(this.buffer) || 0;
+                val = Math.max(0, val - 1);
+                this.buffer = val.toString();
+                this.render(false);
+            }
+        }
+    }
+}
+exports.BytePrompt = BytePrompt;

package/dist/prompts/calculator.d.ts

@@ -0,0 +1,16 @@
+import { Prompt } from '../base';
+import { CalculatorOptions } from '../types';
+export declare class CalculatorPrompt extends Prompt<number, CalculatorOptions> {
+    protected errorMsg: string;
+    protected cursor: number;
+    protected hasTyped: boolean;
+    protected segments: string[];
+    protected lastLinesUp: number;
+    protected previewValue: string;
+    constructor(options: CalculatorOptions);
+    private updatePreview;
+    private evaluate;
+    protected render(firstRender: boolean): void;
+    private getVisualCursorPosition;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/calculator.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalculatorPrompt = 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 CalculatorPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.errorMsg = '';
+        this.cursor = 0;
+        this.hasTyped = false;
+        this.segments = [];
+        this.lastLinesUp = 0;
+        this.previewValue = '';
+        this.value = options.initial ? String(options.initial) : '';
+        this.segments = (0, utils_1.safeSplit)(this.value);
+        this.cursor = this.segments.length;
+        this.updatePreview();
+    }
+    updatePreview() {
+        const input = this.segments.join('');
+        if (!input.trim()) {
+            this.previewValue = '';
+            return;
+        }
+        try {
+            const result = this.evaluate(input);
+            if (result !== null && !isNaN(result) && isFinite(result)) {
+                // Format precision if needed
+                if (this.options.precision !== undefined) {
+                    this.previewValue = parseFloat(result.toFixed(this.options.precision)).toString();
+                }
+                else {
+                    this.previewValue = result.toString();
+                }
+            }
+            else {
+                this.previewValue = '';
+            }
+        }
+        catch (_e) {
+            this.previewValue = '';
+        }
+    }
+    evaluate(expression) {
+        let expr = expression;
+        // 1. Substitute variables
+        if (this.options.variables) {
+            // Sort keys by length desc to avoid partial replacement issues (e.g. 'var11' vs 'var1')
+            const keys = Object.keys(this.options.variables).sort((a, b) => b.length - a.length);
+            for (const key of keys) {
+                const val = this.options.variables[key];
+                const regex = new RegExp(`\\b${key}\\b`, 'g');
+                expr = expr.replace(regex, String(val));
+            }
+        }
+        // 2. Validate characters
+        if (/[a-zA-Z_]/.test(expr)) {
+            // Support basic Math functions: sin, cos, tan, log, sqrt, abs, pow, floor, ceil, round
+            const allowedMath = ['sin', 'cos', 'tan', 'log', 'sqrt', 'abs', 'pow', 'floor', 'ceil', 'round', 'PI', 'E'];
+            // We can prefix them with Math.
+            let checkStr = expr;
+            allowedMath.forEach(k => {
+                checkStr = checkStr.replace(new RegExp(k, 'g'), '');
+            });
+            if (/[a-zA-Z_]/.test(checkStr)) {
+                return null; // Contains unknown variables or functions
+            }
+            // Now prefix Math functions in the real expr
+            allowedMath.forEach(k => {
+                // Replace 'sin(' with 'Math.sin('
+                // Be careful with PI and E
+                if (['PI', 'E'].includes(k)) {
+                    expr = expr.replace(new RegExp(`\\b${k}\\b`, 'g'), `Math.${k}`);
+                }
+                else {
+                    expr = expr.replace(new RegExp(`\\b${k}\\(`, 'g'), `Math.${k}(`);
+                }
+            });
+        }
+        // 3. Safe Eval using Function
+        try {
+            const func = new Function(`return (${expr})`);
+            const res = func();
+            return typeof res === 'number' ? res : null;
+        }
+        catch (_err) {
+            return null;
+        }
+    }
+    render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
+        const prefix = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        const prefixVisualLen = this.stripAnsi(prefix).length;
+        // Render Input Line
+        let displayValue = '';
+        const inputStr = this.segments.join('');
+        if (!inputStr && this.options.placeholder && !this.errorMsg && !this.hasTyped) {
+            displayValue = `${theme_1.theme.muted}${this.options.placeholder}${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            displayValue = theme_1.theme.main + inputStr + ansi_1.ANSI.RESET;
+        }
+        let output = `${prefix}${displayValue}`;
+        // Add Preview Line (if available and no error)
+        let previewStr = '';
+        if (this.previewValue && !this.errorMsg) {
+            // Display as "= Result" in muted color
+            previewStr = `\n${theme_1.theme.muted}= ${this.previewValue}${ansi_1.ANSI.RESET}`;
+            output += previewStr;
+        }
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        let totalRows = 1;
+        if (previewStr)
+            totalRows++;
+        if (this.errorMsg)
+            totalRows++;
+        const linesUp = (totalRows - 1);
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+        }
+        this.lastLinesUp = linesUp;
+        // Move cursor to correct column
+        // We assume single line input for now
+        const cursorVisualCol = this.getVisualCursorPosition();
+        const targetCol = prefixVisualLen + cursorVisualCol;
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (targetCol > 0) {
+            this.print(`\x1b[${targetCol}C`);
+        }
+    }
+    getVisualCursorPosition() {
+        let width = 0;
+        for (let i = 0; i < this.cursor; i++) {
+            width += (0, utils_1.stringWidth)(this.segments[i]);
+        }
+        return width;
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            const input = this.segments.join('');
+            const result = this.evaluate(input);
+            if (result === null || isNaN(result)) {
+                this.errorMsg = 'Invalid expression';
+                this.render(false);
+                return;
+            }
+            this.submit(result);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            this.hasTyped = true;
+            if (this.cursor > 0) {
+                this.segments.splice(this.cursor - 1, 1);
+                this.cursor--;
+                this.errorMsg = '';
+                this.updatePreview();
+                this.render(false);
+            }
+            return;
+        }
+        // Arrows
+        if (this.isLeft(char)) {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.cursor < this.segments.length) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+        // Delete
+        if (char === '\u001b[3~') {
+            this.hasTyped = true;
+            if (this.cursor < this.segments.length) {
+                this.segments.splice(this.cursor, 1);
+                this.errorMsg = '';
+                this.updatePreview();
+                this.render(false);
+            }
+            return;
+        }
+        // Normal typing
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.hasTyped = true;
+            const newSegments = (0, utils_1.safeSplit)(char);
+            this.segments.splice(this.cursor, 0, ...newSegments);
+            this.cursor += newSegments.length;
+            this.errorMsg = '';
+            this.updatePreview();
+            this.render(false);
+        }
+    }
+}
+exports.CalculatorPrompt = CalculatorPrompt;

package/dist/prompts/calendar.js

@@ -85,8 +85,6 @@ class CalendarPrompt extends base_1.Prompt {
         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
@@ -96,9 +94,6 @@ class CalendarPrompt extends base_1.Prompt {
                 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);
             }
         }

package/dist/prompts/code.d.ts

@@ -9,7 +9,9 @@ export declare class CodePrompt extends Prompt<string, CodeOptions> {
     private lastLinesUp;
     constructor(options: CodeOptions);
     private parseTemplate;
+    protected cleanup(): void;
     protected render(firstRender: boolean): void;
+    private appendSegment;
     protected handleInput(char: string, _key: Buffer): void;
     protected handleMouse(event: MouseEvent): void;
     private moveFocus;

package/dist/prompts/code.js

@@ -4,7 +4,7 @@ exports.CodePrompt = void 0;
 const ansi_1 = require("../ansi");
 const base_1 = require("../base");
 const theme_1 = require("../theme");
-const highlight_1 = require("../highlight");
+const utils_1 = require("../utils");
 class CodePrompt extends base_1.Prompt {
     constructor(options) {
         super(options);
@@ -18,11 +18,12 @@ class CodePrompt extends base_1.Prompt {
         // Init values
         this.variableTokens.forEach(idx => {
             const name = this.tokens[idx].value;
-            this.values[name] = '';
+            this.values[name] = (this.options.values && this.options.values[name]) || '';
         });
         // Init cursor at end of first var
         if (this.variableTokens.length > 0) {
-            this.cursor = 0; // Start empty
+            const activeName = this.tokens[this.variableTokens[0]].value;
+            this.cursor = this.values[activeName].length;
         }
     }
     parseTemplate() {
@@ -41,80 +42,98 @@ class CodePrompt extends base_1.Prompt {
             this.tokens.push({ type: 'static', value: this.options.template.substring(lastIndex) });
         }
     }
+    // FIX: Override cleanup to ensure cursor is reset to bottom
+    cleanup() {
+        // If the cursor is currently moved up (editing mode), move it back down
+        // before the prompt exits. This prevents the next output (or result)
+        // from overwriting the bottom part of our UI.
+        if (this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+            this.lastLinesUp = 0;
+        }
+        super.cleanup();
+    }
     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 = '';
+        // 1. Build Full Raw Text & Identify Active Variable Range
+        let fullRawText = '';
+        let activeVarStart = -1;
+        let activeVarEnd = -1;
+        const activeTokenIdx = this.variableTokens[this.activeVarIndex];
+        const activeVarName = this.tokens[activeTokenIdx].value;
         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] || '';
-                }
+            const val = (token.type === 'static') ? token.value : (this.values[token.value] || '');
+            if (idx === activeTokenIdx) {
+                activeVarStart = fullRawText.length;
+                activeVarEnd = activeVarStart + val.length;
             }
+            fullRawText += val;
         });
-        // 2. Highlight
+        // 2. Syntax Highlight with Overlap Logic
         let highlighted = '';
-        const shouldHighlight = this.options.highlight !== false; // Default true
+        const shouldHighlight = this.options.highlight !== false;
         if (shouldHighlight) {
-            highlighted = (0, highlight_1.highlightJson)(rawWithPlaceholder);
+            const jsonTokenRegex = /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"?)|(-?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)|(true|false|null)|([{}[\],:])/g;
+            let match;
+            let lastIndex = 0;
+            while ((match = jsonTokenRegex.exec(fullRawText)) !== null) {
+                if (match.index > lastIndex) {
+                    const gap = fullRawText.substring(lastIndex, match.index);
+                    this.appendSegment(gap, lastIndex, activeVarStart, activeVarEnd, ansi_1.ANSI.FG_WHITE, (s) => highlighted += s);
+                }
+                const tokenText = match[0];
+                const tokenStart = match.index;
+                let color = theme_1.theme.syntax?.punctuation || ansi_1.ANSI.FG_WHITE;
+                if (tokenText.startsWith('"')) {
+                    const remaining = fullRawText.substring(jsonTokenRegex.lastIndex);
+                    if (/^\s*:/.test(remaining)) {
+                        color = theme_1.theme.syntax?.key || ansi_1.ANSI.FG_CYAN;
+                    }
+                    else {
+                        color = theme_1.theme.syntax?.string || ansi_1.ANSI.FG_GREEN;
+                    }
+                }
+                else if (/^-?\d/.test(tokenText)) {
+                    color = theme_1.theme.syntax?.number || ansi_1.ANSI.FG_YELLOW;
+                }
+                else if (/^(true|false|null)$/.test(tokenText)) {
+                    color = (tokenText === 'null')
+                        ? (theme_1.theme.syntax?.null || ansi_1.ANSI.FG_RED)
+                        : (theme_1.theme.syntax?.boolean || ansi_1.ANSI.FG_MAGENTA);
+                }
+                else if (/^[{}[\],:]$/.test(tokenText)) {
+                    color = theme_1.theme.syntax?.punctuation || ansi_1.ANSI.FG_WHITE;
+                }
+                this.appendSegment(tokenText, tokenStart, activeVarStart, activeVarEnd, color, (s) => highlighted += s);
+                lastIndex = jsonTokenRegex.lastIndex;
+            }
+            if (lastIndex < fullRawText.length) {
+                const tail = fullRawText.substring(lastIndex);
+                this.appendSegment(tail, lastIndex, activeVarStart, activeVarEnd, ansi_1.ANSI.FG_WHITE, (s) => highlighted += s);
+            }
         }
         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`;
+            this.appendSegment(fullRawText, 0, activeVarStart, activeVarEnd, ansi_1.ANSI.RESET, (s) => highlighted += s);
+        }
+        // 3. Output Frame
+        const warningMsg = shouldHighlight
+            ? `${ansi_1.ANSI.FG_YELLOW}Warning:${ansi_1.ANSI.RESET} Syntax highlighting is an experimental feature.\n`
+            : '';
+        const prefix = `${warningMsg}${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] || '';
-                }
-            }
-        }
+        // 4. Cursor Calculation
+        const cursorAbsPos = activeVarStart + this.cursor;
+        const textBeforeCursor = fullRawText.substring(0, cursorAbsPos);
         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 cursorCol = (0, utils_1.stringWidth)(rowsBefore[rowsBefore.length - 1]);
+        const totalSnippetLines = fullRawText.split('\n').length;
+        // linesUp calculation: 1 (suffix) + remaining snippet lines
         const linesUp = 1 + (totalSnippetLines - 1 - cursorRow);
         this.print(ansi_1.ANSI.SHOW_CURSOR);
         if (linesUp > 0) {
@@ -126,9 +145,28 @@ class CodePrompt extends base_1.Prompt {
             this.print(`\x1b[${cursorCol}C`);
         }
     }
+    appendSegment(text, absStart, activeStart, activeEnd, syntaxColor, append) {
+        const absEnd = absStart + text.length;
+        const overlapStart = Math.max(absStart, activeStart);
+        const overlapEnd = Math.min(absEnd, activeEnd);
+        if (overlapStart < overlapEnd) {
+            if (absStart < overlapStart) {
+                const part = text.substring(0, overlapStart - absStart);
+                append(`${syntaxColor}${part}${ansi_1.ANSI.RESET}`);
+            }
+            const activePart = text.substring(overlapStart - absStart, overlapEnd - absStart);
+            append(`${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${activePart}${ansi_1.ANSI.RESET}`);
+            if (absEnd > overlapEnd) {
+                const part = text.substring(overlapEnd - absStart);
+                append(`${syntaxColor}${part}${ansi_1.ANSI.RESET}`);
+            }
+        }
+        else {
+            append(`${syntaxColor}${text}${ansi_1.ANSI.RESET}`);
+        }
+    }
     handleInput(char, _key) {
-        // Nav
-        if (char === '\u001b[Z') { // Shift Tab
+        if (char === '\u001b[Z') {
             this.moveFocus(-1);
             return;
         }
@@ -136,7 +174,6 @@ class CodePrompt extends base_1.Prompt {
             this.moveFocus(1);
             return;
         }
-        // Enter
         if (char === '\r' || char === '\n') {
             this.submitCode();
             return;
@@ -144,8 +181,7 @@ class CodePrompt extends base_1.Prompt {
         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 (char === '\u0008' || char === '\x7f') {
             if (this.cursor > 0) {
                 const pre = val.slice(0, this.cursor - 1);
                 const post = val.slice(this.cursor);
@@ -177,12 +213,10 @@ class CodePrompt extends base_1.Prompt {
     }
     handleMouse(event) {
         if (event.action === 'scroll') {
-            if (event.scroll === 'up') {
+            if (event.scroll === 'up')
                 this.moveFocus(-1);
-            }
-            else if (event.scroll === 'down') {
+            else if (event.scroll === 'down')
                 this.moveFocus(1);
-            }
         }
     }
     moveFocus(direction) {
@@ -190,7 +224,7 @@ class CodePrompt extends base_1.Prompt {
         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.cursor = (this.values[varName] || '').length;
             this.render(false);
         }
     }