mepcli 0.1.0 → 0.2.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 CodeTease
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 CodeTease
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,51 +1,51 @@
-# Mep: Minimalist CLI Prompt
-
-**Mep** is a minimalist and zero-dependency library for creating interactive command-line prompts in Node.js. It focuses on simplicity, modern design, and robust input handling, including support for cursor movement and input validation.
-
-## Features
-
-- **Zero Dependency:** Keeps your project clean and fast.
-- **Full-Featured Prompts:** Includes `text`, `password`, `select`, ch`eckbox, and `confirm`.
-- **Responsive Input:** Supports cursor movement (Left/Right) and character insertion/deletion in `text` and `password` prompts.
-- **Validation:** Built-in support for input validation with custom error messages.
-- **Elegant Look:** Uses ANSI colors for a clean, modern CLI experience.
-
-## Installation
-
-```bash
-npm install mepcli
-# or
-yarn add mepcli
-```
-
-## Usage Example
-
-Mep provides a static class facade, `MepCLI`, for all interactions.
-```javascript
-import { MepCLI } from 'mepcli';
-
-async function setup() {
-    // Text input with validation and cursor support
-    const projectName = await MepCLI.text({
-        message: "Enter the project name:",
-        validate: (v) => v.length > 5 || "Must be longer than 5 chars",
-    });
-
-    // Select menu
-    const choice = await MepCLI.select({
-        message: "Choose an option:",
-        choices: [
-            { title: "Option A", value: 1 },
-            { title: "Option B", value: 2 }
-        ]
-    });
-
-    console.log(`\nProject: ${projectName}, Selected: ${choice}`);
-}
-
-setup();
-```
-
-## License
-
+# Mep: Minimalist CLI Prompt
+
+**Mep** is a minimalist and zero-dependency library for creating interactive command-line prompts in Node.js. It focuses on simplicity, modern design, and robust input handling, including support for cursor movement and input validation.
+
+## Features
+
+- **Zero Dependency:** Keeps your project clean and fast.
+- **Full-Featured Prompts:** Includes `text`, `password`, `select`, ch`eckbox, and `confirm`.
+- **Responsive Input:** Supports cursor movement (Left/Right) and character insertion/deletion in `text` and `password` prompts.
+- **Validation:** Built-in support for input validation with custom error messages.
+- **Elegant Look:** Uses ANSI colors for a clean, modern CLI experience.
+
+## Installation
+
+```bash
+npm install mepcli
+# or
+yarn add mepcli
+```
+
+## Usage Example
+
+Mep provides a static class facade, `MepCLI`, for all interactions.
+```javascript
+import { MepCLI } from 'mepcli';
+
+async function setup() {
+    // Text input with validation and cursor support
+    const projectName = await MepCLI.text({
+        message: "Enter the project name:",
+        validate: (v) => v.length > 5 || "Must be longer than 5 chars",
+    });
+
+    // Select menu
+    const choice = await MepCLI.select({
+        message: "Choose an option:",
+        choices: [
+            { title: "Option A", value: 1 },
+            { title: "Option B", value: 2 }
+        ]
+    });
+
+    console.log(`\nProject: ${projectName}, Selected: ${choice}`);
+}
+
+setup();
+```
+
+## License
+
 This project is under the **MIT License**.

package/dist/core.d.ts

@@ -1,11 +1,18 @@
-import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions } from './types';
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions } from './types';
 /**
  * Public Facade for MepCLI
  */
 export declare class MepCLI {
+    static theme: ThemeConfig;
+    /**
+     * Shows a spinner while a promise is pending.
+     */
+    static spin<T>(message: string, taskPromise: Promise<T>): Promise<T>;
     static text(options: TextOptions): Promise<string>;
     static select(options: SelectOptions): Promise<any>;
     static checkbox(options: CheckboxOptions): Promise<any[]>;
     static confirm(options: ConfirmOptions): Promise<boolean>;
     static password(options: TextOptions): Promise<string>;
+    static number(options: NumberOptions): Promise<number>;
+    static toggle(options: ToggleOptions): Promise<boolean>;
 }

package/dist/core.js

@@ -77,6 +77,8 @@ class TextPrompt extends Prompt {
         super(options);
         this.errorMsg = '';
         this.cursor = 0;
+        this.hasTyped = false;
+        this.renderLines = 1;
         this.value = options.initial || '';
         this.cursor = this.value.length;
     }
