mepcli 0.1.0

package/LICENSE

@@ -0,0 +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.

package/README.md

@@ -0,0 +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
+
+This project is under the **MIT License**.

package/dist/ansi.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ANSI Escape Codes
+ * Manual definitions to maintain zero-dependency status.
+ */
+export declare const ANSI: {
+    RESET: string;
+    BOLD: string;
+    DIM: string;
+    ITALIC: string;
+    FG_GREEN: string;
+    FG_CYAN: string;
+    FG_YELLOW: string;
+    FG_RED: string;
+    FG_GRAY: string;
+    FG_WHITE: string;
+    ERASE_LINE: string;
+    CURSOR_LEFT: string;
+    HIDE_CURSOR: string;
+    SHOW_CURSOR: string;
+    UP: string;
+    DOWN: string;
+};

package/dist/ansi.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * ANSI Escape Codes
+ * Manual definitions to maintain zero-dependency status.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSI = void 0;
+exports.ANSI = {
+    RESET: '\x1b[0m',
+    BOLD: '\x1b[1m',
+    DIM: '\x1b[2m',
+    ITALIC: '\x1b[3m',
+    // Colors
+    FG_GREEN: '\x1b[32m',
+    FG_CYAN: '\x1b[36m',
+    FG_YELLOW: '\x1b[33m',
+    FG_RED: '\x1b[31m',
+    FG_GRAY: '\x1b[90m',
+    FG_WHITE: '\x1b[37m',
+    // Cursor & Erasing
+    ERASE_LINE: '\x1b[2K', // Clear current line
+    CURSOR_LEFT: '\x1b[1000D', // Move cursor to start of line
+    HIDE_CURSOR: '\x1b[?25l',
+    SHOW_CURSOR: '\x1b[?25h',
+    UP: '\x1b[A',
+    DOWN: '\x1b[B',
+};

package/dist/core.d.ts

@@ -0,0 +1,11 @@
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions } from './types';
+/**
+ * Public Facade for MepCLI
+ */
+export declare class MepCLI {
+    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>;
+}

