agent-tempo 1.0.1

package/dist/tui/utils/platform.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Platform detection utilities for the TUI.
+ * Determines Unicode support, SSH sessions, and terminal capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_ROWS = exports.MIN_COLUMNS = void 0;
+exports.supportsUnicode = supportsUnicode;
+exports.isSSH = isSSH;
+exports.getTerminalSize = getTerminalSize;
+exports.isTerminalLargeEnough = isTerminalLargeEnough;
+exports.statusIcons = statusIcons;
+exports.metronomeBrailleFrames = metronomeBrailleFrames;
+/** Whether the terminal supports Unicode box-drawing and status icons. */
+function supportsUnicode() {
+    // Windows Terminal and modern terminals support Unicode
+    if (process.env.WT_SESSION)
+        return true;
+    // SSH sessions may have limited support
+    if (isSSH())
+        return false;
+    // Check LANG/LC_ALL for UTF-8
+    const lang = process.env.LANG || process.env.LC_ALL || '';
+    if (/utf-?8/i.test(lang))
+        return true;
+    // macOS default terminal supports Unicode
+    if (process.platform === 'darwin')
+        return true;
+    // Default: assume Unicode on modern systems
+    return process.platform !== 'win32' || !!process.env.WT_SESSION;
+}
+/** Whether we're running inside an SSH session. */
+function isSSH() {
+    return !!(process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION);
+}
+/** Get terminal dimensions, with minimum fallback. */
+function getTerminalSize() {
+    const columns = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    return { columns, rows };
+}
+/** Minimum terminal size for the TUI. */
+exports.MIN_COLUMNS = 80;
+exports.MIN_ROWS = 24;
+/** Check if terminal meets minimum size requirements. */
+function isTerminalLargeEnough() {
+    const { columns, rows } = getTerminalSize();
+    return columns >= exports.MIN_COLUMNS && rows >= exports.MIN_ROWS;
+}
+/** Status icons — Unicode by default, ASCII fallback. */
+function statusIcons(unicode = supportsUnicode()) {
+    if (unicode) {
+        return {
+            active: '\u25CF', // ●
+            stale: '\u25CB', // ○
+            pending: '\u25D4', // ◔
+            blocked: '\u25D0', // ◐
+            terminated: '\u2715', // ✕
+            conductor: '\u2605', // ★
+            player: '\u2022', // •
+            arrow: '\u2192', // →
+            check: '\u2714', // ✔
+            cross: '\u2718', // ✘
+            ellipsis: '\u2026', // …
+        };
+    }
+    return {
+        active: '*',
+        stale: 'o',
+        pending: '~',
+        blocked: '!',
+        terminated: 'x',
+        conductor: '#',
+        player: '-',
+        arrow: '->',
+        check: '+',
+        cross: 'x',
+        ellipsis: '...',
+    };
+}
+// ── Pixel Art Metronome ──
+// ── Braille Rendering ──
+/**
+ * Braille dot matrix bit positions.
+ * Each character = 2 cols × 4 rows of dots.
+ * Bit layout: col0=[0,1,2,6], col1=[3,4,5,7]
+ */
+const BRAILLE_BASE = 0x2800;
+const BRAILLE_DOTS = [
+    [0, 0], // bit 0: row 0, col 0
+    [1, 0], // bit 1: row 1, col 0
+    [2, 0], // bit 2: row 2, col 0
+    [0, 1], // bit 3: row 0, col 1
+    [1, 1], // bit 4: row 1, col 1
+    [2, 1], // bit 5: row 2, col 1
+    [3, 0], // bit 6: row 3, col 0
+    [3, 1], // bit 7: row 3, col 1
+];
+/**
+ * Braille dot canvas — plot dots at high resolution, encode to braille characters.
+ * Each character cell = 2 dots wide × 4 dots tall.
+ */
+class BrailleCanvas {
+    /** Dot grid: dotRows × dotCols, each cell stores a color tag or 0 (empty). */
+    dots;
+    /** Character grid dimensions. */
+    charCols;
+    charRows;
+    /** Dot grid dimensions. */
+    dotCols;
+    dotRows;
+    /** Color tags: 1 = triangle (cream), 2 = arm/pivot (terracotta). */
+    static TRIANGLE = 1;
+    static ARM = 2;
+    constructor(charCols, charRows) {
+        this.charCols = charCols;
+        this.charRows = charRows;
+        this.dotCols = charCols * 2;
+        this.dotRows = charRows * 4;
+        this.dots = Array.from({ length: this.dotRows }, () => Array(this.dotCols).fill(0));
+    }
+    /** Set a dot at (x, y) in dot coordinates. */
+    set(x, y, color) {
+        if (x >= 0 && x < this.dotCols && y >= 0 && y < this.dotRows) {
+            this.dots[y][x] = color;
+        }
+    }
+    /** Draw a line using Bresenham's algorithm. */
+    line(x0, y0, x1, y1, color) {
+        const dx = Math.abs(x1 - x0);
+        const dy = Math.abs(y1 - y0);
+        const sx = x0 < x1 ? 1 : -1;
+        const sy = y0 < y1 ? 1 : -1;
+        let err = dx - dy;
+        let cx = x0, cy = y0;
+        while (true) {
+            this.set(cx, cy, color);
+            if (cx === x1 && cy === y1)
+                break;
+            const e2 = 2 * err;
+            if (e2 > -dy) {
+                err -= dy;
+                cx += sx;
+            }
+            if (e2 < dx) {
+                err += dx;
+                cy += sy;
+            }
+        }
+    }
+    /** Draw a filled circle. */
+    circle(cx, cy, r, color) {
+        for (let y = cy - r; y <= cy + r; y++) {
+            for (let x = cx - r; x <= cx + r; x++) {
+                if ((x - cx) * (x - cx) + (y - cy) * (y - cy) <= r * r) {
+                    this.set(x, y, color);
+                }
+            }
+        }
+    }
+    /**
+     * Encode the canvas to braille character lines with color segments.
+     * For cells with mixed colors (triangle + arm overlap), arm wins (accent).
+     */
+    render() {
+        const COLORS = {
+            [BrailleCanvas.TRIANGLE]: '#FAF3EE',
+            [BrailleCanvas.ARM]: '#E07A5F',
+        };
+        const lines = [];
+        for (let cr = 0; cr < this.charRows; cr++) {
+            const segments = [];
+            let buf = '';
+            let bufColor = '';
+            for (let cc = 0; cc < this.charCols; cc++) {
+                let code = BRAILLE_BASE;
+                let cellColor = 0; // dominant color in this cell
+                for (let bit = 0; bit < 8; bit++) {
+                    const [dr, dc] = BRAILLE_DOTS[bit];
+                    const dotY = cr * 4 + dr;
+                    const dotX = cc * 2 + dc;
+                    const val = this.dots[dotY]?.[dotX] || 0;
+                    if (val) {
+                        code |= (1 << bit);
+                        // Arm/pivot wins over triangle for color priority
+                        if (val === BrailleCanvas.ARM || cellColor === 0) {
+                            cellColor = val;
+                        }
+                    }
+                }
+                const char = code === BRAILLE_BASE ? ' ' : String.fromCharCode(code);
+                const color = cellColor ? (COLORS[cellColor] || '') : '';
+                if (color === bufColor) {
+                    buf += char;
+                }
+                else {
+                    if (buf)
+                        segments.push({ char: buf, color: bufColor });
+                    buf = char;
+                    bufColor = color;
+                }
+            }
+            if (buf)
+                segments.push({ char: buf, color: bufColor });
+            lines.push(segments);
+        }
+        return lines;
+    }
+}
+/**
+ * Braille metronome — 3 frames (left, center, right).
+ * Renders at 60×48 dot resolution (30 cols × 12 rows of braille characters).
+ * Thin hairline triangle outline with thin pendulum arm and small pivot dot.
+ */
+function metronomeBrailleFrames() {
+    // ASCII fallback for terminals without Unicode support
+    if (!supportsUnicode()) {
+        const asciiFrame = [
+            [{ char: '  agent-tempo', color: 'cyan' }],
+        ];
+        return [asciiFrame, asciiFrame, asciiFrame];
+    }
+    const COLS = 30;
+    const ROWS = 12;
+    // SVG: viewport 64×64, triangle apex(32,8)→bl(14,54)→br(50,54), pivot(32,46)
+    // Dot resolution: 60×48
+    // Scale: x * 60/64 ≈ x * 0.9375, y * 48/64 = y * 0.75
+    const apex = { x: 30, y: 6 };
+    const bl = { x: 13, y: 40 };
+    const br = { x: 47, y: 40 };
+    const pivot = { x: 30, y: 34 };
+    // Pendulum tips — extend above apex
+    const tips = [
+        { x: 18, y: 1 }, // left
+        { x: 30, y: 1 }, // center
+        { x: 42, y: 1 }, // right
+    ];
+    function buildFrame(tipIdx) {
+        const canvas = new BrailleCanvas(COLS, ROWS);
+        const T = BrailleCanvas.TRIANGLE;
+        const A = BrailleCanvas.ARM;
+        // Draw triangle outline (thin hairlines)
+        canvas.line(apex.x, apex.y, bl.x, bl.y, T);
+        canvas.line(apex.x, apex.y, br.x, br.y, T);
+        canvas.line(bl.x, bl.y, br.x, br.y, T);
+        // Draw pendulum arm (thin line, draws over triangle where they cross)
+        const tip = tips[tipIdx];
+        canvas.line(pivot.x, pivot.y, tip.x, tip.y, A);
+        // Draw pivot dot
+        canvas.circle(pivot.x, pivot.y, 2, A);
+        return canvas.render();
+    }
+    return [
+        buildFrame(0), // left
+        buildFrame(1), // center
+        buildFrame(2), // right
+    ];
+}