@@ -84,62 +86,147 @@ class TextPrompt extends Prompt {
         // TextPrompt needs the cursor visible!
         this.print(ansi_1.ANSI.SHOW_CURSOR);
         if (!firstRender) {
-            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
-            if (this.errorMsg) {
-                this.print(ansi_1.ANSI.UP + ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            // Clear previous lines
+            // Note: renderLines now represents visual wrapped lines
+            for (let i = 0; i < this.renderLines; i++) {
+                this.print(ansi_1.ANSI.ERASE_LINE);
+                if (i < this.renderLines - 1)
+                    this.print(ansi_1.ANSI.UP);
             }
+            this.print(ansi_1.ANSI.CURSOR_LEFT);
         }
+        let output = '';
         // 1. Render the Prompt Message
-        this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
-        const icon = this.errorMsg ? `${ansi_1.ANSI.FG_RED}✖` : `${ansi_1.ANSI.FG_GREEN}?`;
-        this.print(`${icon} ${ansi_1.ANSI.BOLD}${this.options.message}${ansi_1.ANSI.RESET} `);
+        const icon = this.errorMsg ? `${MepCLI.theme.error}✖` : `${MepCLI.theme.success}?`;
+        const multilineHint = this.options.multiline ? ` ${MepCLI.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
+        output += `${icon} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${multilineHint} `;
         // 2. Render the Value or Placeholder
-        if (!this.value && this.options.placeholder && !this.errorMsg) {
-            this.print(`${ansi_1.ANSI.FG_GRAY}${this.options.placeholder}${ansi_1.ANSI.RESET}`);
-            // Move cursor back to start so typing overwrites placeholder visually
-            this.print(`\x1b[${this.options.placeholder.length}D`);
+        let displayValue = '';
+        if (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped) {
+            displayValue = `${MepCLI.theme.muted}${this.options.placeholder}${ansi_1.ANSI.RESET}`;
         }
         else {
-            const displayValue = this.options.isPassword ? '*'.repeat(this.value.length) : this.value;
-            this.print(`${ansi_1.ANSI.FG_CYAN}${displayValue}${ansi_1.ANSI.RESET}`);
+            displayValue = this.options.isPassword ? '*'.repeat(this.value.length) : this.value;
+            displayValue = `${MepCLI.theme.main}${displayValue}${ansi_1.ANSI.RESET}`;
         }
+        output += displayValue;
         // 3. Handle Error Message
         if (this.errorMsg) {
-            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.FG_RED}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
-            this.print(ansi_1.ANSI.UP); // Go back to input line
-            // Re-calculate position to end of input
-            const promptLen = this.options.message.length + 3; // Icon + 2 spaces
-            const valLen = this.value.length;
-            // Move to absolute start of line, then move right to end of string
-            this.print(`\x1b[1000D\x1b[${promptLen + valLen}C`);
+            output += `\n${MepCLI.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
         }
-        // 4. Position Cursor Logic
-        // At this point, the physical cursor is at the END of the value string.
-        // We need to move it LEFT by (length - cursor_index)
-        const diff = this.value.length - this.cursor;
-        if (diff > 0) {
-            this.print(`\x1b[${diff}D`);
+        this.print(output);
+        // 4. Calculate Visual Metrics for Wrapping
+        const cols = process.stdout.columns || 80;
+        const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
+        // Prompt String (visual part before value)
+        const promptStr = `${icon} ${MepCLI.theme.title}${this.options.message} ${multilineHint} `;
+        const promptVisualLen = stripAnsi(promptStr).length;
+        // Value String (visual part)
+        const rawValue = (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped)
+            ? this.options.placeholder || ''
+            : (this.options.isPassword ? '*'.repeat(this.value.length) : this.value);
+        // Error String (visual part)
+        const errorVisualLines = this.errorMsg ? Math.ceil((3 + this.errorMsg.length) / cols) : 0;
+        // Calculate Total Lines and Cursor Position
+        // We simulate printing the prompt + value + error
+        let currentVisualLine = 0;
+        let currentCol = 0;
+        // State tracking for cursor
+        let cursorRow = 0;
+        let cursorCol = 0;
+        // Add Prompt
+        currentCol += promptVisualLen;
+        while (currentCol >= cols) {
+            currentVisualLine++;
+            currentCol -= cols;
+        }
+        // Add Value (Character by character to handle wrapping and cursor tracking accurately)
+        // Note: This doesn't handle multi-width chars perfectly, but handles wrapping better than before
+        const valueLen = rawValue.length;
+        // If placeholder, we treat it as value for render height, but cursor is at 0
+        const isPlaceholder = (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped);
+        for (let i = 0; i < valueLen; i++) {
+            // Check if we are at cursor position
+            if (!isPlaceholder && i === this.cursor) {
+                cursorRow = currentVisualLine;
+                cursorCol = currentCol;
+            }
+            const char = rawValue[i];
+            if (char === '\n') {
+                currentVisualLine++;
+                currentCol = 0;
+            }
+            else {
+                currentCol++;
+                if (currentCol >= cols) {
+                    currentVisualLine++;
+                    currentCol = 0;
+                }
+            }
+        }
+        // If cursor is at the very end
+        if (!isPlaceholder && this.cursor === valueLen) {
+            cursorRow = currentVisualLine;
+            cursorCol = currentCol;
+        }
+        // If placeholder, cursor is at start of value
+        if (isPlaceholder) {
+            // Re-calc cursor position as if it's at index 0 of value
+            // Which is effectively where prompt ends
+            // We already updated currentCol/Line for prompt above, but loop continued for placeholder
+            // So we need to recalculate or store prompt end state
+            // Let's just use prompt end state:
+            let pCol = promptVisualLen;
+            let pRow = 0;
+            while (pCol >= cols) {
+                pRow++;
+                pCol -= cols;
+            }
+            cursorRow = pRow;
+            cursorCol = pCol;
+        }
+        // Final height
+        // If we are at col 0 of a new line (e.g. just wrapped or \n), we count that line
+        // currentVisualLine is 0-indexed index of the line we are on.
+        // Total lines = currentVisualLine + 1 + errorLines
+        // Special case: if input ends with \n, we are on a new empty line
+        const totalValueRows = currentVisualLine + 1;
+        this.renderLines = totalValueRows + errorVisualLines;
+        // 5. Position Cursor Logic
+        // We are currently at the end of output.
+        // End row relative to start: this.renderLines - 1
+        const endRow = this.renderLines - 1;
+        // Move up to cursor row
+        const linesUp = endRow - cursorRow;
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+        }
+        // Move to cursor col
+        this.print(ansi_1.ANSI.CURSOR_LEFT); // Go to col 0
+        if (cursorCol > 0) {
+            this.print(`\x1b[${cursorCol}C`);
         }
     }
     handleInput(char) {
         // Enter
         if (char === '\r' || char === '\n') {
-            if (this.options.validate) {
-                const validationResult = this.options.validate(this.value);
-                if (typeof validationResult === 'string' && validationResult.length > 0) {
-                    this.errorMsg = validationResult;
-                    this.render(false);
-                    return;
-                }
-            }
-            if (this.errorMsg) {
-                this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
+            if (this.options.multiline) {
+                this.value = this.value.slice(0, this.cursor) + '\n' + this.value.slice(this.cursor);
+                this.cursor++;
+                this.render(false);
+                return;
             }
-            this.submit(this.value);
+            this.validateAndSubmit();
+            return;
+        }
+        // Ctrl+D (EOF) or Ctrl+S for Submit in Multiline
+        if (this.options.multiline && (char === '\u0004' || char === '\u0013')) {
+            this.validateAndSubmit();
             return;
         }
         // Backspace
         if (char === '\u0008' || char === '\x7f') {
+            this.hasTyped = true;
             if (this.cursor > 0) {
                 this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor);
                 this.cursor--;
@@ -166,6 +253,7 @@ class TextPrompt extends Prompt {
         }
         // Delete key
         if (char === '\u001b[3~') {
+            this.hasTyped = true;
             if (this.cursor < this.value.length) {
                 this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
                 this.errorMsg = '';
@@ -173,54 +261,218 @@ class TextPrompt extends Prompt {
             }
             return;
         }
-        // Regular Typing
-        if (char.length === 1 && !/^[\x00-\x1F]/.test(char)) {
+        // Regular Typing & Paste
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.hasTyped = true;
             this.value = this.value.slice(0, this.cursor) + char + this.value.slice(this.cursor);
-            this.cursor++;
+            this.cursor += char.length;
             this.errorMsg = '';
             this.render(false);
         }
     }
+    validateAndSubmit() {
+        if (this.options.validate) {
+            const result = this.options.validate(this.value);
+            // Handle Promise validation
+            if (result instanceof Promise) {
+                // Show loading state
+                this.print(`\n${ansi_1.ANSI.ERASE_LINE}${MepCLI.theme.main}Validating...${ansi_1.ANSI.RESET}`);
+                this.print(ansi_1.ANSI.UP);
+                result.then(valid => {
+                    // Clear loading message
+                    this.print(`\n${ansi_1.ANSI.ERASE_LINE}`);
+                    this.print(ansi_1.ANSI.UP);
+                    if (typeof valid === 'string' && valid.length > 0) {
+                        this.errorMsg = valid;
+                        this.render(false);
+                    }
+                    else if (valid === false) {
+                        this.errorMsg = 'Invalid input';
+                        this.render(false);
+                    }
+                    else {
+                        if (this.errorMsg) {
+                            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
+                        }
+                        this.submit(this.value);
+                    }
+                }).catch(err => {
+                    this.print(`\n${ansi_1.ANSI.ERASE_LINE}`);
+                    this.print(ansi_1.ANSI.UP);
+                    this.errorMsg = err.message || 'Validation failed';
+                    this.render(false);
+                });
+                return;
+            }
+            // Handle Sync validation
+            if (typeof result === 'string' && result.length > 0) {
+                this.errorMsg = result;
+                this.render(false);
+                return;
+            }
+            if (result === false) {
+                this.errorMsg = 'Invalid input';
+                this.render(false);
+                return;
+            }
+        }
+        if (this.errorMsg) {
+            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
+        }
+        this.submit(this.value);
+    }
 }
 // --- Implementation: Select Prompt ---
 class SelectPrompt extends Prompt {
     constructor(options) {
         super(options);
         this.selectedIndex = 0;
+        this.searchBuffer = '';
+        this.scrollTop = 0;
+        this.pageSize = 7;
+        // Custom render to handle variable height clearing
+        this.lastRenderHeight = 0;
+        // Find first non-separator index
+        this.selectedIndex = this.findNextSelectableIndex(-1, 1);
     }
-    render(firstRender) {
-        // Ensure cursor is HIDDEN for menus
-        this.print(ansi_1.ANSI.HIDE_CURSOR);
-        if (!firstRender) {
-            this.print(`\x1b[${this.options.choices.length + 1}A`);
+    isSeparator(item) {
+        return item && item.separator === true;
+    }
+    findNextSelectableIndex(currentIndex, direction) {
+        let nextIndex = currentIndex + direction;
+        const choices = this.getFilteredChoices();
+        // Loop around logic
+        if (nextIndex < 0)
+            nextIndex = choices.length - 1;
+        if (nextIndex >= choices.length)
+            nextIndex = 0;
+        if (choices.length === 0)
+            return 0;
+        // Safety check to prevent infinite loop if all are separators (shouldn't happen in practice)
+        let count = 0;
+        while (this.isSeparator(choices[nextIndex]) && count < choices.length) {
+            nextIndex += direction;
+            if (nextIndex < 0)
+                nextIndex = choices.length - 1;
+            if (nextIndex >= choices.length)
+                nextIndex = 0;
+            count++;
         }
-        this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-        this.print(`${ansi_1.ANSI.FG_GREEN}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${this.options.message}${ansi_1.ANSI.RESET}\n`);
-        this.options.choices.forEach((choice, index) => {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-            if (index === this.selectedIndex) {
-                this.print(`${ansi_1.ANSI.FG_CYAN}❯ ${choice.title}${ansi_1.ANSI.RESET}\n`);
-            }
-            else {
-                this.print(`  ${choice.title}\n`);
-            }
+        return nextIndex;
+    }
+    getFilteredChoices() {
+        if (!this.searchBuffer)
+            return this.options.choices;
+        return this.options.choices.filter(c => {
+            if (this.isSeparator(c))
+                return false; // Hide separators when searching
+            return c.title.toLowerCase().includes(this.searchBuffer.toLowerCase());
         });
     }
+    renderWrapper(firstRender) {
+        if (!firstRender && this.lastRenderHeight > 0) {
+            this.print(`\x1b[${this.lastRenderHeight}A`);
+        }
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        // Handle Filtering Edge Case: if list shrinks, scrollTop might be too high
+        if (this.scrollTop > choices.length - 1) {
+            this.scrollTop = Math.max(0, choices.length - this.pageSize);
+        }
+        // Header
+        const searchStr = this.searchBuffer ? ` ${MepCLI.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}  ${MepCLI.theme.muted}No results found${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleChoices.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                output += `${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`;
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || '────────'}${ansi_1.ANSI.RESET}\n`;
+                }
+                else {
+                    if (actualIndex === this.selectedIndex) {
+                        output += `${MepCLI.theme.main}❯ ${choice.title}${ansi_1.ANSI.RESET}\n`;
+                    }
+                    else {
+                        output += `  ${choice.title}\n`;
+                    }
+                }
+            });
+        }
+        this.print(output);
+        // Clear remaining lines if list shrunk
+        const visibleCount = Math.min(choices.length, this.pageSize);
+        const currentHeight = visibleCount + 1 + (choices.length === 0 ? 1 : 0);
+        const linesToClear = this.lastRenderHeight - currentHeight;
+        if (linesToClear > 0) {
+            for (let i = 0; i < linesToClear; i++) {
+                this.print(`${ansi_1.ANSI.ERASE_LINE}\n`);
+            }
+            this.print(`\x1b[${linesToClear}A`); // Move back up
+        }
+        this.lastRenderHeight = currentHeight;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        this.renderWrapper(firstRender);
+    }
     handleInput(char) {
+        const choices = this.getFilteredChoices();
         if (char === '\r' || char === '\n') {
+            if (choices.length === 0) {
+                this.searchBuffer = '';
+                this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+                this.render(false);
+                return;
+            }
+            if (this.isSeparator(choices[this.selectedIndex]))
+                return;
             this.cleanup();
-            this.print(`\x1b[${this.options.choices.length - this.selectedIndex}B`);
             this.print(ansi_1.ANSI.SHOW_CURSOR);
             if (this._resolve)
-                this._resolve(this.options.choices[this.selectedIndex].value);
+                this._resolve(choices[this.selectedIndex].value);
             return;
         }
         if (char === '\u001b[A') { // Up
-            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
-            this.render(false);
+            if (choices.length > 0) {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, -1);
+                this.render(false);
+            }
+            return;
         }
         if (char === '\u001b[B') { // Down
-            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            if (choices.length > 0) {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, 1);
+                this.render(false);
+            }
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.selectedIndex = 0; // Reset selection
+                this.selectedIndex = this.findNextSelectableIndex(-1, 1);
+                this.render(false);
+            }
+            return;
+        }
+        // Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char)) {
+            this.searchBuffer += char;
+            this.selectedIndex = 0; // Reset selection
+            this.selectedIndex = this.findNextSelectableIndex(-1, 1);
             this.render(false);
         }
     }
@@ -241,22 +493,22 @@ class CheckboxPrompt extends Prompt {
             this.print(`\x1b[${this.options.choices.length + 1 + extraLines}A`);
         }
         this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-        const icon = this.errorMsg ? `${ansi_1.ANSI.FG_RED}✖` : `${ansi_1.ANSI.FG_GREEN}?`;
-        this.print(`${icon} ${ansi_1.ANSI.BOLD}${this.options.message}${ansi_1.ANSI.RESET} ${ansi_1.ANSI.FG_GRAY}(Press <space> to select, <enter> to confirm)${ansi_1.ANSI.RESET}\n`);
+        const icon = this.errorMsg ? `${MepCLI.theme.error}✖` : `${MepCLI.theme.success}?`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${MepCLI.theme.muted}(Press <space> to select, <enter> to confirm)${ansi_1.ANSI.RESET}\n`);
         this.options.choices.forEach((choice, index) => {
             this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-            const cursor = index === this.selectedIndex ? `${ansi_1.ANSI.FG_CYAN}❯${ansi_1.ANSI.RESET}` : ' ';
+            const cursor = index === this.selectedIndex ? `${MepCLI.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
             const isChecked = this.checkedState[index];
             const checkbox = isChecked
-                ? `${ansi_1.ANSI.FG_GREEN}◉${ansi_1.ANSI.RESET}`
-                : `${ansi_1.ANSI.FG_GRAY}◯${ansi_1.ANSI.RESET}`;
+                ? `${MepCLI.theme.success}◉${ansi_1.ANSI.RESET}`
+                : `${MepCLI.theme.muted}◯${ansi_1.ANSI.RESET}`;
             const title = index === this.selectedIndex
-                ? `${ansi_1.ANSI.FG_CYAN}${choice.title}${ansi_1.ANSI.RESET}`
+                ? `${MepCLI.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
                 : choice.title;
             this.print(`${cursor} ${checkbox} ${title}\n`);
         });
         if (this.errorMsg) {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.FG_RED}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+            this.print(`${ansi_1.ANSI.ERASE_LINE}${MepCLI.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
         }
         else if (!firstRender) {
             this.print(`${ansi_1.ANSI.ERASE_LINE}`);
@@ -323,9 +575,9 @@ class ConfirmPrompt extends Prompt {
             this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
         }
         const hint = this.value ? `${ansi_1.ANSI.BOLD}Yes${ansi_1.ANSI.RESET}/no` : `yes/${ansi_1.ANSI.BOLD}No${ansi_1.ANSI.RESET}`;
-        this.print(`${ansi_1.ANSI.FG_GREEN}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${this.options.message}${ansi_1.ANSI.RESET} ${ansi_1.ANSI.FG_GRAY}(${hint})${ansi_1.ANSI.RESET} `);
+        this.print(`${MepCLI.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${MepCLI.theme.muted}(${hint})${ansi_1.ANSI.RESET} `);
         const text = this.value ? 'Yes' : 'No';
-        this.print(`${ansi_1.ANSI.FG_CYAN}${text}${ansi_1.ANSI.RESET}\x1b[${text.length}D`);
+        this.print(`${MepCLI.theme.main}${text}${ansi_1.ANSI.RESET}\x1b[${text.length}D`);
     }
     handleInput(char) {
         const c = char.toLowerCase();
@@ -343,10 +595,203 @@ class ConfirmPrompt extends Prompt {
         }
     }
 }
+// --- Implementation: Toggle Prompt ---
+class TogglePrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? false;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
+        }
+        const activeText = this.options.activeText || 'ON';
+        const inactiveText = this.options.inactiveText || 'OFF';
+        let toggleDisplay = '';
+        if (this.value) {
+            toggleDisplay = `${MepCLI.theme.main}[${ansi_1.ANSI.BOLD}${activeText}${ansi_1.ANSI.RESET}${MepCLI.theme.main}]${ansi_1.ANSI.RESET}  ${MepCLI.theme.muted}${inactiveText}${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            toggleDisplay = `${MepCLI.theme.muted}${activeText}${ansi_1.ANSI.RESET}  ${MepCLI.theme.main}[${ansi_1.ANSI.BOLD}${inactiveText}${ansi_1.ANSI.RESET}${MepCLI.theme.main}]${ansi_1.ANSI.RESET}`;
+        }
+        this.print(`${MepCLI.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${toggleDisplay}`);
+        this.print(`\x1b[${toggleDisplay.length}D`); // Move back is not really needed as we hide cursor, but kept for consistency
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (char === '\u001b[D' || char === '\u001b[C' || char === 'h' || char === 'l') { // Left/Right
+            this.value = !this.value;
+            this.render(false);
+        }
+        if (char === ' ') {
+            this.value = !this.value;
+            this.render(false);
+        }
+    }
+}
+// --- Implementation: Number Prompt ---
+class NumberPrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.errorMsg = '';
+        this.value = options.initial ?? 0;
+        this.stringValue = this.value.toString();
+        this.cursor = this.stringValue.length;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (!firstRender) {
+            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            if (this.errorMsg) {
+                this.print(ansi_1.ANSI.UP + ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            }
+        }
+        // 1. Render the Prompt Message
+        this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+        const icon = this.errorMsg ? `${MepCLI.theme.error}✖` : `${MepCLI.theme.success}?`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${MepCLI.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `);
+        // 2. Render the Value
+        this.print(`${MepCLI.theme.main}${this.stringValue}${ansi_1.ANSI.RESET}`);
+        // 3. Handle Error Message
+        if (this.errorMsg) {
+            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${MepCLI.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+            this.print(ansi_1.ANSI.UP);
+            const promptLen = this.options.message.length + 3;
+            const valLen = this.stringValue.length;
+            this.print(`\x1b[1000D\x1b[${promptLen + valLen}C`);
+        }
+        // 4. Position Cursor
+        const diff = this.stringValue.length - this.cursor;
+        if (diff > 0) {
+            this.print(`\x1b[${diff}D`);
+        }
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            const num = parseFloat(this.stringValue);
+            if (isNaN(num)) {
+                this.errorMsg = 'Please enter a valid number.';
+                this.render(false);
+                return;
+            }
+            if (this.options.min !== undefined && num < this.options.min) {
+                this.errorMsg = `Minimum value is ${this.options.min}`;
+                this.render(false);
+                return;
+            }
+            if (this.options.max !== undefined && num > this.options.max) {
+                this.errorMsg = `Maximum value is ${this.options.max}`;
+                this.render(false);
+                return;
+            }
+            if (this.errorMsg) {
+                this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
+            }
+            this.submit(num);
+            return;
+        }
+        // Up Arrow (Increment)
+        if (char === '\u001b[A') {
+            let num = parseFloat(this.stringValue) || 0;
+            num += (this.options.step ?? 1);
+            if (this.options.max !== undefined && num > this.options.max)
+                num = this.options.max;
+            this.stringValue = num.toString();
+            this.cursor = this.stringValue.length;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Down Arrow (Decrement)
+        if (char === '\u001b[B') {
+            let num = parseFloat(this.stringValue) || 0;
+            num -= (this.options.step ?? 1);
+            if (this.options.min !== undefined && num < this.options.min)
+                num = this.options.min;
+            this.stringValue = num.toString();
+            this.cursor = this.stringValue.length;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.cursor > 0) {
+                this.stringValue = this.stringValue.slice(0, this.cursor - 1) + this.stringValue.slice(this.cursor);
+                this.cursor--;
+                this.errorMsg = '';
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Left
+        if (char === '\u001b[D') {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Right
+        if (char === '\u001b[C') {
+            if (this.cursor < this.stringValue.length) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+        // Numeric Input (and . and -)
+        // Simple paste support for numbers is also good
+        if (/^[0-9.\-]+$/.test(char)) {
+            // Basic validation for pasted content
+            if (char.includes('-') && (this.cursor !== 0 || this.stringValue.includes('-') || char.lastIndexOf('-') > 0)) {
+                // If complex paste fails simple checks, ignore or let user correct
+                // For now, strict check on single char logic is preserved if we want, 
+                // but let's allow pasting valid number strings
+            }
+            // Allow if it looks like a number part
+            this.stringValue = this.stringValue.slice(0, this.cursor) + char + this.stringValue.slice(this.cursor);
+            this.cursor += char.length;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
 /**
  * Public Facade for MepCLI
  */
 class MepCLI {
+    /**
+     * Shows a spinner while a promise is pending.
+     */
+    static async spin(message, taskPromise) {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        process.stdout.write(ansi_1.ANSI.HIDE_CURSOR);
+        const interval = setInterval(() => {
+            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.main}${frames[i]}${ansi_1.ANSI.RESET} ${message}`);
+            i = (i + 1) % frames.length;
+        }, 80);
+        try {
+            const result = await taskPromise;
+            clearInterval(interval);
+            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.success}✔${ansi_1.ANSI.RESET} ${message}\n`);
+            process.stdout.write(ansi_1.ANSI.SHOW_CURSOR);
+            return result;
+        }
+        catch (error) {
+            clearInterval(interval);
+            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.error}✖${ansi_1.ANSI.RESET} ${message}\n`);
+            process.stdout.write(ansi_1.ANSI.SHOW_CURSOR);
+            throw error;
+        }
+    }
     static text(options) {
         return new TextPrompt(options).run();
     }
@@ -362,5 +807,18 @@ class MepCLI {
     static password(options) {
         return new TextPrompt({ ...options, isPassword: true }).run();
     }
+    static number(options) {
+        return new NumberPrompt(options).run();
+    }
+    static toggle(options) {
+        return new TogglePrompt(options).run();
+    }
 }
 exports.MepCLI = MepCLI;
+MepCLI.theme = {
+    main: ansi_1.ANSI.FG_CYAN,
+    success: ansi_1.ANSI.FG_GREEN,
+    error: ansi_1.ANSI.FG_RED,
+    muted: ansi_1.ANSI.FG_GRAY,
+    title: ansi_1.ANSI.RESET
+};

package/dist/types.d.ts

@@ -1,14 +1,26 @@
 /**
  * Type definitions for Mep CLI interactions.
  */
+export interface ThemeConfig {
+    main: string;
+    success: string;
+    error: string;
+    muted: string;
+    title: string;
+}
 export interface BaseOptions {
     message: string;
 }
 export interface TextOptions extends BaseOptions {
     placeholder?: string;
     initial?: string;
-    validate?: (value: string) => string | boolean;
+    validate?: (value: string) => string | boolean | Promise<string | boolean>;
     isPassword?: boolean;
+    multiline?: boolean;
+}
+export interface Separator {
+    separator: true;
+    text?: string;
 }
 export interface SelectChoice {
     title: string;
@@ -16,7 +28,7 @@ export interface SelectChoice {
     description?: string;
 }
 export interface SelectOptions extends BaseOptions {
-    choices: SelectChoice[];
+    choices: (SelectChoice | Separator)[];
 }
 export interface CheckboxChoice extends SelectChoice {
     selected?: boolean;
@@ -29,3 +41,15 @@ export interface CheckboxOptions extends BaseOptions {
 export interface ConfirmOptions extends BaseOptions {
     initial?: boolean;
 }
+export interface NumberOptions extends BaseOptions {
+    initial?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+}
+export interface ToggleOptions extends BaseOptions {
+    initial?: boolean;
+    activeText?: string;
+    inactiveText?: string;
+}

package/example.ts

@@ -1,83 +1,103 @@
-import { MepCLI } from './src'; // Or mepcli if installed via NPM
-
-/**
- * Runs a comprehensive set of tests for all MepCLI prompt types.
- */
-async function runAllTests() {
-    console.clear();
-    console.log("--- MepCLI Comprehensive Test Suite (Neutralized) ---\n");
-
-    try {
-        // --- 1. Text Prompt Test (with Validation) ---
-        const projectName = await MepCLI.text({
-            message: "Enter the name for your new project:",
-            placeholder: "e.g., minimalist-cli-app",
-            initial: "MepProject",
-            validate: (value) => {
-                if (value.length < 3) {
-                    return "Project name must be at least 3 characters long.";
-                }
-                if (value.includes('&')) {
-                    return "Project name cannot contain '&' symbol.";
-                }
-                return true;
-            }
-        });
-        console.log(`\n✅ Text Result: Project name set to '${projectName}'`);
-
-        // --- 2. Password Prompt Test ---
-        const apiKey = await MepCLI.password({
-            message: "Enter the project's external API key:",
-            placeholder: "Input will be hidden..."
-        });
-        // Note: Do not log the actual key in a real app.
-        console.log(`\n✅ Password Result: API key entered (length: ${apiKey.length})`);
-
-
-        // --- 3. Select Prompt Test (Single Choice) ---
-        const theme = await MepCLI.select({
-            message: "Choose your preferred editor color theme:",
-            choices: [
-                { title: "Dark Mode (Default)", value: "dark" },
-                { title: "Light Mode (Classic)", value: "light" },
-                { title: "High Contrast (Accessibility)", value: "contrast" },
-                { title: "Monokai Pro", value: "monokai" },
-            ]
-        });
-        console.log(`\n✅ Select Result: Chosen theme is: ${theme}`);
-
-
-        // --- 4. Checkbox Prompt Test (Multi-Choice with Min/Max) ---
-        const buildTools = await MepCLI.checkbox({
-            message: "Select your required bundlers/build tools (Min 1, Max 2):",
-            min: 1, 
-            max: 2, 
-            choices: [
-                { title: "Webpack", value: "webpack" },
-                { title: "Vite", value: "vite", selected: true },
-                { title: "Rollup", value: "rollup" },
-                { title: "esbuild", value: "esbuild" }
-            ]
-        });
-        console.log(`\n✅ Checkbox Result: Selected build tools: [${buildTools.join(', ')}]`);
-
-
-        // --- 5. Confirm Prompt Test ---
-        const proceed = await MepCLI.confirm({
-            message: "Do you want to continue with the installation setup?",
-            initial: true
-        });
-        console.log(`\n✅ Confirm Result: Setup decision: ${proceed ? 'Proceed' : 'Cancel'}`);
-
-        console.log("\n--- All MepCLI tests completed successfully! ---");
-
-    } catch (e) {
-        if (e instanceof Error && e.message === 'User force closed') {
-             console.log("\nOperation cancelled by user (Ctrl+C).");
-        } else {
-             console.error("\nAn error occurred during prompt execution:", e);
-        }
-    }
-}
-
-runAllTests();
+import { MepCLI } from './src'; // Or 'mepcli' if installed via NPM
+
+/**
+ * Runs a comprehensive demo showcasing all MepCLI prompt types and utilities.
+ * This demonstrates all core functionalities including Text, Password, Select,
+ * Checkbox, Number, Toggle, Confirm, and the Spin utility.
+ */
+async function runComprehensiveDemo() {
+    console.clear();
+    console.log("--- MepCLI Comprehensive Demo (All 7 Prompts + Spin Utility) ---\n");
+
+    try {
+        // --- 1. Text Prompt (Input with Validation and initial value) ---
+        const projectName = await MepCLI.text({
+            message: "Enter the name for your new project:",
+            placeholder: "e.g., minimalist-cli-app",
+            initial: "MepProject",
+            validate: (value) => {
+                if (value.length < 3) return "Project name must be at least 3 characters long.";
+                return true;
+            }
+        });
+        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})`);
+
+        // --- 3. Select Prompt (Single choice, supports filtering/searching by typing) ---
+        const theme = await MepCLI.select({
+            message: "Choose your preferred editor color theme:",
+            choices: [
+                { title: "Dark Mode (Default)", value: "dark" },
+                { title: "Light Mode (Classic)", value: "light" },
+                { title: "High Contrast (Accessibility)", value: "contrast" },
+                // Demonstrates a separator option
+                { separator: true, text: "--- Pro Themes ---" },
+                { title: "Monokai Pro", value: "monokai" },
+            ]
+        });
+        console.log(`\n✅ Select Result: Chosen theme is: ${theme}`);
+
+        // --- 4. Checkbox Prompt (Multi-choice with Min/Max limits) ---
+        const buildTools = await MepCLI.checkbox({
+            message: "Select your required bundlers/build tools (Min 1, Max 2):",
+            min: 1, 
+            max: 2, 
+            choices: [
+                { title: "Webpack", value: "webpack" },
+                { title: "Vite", value: "vite", selected: true }, // Default selected state
+                { title: "Rollup", value: "rollup" },
+                { title: "esbuild", value: "esbuild" }
+            ]
+        });
+        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({
+            message: "Which port should the server run on?",
+            initial: 3000,
+            min: 1024,
+            max: 65535,
+            step: 100 // Increments/decrements by 100 with arrows
+        });
+        console.log(`\n✅ Number Result: Server port: ${port}`);
+        
+        // --- 6. Toggle Prompt (Boolean input, supports custom labels) ---
+        const isSecure = await MepCLI.toggle({
+            message: "Enable HTTPS/SSL for production?",
+            initial: false,
+            activeText: "SECURE", // Custom 'on' label
+            inactiveText: "INSECURE" // Custom 'off' label
+        });
+        console.log(`\n✅ Toggle Result: HTTPS enabled: ${isSecure}`);
+
+        // --- 7. 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'}`);
+
+        // --- 8. Spin Utility (Loading/Async Task Indicator) ---
+        await MepCLI.spin(
+            "Finalizing configuration and deploying to Teaserverse...",
+            new Promise(resolve => setTimeout(resolve, 1500)) // Simulates a 1.5 second async task
+        );
+        console.log("\n--- Deployment successful! All MepCLI features demonstrated! ---");
+
+    } catch (e) {
+        // Global handler for Ctrl+C closure
+        if (e instanceof Error && e.message === 'User force closed') {
+             console.log("\nOperation cancelled by user (Ctrl+C).");
+        } else {
+             console.error("\nAn error occurred during prompt execution:", e);
+        }
+    }
+}
+
+runComprehensiveDemo();

package/package.json

@@ -1,37 +1,37 @@
-{
-  "name": "mepcli",
-  "version": "0.1.0",
-  "description": "Zero-dependency, minimalist interactive CLI prompt for Node.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/CodeTease/mep.git"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "example.ts"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "ts-node example.ts"
-  },
-  "keywords": [
-    "cli",
-    "prompt",
-    "inquirer",
-    "interactive",
-    "zero-dependency",
-    "codetease"
-  ],
-  "author": "CodeTease",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "ts-node": "^10.9.0",
-    "typescript": "^5.0.0"
-  }
-}
+{
+  "name": "mepcli",
+  "version": "0.2.1",
+  "description": "Zero-dependency, minimalist interactive CLI prompt for Node.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeTease/mep.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "example.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "ts-node example.ts"
+  },
+  "keywords": [
+    "cli",
+    "prompt",
+    "inquirer",
+    "interactive",
+    "zero-dependency",
+    "codetease"
+  ],
+  "author": "CodeTease",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.19.25",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.0.0"
+  }
+}