@minko-ai/minko 0.1.0 → 0.1.1

package/dist/ui/ansi.js

@@ -0,0 +1,135 @@
+import { colorEnabled, PURPLE } from "../theme.js";
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+export function hexToRgb(hex) {
+    const raw = hex.replace('#', '');
+    const full = raw.length === 3 ? raw.split('').map((c) => c + c).join('') : raw;
+    const value = parseInt(full, 16);
+    return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
+}
+/** A small painter: every method is a no-op when colour is disabled. */
+export class Painter {
+    enabled;
+    constructor(enabled = colorEnabled()) {
+        this.enabled = enabled;
+    }
+    fg(hex, text) {
+        if (!this.enabled) {
+            return text;
+        }
+        const [r, g, b] = hexToRgb(hex);
+        return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+    }
+    bg(hex, text) {
+        if (!this.enabled) {
+            return text;
+        }
+        const [r, g, b] = hexToRgb(hex);
+        return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+    }
+    bold(text) {
+        if (!this.enabled) {
+            return text;
+        }
+        return `\x1b[1m${text}\x1b[22m`;
+    }
+    dim(text) {
+        if (!this.enabled) {
+            return text;
+        }
+        return `\x1b[2m${text}\x1b[22m`;
+    }
+    italic(text) {
+        if (!this.enabled) {
+            return text;
+        }
+        return `\x1b[3m${text}\x1b[23m`;
+    }
+    underline(text) {
+        if (!this.enabled) {
+            return text;
+        }
+        return `\x1b[4m${text}\x1b[24m`;
+    }
+    primary(text) { return this.fg(PURPLE.primary, text); }
+    soft(text) { return this.fg(PURPLE.soft, text); }
+    deep(text) { return this.fg(PURPLE.deep, text); }
+    muted(text) { return this.fg(PURPLE.muted, text); }
+    dimmed(text) { return this.dim(this.fg(PURPLE.dim, text)); }
+    error(text) { return this.fg(PURPLE.error, text); }
+    ok(text) { return this.fg(PURPLE.ok, text); }
+    warn(text) { return this.fg(PURPLE.warn, text); }
+}
+export function stripAnsi(text) {
+    return text.replace(ANSI_PATTERN, '');
+}
+/** Terminal columns occupied by a string (CJK and emoji count double). */
+export function visibleWidth(text) {
+    let width = 0;
+    for (const char of stripAnsi(text)) {
+        width += charWidth(char);
+    }
+    return width;
+}
+export function charWidth(char) {
+    const code = char.codePointAt(0) ?? 0;
+    return isWide(code) ? 2 : 1;
+}
+/** Splits plain text into lines no wider than `width` terminal columns. */
+export function wrapText(text, width) {
+    if (width <= 4 || visibleWidth(text) <= width) {
+        return [text];
+    }
+    const lines = [];
+    let current = '';
+    let currentWidth = 0;
+    for (const char of text) {
+        const w = charWidth(char);
+        if (currentWidth + w > width && current.length > 0) {
+            lines.push(current);
+            current = '';
+            currentWidth = 0;
+        }
+        current += char;
+        currentWidth += w;
+    }
+    if (current.length > 0) {
+        lines.push(current);
+    }
+    return lines;
+}
+function isWide(code) {
+    return (code >= 0x1100 && code <= 0x115f)
+        || (code >= 0x2e80 && code <= 0xa4cf)
+        || (code >= 0xac00 && code <= 0xd7a3)
+        || (code >= 0xf900 && code <= 0xfaff)
+        || (code >= 0xfe30 && code <= 0xfe4f)
+        || (code >= 0xff00 && code <= 0xff60)
+        || (code >= 0xffe0 && code <= 0xffe6)
+        || (code >= 0x1f300 && code <= 0x1faff)
+        || (code >= 0x20000 && code <= 0x3fffd);
+}
+export function truncateVisible(text, max) {
+    if (visibleWidth(text) <= max) {
+        return text;
+    }
+    let out = '';
+    let width = 0;
+    for (const char of stripAnsi(text)) {
+        const code = char.codePointAt(0) ?? 0;
+        const w = isWide(code) ? 2 : 1;
+        if (width + w > max - 1) {
+            break;
+        }
+        out += char;
+        width += w;
+    }
+    return out + '…';
+}
+export function terminalWidth(fallback = 80) {
+    const columns = process.stdout.columns;
+    return typeof columns === 'number' && columns > 20 ? columns : fallback;
+}
+/** Text with an even two-column grid, used by the banner. */
+export function spaced(text, gap = ' ') {
+    return text.split('').join(gap);
+}