package/dist/tui/utils/theme.d.ts

@@ -0,0 +1,21 @@
+/**
+ * TUI color theme constants.
+ * Used by all TUI components for consistent styling.
+ * Respects NO_COLOR (https://no-color.org/) — all colors become undefined.
+ */
+declare const COLORS: {
+    bg: string;
+    bgTitle: string;
+    border: string;
+    muted: string;
+    dim: string;
+    text: string;
+    textMuted: string;
+    accent: string;
+    success: string;
+    warning: string;
+    error: string;
+    inputBg: string;
+};
+export declare const THEME: typeof COLORS;
+export {};

package/dist/tui/utils/theme.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * TUI color theme constants.
+ * Used by all TUI components for consistent styling.
+ * Respects NO_COLOR (https://no-color.org/) — all colors become undefined.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEME = void 0;
+const COLORS = {
+    bg: '#0A0E12',
+    bgTitle: '#141820',
+    border: '#2A3140',
+    muted: '#3D4555',
+    dim: '#6B7280',
+    text: '#FAF3EE',
+    textMuted: '#9CA3AF',
+    accent: '#E07A5F', // terracotta
+    success: '#81C784',
+    warning: '#F2CC8F',
+    error: '#EF5350',
+    inputBg: '#1A1F28',
+};
+const MONO = Object.fromEntries(Object.keys(COLORS).map(k => [k, undefined]));
+exports.THEME = process.env.NO_COLOR ? MONO : COLORS;