mepcli 0.2.1 → 0.2.6

package/dist/prompts/text.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+// --- Implementation: Text Prompt ---
+class TextPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.errorMsg = '';
+        // cursor is now an index into the grapheme segments array
+        this.cursor = 0;
+        this.hasTyped = false;
+        this.segments = [];
+        this.value = options.initial || '';
+        // Initialize segments from value
+        this.segments = (0, utils_1.safeSplit)(this.value);
+        this.cursor = this.segments.length;
+    }
+    render(firstRender) {
+        // Calculate available width
+        const cols = process.stdout.columns || 80;
+        // 1. Prepare Prompt Label
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        const hint = this.options.multiline ? ` ${theme_1.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
+        const prefix = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${hint} `;
+        // We need visual length of prefix to calculate available space for input on the first line
+        const prefixVisualLen = this.stripAnsi(prefix).length;
+        // 2. Prepare Value Display
+        let displayValueLines = [];
+        let cursorRelativeRow = 0;
+        let cursorRelativeCol = 0; // Visual column index
+        // Reconstruct value from segments for logic that needs raw string
+        this.value = this.segments.join('');
+        if (this.segments.length === 0 && this.options.placeholder && !this.errorMsg && !this.hasTyped) {
+            // Placeholder case
+            const placeholder = `${theme_1.theme.muted}${this.options.placeholder}${ansi_1.ANSI.RESET}`;
+            displayValueLines = [placeholder];
+            cursorRelativeRow = 0;
+            cursorRelativeCol = 0;
+        }
+        else {
+            const rawValue = this.options.isPassword ? '*'.repeat(this.segments.length) : this.value;
+            // Note: password masking replaces each grapheme with '*'
+            // Split by lines (for multiline support)
+            const lines = rawValue.split('\n');
+            // Determine which line the cursor is on
+            // We need to map 'cursor' (segments index) to line/col.
+            // This is tricky because segments might contain '\n'.
+            // safeSplit treats '\n' as a segment.
+            let cursorLineIndex = 0;
+            let cursorSegmentIndexOnLine = 0;
+            let 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;
+                // 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?
+            // If we want visual cursor position, we need visual width of segments.
+            let visualColIndex = 0;
+            for (let i = 0; i < this.cursor; i++) {
+                const seg = this.segments[i];
+                if (seg === '\n') {
+                    cursorLineIndex++;
+                    visualColIndex = 0;
+                }
+                else {
+                    // Calculate width of this segment? 
+                    // No, for simple text editor logic we often assume 1 char = 1 pos unless we do full layout.
+                    // But here we want correct cursor placement over wide chars.
+                    // So we should sum width.
+                    // However, standard terminals handle wide chars by advancing cursor 2 spots.
+                    // So we just need to sum the string length of the segment? 
+                    // Or 2 if it's wide?
+                    // Standard terminal behavior:
+                    // If I write an Emoji (2 cols), the cursor advances 2 cols.
+                    // So visualColIndex should track stringWidth(seg).
+                    // But if isPassword, it's '*'. Width 1.
+                    if (this.options.isPassword) {
+                        visualColIndex += 1;
+                    }
+                    else {
+                        // Use our helper? Or just length?
+                        // If we used stringWidth, it would be accurate.
+                        // But we don't have access to stringWidth here easily unless we import it again (we did in base).
+                        // Let's assume segment.length for now (byte length), 
+                        // because `\x1b[<N>C` moves N COLUMNS? No, N characters? 
+                        // ANSI `CUB` / `CUF` moves N *columns* usually? 
+                        // "The Cursor Forward (CUF) sequence moves the cursor forward by n columns."
+                        // So if we have an emoji (2 cols), we need to move past it.
+                        // If we print an emoji, cursor is at +2.
+                        // Wait, if we use `renderFrame`, we rewrite everything.
+                        // Then we calculate where to put the cursor.
+                        // If line is "A <Emoji> B".
+                        // Output: "A <Emoji> B".
+                        // If cursor is after Emoji.
+                        // We need to be at position: width("A") + width("<Emoji>").
+                        // = 1 + 2 = 3.
+                        // So `visualColIndex` should use `stringWidth(seg)`.
+                        // But I didn't export `stringWidth` from `utils.ts` in the last step?
+                        // Checking `src/utils.ts`... I did export it.
+                        // But I need to import it here.
+                        visualColIndex += this.options.isPassword ? 1 : this.getSegmentWidth(seg);
+                    }
+                }
+            }
+            cursorRelativeRow = cursorLineIndex;
+            cursorRelativeCol = visualColIndex;
+            // 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
+            for (const seg of this.segments) {
+                if (seg === '\n') {
+                    processedLines.push(currentLineSegments);
+                    currentLineSegments = [];
+                }
+                else {
+                    currentLineSegments.push(seg);
+                }
+            }
+            processedLines.push(currentLineSegments); // Last line
+            processedLines.forEach((lineSegs, idx) => {
+                const isCursorLine = idx === cursorLineIndex;
+                const linePrefixLen = (idx === 0) ? prefixVisualLen : 0;
+                const maxContentLen = Math.max(10, cols - linePrefixLen - 1);
+                // Reconstruct line string for display calculation
+                // If password, join with *?
+                let visibleLine = '';
+                if (this.options.isPassword) {
+                    visibleLine = '*'.repeat(lineSegs.length);
+                }
+                else {
+                    visibleLine = lineSegs.join('');
+                }
+                // If this is cursor line, we need to handle horizontal scroll based on cursorRelativeCol.
+                // But cursorRelativeCol is global? No, we reset it on newline.
+                // So cursorRelativeCol above was correct for the current line.
+                if (isCursorLine) {
+                    // Check if we need to scroll
+                    // We need visual width of the line up to cursor.
+                    // cursorRelativeCol holds that.
+                    // If visual position > maxContentLen, we scroll.
+                    // This logic is similar to before but needs to use widths.
+                    // For simplicity, let's stick to the previous slice logic but apply it to SEGMENTS if possible.
+                    // But slicing segments for display is safer.
+                    // Let's implement simple tail truncation for now to keep it robust.
+                    // Ideally we scroll, but scrolling with variable width chars is complex.
+                    // "Good Enough": if it fits, show it. If not, truncate end.
+                    // If cursor is beyond end, scroll (slice from left).
+                    // Simplified: just show visibleLine truncated by base class renderFrame?
+                    // But renderFrame truncates blindly. We want the cursor visible.
+                    // Let's leave scrolling out for this specific "Backspace" fix task unless it's critical.
+                    // The user asked for "Backspace Emoji fix".
+                    // The scrolling logic is secondary but important.
+                    // I will preserve the existing simple scrolling logic but using segments?
+                    // No, let's just use the string for display and let renderFrame truncate.
+                    // Fix: Ensure we don't crash or show garbage.
+                }
+                displayValueLines.push(theme_1.theme.main + visibleLine + ansi_1.ANSI.RESET);
+            });
+        }
+        // 3. Assemble Output
+        let output = '';
+        displayValueLines.forEach((lineStr, idx) => {
+            if (idx === 0) {
+                output += prefix + lineStr;
+            }
+            else {
+                output += '\n' + lineStr;
+            }
+        });
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        // 4. Render Frame
+        this.renderFrame(output);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        // 5. Move Cursor
+        const errorOffset = this.errorMsg ? 1 : 0;
+        const totalRows = displayValueLines.length + errorOffset;
+        const linesUp = (totalRows - 1) - cursorRelativeRow;
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+        }
+        let targetCol = 0;
+        if (cursorRelativeRow === 0) {
+            targetCol = prefixVisualLen + cursorRelativeCol;
+        }
+        else {
+            targetCol = cursorRelativeCol;
+        }
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (targetCol > 0) {
+            this.print(`\x1b[${targetCol}C`);
+        }
+    }
+    // Helper to get width of a segment
+    getSegmentWidth(seg) {
+        return (0, utils_1.stringWidth)(seg);
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.options.multiline) {
+                // Insert newline segment
+                this.segments.splice(this.cursor, 0, '\n');
+                this.cursor++;
+                this.render(false);
+                return;
+            }
+            this.validateAndSubmit();
+            return;
+        }
+        // Ctrl+D / Ctrl+S
+        if (this.options.multiline && (char === '\u0004' || char === '\u0013')) {
+            this.validateAndSubmit();
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            this.hasTyped = true;
+            if (this.cursor > 0) {
+                // Remove segment at cursor - 1
+                this.segments.splice(this.cursor - 1, 1);
+                this.cursor--;
+                this.errorMsg = '';
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Left
+        if (this.isLeft(char)) {
+            if (this.cursor > 0) {
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Arrow Right
+        if (this.isRight(char)) {
+            if (this.cursor < this.segments.length) {
+                this.cursor++;
+                this.render(false);
+            }
+            return;
+        }
+        // Delete key
+        if (char === '\u001b[3~') {
+            this.hasTyped = true;
+            if (this.cursor < this.segments.length) {
+                this.segments.splice(this.cursor, 1);
+                this.errorMsg = '';
+                this.render(false);
+            }
+            return;
+        }
+        // Regular Typing & Paste
+        // safeSplit the input char(s) - could be pasted text
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.hasTyped = true;
+            const newSegments = (0, utils_1.safeSplit)(char);
+            this.segments.splice(this.cursor, 0, ...newSegments);
+            this.cursor += newSegments.length;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+    validateAndSubmit() {
+        this.value = this.segments.join('');
+        if (this.options.validate) {
+            const result = this.options.validate(this.value);
+            if (result instanceof Promise) {
+                this.errorMsg = 'Validating...';
+                this.render(false);
+                result.then(valid => {
+                    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 {
+                        this.errorMsg = '';
+                        this.render(false);
+                        this.submit(this.value);
+                    }
+                }).catch(err => {
+                    this.errorMsg = err.message || 'Validation failed';
+                    this.render(false);
+                });
+                return;
+            }
+            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;
+            }
+        }
+        this.submit(this.value);
+    }
+}
+exports.TextPrompt = TextPrompt;

package/dist/prompts/toggle.d.ts

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

package/dist/prompts/toggle.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TogglePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Toggle Prompt ---
+class TogglePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? false;
+    }
+    render(firstRender) {
+        const activeText = this.options.activeText || 'ON';
+        const inactiveText = this.options.inactiveText || 'OFF';
+        let toggleDisplay = '';
+        if (this.value) {
+            toggleDisplay = `${theme_1.theme.main}[${ansi_1.ANSI.BOLD}${activeText}${ansi_1.ANSI.RESET}${theme_1.theme.main}]${ansi_1.ANSI.RESET}  ${theme_1.theme.muted}${inactiveText}${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            toggleDisplay = `${theme_1.theme.muted}${activeText}${ansi_1.ANSI.RESET}  ${theme_1.theme.main}[${ansi_1.ANSI.BOLD}${inactiveText}${ansi_1.ANSI.RESET}${theme_1.theme.main}]${ansi_1.ANSI.RESET}`;
+        }
+        const output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${toggleDisplay}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (this.isLeft(char) || this.isRight(char) || char === 'h' || char === 'l') { // Left/Right
+            this.value = !this.value;
+            this.render(false);
+        }
+        if (char === ' ') {
+            this.value = !this.value;
+            this.render(false);
+        }
+    }
+}
+exports.TogglePrompt = TogglePrompt;

package/dist/theme.d.ts

@@ -0,0 +1,2 @@
+import { ThemeConfig } from './types';
+export declare const theme: ThemeConfig;

package/dist/theme.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.theme = void 0;
+const ansi_1 = require("./ansi");
+exports.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

@@ -53,3 +53,27 @@ export interface ToggleOptions extends BaseOptions {
     activeText?: string;
     inactiveText?: string;
 }
+export interface ListOptions extends BaseOptions {
+    placeholder?: string;
+    initial?: string[];
+    validate?: (value: string[]) => string | boolean | Promise<string | boolean>;
+}
+export interface SliderOptions extends BaseOptions {
+    min: number;
+    max: number;
+    initial?: number;
+    step?: number;
+    unit?: string;
+}
+export interface DateOptions extends BaseOptions {
+    initial?: Date;
+    min?: Date;
+    max?: Date;
+}
+export interface FileOptions extends BaseOptions {
+    basePath?: string;
+    extensions?: string[];
+    onlyDirectories?: boolean;
+}
+export interface MultiSelectOptions extends CheckboxOptions {
+}

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Detects terminal capabilities.
+ */
+export declare function detectCapabilities(): {
+    isCI: boolean;
+    hasTrueColor: boolean;
+    hasUnicode: boolean;
+};
+/**
+ * Strips ANSI escape codes from a string.
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Calculates the visual width of a string.
+ * Uses binary search for wide characters.
+ * Handles ANSI codes (zero width).
+ */
+export declare function stringWidth(str: string): number;
+/**
+ * Safely splits a string into an array of grapheme clusters.
+ * Uses Intl.Segmenter (Node 16+).
+ */
+export declare function safeSplit(str: string): string[];

package/dist/utils.js

@@ -0,0 +1,135 @@
+"use strict";
+// src/utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCapabilities = detectCapabilities;
+exports.stripAnsi = stripAnsi;
+exports.stringWidth = stringWidth;
+exports.safeSplit = safeSplit;
+/**
+ * Detects terminal capabilities.
+ */
+function detectCapabilities() {
+    const env = process.env;
+    // Check for CI
+    const isCI = !!env.CI;
+    // Check for True Color support
+    const hasTrueColor = env.COLORTERM === 'truecolor';
+    // Check for Unicode support
+    // Windows Terminal (WT_SESSION), VS Code (TERM_PROGRAM=vscode), or modern Linux terminals usually support it.
+    const isWindows = process.platform === 'win32';
+    const hasUnicode = !!env.WT_SESSION ||
+        env.TERM_PROGRAM === 'vscode' ||
+        env.TERM_PROGRAM === 'Apple_Terminal' ||
+        (!isWindows && env.LANG && env.LANG.toUpperCase().endsWith('UTF-8'));
+    return {
+        isCI,
+        hasTrueColor,
+        hasUnicode: hasUnicode || !isWindows // Assume non-windows has unicode by default if not strictly detected?
+    };
+}
+/**
+ * Strips ANSI escape codes from a string.
+ */
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+/**
+ * Sorted array of Unicode ranges that are typically full-width (2 columns).
+ * Includes CJK, Emoji, Fullwidth forms, etc.
+ * Format: [start, end] inclusive.
+ */
+const WIDE_RANGES = [
+    [0x1100, 0x11FF], // Hangul Jamo
+    [0x2E80, 0x2EFF], // CJK Radicals Supplement
+    [0x2F00, 0x2FDF], // Kangxi Radicals
+    [0x3000, 0x303F], // CJK Symbols and Punctuation
+    [0x3040, 0x309F], // Hiragana
+    [0x30A0, 0x30FF], // Katakana
+    [0x3100, 0x312F], // Bopomofo
+    [0x3130, 0x318F], // Hangul Compatibility Jamo
+    [0x3200, 0x32FF], // Enclosed CJK Letters and Months
+    [0x3300, 0x33FF], // CJK Compatibility
+    [0x3400, 0x4DBF], // CJK Unified Ideographs Extension A
+    [0x4E00, 0x9FFF], // CJK Unified Ideographs
+    [0xA960, 0xA97F], // Hangul Jamo Extended-A
+    [0xAC00, 0xD7AF], // Hangul Syllables
+    [0xD7B0, 0xD7FF], // Hangul Jamo Extended-B
+    [0xF900, 0xFAFF], // CJK Compatibility Ideographs
+    [0xFE10, 0xFE1F], // Vertical Forms
+    [0xFE30, 0xFE4F], // CJK Compatibility Forms
+    [0xFE50, 0xFE6F], // Small Form Variants
+    [0xFF01, 0xFF60], // Fullwidth ASCII variants
+    [0xFFE0, 0xFFE6], // Fullwidth currency/symbols
+    [0x1F300, 0x1F6FF], // Miscellaneous Symbols and Pictographs (Emoji)
+    [0x1F900, 0x1F9FF], // Supplemental Symbols and Pictographs
+];
+/**
+ * Binary search to check if a code point is in the wide ranges.
+ */
+function isWideCodePoint(cp) {
+    let low = 0;
+    let high = WIDE_RANGES.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const [start, end] = WIDE_RANGES[mid];
+        if (cp >= start && cp <= end) {
+            return true;
+        }
+        else if (cp < start) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return false;
+}
+/**
+ * Calculates the visual width of a string.
+ * Uses binary search for wide characters.
+ * Handles ANSI codes (zero width).
+ */
+function stringWidth(str) {
+    let width = 0;
+    let inAnsi = false;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        // Simple ANSI parser state check
+        if (str[i] === '\x1b') {
+            inAnsi = true;
+            continue;
+        }
+        if (inAnsi) {
+            if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
+                inAnsi = false;
+            }
+            continue;
+        }
+        // Handle surrogate pairs for high code points (Emoji)
+        let cp = code;
+        if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
+            const next = str.charCodeAt(i + 1);
+            if (next >= 0xDC00 && next <= 0xDFFF) {
+                // Calculate code point from surrogate pair
+                cp = (code - 0xD800) * 0x400 + (next - 0xDC00) + 0x10000;
+                i++; // Skip next char
+            }
+        }
+        width += isWideCodePoint(cp) ? 2 : 1;
+    }
+    return width;
+}
+/**
+ * Safely splits a string into an array of grapheme clusters.
+ * Uses Intl.Segmenter (Node 16+).
+ */
+function safeSplit(str) {
+    // @ts-ignore - Intl.Segmenter is available in Node 16+ but TS might complain depending on lib settings
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    const segments = segmenter.segment(str);
+    const result = [];
+    for (const segment of segments) {
+        result.push(segment.segment);
+    }
+    return result;
+}

package/example.ts

@@ -3,11 +3,12 @@ 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.
+ * Checkbox, Number, Toggle, Confirm, List, Slider, Date, File, MultiSelect,
+ * and the Spin utility.
  */
 async function runComprehensiveDemo() {
     console.clear();
-    console.log("--- MepCLI Comprehensive Demo (All 7 Prompts + Spin Utility) ---\n");
+    console.log("--- MepCLI Comprehensive Demo (All 12 Prompts + Spin Utility) ---\n");
 
     try {
         // --- 1. Text Prompt (Input with Validation and initial value) ---
@@ -76,16 +77,67 @@ async function runComprehensiveDemo() {
         });
         console.log(`\n✅ Toggle Result: HTTPS enabled: ${isSecure}`);
 
-        // --- 7. Confirm Prompt (Simple Yes/No) ---
+        // --- 7. List / Tags Input (New) ---
+        const keywords = await MepCLI.list({
+            message: "Enter keywords for package.json (Enter to add, Backspace to remove):",
+            initial: ["cli", "mep"],
+            validate: (tags) => tags.length > 0 || "Please add at least one keyword."
+        });
+        console.log(`\n✅ List Result: Keywords: [${keywords.join(', ')}]`);
+
+        // --- 8. Slider / Scale (New) ---
+        const brightness = await MepCLI.slider({
+            message: "Set initial brightness:",
+            min: 0,
+            max: 100,
+            initial: 80,
+            step: 5,
+            unit: "%"
+        });
+        console.log(`\n✅ Slider Result: Brightness: ${brightness}%`);
+
+        // --- 9. Date / Time Picker (New) ---
+        // We capture 'now' once to ensure initial >= min
+        const now = new Date();
+        const releaseDate = await MepCLI.date({
+            message: "Schedule release date:",
+            initial: now,
+            min: now // Cannot be in the past
+        });
+        console.log(`\n✅ Date Result: Release set for: ${releaseDate.toLocaleString()}`);
+
+        // --- 10. 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}`);
+
+        // --- 11. Multi-Select Autocomplete (New) ---
+        const linters = await MepCLI.multiSelect({
+            message: "Select linters to install (Type to search, Space to select):",
+            choices: [
+                { title: "ESLint", value: "eslint", selected: true },
+                { title: "Prettier", value: "prettier" },
+                { title: "Stylelint", value: "stylelint" },
+                { title: "TSLint (Deprecated)", value: "tslint" },
+                { title: "JSHint", value: "jshint" },
+                { title: "StandardJS", value: "standard" }
+            ],
+            min: 1
+        });
+        console.log(`\n✅ MultiSelect Result: Linters: [${linters.join(', ')}]`);
+
+        // --- 12. 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) ---
+        // --- 13. Spin Utility (Loading/Async Task Indicator) ---
         await MepCLI.spin(
-            "Finalizing configuration and deploying to Teaserverse...",
+            "Finalizing configuration and deploying...",
             new Promise(resolve => setTimeout(resolve, 1500)) // Simulates a 1.5 second async task
         );
         console.log("\n--- Deployment successful! All MepCLI features demonstrated! ---");