package/dist/core.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MepCLI = void 0;
+const ansi_1 = require("./ansi");
+/**
+ * Abstract base class for all prompts.
+ * Handles common logic like stdin management, raw mode, and cleanup
+ * to enforce DRY (Don't Repeat Yourself) principles.
+ */
+class Prompt {
+    constructor(options) {
+        this.options = options;
+        this.stdin = process.stdin;
+        this.stdout = process.stdout;
+    }
+    print(text) {
+        this.stdout.write(text);
+    }
+    /**
+     * Starts the prompt interaction.
+     * Sets up raw mode and listeners, returning a Promise.
+     */
+    run() {
+        return new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+            if (typeof this.stdin.setRawMode === 'function') {
+                this.stdin.setRawMode(true);
+            }
+            this.stdin.resume();
+            this.stdin.setEncoding('utf8');
+            // Initial render: Default to hidden cursor (good for menus)
+            // Subclasses like TextPrompt will explicitly show it if needed.
+            this.print(ansi_1.ANSI.HIDE_CURSOR);
+            this.render(true);
+            this._onDataHandler = (buffer) => {
+                const char = buffer.toString();
+                // Global Exit Handler (Ctrl+C)
+                if (char === '\u0003') {
+                    this.cleanup();
+                    this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
+                    if (this._reject)
+                        this._reject(new Error('User force closed'));
+                    return;
+                }
+                this.handleInput(char, buffer);
+            };
+            this.stdin.on('data', this._onDataHandler);
+        });
+    }
+    /**
+     * Cleans up listeners and restores stdin state.
+     */
+    cleanup() {
+        if (this._onDataHandler) {
+            this.stdin.removeListener('data', this._onDataHandler);
+        }
+        if (typeof this.stdin.setRawMode === 'function') {
+            this.stdin.setRawMode(false);
+        }
+        this.stdin.pause();
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+    }
+    /**
+     * Submits the final value and resolves the promise.
+     */
+    submit(result) {
+        this.cleanup();
+        this.print('\n');
+        if (this._resolve)
+            this._resolve(result);
+    }
+}
+// --- Implementation: Text Prompt ---
+class TextPrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.errorMsg = '';
+        this.cursor = 0;
+        this.value = options.initial || '';
+        this.cursor = this.value.length;
+    }
+    render(firstRender) {
+        // 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);
+            }
+        }
+        // 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} `);
+        // 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`);
+        }
+        else {
+            const displayValue = this.options.isPassword ? '*'.repeat(this.value.length) : this.value;
+            this.print(`${ansi_1.ANSI.FG_CYAN}${displayValue}${ansi_1.ANSI.RESET}`);
+        }
+        // 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`);
+        }
+        // 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`);
+        }
+    }
+    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}`);
+            }
+            this.submit(this.value);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.cursor > 0) {
+                this.value = this.value.slice(0, this.cursor - 1) + this.value.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.value.length) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+        // Delete key
+        if (char === '\u001b[3~') {
+            if (this.cursor < this.value.length) {
+                this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+                this.errorMsg = '';
+                this.render(false);
+            }
+            return;
+        }
+        // Regular Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char)) {
+            this.value = this.value.slice(0, this.cursor) + char + this.value.slice(this.cursor);
+            this.cursor++;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
+// --- Implementation: Select Prompt ---
+class SelectPrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+    }
+    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`);
+        }
+        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`);
+            }
+        });
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            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);
+            return;
+        }
+        if (char === '\u001b[A') { // Up
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+            this.render(false);
+        }
+        if (char === '\u001b[B') { // Down
+            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            this.render(false);
+        }
+    }
+}
+// --- Implementation: Checkbox Prompt ---
+class CheckboxPrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.errorMsg = '';
+        this.checkedState = options.choices.map(c => !!c.selected);
+    }
+    render(firstRender) {
+        // Ensure cursor is HIDDEN for menus
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            const extraLines = this.errorMsg ? 1 : 0;
+            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`);
+        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 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}`;
+            const title = index === this.selectedIndex
+                ? `${ansi_1.ANSI.FG_CYAN}${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}`);
+        }
+        else if (!firstRender) {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}`);
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { min = 0, max } = this.options;
+            if (selectedCount < min) {
+                this.errorMsg = `You must select at least ${min} options.`;
+                this.render(false);
+                return;
+            }
+            if (max && selectedCount > max) {
+                this.errorMsg = `You can only select up to ${max} options.`;
+                this.render(false);
+                return;
+            }
+            this.cleanup();
+            this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
+            const results = this.options.choices
+                .filter((_, i) => this.checkedState[i])
+                .map(c => c.value);
+            if (this._resolve)
+                this._resolve(results);
+            return;
+        }
+        if (char === ' ') {
+            const currentChecked = this.checkedState[this.selectedIndex];
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { max } = this.options;
+            if (!currentChecked && max && selectedCount >= max) {
+                this.errorMsg = `Max ${max} selections allowed.`;
+            }
+            else {
+                this.checkedState[this.selectedIndex] = !currentChecked;
+                this.errorMsg = '';
+            }
+            this.render(false);
+        }
+        if (char === '\u001b[A') { // Up
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+            this.errorMsg = '';
+            this.render(false);
+        }
+        if (char === '\u001b[B') { // Down
+            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
+// --- Implementation: Confirm Prompt ---
+class ConfirmPrompt extends Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? true;
+    }
+    render(firstRender) {
+        // Hide cursor for confirm, user just hits Y/N or Enter
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            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} `);
+        const text = this.value ? 'Yes' : 'No';
+        this.print(`${ansi_1.ANSI.FG_CYAN}${text}${ansi_1.ANSI.RESET}\x1b[${text.length}D`);
+    }
+    handleInput(char) {
+        const c = char.toLowerCase();
+        if (c === '\r' || c === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (c === 'y') {
+            this.value = true;
+            this.render(false);
+        }
+        if (c === 'n') {
+            this.value = false;
+            this.render(false);
+        }
+    }
+}
+/**
+ * Public Facade for MepCLI
+ */
+class MepCLI {
+    static text(options) {
+        return new TextPrompt(options).run();
+    }
+    static select(options) {
+        return new SelectPrompt(options).run();
+    }
+    static checkbox(options) {
+        return new CheckboxPrompt(options).run();
+    }
+    static confirm(options) {
+        return new ConfirmPrompt(options).run();
+    }
+    static password(options) {
+        return new TextPrompt({ ...options, isPassword: true }).run();
+    }
+}
+exports.MepCLI = MepCLI;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mep (Minimalist Interactive CLI Prompt)
+ * Export file
+ */
+export * from './types';
+export * from './core';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Mep (Minimalist Interactive CLI Prompt)
+ * Export file
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./core"), exports);

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type definitions for Mep CLI interactions.
+ */
+export interface BaseOptions {
+    message: string;
+}
+export interface TextOptions extends BaseOptions {
+    placeholder?: string;
+    initial?: string;
+    validate?: (value: string) => string | boolean;
+    isPassword?: boolean;
+}
+export interface SelectChoice {
+    title: string;
+    value: any;
+    description?: string;
+}
+export interface SelectOptions extends BaseOptions {
+    choices: SelectChoice[];
+}
+export interface CheckboxChoice extends SelectChoice {
+    selected?: boolean;
+}
+export interface CheckboxOptions extends BaseOptions {
+    choices: CheckboxChoice[];
+    min?: number;
+    max?: number;
+}
+export interface ConfirmOptions extends BaseOptions {
+    initial?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for Mep CLI interactions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/example.ts

@@ -0,0 +1,83 @@
+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();

package/package.json

@@ -0,0 +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"
+  }
+}