@poolzin/pool-bot 2026.3.6 → 2026.3.9

package/dist/tui/index.js

@@ -0,0 +1,595 @@
+/**
+ * Terminal UI (TUI) Components
+ *
+ * Modern, interactive terminal interface components for PoolBot.
+ * Provides rich terminal experiences with progress bars, spinners,
+ * tables, and interactive prompts.
+ */
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline";
+/**
+ * Detect terminal capabilities
+ */
+export function detectCapabilities() {
+    const isTTY = stdout.isTTY ?? false;
+    const env = process.env;
+    // Check color support
+    const term = env.TERM ?? "";
+    const colorterm = env.COLORTERM ?? "";
+    const trueColor = colorterm === "truecolor" || colorterm === "24bit";
+    const colors256 = trueColor || term.includes("256") || term.includes("color");
+    // Check Unicode support
+    const lang = env.LANG ?? "";
+    const lcAll = env.LC_ALL ?? "";
+    const unicode = /utf-?8/i.test(lang) || /utf-?8/i.test(lcAll) || process.platform !== "win32";
+    return {
+        unicode,
+        colors256,
+        trueColor,
+        width: stdout.columns ?? 80,
+        height: stdout.rows ?? 24,
+        cursor: isTTY,
+        isTTY,
+    };
+}
+/**
+ * ANSI color codes
+ */
+export const Colors = {
+    // Reset
+    reset: "\x1b[0m",
+    // Foreground colors
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+    // Bright colors
+    brightRed: "\x1b[91m",
+    brightGreen: "\x1b[92m",
+    brightYellow: "\x1b[93m",
+    brightBlue: "\x1b[94m",
+    brightMagenta: "\x1b[95m",
+    brightCyan: "\x1b[96m",
+    brightWhite: "\x1b[97m",
+    // Background colors
+    bgBlack: "\x1b[40m",
+    bgRed: "\x1b[41m",
+    bgGreen: "\x1b[42m",
+    bgYellow: "\x1b[43m",
+    bgBlue: "\x1b[44m",
+    bgMagenta: "\x1b[45m",
+    bgCyan: "\x1b[46m",
+    bgWhite: "\x1b[47m",
+    // Styles
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    italic: "\x1b[3m",
+    underline: "\x1b[4m",
+    strikethrough: "\x1b[9m",
+};
+/**
+ * Colorize text with ANSI codes
+ */
+export function colorize(text, ...codes) {
+    const caps = detectCapabilities();
+    if (!caps.colors256)
+        return text;
+    return codes.join("") + text + Colors.reset;
+}
+/**
+ * Spinner characters for different styles
+ */
+export const SpinnerChars = {
+    dots: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    line: ["-", "\\", "|", "/"],
+    arrow: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+    bounce: ["( ●    )", "(  ●   )", "(   ●  )", "(    ● )", "(     ●)", "(    ● )", "(   ●  )", "(  ●   )", "( ●    )", "(●     )"],
+    pulse: ["█", "▉", "▊", "▋", "▌", "▍", "▎", "▏"],
+};
+/**
+ * Terminal spinner for loading states
+ */
+export class Spinner {
+    frames;
+    interval;
+    text;
+    color;
+    currentFrame = 0;
+    timer = null;
+    active = false;
+    caps;
+    constructor(options) {
+        this.caps = detectCapabilities();
+        this.frames = SpinnerChars[options.style ?? "dots"];
+        this.interval = options.interval ?? 80;
+        this.text = options.text;
+        this.color = options.color ?? Colors.cyan;
+    }
+    /**
+     * Start the spinner
+     */
+    start() {
+        if (this.active || !this.caps.isTTY)
+            return this;
+        this.active = true;
+        this.render();
+        this.timer = setInterval(() => {
+            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+            this.render();
+        }, this.interval);
+        return this;
+    }
+    /**
+     * Stop the spinner
+     */
+    stop(finalText) {
+        if (!this.active)
+            return;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.active = false;
+        // Clear line and show final text
+        if (finalText) {
+            stdout.write("\r\x1b[K" + finalText + "\n");
+        }
+        else {
+            stdout.write("\r\x1b[K");
+        }
+    }
+    /**
+     * Update spinner text
+     */
+    update(text) {
+        this.text = text;
+        if (this.active) {
+            this.render();
+        }
+    }
+    /**
+     * Render current frame
+     */
+    render() {
+        if (!this.caps.isTTY)
+            return;
+        const frame = this.frames[this.currentFrame];
+        const coloredFrame = this.caps.colors256 ? this.color + frame + Colors.reset : frame;
+        stdout.write(`\r\x1b[K${coloredFrame} ${this.text}`);
+    }
+}
+/**
+ * Terminal progress bar
+ */
+export class ProgressBar {
+    total;
+    current = 0;
+    width;
+    completeChar;
+    incompleteChar;
+    showPercent;
+    showValue;
+    prefix;
+    completeColor;
+    incompleteColor;
+    caps;
+    constructor(options) {
+        this.caps = detectCapabilities();
+        this.total = options.total;
+        this.width = options.width ?? 40;
+        this.completeChar = options.completeChar ?? (this.caps.unicode ? "█" : "=");
+        this.incompleteChar = options.incompleteChar ?? (this.caps.unicode ? "░" : "-");
+        this.showPercent = options.showPercent ?? true;
+        this.showValue = options.showValue ?? false;
+        this.prefix = options.prefix ?? "";
+        this.completeColor = options.completeColor ?? Colors.green;
+        this.incompleteColor = options.incompleteColor ?? Colors.gray;
+    }
+    /**
+     * Update progress
+     */
+    update(value) {
+        this.current = Math.min(value, this.total);
+        this.render();
+    }
+    /**
+     * Increment progress
+     */
+    increment(amount = 1) {
+        this.update(this.current + amount);
+    }
+    /**
+     * Complete the progress bar
+     */
+    complete(message) {
+        this.update(this.total);
+        if (message) {
+            stdout.write(" " + message);
+        }
+        stdout.write("\n");
+    }
+    /**
+     * Render the progress bar
+     */
+    render() {
+        if (!this.caps.isTTY)
+            return;
+        const percent = this.current / this.total;
+        const filled = Math.round(this.width * percent);
+        const empty = this.width - filled;
+        const completeStr = this.completeChar.repeat(filled);
+        const incompleteStr = this.incompleteChar.repeat(empty);
+        const coloredComplete = this.caps.colors256
+            ? this.completeColor + completeStr + Colors.reset
+            : completeStr;
+        const coloredIncomplete = this.caps.colors256
+            ? this.incompleteColor + incompleteStr + Colors.reset
+            : incompleteStr;
+        let suffix = "";
+        if (this.showPercent) {
+            suffix += ` ${(percent * 100).toFixed(1)}%`;
+        }
+        if (this.showValue) {
+            suffix += ` [${this.current}/${this.total}]`;
+        }
+        const prefix = this.prefix ? this.prefix + " " : "";
+        stdout.write(`\r\x1b[K${prefix}${coloredComplete}${coloredIncomplete}${suffix}`);
+    }
+}
+/**
+ * Border characters for different styles
+ */
+const BorderChars = {
+    simple: {
+        topLeft: "+",
+        topRight: "+",
+        bottomLeft: "+",
+        bottomRight: "+",
+        horizontal: "-",
+        vertical: "|",
+        cross: "+",
+        leftT: "+",
+        rightT: "+",
+        topT: "+",
+        bottomT: "+",
+    },
+    rounded: {
+        topLeft: "╭",
+        topRight: "╮",
+        bottomLeft: "╰",
+        bottomRight: "╯",
+        horizontal: "─",
+        vertical: "│",
+        cross: "┼",
+        leftT: "├",
+        rightT: "┤",
+        topT: "┬",
+        bottomT: "┴",
+    },
+    heavy: {
+        topLeft: "┏",
+        topRight: "┓",
+        bottomLeft: "┗",
+        bottomRight: "┛",
+        horizontal: "━",
+        vertical: "┃",
+        cross: "╋",
+        leftT: "┣",
+        rightT: "┫",
+        topT: "┳",
+        bottomT: "┻",
+    },
+    none: {
+        topLeft: "",
+        topRight: "",
+        bottomLeft: "",
+        bottomRight: "",
+        horizontal: "",
+        vertical: "",
+        cross: "",
+        leftT: "",
+        rightT: "",
+        topT: "",
+        bottomT: "",
+    },
+};
+/**
+ * Terminal table renderer
+ */
+export class Table {
+    columns;
+    data;
+    showHeader;
+    borderStyle;
+    rowSeparator;
+    caps;
+    constructor(options) {
+        this.caps = detectCapabilities();
+        this.columns = options.columns;
+        this.data = options.data;
+        this.showHeader = options.showHeader ?? true;
+        this.borderStyle = options.borderStyle ?? "simple";
+        this.rowSeparator = options.rowSeparator ?? false;
+    }
+    /**
+     * Render the table
+     */
+    render() {
+        const borders = BorderChars[this.borderStyle];
+        const colWidths = this.calculateWidths();
+        const lines = [];
+        // Top border
+        if (this.borderStyle !== "none") {
+            lines.push(this.renderHorizontalLine(borders.topLeft, borders.topRight, borders.horizontal, borders.topT, colWidths));
+        }
+        // Header row
+        if (this.showHeader) {
+            const headerCells = this.columns.map((col, i) => {
+                const width = colWidths[i];
+                const text = this.truncate(col.header, width);
+                const aligned = this.align(text, width, col.align ?? "left");
+                const colored = col.headerColor && this.caps.colors256
+                    ? col.headerColor + aligned + Colors.reset
+                    : aligned;
+                return colored;
+            });
+            lines.push(this.renderRow(headerCells, borders.vertical));
+            // Header separator
+            if (this.borderStyle !== "none") {
+                lines.push(this.renderHorizontalLine(borders.leftT, borders.rightT, borders.horizontal, borders.cross, colWidths));
+            }
+        }
+        // Data rows
+        for (let i = 0; i < this.data.length; i++) {
+            const row = this.data[i];
+            const cells = row.map((cell, j) => {
+                const width = colWidths[j];
+                const text = this.truncate(cell ?? "", width);
+                return this.align(text, width, this.columns[j]?.align ?? "left");
+            });
+            lines.push(this.renderRow(cells, borders.vertical));
+            // Row separator
+            if (this.rowSeparator && i < this.data.length - 1 && this.borderStyle !== "none") {
+                lines.push(this.renderHorizontalLine(borders.leftT, borders.rightT, borders.horizontal, borders.cross, colWidths));
+            }
+        }
+        // Bottom border
+        if (this.borderStyle !== "none") {
+            lines.push(this.renderHorizontalLine(borders.bottomLeft, borders.bottomRight, borders.horizontal, borders.bottomT, colWidths));
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Print the table to stdout
+     */
+    print() {
+        console.log(this.render());
+    }
+    calculateWidths() {
+        const caps = detectCapabilities();
+        const maxWidth = caps.width - 4; // Padding for borders
+        return this.columns.map((col, i) => {
+            if (col.width)
+                return col.width;
+            // Calculate based on content
+            const headerLen = col.header.length;
+            const maxDataLen = this.data.reduce((max, row) => {
+                const cellLen = (row[i] ?? "").length;
+                return Math.max(max, cellLen);
+            }, 0);
+            return Math.min(Math.max(headerLen, maxDataLen) + 2, Math.floor(maxWidth / this.columns.length));
+        });
+    }
+    renderHorizontalLine(left, right, horizontal, cross, widths) {
+        const segments = widths.map(w => horizontal.repeat(w));
+        return left + segments.join(cross) + right;
+    }
+    renderRow(cells, vertical) {
+        return vertical + cells.join(vertical) + vertical;
+    }
+    truncate(text, width) {
+        if (text.length <= width)
+            return text;
+        return text.slice(0, width - 3) + "...";
+    }
+    align(text, width, align) {
+        const padding = width - text.length;
+        switch (align) {
+            case "center": {
+                const left = Math.floor(padding / 2);
+                const right = padding - left;
+                return " ".repeat(left) + text + " ".repeat(right);
+            }
+            case "right":
+                return " ".repeat(padding) + text;
+            case "left":
+            default:
+                return text + " ".repeat(padding);
+        }
+    }
+}
+/**
+ * Interactive prompts
+ */
+export class Prompts {
+    /**
+     * Confirm yes/no prompt
+     */
+    static async confirm(options) {
+        const defaultText = options.default === false ? "y/N" : "Y/n";
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = await new Promise((resolve) => {
+                rl.question(`${options.message} [${defaultText}] `, resolve);
+            });
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === "")
+                return options.default ?? true;
+            return normalized === "y" || normalized === "yes";
+        }
+        finally {
+            rl.close();
+        }
+    }
+    /**
+     * Text input prompt
+     */
+    static async input(options) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+            const prompt = options.default
+                ? `${options.message} (${options.default}) `
+                : `${options.message} `;
+            const answer = await new Promise((resolve) => {
+                rl.question(prompt, resolve);
+            });
+            const value = answer.trim() || options.default || "";
+            if (options.validate) {
+                const result = options.validate(value);
+                if (result !== true) {
+                    console.log(colorize(`Error: ${result}`, Colors.red));
+                    return Prompts.input(options);
+                }
+            }
+            return value;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    /**
+     * Select from list prompt
+     */
+    static async select(options) {
+        const available = options.choices.filter(c => !c.disabled);
+        console.log(options.message);
+        available.forEach((choice, i) => {
+            const marker = choice.value === options.default ? colorize("›", Colors.cyan) : " ";
+            console.log(`  ${marker} ${i + 1}) ${choice.name}`);
+        });
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = await new Promise((resolve) => {
+                rl.question("Select: ", resolve);
+            });
+            const num = parseInt(answer.trim(), 10);
+            if (num >= 1 && num <= available.length) {
+                return available[num - 1].value;
+            }
+            // Try matching by value
+            const match = available.find(c => c.value.toLowerCase() === answer.trim().toLowerCase());
+            if (match)
+                return match.value;
+            console.log(colorize("Invalid selection", Colors.red));
+            return Prompts.select(options);
+        }
+        finally {
+            rl.close();
+        }
+    }
+}
+/**
+ * Status indicators
+ */
+export const Status = {
+    success: colorize("✓", Colors.green),
+    error: colorize("✗", Colors.red),
+    warning: colorize("⚠", Colors.yellow),
+    info: colorize("ℹ", Colors.blue),
+    pending: colorize("○", Colors.gray),
+};
+/**
+ * Log a message with a status indicator
+ */
+export function logStatus(status, message) {
+    console.log(`${Status[status]} ${message}`);
+}
+/**
+ * Draw a box around content
+ */
+export function box(content, options = {}) {
+    const caps = detectCapabilities();
+    const lines = content.split("\n");
+    const maxLineLen = Math.max(...lines.map(l => l.length));
+    const width = options.width ?? maxLineLen + 4;
+    const padding = options.padding ?? 1;
+    const borders = {
+        simple: { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" },
+        rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" },
+        heavy: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+        double: { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" },
+    }[options.style ?? "rounded"];
+    const result = [];
+    // Top border with title
+    let topBorder = borders.tl + borders.h.repeat(width - 2) + borders.tr;
+    if (options.title) {
+        const title = caps.colors256 && options.titleColor
+            ? options.titleColor + options.title + Colors.reset
+            : options.title;
+        const titleWithPadding = ` ${title} `;
+        const before = Math.floor((width - titleWithPadding.length) / 2);
+        topBorder = borders.tl + borders.h.repeat(before) + titleWithPadding + borders.h.repeat(width - before - titleWithPadding.length - 2) + borders.tr;
+    }
+    result.push(topBorder);
+    // Padding top
+    for (let i = 0; i < padding; i++) {
+        result.push(borders.v + " ".repeat(width - 2) + borders.v);
+    }
+    // Content
+    for (const line of lines) {
+        const contentWidth = Math.max(0, width - line.length - 2 - padding * 2);
+        const padded = " ".repeat(padding) + line + " ".repeat(contentWidth);
+        result.push(borders.v + padded + borders.v);
+    }
+    // Padding bottom
+    for (let i = 0; i < padding; i++) {
+        result.push(borders.v + " ".repeat(width - 2) + borders.v);
+    }
+    // Bottom border
+    result.push(borders.bl + borders.h.repeat(width - 2) + borders.br);
+    return result.join("\n");
+}
+/**
+ * Create a multi-step wizard
+ */
+export class Wizard {
+    steps = [];
+    _currentStep = 0;
+    /**
+     * Add a step to the wizard
+     */
+    step(name, run) {
+        this.steps.push({ name, run });
+        return this;
+    }
+    /**
+     * Run the wizard
+     */
+    async run() {
+        console.log(box("Starting Setup Wizard", { title: "Wizard", style: "rounded" }));
+        for (let i = 0; i < this.steps.length; i++) {
+            this._currentStep = i;
+            const step = this.steps[i];
+            console.log(`\n${colorize(`Step ${i + 1}/${this.steps.length}:`, Colors.cyan)} ${step.name}`);
+            try {
+                const success = await step.run();
+                if (!success) {
+                    logStatus("error", `Step "${step.name}" failed`);
+                    return false;
+                }
+                logStatus("success", `Step "${step.name}" completed`);
+            }
+            catch (error) {
+                logStatus("error", `Step "${step.name}" error: ${error instanceof Error ? error.message : String(error)}`);
+                return false;
+            }
+        }
+        console.log("\n" + box("Wizard completed successfully!", { style: "rounded", title: "✓ Complete" }));
+        return true;
+    }
+}