mepcli 0.5.0 → 0.5.5

package/README.md

@@ -5,7 +5,7 @@
 ## Features
 
 - **Zero Dependency:** Keeps your project clean and fast.
-- **Comprehensive Prompts:** Includes `text`, `password`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `date`, `file`, `multiSelect`, `autocomplete`, `sort`, `table`, and `rating`.
+- **Comprehensive Prompts:** Includes `text`, `password`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `date`, `file`, `multiSelect`, `autocomplete`, `sort`, `table`, `rating`, `editor`, `tree`, and `keypress`.
 - **Mouse Support:** Built-in support for mouse interaction (SGR 1006 protocol). Scroll to navigate lists or change values; click to select.
 - **Responsive Input:** Supports cursor movement (Left/Right) and character insertion/deletion in text-based prompts.
 - **Validation:** Built-in support for input validation (sync and async) with custom error messages.
@@ -104,7 +104,13 @@ async function main() {
         ]
     });
 
-    console.log({ name, age, newsletter, lang, tools, stars, city, priorities, user });
+    // Editor (External text editor)
+    const bio = await MepCLI.editor({
+        message: "Write your biography:",
+        extension: ".md"
+    });
+
+    console.log({ name, age, newsletter, lang, tools, stars, city, priorities, user, bio });
 }
 
 main();
@@ -130,6 +136,9 @@ main();
 *   `autocomplete(options)` - Searchable selection with async suggestions.
 *   `sort(options)` - Reorder a list of items.
 *   `table(options)` - Display data in columns and select rows.
+*   `tree(options)` - Navigate and select from a hierarchical tree structure.
+*   `keypress(options)` - Wait for a specific key press or any key.
+*   `editor(options)` - Launch an external editor (Vim, Nano, Notepad, etc.) to capture multi-line content.
 *   `spinner(message)` - Returns a `Spinner` instance for manual control (`start`, `stop`, `update`, `success`, `error`).
 
 ## Mouse Support
@@ -137,7 +146,7 @@ main();
 MepCLI automatically detects modern terminals and enables **Mouse Tracking** (using SGR 1006 protocol).
 
 *   **Scrolling:**
-    *   `select`, `multiSelect`, `checkbox`, `autocomplete`, `table`: Scroll to navigate the list.
+    *   `select`, `multiSelect`, `checkbox`, `autocomplete`, `table`, `tree`: Scroll to navigate the list.
     *   `number`, `slider`, `rating`, `date`: Scroll to increment/decrement values or fields.
     *   `sort`: Scroll to navigate or reorder items (when grabbed).
     *   `toggle`, `confirm`: Scroll to toggle the state.

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions } from './types';
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions, EditorOptions, TreeOptions, KeypressOptions } from './types';
 import { Spinner } from './spinner';
 /**
  * Public Facade for MepCLI
@@ -25,4 +25,7 @@ export declare class MepCLI {
     static autocomplete<const V>(options: AutocompleteOptions<V>): Promise<V>;
     static sort(options: SortOptions): Promise<string[]>;
     static table<const V>(options: TableOptions<V>): Promise<V>;
+    static editor(options: EditorOptions): Promise<string>;
+    static tree<const V>(options: TreeOptions<V>): Promise<V>;
+    static keypress(options: KeypressOptions): Promise<string>;
 }

package/dist/core.js

@@ -18,6 +18,9 @@ const rating_1 = require("./prompts/rating");
 const autocomplete_1 = require("./prompts/autocomplete");
 const sort_1 = require("./prompts/sort");
 const table_1 = require("./prompts/table");
+const editor_1 = require("./prompts/editor");
+const tree_1 = require("./prompts/tree");
+const keypress_1 = require("./prompts/keypress");
 /**
  * Public Facade for MepCLI
  */
@@ -76,6 +79,15 @@ class MepCLI {
     static table(options) {
         return new table_1.TablePrompt(options).run();
     }
+    static editor(options) {
+        return new editor_1.EditorPrompt(options).run();
+    }
+    static tree(options) {
+        return new tree_1.TreePrompt(options).run();
+    }
+    static keypress(options) {
+        return new keypress_1.KeypressPrompt(options).run();
+    }
 }
 exports.MepCLI = MepCLI;
 MepCLI.theme = theme_1.theme;

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/keypress.d.ts