package/dist/ui/banner.js

@@ -0,0 +1,103 @@
+import { terminalWidth, visibleWidth } from "./ansi.js";
+import { mascotFrames, MASCOT_ROWS } from "./mascot.js";
+import { MASCOT_WIDTH } from "./mascotData.js";
+import { PURPLE } from "../theme.js";
+const GAP = '      ';
+const MIN_BOX = 36;
+const MAX_BOX = 72;
+export function bannerLines(painter, info, frame) {
+    const content = [
+        painter.bold(painter.soft('Minko')) + '  ' + painter.dimmed('v' + info.version),
+        '',
+        painter.primary(info.model),
+        painter.muted(info.cwd),
+    ];
+    const widest = content.reduce((max, line) => Math.max(max, visibleWidth(line)), 0);
+    const boxWidth = Math.min(MAX_BOX, Math.max(MIN_BOX, widest + 4));
+    const box = boxLines(painter, content, boxWidth);
+    if (!frame) {
+        return box.map((line) => '  ' + line);
+    }
+    const rows = Math.max(MASCOT_ROWS, box.length);
+    const padTop = Math.max(0, Math.floor((rows - box.length) / 2));
+    const lines = [];
+    for (let index = 0; index < rows; index += 1) {
+        const left = frame[index] ?? '';
+        const padded = left + ' '.repeat(Math.max(0, MASCOT_WIDTH - visibleWidth(left)));
+        const boxIndex = index - padTop;
+        const right = boxIndex >= 0 && boxIndex < box.length ? box[boxIndex] : '';
+        lines.push('  ' + padded + GAP + right);
+    }
+    return lines;
+}
+function boxLines(painter, content, width) {
+    const border = (text) => painter.fg(PURPLE.border, text);
+    const inner = width - 4;
+    const lines = [border('╭' + '─'.repeat(width - 2) + '╮')];
+    for (const line of content) {
+        const padding = ' '.repeat(Math.max(0, inner - visibleWidth(line)));
+        lines.push(border('│') + ' ' + line + padding + ' ' + border('│'));
+    }
+    lines.push(border('╰' + '─'.repeat(width - 2) + '╯'));
+    return lines;
+}
+/** Two-line header for terminals too short for the full welcome block. */
+export function compactBanner(painter, info) {
+    return [
+        '  ' + painter.bold(painter.soft('Minko')) + '  ' + painter.dimmed('v' + info.version)
+            + painter.dimmed('  ·  ' + info.model),
+        '',
+    ];
+}
+/** Draws the welcome block, animating the mascot in place when allowed. */
+export async function printBanner(painter, info) {
+    const animated = Boolean(process.stdout.isTTY) && painter.enabled
+        && process.env.MINKO_NO_ANIMATION !== '1';
+    const allowMascot = process.env.MINKO_MASCOT !== '0';
+    const frames = allowMascot && terminalWidth() >= MASCOT_WIDTH + 6
+        ? mascotFrames(painter)
+        : [];
+    const sideBySide = terminalWidth() - (MASCOT_WIDTH + GAP.length + 4) >= MIN_BOX;
+    const compose = (index) => {
+        if (frames.length === 0) {
+            return bannerLines(painter, info, null);
+        }
+        if (sideBySide) {
+            return bannerLines(painter, info, frames[index]);
+        }
+        return [...frames[index].map((line) => '  ' + line), '', ...bannerLines(painter, info, null)];
+    };
+    process.stdout.write('\n' + compose(0).join('\n') + '\n');
+    if (!animated || frames.length === 0) {
+        process.stdout.write('\n');
+        return;
+    }
+    const plan = [[1, 480], [2, 140], [3, 700], [4, 520]];
+    const rows = compose(0).length;
+    for (const [index, delay] of plan) {
+        if (index >= frames.length) {
+            continue;
+        }
+        await sleep(delay);
+        process.stdout.write('\x1b[' + rows + 'A');
+        for (const line of compose(index)) {
+            process.stdout.write('\x1b[2K' + line + '\n');
+        }
+    }
+    process.stdout.write('\n');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function formatTokens(value) {
+    if (value < 1000) {
+        return String(value);
+    }
+    return (value / 1000).toFixed(1) + 'k';
+}
+export function formatDuration(ms) {
+    if (ms < 1000) {
+        return ms + 'ms';
+    }
+    return (ms / 1000).toFixed(1) + 's';
+}

package/dist/ui/input.js

@@ -0,0 +1,49 @@
+/**
+ * Reads a line with echo disabled (API keys). Falls back to a normal question
+ * when stdin is not a TTY.
+ */
+export async function askHidden(rl, question) {
+    if (!process.stdin.isTTY) {
+        const answer = await rl.question(question);
+        return answer.trim();
+    }
+    rl.pause();
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    return await new Promise((resolve, reject) => {
+        let value = '';
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener('data', onData);
+            rl.resume();
+        };
+        const onData = (chunk) => {
+            const text = chunk.toString('utf8');
+            for (const char of text) {
+                if (char === '\r' || char === '\n') {
+                    cleanup();
+                    process.stdout.write('\n');
+                    resolve(value);
+                    return;
+                }
+                if (char === '\u0003') {
+                    cleanup();
+                    process.stdout.write('\n');
+                    reject(new Error('已取消'));
+                    return;
+                }
+                if (char === '\u007f' || char === '\b') {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                if (char >= ' ') {
+                    value += char;
+                }
+            }
+        };
+        stdin.on('data', onData);
+    });
+}

package/dist/ui/inputModel.js

@@ -0,0 +1,113 @@
+import { visibleWidth } from "./ansi.js";
+/** Editable single-line input with a char-level cursor and history. */
+export class InputModel {
+    chars = [];
+    cursor = 0;
+    history = [];
+    historyIndex = -1;
+    draft = '';
+    get text() {
+        return this.chars.join('');
+    }
+    get empty() {
+        return this.chars.length === 0;
+    }
+    setText(text) {
+        this.chars = Array.from(text.replace(/\r\n?/g, '\n'));
+        this.cursor = this.chars.length;
+    }
+    insert(text) {
+        const incoming = Array.from(text.replace(/\r\n?/g, '\n'));
+        this.chars.splice(this.cursor, 0, ...incoming);
+        this.cursor += incoming.length;
+    }
+    backspace() {
+        if (this.cursor === 0) {
+            return;
+        }
+        this.chars.splice(this.cursor - 1, 1);
+        this.cursor -= 1;
+    }
+    deleteForward() {
+        if (this.cursor >= this.chars.length) {
+            return;
+        }
+        this.chars.splice(this.cursor, 1);
+    }
+    move(delta) {
+        this.cursor = Math.max(0, Math.min(this.chars.length, this.cursor + delta));
+    }
+    home() { this.cursor = 0; }
+    end() { this.cursor = this.chars.length; }
+    clear() {
+        this.chars = [];
+        this.cursor = 0;
+        this.historyIndex = -1;
+    }
+    remember() {
+        const value = this.text.trim();
+        if (value.length === 0) {
+            return;
+        }
+        if (this.history[this.history.length - 1] !== value) {
+            this.history.push(value);
+        }
+        this.historyIndex = -1;
+        this.draft = '';
+    }
+    previous() {
+        if (this.history.length === 0) {
+            return;
+        }
+        if (this.historyIndex === -1) {
+            this.draft = this.text;
+            this.historyIndex = this.history.length - 1;
+        }
+        else if (this.historyIndex > 0) {
+            this.historyIndex -= 1;
+        }
+        this.setText(this.history[this.historyIndex]);
+    }
+    next() {
+        if (this.historyIndex === -1) {
+            return;
+        }
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex += 1;
+            this.setText(this.history[this.historyIndex]);
+            return;
+        }
+        this.historyIndex = -1;
+        this.setText(this.draft);
+    }
+}
+/** Wraps the input text and reports where the caret sits inside it. */
+export function wrapInput(text, caret, width) {
+    if (width < 4) {
+        return { lines: [text], row: 0, column: caret };
+    }
+    const chars = Array.from(text);
+    const lines = [''];
+    const widths = [0];
+    let caretRow = 0;
+    let caretColumn = 0;
+    for (let index = 0; index <= chars.length; index += 1) {
+        if (index === caret) {
+            caretRow = lines.length - 1;
+            caretColumn = widths[widths.length - 1];
+        }
+        if (index === chars.length) {
+            break;
+        }
+        const char = chars[index];
+        const charWidth = visibleWidth(char);
+        const last = lines.length - 1;
+        if (widths[last] + charWidth > width && lines[last].length > 0) {
+            lines.push('');
+            widths.push(0);
+        }
+        lines[lines.length - 1] += char;
+        widths[widths.length - 1] += charWidth;
+    }
+    return { lines, row: caretRow, column: caretColumn };
+}

