mepcli 0.5.0 → 0.6.0

package/dist/prompts/color.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class ColorPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.activeChannel = 'r';
+        this.inputBuffer = '';
+        this.rgb = this.parseHex(options.initial || '#000000');
+    }
+    parseHex(hex) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : { r: 0, g: 0, b: 0 };
+    }
+    rgbToHex(r, g, b) {
+        return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase();
+    }
+    // Helper to format ANSI TrueColor background
+    getBgColorCode(r, g, b) {
+        return `\x1b[48;2;${r};${g};${b}m`;
+    }
+    render(_firstRender) {
+        const { r, g, b } = this.rgb;
+        const hex = this.rgbToHex(r, g, b);
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        output += `${ansi_1.ANSI.BOLD}${hex}${ansi_1.ANSI.RESET}\n\n`;
+        // Preview Block
+        if (this.capabilities.hasTrueColor) {
+            const bg = this.getBgColorCode(r, g, b);
+            const block = `${bg}        ${ansi_1.ANSI.RESET}`; // 8 spaces
+            output += `  ${block}\n`;
+            output += `  ${block}\n`;
+            output += `  ${block}\n\n`;
+        }
+        else {
+            // Fallback for no true color?
+            // Maybe just show text or use closest 256 color?
+            // For now, simpler fallback:
+            output += `  (Preview unavailable in this terminal)\n\n`;
+        }
+        // Sliders
+        const channels = ['r', 'g', 'b'];
+        const labels = { r: 'Red  ', g: 'Green', b: 'Blue ' };
+        channels.forEach(ch => {
+            const val = this.rgb[ch];
+            const isActive = this.activeChannel === ch;
+            // Render slider track
+            // Width 20 chars for 0-255
+            const width = 20;
+            const pos = Math.floor((val / 255) * width);
+            // Wait, '⚪' might be wide. using simpler char if needed. 'O' or ANSI reverse space.
+            // Let's use standard chars.
+            const trackSimple = '━'.repeat(pos) + (isActive ? '●' : '○') + '─'.repeat(width - pos);
+            let line = `${labels[ch]}: ${val.toString().padStart(3)} [${trackSimple}]`;
+            if (isActive) {
+                line = `${theme_1.theme.main}${ansi_1.ANSI.REVERSE} ${line} ${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                line = ` ${line} `;
+            }
+            output += line + '\n';
+        });
+        output += `\n${theme_1.theme.muted}Arrows: Adjust/Switch | Shift+Arrows: Adjust fast | Enter: Submit${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        const isLeft = this.isLeft(char);
+        const isRight = this.isRight(char);
+        // Detect Shift key for faster movement (generic check if possible, or mapping specific codes)
+        // \x1b[1;2C is Shift+Right usually. \x1b[1;2D is Shift+Left.
+        // It varies by terminal.
+        const isShiftRight = char === '\x1b[1;2C';
+        const isShiftLeft = char === '\x1b[1;2D';
+        // Channel Switching (Up/Down)
+        if (isUp) {
+            if (this.activeChannel === 'g')
+                this.activeChannel = 'r';
+            else if (this.activeChannel === 'b')
+                this.activeChannel = 'g';
+            this.render(false);
+            return;
+        }
+        if (isDown) {
+            if (this.activeChannel === 'r')
+                this.activeChannel = 'g';
+            else if (this.activeChannel === 'g')
+                this.activeChannel = 'b';
+            this.render(false);
+            return;
+        }
+        // Value Adjustment (Left/Right)
+        if (isLeft || isRight || isShiftLeft || isShiftRight) {
+            let change = 0;
+            if (isRight)
+                change = 1;
+            if (isLeft)
+                change = -1;
+            if (isShiftRight)
+                change = 10;
+            if (isShiftLeft)
+                change = -10;
+            const val = this.rgb[this.activeChannel] + change;
+            this.rgb[this.activeChannel] = Math.max(0, Math.min(255, val));
+            this.render(false);
+            return;
+        }
+        // Tab to cycle channels
+        if (char === '\t') {
+            if (this.activeChannel === 'r')
+                this.activeChannel = 'g';
+            else if (this.activeChannel === 'g')
+                this.activeChannel = 'b';
+            else
+                this.activeChannel = 'r';
+            this.render(false);
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            this.submit(this.rgbToHex(this.rgb.r, this.rgb.g, this.rgb.b));
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            // On scroll, adjust the currently active channel's value.
+            // If Ctrl is held, adjust by a larger step (fast adjust).
+            const fast = !!event.ctrl;
+            const step = fast ? 10 : 1;
+            const change = event.scroll === 'up' ? step : (event.scroll === 'down' ? -step : 0);
+            if (change !== 0) {
+                const val = this.rgb[this.activeChannel] + change;
+                this.rgb[this.activeChannel] = Math.max(0, Math.min(255, val));
+                this.render(false);
+            }
+        }
+    }
+}
+exports.ColorPrompt = ColorPrompt;

package/dist/prompts/confirm.d.ts

@@ -2,7 +2,7 @@ import { Prompt } from '../base';
 import { ConfirmOptions, MouseEvent } from '../types';
 export declare class ConfirmPrompt extends Prompt<boolean, ConfirmOptions> {
     constructor(options: ConfirmOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/confirm.js

@@ -10,7 +10,7 @@ class ConfirmPrompt extends base_1.Prompt {
         super(options);
         this.value = options.initial ?? true;
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Prepare content
         const hint = this.value ? `${ansi_1.ANSI.BOLD}Yes${ansi_1.ANSI.RESET}/no` : `yes/${ansi_1.ANSI.BOLD}No${ansi_1.ANSI.RESET}`;
         let output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(${hint})${ansi_1.ANSI.RESET} `;

package/dist/prompts/cron.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { CronOptions, MouseEvent } from '../types';
+export declare class CronPrompt extends Prompt<string, CronOptions> {
+    private fields;
+    private activeField;
+    private buffer;
+    constructor(options: CronOptions);
+    private get currentConfig();
+    protected render(_firstRender: boolean): void;
+    private validateCurrentField;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/cron.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const FIELDS = [
+    { label: 'Minute', min: 0, max: 59 },
+    { label: 'Hour', min: 0, max: 23 },
+    { label: 'Day', min: 1, max: 31 },
+    { label: 'Month', min: 1, max: 12 },
+    { label: 'Weekday', min: 0, max: 6 }
+];
+class CronPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.fields = ['*', '*', '*', '*', '*'];
+        this.activeField = 0;
+        this.buffer = '';
+        if (options.initial) {
+            const parts = options.initial.split(' ');
+            if (parts.length === 5) {
+                this.fields = parts;
+            }
+        }
+    }
+    get currentConfig() {
+        return FIELDS[this.activeField];
+    }
+    render(_firstRender) {
+        let 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`;
+        // Render fields
+        let fieldsStr = '';
+        this.fields.forEach((val, index) => {
+            const isSelected = index === this.activeField;
+            const displayVal = val.padStart(2, ' ');
+            if (isSelected) {
+                fieldsStr += `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${displayVal}${ansi_1.ANSI.RESET} `;
+            }
+            else {
+                fieldsStr += `${ansi_1.ANSI.DIM}${displayVal}${ansi_1.ANSI.RESET} `;
+            }
+        });
+        output += `  ${fieldsStr}\n`;
+        // Render Label and Hints
+        const config = this.currentConfig;
+        output += `  ${theme_1.theme.muted}${config.label} (${config.min}-${config.max})${ansi_1.ANSI.RESET}\n`;
+        output += `  ${ansi_1.ANSI.DIM}(Arrows: Adjust | Space: Toggle * | 0-9: Type | Tab: Next)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    validateCurrentField() {
+        const config = this.currentConfig;
+        const val = this.fields[this.activeField];
+        if (val === '*')
+            return;
+        let num = parseInt(val);
+        if (isNaN(num)) {
+            this.fields[this.activeField] = config.min.toString();
+        }
+        else {
+            num = Math.max(config.min, Math.min(num, config.max));
+            this.fields[this.activeField] = num.toString();
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.validateCurrentField();
+            this.submit(this.fields.join(' '));
+            return;
+        }
+        if (char === '\t' || this.isRight(char)) {
+            this.validateCurrentField();
+            this.activeField = (this.activeField + 1) % 5;
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        // Shift+Tab detection is often '\x1b[Z'
+        if (char === '\x1b[Z' || this.isLeft(char)) {
+            this.validateCurrentField();
+            this.activeField = (this.activeField - 1 + 5) % 5;
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        const config = this.currentConfig;
+        const currentVal = this.fields[this.activeField];
+        let numVal = parseInt(currentVal);
+        if (this.isUp(char)) {
+            if (currentVal === '*') {
+                this.fields[this.activeField] = config.min.toString();
+            }
+            else if (!isNaN(numVal)) {
+                numVal++;
+                if (numVal > config.max)
+                    numVal = config.min;
+                this.fields[this.activeField] = numVal.toString();
+            }
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (currentVal === '*') {
+                this.fields[this.activeField] = config.max.toString();
+            }
+            else if (!isNaN(numVal)) {
+                numVal--;
+                if (numVal < config.min)
+                    numVal = config.max;
+                this.fields[this.activeField] = numVal.toString();
+            }
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        if (char === ' ' || char.toLowerCase() === 'x') {
+            this.fields[this.activeField] = '*';
+            this.buffer = '';
+            this.render(false);
+            return;
+        }
+        // Direct Input
+        if (/^[0-9]$/.test(char)) {
+            const nextBuffer = this.buffer + char;
+            const nextNum = parseInt(nextBuffer);
+            // Check if valid
+            if (!isNaN(nextNum) && nextNum <= config.max) {
+                this.buffer = nextBuffer;
+                if (nextNum >= 0) { // Should be positive
+                    this.fields[this.activeField] = nextNum.toString();
+                }
+            }
+            else {
+                const freshNum = parseInt(char);
+                if (!isNaN(freshNum) && freshNum <= config.max) {
+                    this.buffer = char;
+                    this.fields[this.activeField] = freshNum.toString();
+                }
+            }
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const config = this.currentConfig;
+            const currentVal = this.fields[this.activeField];
+            let numVal = parseInt(currentVal);
+            if (event.scroll === 'up') { // Increase
+                if (currentVal === '*') {
+                    this.fields[this.activeField] = config.min.toString();
+                }
+                else if (!isNaN(numVal)) {
+                    numVal++;
+                    if (numVal > config.max)
+                        numVal = config.min;
+                    this.fields[this.activeField] = numVal.toString();
+                }
+            }
+            else { // Decrease
+                if (currentVal === '*') {
+                    this.fields[this.activeField] = config.max.toString();
+                }
+                else if (!isNaN(numVal)) {
+                    numVal--;
+                    if (numVal < config.min)
+                        numVal = config.max;
+                    this.fields[this.activeField] = numVal.toString();
+                }
+            }
+            this.buffer = '';
+            this.render(false);
+        }
+    }
+}
+exports.CronPrompt = CronPrompt;

package/dist/prompts/date.d.ts

@@ -5,7 +5,7 @@ export declare class DatePrompt extends Prompt<Date, DateOptions> {
     private errorMsg;
     private inputBuffer;
     constructor(options: DateOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
     private adjustDate;

package/dist/prompts/date.js

@@ -14,7 +14,7 @@ class DatePrompt extends base_1.Prompt {
         this.inputBuffer = '';
         this.value = options.initial || new Date();
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Date formatting
         const y = this.value.getFullYear();
         const m = (this.value.getMonth() + 1).toString().padStart(2, '0');
@@ -52,15 +52,25 @@ class DatePrompt extends base_1.Prompt {
             this.submit(this.value);
             return;
         }
-        if (this.isLeft(char)) { // Left
-            this.selectedField = Math.max(0, this.selectedField - 1);
+        if (char === '\t' || this.isRight(char)) { // Right / Tab
+            if (char === '\t') {
+                this.selectedField = (this.selectedField + 1) % 5;
+            }
+            else {
+                this.selectedField = Math.min(4, this.selectedField + 1);
+            }
             this.inputBuffer = ''; // Reset buffer on move
             this.errorMsg = '';
             this.render(false);
             return;
         }
-        if (this.isRight(char)) { // Right
-            this.selectedField = Math.min(4, this.selectedField + 1);
+        if (char === '\x1b[Z' || this.isLeft(char)) { // Left / Shift+Tab
+            if (char === '\x1b[Z') {
+                this.selectedField = (this.selectedField - 1 + 5) % 5;
+            }
+            else {
+                this.selectedField = Math.max(0, this.selectedField - 1);
+            }
             this.inputBuffer = ''; // Reset buffer on move
             this.errorMsg = '';
             this.render(false);

package/dist/prompts/editor.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { EditorOptions } from '../types';
+export declare class EditorPrompt extends Prompt<string, EditorOptions> {
+    private errorMsg;
+    private status;
+    private tempFilePath;
+    constructor(options: EditorOptions);
+    protected cleanup(): void;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    private resolveEditor;
+    private spawnEditor;
+    private restoreMep;
+}

package/dist/prompts/editor.js

@@ -0,0 +1,207 @@
+"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.EditorPrompt = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const ansi_1 = require("../ansi");
+class EditorPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.errorMsg = '';
+        this.status = 'pending';
+        this.tempFilePath = null;
+        // Default waitUserInput to true if not specified
+        if (this.options.waitUserInput === undefined) {
+            this.options.waitUserInput = true;
+        }
+    }
+    cleanup() {
+        if (this.tempFilePath) {
+            try {
+                if (fs.existsSync(this.tempFilePath)) {
+                    fs.unlinkSync(this.tempFilePath);
+                }
+            }
+            catch (_error) {
+                // Ignore cleanup errors
+            }
+        }
+        super.cleanup();
+    }
+    render(firstRender) {
+        if (this.status === 'editing') {
+            return; // Don't render while editor is open (stdio inherited)
+        }
+        const icon = this.status === 'done' ? theme_1.theme.success + symbols_1.symbols.tick : theme_1.theme.main + '?';
+        const message = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`;
+        const hint = this.options.waitUserInput
+            ? ` ${theme_1.theme.muted}[Press <Enter> to launch editor]${ansi_1.ANSI.RESET}`
+            : ` ${theme_1.theme.muted}[Launching editor...]${ansi_1.ANSI.RESET}`;
+        let output = `${icon} ${ansi_1.ANSI.BOLD}${message}${ansi_1.ANSI.RESET}${hint}`;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+        // Auto-launch handling
+        if (firstRender && this.options.waitUserInput === false) {
+            // We need to delay slightly to ensure the render frame is flushed
+            // and raw mode setup is complete from .run()
+            setTimeout(() => {
+                this.spawnEditor();
+            }, 50);
+        }
+    }
+    handleInput(char) {
+        if (this.status !== 'pending')
+            return;
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.spawnEditor();
+        }
+    }
+    resolveEditor() {
+        // 1. Env vars
+        const envEditor = process.env.VISUAL || process.env.EDITOR;
+        if (envEditor) {
+            const parts = envEditor.split(' ');
+            return { cmd: parts[0], args: parts.slice(1) };
+        }
+        // 2. OS specific
+        if (process.platform === 'win32') {
+            // Priority: notepad -> code -> wordpad
+            return { cmd: 'notepad', args: [] };
+        }
+        else {
+            // Unix/Linux/Mac
+            // Priority: vim -> nano -> vi
+            // We'll stick to 'vim' as the default safe bet if we can't detect.
+            // A more robust solution would check paths, but for now we assume 'vim'.
+            return { cmd: 'vim', args: [] };
+        }
+    }
+    spawnEditor() {
+        this.status = 'editing';
+        // 1. Prepare Temp File
+        const ext = this.options.extension || '.txt';
+        // Ensure extension has dot
+        const safeExt = ext.startsWith('.') ? ext : '.' + ext;
+        const filename = `mep-editor-${Date.now()}-${Math.floor(Math.random() * 1000)}${safeExt}`;
+        this.tempFilePath = path.join(os.tmpdir(), filename);
+        const initialContent = this.options.initial || '';
+        try {
+            fs.writeFileSync(this.tempFilePath, initialContent, 'utf8');
+        }
+        catch (e) {
+            this.errorMsg = `Failed to create temp file: ${e.message}`;
+            this.status = 'pending';
+            this.render(false);
+            return;
+        }
+        // 2. Resolve Editor
+        const { cmd, args } = this.resolveEditor();
+        const editorArgs = [...args, this.tempFilePath];
+        // 3. Pause Mep
+        // Temporarily disable mouse tracking if it was enabled
+        const shouldEnableMouse = this.options.mouse !== false && this.capabilities.hasMouse;
+        if (shouldEnableMouse) {
+            this.print(ansi_1.ANSI.DISABLE_MOUSE);
+        }
+        // Pause stdin and raw mode to allow child process to take over TTY
+        this.stdin.setRawMode(false);
+        this.stdin.pause();
+        // 4. Spawn
+        const child = (0, child_process_1.spawn)(cmd, editorArgs, {
+            stdio: 'inherit',
+            shell: true
+        });
+        child.on('error', (err) => {
+            this.restoreMep();
+            this.status = 'pending';
+            this.errorMsg = `Could not launch editor '${cmd}': ${err.message}`;
+            this.render(false);
+        });
+        child.on('exit', (code) => {
+            // 5. Read Result
+            let content = initialContent;
+            try {
+                if (this.tempFilePath && fs.existsSync(this.tempFilePath)) {
+                    content = fs.readFileSync(this.tempFilePath, 'utf8');
+                    fs.unlinkSync(this.tempFilePath); // Cleanup
+                    this.tempFilePath = null; // Mark as cleaned
+                }
+            }
+            catch (_e) {
+                // Ignore read/delete errors
+            }
+            this.restoreMep();
+            if (code !== 0) {
+                this.status = 'pending';
+                this.errorMsg = `Editor exited with code ${code}`;
+                this.render(false);
+                return;
+            }
+            // Success
+            this.status = 'done';
+            // Trim trailing newline which editors often add
+            // We only trim the *last* newline added by the editor if it wasn't there?
+            // Usually editors ensure a final newline.
+            // If the user entered "abc", vim saves "abc\n". We probably want "abc".
+            if (content.endsWith('\n')) {
+                content = content.slice(0, -1);
+            }
+            if (content.endsWith('\r')) {
+                content = content.slice(0, -1);
+            }
+            this.submit(content);
+        });
+    }
+    restoreMep() {
+        this.stdin.resume();
+        this.stdin.setRawMode(true);
+        // Re-enable mouse if it was enabled
+        const shouldEnableMouse = this.options.mouse !== false && this.capabilities.hasMouse;
+        if (shouldEnableMouse) {
+            this.print(ansi_1.ANSI.SET_ANY_EVENT_MOUSE + ansi_1.ANSI.SET_SGR_EXT_MODE_MOUSE);
+        }
+        this.print(ansi_1.ANSI.HIDE_CURSOR); // Ensure cursor is hidden again for Mep
+    }
+}
+exports.EditorPrompt = EditorPrompt;

package/dist/prompts/file.d.ts

@@ -1,12 +1,19 @@
 import { Prompt } from '../base';
 import { FileOptions } from '../types';
+/**
+ * Implementation of FilePrompt with autocomplete.
+ */
 export declare class FilePrompt extends Prompt<string, FileOptions> {
     private input;
     private cursor;
     private suggestions;
     private selectedSuggestion;
     private errorMsg;
+    private lastLinesUp;
     constructor(options: FileOptions);
+    /**
+     * Updates the suggestions list based on the current input path.
+     */
     private updateSuggestions;
     protected render(firstRender: boolean): void;
     protected handleInput(char: string): void;