@@ -0,0 +1,7 @@
+import { Prompt } from '../base';
+import { KeypressOptions } from '../types';
+export declare class KeypressPrompt extends Prompt<string, KeypressOptions> {
+    constructor(options: KeypressOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string, key: Buffer): void;
+}

package/dist/prompts/keypress.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeypressPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class KeypressPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+    }
+    render(firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`;
+        if (this.options.keys) {
+            const hint = this.options.keys.map(k => {
+                if (k === '\r' || k === '\n' || k === 'enter')
+                    return 'enter';
+                if (k === ' ' || k === 'space')
+                    return 'space';
+                return k;
+            }).join('/');
+            // Only show hint if it's short enough to be helpful, or always?
+            // Let's always show it if provided, or maybe just dimmed.
+            output += ` ${theme_1.theme.muted}(${hint})${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += ` ${theme_1.theme.muted}(Press any key)${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        let keyName = char;
+        if (char === '\r' || char === '\n')
+            keyName = 'enter';
+        else if (char === ' ')
+            keyName = 'space';
+        else if (char === '\u001b')
+            keyName = 'escape';
+        else if (char === '\t')
+            keyName = 'tab';
+        // Handle backspace
+        else if (char === '\x7f' || char === '\b')
+            keyName = 'backspace';
+        // Check against whitelist
+        if (this.options.keys) {
+            const allowed = this.options.keys.map(k => k.toLowerCase());
+            // Check normalized name or exact char
+            if (!allowed.includes(keyName) && !allowed.includes(char)) {
+                return;
+            }
+        }
+        if (this.options.showInvisible) {
+            this.print(` ${theme_1.theme.success}${keyName}${ansi_1.ANSI.RESET}`);
+        }
+        this.submit(keyName);
+    }
+}
+exports.KeypressPrompt = KeypressPrompt;

package/dist/prompts/text.js

@@ -52,22 +52,22 @@ class TextPrompt extends base_1.Prompt {
             // This is tricky because segments might contain '\n'.
             // safeSplit treats '\n' as a segment.
             let cursorLineIndex = 0;
-            let cursorSegmentIndexOnLine = 0;
-            let currentSegmentIndex = 0;
+            const cursorSegmentIndexOnLine = 0;
+            const currentSegmentIndex = 0;
             for (let i = 0; i < lines.length; i++) {
                 // How many segments in this line?
                 // We can't just use lines[i].length because that's chars.
                 // We need to split the line again or iterate segments.
                 // Iterating segments is safer.
                 // Let's assume we iterate global segments until we hit a newline segment
-                let lineSegmentsCount = 0;
+                const lineSegmentsCount = 0;
                 // Since rawValue.split('\n') consumes the newlines, we need to account for them.
                 // Alternative: iterate this.segments
                 // Find where the cursor falls.
             }
             // Let's iterate segments to find cursor position (row, col)
             cursorLineIndex = 0;
-            let colIndex = 0; // Visual column or char index?
+            const colIndex = 0; // Visual column or char index?
             // If we want visual cursor position, we need visual width of segments.
             let visualColIndex = 0;
             for (let i = 0; i < this.cursor; i++) {
@@ -90,7 +90,7 @@ class TextPrompt extends base_1.Prompt {
             // Now prepare lines for display (scrolling/truncation)
             // We need to reconstruct lines from segments to apply styling/truncation logic per line.
             let currentLineSegments = [];
-            let processedLines = []; // Array of segment arrays
+            const processedLines = []; // Array of segment arrays
             for (const seg of this.segments) {
                 if (seg === '\n') {
                     processedLines.push(currentLineSegments);

package/dist/prompts/tree.d.ts

@@ -0,0 +1,20 @@
+import { Prompt } from '../base';
+import { TreeOptions, MouseEvent } from '../types';
+export declare class TreePrompt<V> extends Prompt<V, TreeOptions<V>> {
+    private cursor;
+    private expandedNodes;
+    private flatList;
+    private scrollTop;
+    private readonly pageSize;
+    private readonly ICON_CLOSED;
+    private readonly ICON_OPEN;
+    private readonly ICON_LEAF;
+    constructor(options: TreeOptions<V>);
+    private expandPathTo;
+    private initializeExpanded;
+    private recalculateFlatList;
+    private traverse;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string, key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/tree.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class TreePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.expandedNodes = new Set();
+        this.flatList = [];
+        this.scrollTop = 0;
+        this.pageSize = 15;
+        // Icons
+        this.ICON_CLOSED = symbols_1.symbols.pointer === '>' ? '+' : '▸';
+        this.ICON_OPEN = symbols_1.symbols.pointer === '>' ? '-' : '▾';
+        this.ICON_LEAF = symbols_1.symbols.pointer === '>' ? ' ' : ' '; // No specific icon for leaf, just indentation
+        this.initializeExpanded(this.options.data);
+        // Handle initial value
+        if (this.options.initial !== undefined) {
+            this.expandPathTo(this.options.initial);
+        }
+        this.recalculateFlatList();
+        if (this.options.initial !== undefined) {
+            const index = this.flatList.findIndex(item => item.node.value === this.options.initial);
+            if (index !== -1) {
+                this.cursor = index;
+            }
+        }
+    }
+    expandPathTo(value) {
+        const find = (nodes) => {
+            for (const node of nodes) {
+                if (node.value === value)
+                    return true;
+                if (node.children) {
+                    if (find(node.children)) {
+                        this.expandedNodes.add(node);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        find(this.options.data);
+    }
+    initializeExpanded(nodes) {
+        for (const node of nodes) {
+            if (node.expanded) {
+                this.expandedNodes.add(node);
+            }
+            if (node.children) {
+                this.initializeExpanded(node.children);
+            }
+        }
+    }
+    recalculateFlatList() {
+        this.flatList = [];
+        this.traverse(this.options.data, 0, null);
+        // Adjust cursor if it went out of bounds (e.g. collapsing a folder above cursor)
+        if (this.cursor >= this.flatList.length) {
+            this.cursor = Math.max(0, this.flatList.length - 1);
+        }
+    }
+    traverse(nodes, depth, parent) {
+        for (const node of nodes) {
+            this.flatList.push({
+                node,
+                depth,
+                parent
+            });
+            if (node.children && node.children.length > 0 && this.expandedNodes.has(node)) {
+                this.traverse(node.children, depth + 1, node);
+            }
+        }
+    }
+    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`;
+        if (this.flatList.length === 0) {
+            output += `  ${theme_1.theme.muted}No data${ansi_1.ANSI.RESET}`;
+            this.renderFrame(output);
+            return;
+        }
+        // Adjust Scroll
+        if (this.cursor < this.scrollTop) {
+            this.scrollTop = this.cursor;
+        }
+        else if (this.cursor >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.cursor - this.pageSize + 1;
+        }
+        const visible = this.flatList.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visible.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            const isSelected = actualIndex === this.cursor;
+            // Indentation
+            const indentSize = this.options.indent || 2;
+            const indentation = ' '.repeat(item.depth * indentSize);
+            // Pointer
+            let linePrefix = '';
+            if (isSelected) {
+                linePrefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+            }
+            else {
+                linePrefix = '  ';
+            }
+            // Folder Icon
+            let icon = '  '; // Default 2 spaces for alignment
+            const hasChildren = item.node.children && item.node.children.length > 0;
+            if (hasChildren) {
+                if (this.expandedNodes.has(item.node)) {
+                    icon = `${this.ICON_OPEN} `;
+                }
+                else {
+                    icon = `${this.ICON_CLOSED} `;
+                }
+            }
+            // Title
+            let title = item.node.title;
+            if (item.node.disabled) {
+                title = `${theme_1.theme.muted}${title} (disabled)${ansi_1.ANSI.RESET}`;
+            }
+            // Compose line
+            let line = `${indentation}${icon}${title}`;
+            if (isSelected) {
+                line = `${theme_1.theme.main}${line}${ansi_1.ANSI.RESET}`;
+            }
+            output += linePrefix + line;
+            if (index < visible.length - 1)
+                output += '\n';
+        });
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        if (this.flatList.length === 0)
+            return;
+        // Navigation
+        if (this.isUp(char)) {
+            this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.cursor = (this.cursor + 1) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        const currentItem = this.flatList[this.cursor];
+        const node = currentItem.node;
+        const hasChildren = node.children && node.children.length > 0;
+        // Right: Expand or Go Down
+        if (this.isRight(char)) {
+            if (hasChildren) {
+                if (!this.expandedNodes.has(node)) {
+                    this.expandedNodes.add(node);
+                    this.recalculateFlatList();
+                }
+                else {
+                    // Go to first child (next item in flat list)
+                    if (this.cursor + 1 < this.flatList.length) {
+                        this.cursor++;
+                    }
+                }
+                this.render(false);
+                return;
+            }
+        }
+        // Left: Collapse or Go Up (Parent)
+        if (this.isLeft(char)) {
+            if (hasChildren && this.expandedNodes.has(node)) {
+                this.expandedNodes.delete(node);
+                this.recalculateFlatList();
+                this.render(false);
+                return;
+            }
+            else {
+                // Go to parent
+                if (currentItem.parent) {
+                    const parentIndex = this.flatList.findIndex(x => x.node === currentItem.parent);
+                    if (parentIndex !== -1) {
+                        this.cursor = parentIndex;
+                        this.render(false);
+                        return;
+                    }
+                }
+            }
+        }
+        // Toggle (Space)
+        if (char === ' ') {
+            if (hasChildren) {
+                if (this.expandedNodes.has(node)) {
+                    this.expandedNodes.delete(node);
+                }
+                else {
+                    this.expandedNodes.add(node);
+                }
+                this.recalculateFlatList();
+                this.render(false);
+            }
+            return;
+        }
+        // Submit (Enter)
+        if (char === '\r' || char === '\n') {
+            if (!node.disabled) {
+                this.submit(node.value);
+            }
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.cursor = (this.cursor + 1) % this.flatList.length;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.TreePrompt = TreePrompt;

package/dist/types.d.ts

@@ -100,6 +100,11 @@ export interface AutocompleteOptions<V> extends BaseOptions {
 export interface SortOptions extends BaseOptions {
     items: string[];
 }
+export interface EditorOptions extends BaseOptions {
+    initial?: string;
+    extension?: string;
+    waitUserInput?: boolean;
+}
 export interface TableRow<V> {
     value: V;
     row: string[];
@@ -109,3 +114,19 @@ export interface TableOptions<V> extends BaseOptions {
     data: TableRow<V>[];
     rows?: number;
 }
+export interface TreeNode<V> {
+    title: string;
+    value: V;
+    children?: TreeNode<V>[];
+    expanded?: boolean;
+    disabled?: boolean;
+}
+export interface TreeOptions<V> extends BaseOptions {
+    data: TreeNode<V>[];
+    initial?: V;
+    indent?: number;
+}
+export interface KeypressOptions extends BaseOptions {
+    keys?: string[];
+    showInvisible?: boolean;
+}

package/dist/utils.js

@@ -131,7 +131,11 @@ function stringWidth(str) {
             continue;
         }
         if (inAnsi) {
-            if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
+            if (str[i] === '[') {
+                // Continue, this is the start of CSI
+                continue;
+            }
+            if ((str[i] >= '@' && str[i] <= '~')) {
                 inAnsi = false;
             }
             continue;

package/example.ts

@@ -21,14 +21,14 @@ async function runComprehensiveDemo() {
                 return true;
             }
         });
-        console.log(`\n✅ Text Result: Project name set to '${projectName}'`);
+        console.log(`\n Text Result: Project name set to '${projectName}'`);
 
         // --- 2. Password Prompt (Hidden input) ---
         const apiKey = await MepCLI.password({
             message: "Enter the project's external API key:",
             placeholder: "Input will be hidden..."
         });
-        console.log(`\n✅ Password Result: API key entered (length: ${apiKey.length})`);
+        console.log(`\n Password Result: API key entered (length: ${apiKey.length})`);
 
         // --- 3. Select Prompt (Single choice, supports filtering/searching by typing) ---
         const theme = await MepCLI.select({
@@ -42,7 +42,7 @@ async function runComprehensiveDemo() {
                 { title: "Monokai Pro", value: "monokai" },
             ]
         });
-        console.log(`\n✅ Select Result: Chosen theme is: ${theme}`);
+        console.log(`\n Select Result: Chosen theme is: ${theme}`);
 
         // --- 4. Checkbox Prompt (Multi-choice with Min/Max limits) ---
         const buildTools = await MepCLI.checkbox({
@@ -56,7 +56,7 @@ async function runComprehensiveDemo() {
                 { title: "esbuild", value: "esbuild" }
             ]
         });
-        console.log(`\n✅ Checkbox Result: Selected build tools: [${buildTools.join(', ')}]`);
+        console.log(`\n Checkbox Result: Selected build tools: [${buildTools.join(', ')}]`);
 
         // --- 5. Number Prompt (Numeric input, supports Min/Max and Up/Down arrow for Step) ---
         const port = await MepCLI.number({
@@ -66,7 +66,7 @@ async function runComprehensiveDemo() {
             max: 65535,
             step: 100 // Increments/decrements by 100 with arrows
         });
-        console.log(`\n✅ Number Result: Server port: ${port}`);
+        console.log(`\n Number Result: Server port: ${port}`);
         
         // --- 6. Toggle Prompt (Boolean input, supports custom labels) ---
         const isSecure = await MepCLI.toggle({
@@ -75,7 +75,7 @@ async function runComprehensiveDemo() {
             activeText: "SECURE", // Custom 'on' label
             inactiveText: "INSECURE" // Custom 'off' label
         });
-        console.log(`\n✅ Toggle Result: HTTPS enabled: ${isSecure}`);
+        console.log(`\n Toggle Result: HTTPS enabled: ${isSecure}`);
 
         // --- 7. List / Tags Input (New) ---
         const keywords = await MepCLI.list({
@@ -83,7 +83,7 @@ async function runComprehensiveDemo() {
             initial: ["cli", "mep"],
             validate: (tags) => tags.length > 0 || "Please add at least one keyword."
         });
-        console.log(`\n✅ List Result: Keywords: [${keywords.join(', ')}]`);
+        console.log(`\n List Result: Keywords: [${keywords.join(', ')}]`);
 
         // --- 8. Slider / Scale (New) ---
         const brightness = await MepCLI.slider({
@@ -94,7 +94,7 @@ async function runComprehensiveDemo() {
             step: 5,
             unit: "%"
         });
-        console.log(`\n✅ Slider Result: Brightness: ${brightness}%`);
+        console.log(`\n Slider Result: Brightness: ${brightness}%`);
 
         // --- 9. Rating Prompt (New) ---
         const userRating = await MepCLI.rating({
@@ -103,7 +103,7 @@ async function runComprehensiveDemo() {
             max: 5,
             initial: 5
         });
-        console.log(`\n✅ Rating Result: You rated it: ${userRating}/5`);
+        console.log(`\n Rating Result: You rated it: ${userRating}/5`);
 
         // --- 10. Date / Time Picker (New) ---
         // We capture 'now' once to ensure initial >= min
@@ -113,14 +113,14 @@ async function runComprehensiveDemo() {
             initial: now,
             min: now // Cannot be in the past
         });
-        console.log(`\n✅ Date Result: Release set for: ${releaseDate.toLocaleString()}`);
+        console.log(`\n Date Result: Release set for: ${releaseDate.toLocaleString()}`);
 
         // --- 11. File Path Selector (New) ---
         const configPath = await MepCLI.file({
             message: "Select configuration file (Tab to autocomplete):",
             basePath: process.cwd()
         });
-        console.log(`\n✅ File Result: Path: ${configPath}`);
+        console.log(`\n File Result: Path: ${configPath}`);
 
         // --- 12. Multi-Select Autocomplete (New) ---
         const linters = await MepCLI.multiSelect({
@@ -135,7 +135,7 @@ async function runComprehensiveDemo() {
             ],
             min: 1
         });
-        console.log(`\n✅ MultiSelect Result: Linters: [${linters.join(', ')}]`);
+        console.log(`\n MultiSelect Result: Linters: [${linters.join(', ')}]`);
 
         // --- 13. Autocomplete Prompt (New) ---
         const city = await MepCLI.autocomplete({
@@ -155,14 +155,14 @@ async function runComprehensiveDemo() {
                 return cities.filter(c => c.title.toLowerCase().includes(query.toLowerCase()));
             }
         });
-        console.log(`\n✅ Autocomplete Result: City code: ${city}`);
+        console.log(`\n Autocomplete Result: City code: ${city}`);
 
         // --- 14. Sort Prompt (New) ---
         const priorities = await MepCLI.sort({
             message: "Rank your top priorities (Space to grab/drop, Arrows to move):",
             items: ["Performance", "Security", "Features", "Usability", "Cost"]
         });
-        console.log(`\n✅ Sort Result: Priorities: [${priorities.join(', ')}]`);
+        console.log(`\n Sort Result: Priorities: [${priorities.join(', ')}]`);
 
         // --- 15. Table Prompt (New) ---
         const userId = await MepCLI.table({
@@ -175,21 +175,72 @@ async function runComprehensiveDemo() {
                 { value: 4, row: ["004", "David", "Manager", "Active"] },
             ]
         });
-        console.log(`\n✅ Table Result: Selected User ID: ${userId}`);
+        console.log(`\n Table Result: Selected User ID: ${userId}`);
 
         // --- 16. Confirm Prompt (Simple Yes/No) ---
         const proceed = await MepCLI.confirm({
             message: "Ready to deploy the project now?",
             initial: true
         });
-        console.log(`\n✅ Confirm Result: Deployment decision: ${proceed ? 'Proceed' : 'Cancel'}`);
-
-        // --- 17. Spin Utility (Loading/Async Task Indicator) ---
+        console.log(`\n Confirm Result: Deployment decision: ${proceed ? 'Proceed' : 'Cancel'}`);
+
+        // --- 17. Editor Prompt (New) ---
+        const bio = await MepCLI.editor({
+            message: "Write your biography (opens default editor):",
+            initial: "Hi, I am a developer...",
+            extension: ".md",
+            waitUserInput: true
+        });
+        console.log(`\n Editor Result: Biography length: ${bio.length} chars`);
+
+        // --- 18. Keypress Prompt (New) ---
+        console.log("\n--- Press any key to continue to the Tree Prompt Demo... ---");
+        const key = await MepCLI.keypress({
+            message: "Press any key to proceed (or 'q' to quit):",
+            keys: ['q', 'enter', 'space', 'escape'] // Optional whitelist, or leave undefined for any
+        });
+        console.log(`\n Keypress Result: You pressed '${key}'`);
+        if (key === 'q') return;
+
+        // --- 19. Tree Prompt (New) ---
+        const selectedFile = await MepCLI.tree({
+             message: "Select a file from the project structure (Space to toggle, Enter to select):",
+             data: [
+                 {
+                     title: "src",
+                     value: "src",
+                     children: [
+                         { title: "index.ts", value: "src/index.ts" },
+                         { title: "utils.ts", value: "src/utils.ts" },
+                         { 
+                             title: "prompts", 
+                             value: "src/prompts", 
+                             expanded: true,
+                             children: [
+                                 { title: "text.ts", value: "src/prompts/text.ts" },
+                                 { title: "select.ts", value: "src/prompts/select.ts" }
+                             ]
+                         }
+                     ]
+                 },
+                 {
+                     title: "package.json",
+                     value: "package.json"
+                 },
+                 {
+                     title: "README.md",
+                     value: "README.md"
+                 }
+             ]
+        });
+        console.log(`\n Tree Result: Selected path: ${selectedFile}`);
+
+        // --- 20. Spin Utility (Loading/Async Task Indicator) ---
         const s = MepCLI.spinner("Finalizing configuration and deploying...").start();
         await new Promise(resolve => setTimeout(resolve, 1500)); // Simulates a 1.5 second async task
         s.success();
         
-        console.log("\n--- Deployment successful! All MepCLI features demonstrated! ---");
+        console.log("\n--- Deployment successful! All MepCLI features (including Editor) demonstrated! ---");
 
     } catch (e) {
         // Global handler for Ctrl+C closure

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mepcli",
-  "version": "0.5.0",
+  "version": "0.5.5",
   "description": "Zero-dependency, minimalist interactive CLI prompt for Node.js",
   "repository": {
     "type": "git",
@@ -17,7 +17,10 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "ts-node example.ts"
+    "test": "jest",
+    "demo": "ts-node example.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
   "keywords": [
     "cli",
@@ -30,8 +33,15 @@
   "author": "CodeTease",
   "license": "MIT",
   "devDependencies": {
+    "@eslint/js": "^9",
+    "@types/jest": "^30",
     "@types/node": "^22",
+    "eslint": "^9",
+    "globals": "^17",
+    "jest": "^30",
+    "ts-jest": "^29",
     "ts-node": "^10",
-    "typescript": "^5"
+    "typescript": "^5",
+    "typescript-eslint": "^8"
   }
 }