package/dist/ui/keyboard.js

@@ -0,0 +1,142 @@
+const SEQUENCES = [
+    ['\x1b[A', { type: 'up' }],
+    ['\x1b[B', { type: 'down' }],
+    ['\x1b[C', { type: 'right' }],
+    ['\x1b[D', { type: 'left' }],
+    ['\x1b[H', { type: 'home' }],
+    ['\x1b[F', { type: 'end' }],
+    ['\x1b[1~', { type: 'home' }],
+    ['\x1b[4~', { type: 'end' }],
+    ['\x1b[5~', { type: 'pageup' }],
+    ['\x1b[6~', { type: 'pagedown' }],
+    ['\x1b[3~', { type: 'delete' }],
+    ['\x1b[2~', { type: 'tab' }],
+    ['\x1bOA', { type: 'up' }],
+    ['\x1bOB', { type: 'down' }],
+    ['\x1bOC', { type: 'right' }],
+    ['\x1bOD', { type: 'left' }],
+];
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** Turns raw terminal chunks into key presses, tolerating split sequences. */
+export class KeyParser {
+    buffer = '';
+    push(chunk) {
+        this.buffer += chunk;
+        const keys = [];
+        for (;;) {
+            if (this.buffer.length === 0) {
+                break;
+            }
+            if (this.buffer.startsWith(PASTE_START)) {
+                const end = this.buffer.indexOf(PASTE_END, PASTE_START.length);
+                if (end < 0) {
+                    break;
+                }
+                keys.push({ type: 'paste', text: this.buffer.slice(PASTE_START.length, end) });
+                this.buffer = this.buffer.slice(end + PASTE_END.length);
+                continue;
+            }
+            if (this.buffer.startsWith('\x1b[<')) {
+                const match = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(this.buffer);
+                if (!match) {
+                    break;
+                }
+                this.buffer = this.buffer.slice(match[0].length);
+                const button = Number(match[1]);
+                const row = Number(match[3]);
+                const col = Number(match[2]);
+                if (button === 64) {
+                    keys.push({ type: 'wheel', delta: 3 });
+                }
+                else if (button === 65) {
+                    keys.push({ type: 'wheel', delta: -3 });
+                }
+                else if (match[4] === 'm') {
+                    keys.push({ type: 'mouse', kind: 'up', row, col });
+                }
+                else if (button === 0) {
+                    keys.push({ type: 'mouse', kind: 'down', row, col });
+                }
+                else if (button === 32) {
+                    keys.push({ type: 'mouse', kind: 'drag', row, col });
+                }
+                continue;
+            }
+            if (this.buffer.startsWith('\x1b[M')) {
+                if (this.buffer.length < 6) {
+                    break;
+                }
+                this.buffer = this.buffer.slice(6);
+                continue;
+            }
+            let matched = false;
+            for (const [sequence, key] of SEQUENCES) {
+                if (this.buffer.startsWith(sequence)) {
+                    keys.push(key);
+                    this.buffer = this.buffer.slice(sequence.length);
+                    matched = true;
+                    break;
+                }
+            }
+            if (matched) {
+                continue;
+            }
+            if (this.buffer.startsWith('\x1b')) {
+                if (this.buffer.length < 3 && /^\x1b(\[<?|\[<|O)?$/.test(this.buffer)) {
+                    break;
+                }
+                keys.push({ type: 'escape' });
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+            const char = this.buffer[0];
+            const code = char.charCodeAt(0);
+            if (char === '\r' || char === '\n') {
+                keys.push({ type: 'enter' });
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+            if (code === 0x7f || code === 0x08) {
+                keys.push({ type: 'backspace' });
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+            if (code === 9) {
+                keys.push({ type: 'tab' });
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+            if (code > 0 && code < 32) {
+                keys.push({ type: 'ctrl', key: String.fromCharCode(96 + code) });
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+            let end = 0;
+            while (end < this.buffer.length) {
+                const value = this.buffer.charCodeAt(end);
+                if (value < 32 || value === 0x7f) {
+                    break;
+                }
+                end += 1;
+            }
+            if (end === 0) {
+                break;
+            }
+            keys.push({ type: 'text', text: this.buffer.slice(0, end) });
+            this.buffer = this.buffer.slice(end);
+        }
+        return keys;
+    }
+    /** Called on a timer so a lone ESC arrives without waiting for more bytes. */
+    flush() {
+        if (this.buffer === '\x1b') {
+            this.buffer = '';
+            return [{ type: 'escape' }];
+        }
+        return [];
+    }
+    get pending() {
+        return this.buffer;
+    }
+}

package/dist/ui/mascot.js

@@ -0,0 +1,34 @@
+import { MASCOT_FRAMES, MASCOT_HEIGHT, MASCOT_WIDTH } from "./mascotData.js";
+/** Half blocks pack two pixel rows into one terminal row. */
+export const MASCOT_ROWS = Math.ceil(MASCOT_HEIGHT / 2);
+export function renderMascot(grid, painter) {
+    const lines = [];
+    for (let row = 0; row < MASCOT_HEIGHT; row += 2) {
+        let line = '';
+        for (let col = 0; col < MASCOT_WIDTH; col += 1) {
+            const top = grid[row]?.[col] ?? null;
+            const bottom = grid[row + 1]?.[col] ?? null;
+            if (top !== null && bottom !== null) {
+                line += top === bottom
+                    ? painter.fg(top, '█')
+                    : painter.fg(top, painter.bg(bottom, '▀'));
+            }
+            else if (top !== null) {
+                line += painter.fg(top, '▀');
+            }
+            else if (bottom !== null) {
+                line += painter.fg(bottom, '▄');
+            }
+            else {
+                line += ' ';
+            }
+        }
+        lines.push(line);
+    }
+    return lines;
+}
+/** All animation frames rendered for the given painter. */
+export function mascotFrames(painter) {
+    return MASCOT_FRAMES.map((grid) => renderMascot(grid, painter));
+}
+export const MASCOT_FRAME_NAMES = ['open', 'blink', 'open', 'bob', 'open'];