@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/tui/term.js

@@ -0,0 +1,309 @@
+/**
+ * Low-level terminal handling: raw mode, ANSI key parser, bracketed paste,
+ * resize, alt-screen, and basic escape sequences.
+ *
+ * Uses no native deps; Termux-compatible.
+ */
+import { createInterface } from 'node:readline';
+import process from 'node:process';
+let rawModeOn = false;
+let rlInterface = null;
+let rlPaused = false;
+const keyListeners = new Set();
+const resizeListeners = new Set();
+let _termSize = [process.stdout.columns || 80, process.stdout.rows || 24];
+let keyBuffer = '';
+let pasteBuffer = '';
+let inPaste = false;
+let escapeTimer = null;
+// ---------------------------------------------------------------------------
+// Resize
+// ---------------------------------------------------------------------------
+function handleResize() {
+    _termSize = [process.stdout.columns || 80, process.stdout.rows || 24];
+    for (const l of resizeListeners)
+        l();
+}
+// ---------------------------------------------------------------------------
+// Raw mode
+// ---------------------------------------------------------------------------
+export function setup() {
+    if (rawModeOn)
+        return;
+    rawModeOn = true;
+    // Save state
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    process.stdout.write('\x1b[?1049h'); // enter alt screen
+    process.stdout.write('\x1b[?25l'); // hide cursor
+    process.stdout.write('\x1b[?2004h'); // bracketed paste on
+    process.stdout.write('\x1b[?7l'); // disable line wrapping
+    process.stdout.write('\x1b[?12h'); // blinking cursor off
+    _termSize = [process.stdout.columns || 80, process.stdout.rows || 24];
+    process.stdin.resume();
+    rlInterface = createInterface({ input: process.stdin, terminal: true });
+    rlInterface.on('line', () => { }); // drain
+    process.stdin.on('data', onData);
+    process.on('SIGWINCH', handleResize);
+}
+export function teardown() {
+    if (!rawModeOn)
+        return;
+    rawModeOn = false;
+    if (escapeTimer) {
+        clearTimeout(escapeTimer);
+        escapeTimer = null;
+    }
+    process.stdout.write('\x1b[?2004l'); // bracketed paste off
+    process.stdout.write('\x1b[?25h'); // show cursor
+    process.stdout.write('\x1b[?1049l'); // alt screen off
+    process.stdout.write('\x1b[?7h'); // re-enable line wrapping
+    process.stdout.write('\x1b[?12l'); // blinking cursor normal
+    if (rlInterface) {
+        rlInterface.close();
+        rlInterface = null;
+    }
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdin.removeListener('data', onData);
+    process.removeListener('SIGWINCH', handleResize);
+}
+export function onKey(cb) {
+    keyListeners.add(cb);
+    return () => { keyListeners.delete(cb); };
+}
+export function onResize(cb) {
+    resizeListeners.add(cb);
+    return () => { resizeListeners.delete(cb); };
+}
+export function termSize() {
+    return _termSize;
+}
+export function columns() { return _termSize[0]; }
+export function rows() { return _termSize[1]; }
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+export function write(s) {
+    process.stdout.write(s);
+}
+export function writeRaw(bytes) {
+    process.stdout.write(bytes);
+}
+export function moveCursorTo(col, row) {
+    process.stdout.write(`\x1b[${row + 1};${col + 1}H`);
+}
+export function hideCursor() { process.stdout.write('\x1b[?25l'); }
+export function showCursor() { process.stdout.write('\x1b[?25h'); }
+export function eraseLine() { process.stdout.write('\x1b[2K'); }
+export function eraseBelow() { process.stdout.write('\x1b[J'); }
+export function eraseAbove() { process.stdout.write('\x1b[1J'); }
+export function eraseRegion(col, row, len) {
+    moveCursorTo(col, row);
+    process.stdout.write('\x1b[2K');
+    moveCursorTo(col, row);
+    process.stdout.write(' '.repeat(len));
+    moveCursorTo(col, row);
+}
+export function saveCursor() { process.stdout.write('\x1b[s'); }
+export function restoreCursor() { process.stdout.write('\x1b[u'); }
+export function alternateScreen() {
+    process.stdout.write('\x1b[?1049h');
+}
+export function mainScreen() {
+    process.stdout.write('\x1b[?1049l');
+}
+export function setScrollRegion(top, bottom) {
+    // top and bottom are 1-indexed row numbers.
+    process.stdout.write(`\x1b[${top};${bottom}r`);
+}
+export function clearScrollRegion() {
+    process.stdout.write('\x1b[r');
+}
+export function scrollUp(lines) {
+    process.stdout.write(`\x1b[${lines}S`);
+}
+export function scrollDown(lines) {
+    process.stdout.write(`\x1b[${lines}T`);
+}
+export function setRgbColor(fg, bg) {
+    if (fg)
+        process.stdout.write(fg);
+    if (bg)
+        process.stdout.write(bg);
+}
+export function resetColor() {
+    process.stdout.write('\x1b[0m');
+}
+// ---------------------------------------------------------------------------
+// Key parser
+// ---------------------------------------------------------------------------
+function onData(data) {
+    keyBuffer += data.toString('utf8');
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const result = tryParseKey(keyBuffer);
+        if (result.consumed > 0) {
+            keyBuffer = keyBuffer.slice(result.consumed);
+            changed = true;
+            if (result.key)
+                emitKey(result.key);
+        }
+    }
+    if (escapeTimer && keyBuffer !== '\x1b') {
+        // The leading ESC got consumed as part of a sequence; drop any pending
+        // lone-ESC timer.
+        clearTimeout(escapeTimer);
+        escapeTimer = null;
+    }
+}
+function tryParseKey(buf) {
+    if (buf.length === 0)
+        return { consumed: 0, key: null };
+    // Start bracketed paste
+    if (buf.startsWith('\x1b[200~')) {
+        inPaste = true;
+        pasteBuffer = '';
+        return { consumed: 6, key: null };
+    }
+    // End bracketed paste
+    if (inPaste) {
+        const end = buf.indexOf('\x1b[201~');
+        if (end === -1) {
+            // accumulate — don't emit yet
+            return { consumed: buf.length, key: null };
+        }
+        const text = buf.slice(0, end);
+        inPaste = false;
+        pasteBuffer = '';
+        return { consumed: end + 5, key: { name: 'paste', value: text, raw: text, paste: true } };
+    }
+    if (buf.startsWith('\x1b')) {
+        return tryParseEscape(buf);
+    }
+    // Control character (byte < 0x20 except ESC)
+    const c = buf.charCodeAt(0);
+    if (c < 0x20) {
+        return tryParseControl(buf);
+    }
+    // Printable character
+    const ch = buf[0];
+    return { consumed: 1, key: { name: 'char', value: ch, raw: ch } };
+}
+function tryParseEscape(buf) {
+    if (buf === '\x1b') {
+        // A bare ESC is ambiguous until more bytes arrive (it could be the prefix
+        // of a CSI/OSC sequence). Wait a beat; if nothing follows, treat it as the
+        // Escape key.
+        scheduleEscape();
+        return { consumed: 0, key: null }; // partial
+    }
+    const c2 = buf[1] ?? '';
+    if (c2 === 'O') {
+        // ESC O x
+        if (buf.length < 3)
+            return { consumed: 0, key: null };
+        const x = buf[2];
+        const map = { H: 'home', F: 'end', P: 'f1', Q: 'f2', R: 'f3', S: 'f4' };
+        if (map[x])
+            return { consumed: 3, key: { name: map[x], value: '', raw: buf.slice(0, 3) } };
+        return { consumed: 3, key: { name: 'char', value: buf.slice(2, 3), raw: buf.slice(0, 3) } };
+    }
+    if (c2 === '[') {
+        if (buf.length < 3)
+            return { consumed: 0, key: null };
+        const third = buf[2];
+        // Sequence: ESC [ <params> <final>
+        let endIdx = 2;
+        while (endIdx < buf.length && (buf.charCodeAt(endIdx) >= 0x30 && buf.charCodeAt(endIdx) <= 0x3f))
+            endIdx++;
+        if (endIdx >= buf.length)
+            return { consumed: 0, key: null }; // partial params
+        const final = buf[endIdx];
+        const params = buf.slice(3, endIdx);
+        return { consumed: endIdx + 1, key: mapCSI(params, final, buf.slice(0, endIdx + 1)) };
+    }
+    // Alt + char
+    const ch = buf[1];
+    return { consumed: 2, key: { name: 'alt-' + ch, value: ch, raw: buf.slice(0, 2) } };
+}
+function mapCSI(params, final, raw) {
+    const num = parseInt(params, 10) || 0;
+    switch (final) {
+        case 'A': return { name: 'up', value: '', raw };
+        case 'B': return { name: 'down', value: '', raw };
+        case 'C': return { name: 'right', value: '', raw };
+        case 'D': return { name: 'left', value: '', raw };
+        case 'H': return { name: 'home', value: '', raw };
+        case 'F': return { name: 'end', value: '', raw };
+        case 'Z': return { name: 'shift-tab', value: '', raw };
+        case '~': {
+            const map = { 1: 'home', 2: 'insert', 3: 'delete', 4: 'end', 5: 'pageup', 6: 'pagedown' };
+            return { name: map[num] ?? 'unknown-' + num, value: '', raw };
+        }
+        case 'C': return { name: 'right', value: '', raw };
+        case 'D': return { name: 'left', value: '', raw };
+        case 'M': {
+            // mouse — ignore for now
+            return { name: 'mouse', value: '', raw };
+        }
+        default:
+            if (params.startsWith('1;5')) {
+                const ctrlMap = { C: 'ctrl-right', D: 'ctrl-left', H: 'ctrl-home', F: 'ctrl-end' };
+                return { name: ctrlMap[final] ?? 'ctrl-' + final, value: '', raw };
+            }
+            if (params.startsWith('27;')) {
+                // ESC [ 27;mod;code ~ — virtual keys (Shift+Enter etc)
+                const parts = params.split(';');
+                const code = parseInt(parts[2] ?? '', 10);
+                if (code === 13)
+                    return { name: 'enter', value: '', raw };
+            }
+            return { name: 'unknown', value: final, raw };
+    }
+}
+function tryParseControl(buf) {
+    const c = buf.charCodeAt(0);
+    if (c === 0x0a || c === 0x0d || c === 0x24) {
+        return { consumed: 1, key: { name: 'enter', value: '', raw: buf.slice(0, 1) } };
+    }
+    if (c === 0x03)
+        return { consumed: 1, key: { name: 'ctrl-c', value: '', raw: '\x03' } };
+    if (c === 0x04)
+        return { consumed: 1, key: { name: 'ctrl-d', value: '', raw: '\x04' } };
+    if (c === 0x08 || c === 0x7f)
+        return { consumed: 1, key: { name: 'backspace', value: '', raw: buf.slice(0, 1) } };
+    if (c === 0x09)
+        return { consumed: 1, key: { name: 'tab', value: '', raw: '\t' } };
+    if (c === 0x1b)
+        return tryParseEscape(buf);
+    if (c >= 0x01 && c <= 0x1a) {
+        // map a-z control
+        const letter = String.fromCharCode(0x60 + c);
+        return { consumed: 1, key: { name: 'ctrl-' + letter, value: '', raw: buf.slice(0, 1) } };
+    }
+    return { consumed: 1, key: { name: 'char', value: buf[0], raw: buf.slice(0, 1) } };
+}
+function emitKey(key) {
+    for (const l of keyListeners)
+        l(key);
+}
+function scheduleEscape() {
+    if (escapeTimer)
+        return;
+    escapeTimer = setTimeout(() => {
+        escapeTimer = null;
+        if (keyBuffer === '\x1b') {
+            keyBuffer = '';
+            emitKey({ name: 'escape', value: '', raw: '\x1b' });
+        }
+    }, 45);
+}
+export function flushKeyBuffer() {
+    if (keyBuffer.length > 0) {
+        emitKey({ name: 'char', value: keyBuffer, raw: keyBuffer });
+        keyBuffer = '';
+    }
+}

package/dist/src/tui/text.js

@@ -0,0 +1,104 @@
+import stringWidth from 'string-width';
+import stripAnsi from 'strip-ansi';
+/**
+ * ANSI-aware text math helpers used across the UI.
+ */
+export { stringWidth };
+export function width(s) {
+    return stringWidth(s);
+}
+export function strip(s) {
+    return stripAnsi(s);
+}
+/**
+ * Word-wrap plain or ANSI text to a given width, splitting long words.
+ * Returns an array of visual lines (each within `width` columns).
+ */
+export function wrapText(text, maxWidth) {
+    if (maxWidth <= 0)
+        return [''];
+    const lines = [];
+    for (const rawLine of text.split('\n')) {
+        if (width(rawLine) <= maxWidth) {
+            lines.push(rawLine);
+            continue;
+        }
+        const words = rawLine.split(/(\s+)/);
+        let current = '';
+        for (const word of words) {
+            const proposed = current === '' ? word : current + word;
+            if (width(proposed) <= maxWidth) {
+                current = proposed;
+                continue;
+            }
+            if (current !== '') {
+                lines.push(current);
+                current = '';
+            }
+            // break the word itself if too long
+            if (width(word) > maxWidth) {
+                let chunk = '';
+                for (const char of Array.from(word)) {
+                    if (width(chunk + char) > maxWidth) {
+                        lines.push(chunk);
+                        chunk = char;
+                    }
+                    else {
+                        chunk += char;
+                    }
+                }
+                current = chunk;
+            }
+            else {
+                current = word;
+            }
+        }
+        lines.push(current);
+    }
+    return lines;
+}
+/**
+ * Truncate to a visual width, appending an ellipsis marker when cut.
+ * ANSI sequences in input are preserved (kept at the edges of the result).
+ */
+export function truncate(text, maxWidth, marker = '…') {
+    if (maxWidth <= 0)
+        return marker;
+    const raw = strip(text);
+    if (stringWidth(raw) <= maxWidth)
+        return text;
+    // Truncate the raw string, then re-apply leading ANSI styles from the input.
+    const ansiPrefix = text.match(/^\x1b\[[0-9;]*m/)?.[0] ?? '';
+    const tail = marker;
+    const bodyWidth = Math.max(0, maxWidth - stringWidth(tail));
+    let out = '';
+    const chars = Array.from(raw);
+    for (const ch of chars) {
+        if (stringWidth(out) + stringWidth(ch) > bodyWidth)
+            break;
+        out += ch;
+    }
+    return `${ansiPrefix}${out}${tail}`;
+}
+/** Pad a string (visually) so the styled text occupies exactly `width` cols. */
+export function padRight(s, totalWidth, fill = ' ') {
+    const w = stringWidth(strip(s));
+    const pad = Math.max(0, totalWidth - w);
+    return s + fill.repeat(pad);
+}
+/** Measure a string but map it to a character-index-safe cursor offset. */
+export function indexAtWidth(text, targetWidth) {
+    let w = 0;
+    let i = 0;
+    for (const ch of Array.from(text)) {
+        if (w + stringWidth(ch) > targetWidth)
+            break;
+        w += stringWidth(ch);
+        i += ch.length;
+    }
+    return i;
+}
+/** Count visible characters before (and including) a byte index. */
+export function visibleLength(text) {
+    return stringWidth(strip(text));
+}

package/dist/src/tui/themes/index.js

@@ -0,0 +1,15 @@
+import { PALETTES } from './palettes.js';
+import { buildTheme, rgbToInt } from '../style.js';
+export { PALETTES, buildTheme, rgbToInt };
+export const THEME_NAMES = [
+    'tokyonight',
+    'catppuccin-mocha',
+    'catppuccin-latte',
+    'nord',
+    'gruvbox',
+    'monokai',
+    'clean-dark',
+];
+export function makeTheme(name) {
+    return buildTheme(name);
+}

package/dist/src/tui/themes/palettes.js

@@ -0,0 +1,137 @@
+import { rgbToInt } from '../style.js';
+const c = rgbToInt;
+export const PALETTES = {
+    tokyonight: {
+        bg: c(26, 27, 38),
+        text: c(192, 202, 245),
+        muted: c(86, 95, 137),
+        dim: c(59, 66, 97),
+        accent: c(122, 162, 247),
+        secondary: c(187, 154, 247),
+        success: c(158, 206, 106),
+        warning: c(224, 175, 104),
+        danger: c(247, 118, 142),
+        info: c(125, 207, 255),
+        border: c(47, 52, 87),
+        borderBright: c(59, 66, 97),
+        selection: c(51, 70, 124),
+        codeBg: c(22, 22, 30),
+        codeText: c(169, 177, 214),
+        prompt: c(122, 162, 247),
+        line: c(86, 95, 137),
+    },
+    'catppuccin-mocha': {
+        bg: c(30, 30, 46),
+        text: c(205, 214, 244),
+        muted: c(127, 132, 156),
+        dim: c(49, 50, 68),
+        accent: c(137, 180, 250),
+        secondary: c(203, 166, 247),
+        success: c(166, 227, 161),
+        warning: c(249, 226, 175),
+        danger: c(243, 139, 168),
+        info: c(137, 220, 235),
+        border: c(49, 50, 68),
+        borderBright: c(69, 71, 90),
+        selection: c(69, 71, 90),
+        codeBg: c(24, 24, 37),
+        codeText: c(166, 173, 200),
+        prompt: c(137, 180, 250),
+        line: c(127, 132, 156),
+    },
+    'catppuccin-latte': {
+        bg: c(239, 241, 245),
+        text: c(76, 79, 105),
+        muted: c(156, 160, 176),
+        dim: c(204, 208, 218),
+        accent: c(30, 102, 245),
+        secondary: c(136, 57, 239),
+        success: c(64, 160, 43),
+        warning: c(223, 142, 29),
+        danger: c(210, 15, 57),
+        info: c(4, 165, 229),
+        border: c(204, 208, 218),
+        borderBright: c(188, 192, 204),
+        selection: c(183, 189, 242),
+        codeBg: c(230, 233, 239),
+        codeText: c(108, 111, 133),
+        prompt: c(30, 102, 245),
+        line: c(156, 160, 176),
+    },
+    nord: {
+        bg: c(46, 52, 64),
+        text: c(216, 222, 233),
+        muted: c(97, 110, 136),
+        dim: c(59, 66, 82),
+        accent: c(136, 192, 208),
+        secondary: c(180, 142, 173),
+        success: c(163, 190, 140),
+        warning: c(235, 203, 139),
+        danger: c(191, 97, 106),
+        info: c(129, 161, 193),
+        border: c(67, 76, 94),
+        borderBright: c(76, 86, 106),
+        selection: c(67, 76, 94),
+        codeBg: c(43, 48, 64),
+        codeText: c(229, 233, 240),
+        prompt: c(136, 192, 208),
+        line: c(76, 86, 106),
+    },
+    gruvbox: {
+        bg: c(40, 40, 40),
+        text: c(235, 219, 178),
+        muted: c(146, 131, 116),
+        dim: c(60, 56, 54),
+        accent: c(131, 165, 152),
+        secondary: c(211, 134, 155),
+        success: c(184, 187, 38),
+        warning: c(250, 189, 47),
+        danger: c(251, 73, 52),
+        info: c(142, 192, 124),
+        border: c(60, 56, 54),
+        borderBright: c(80, 73, 69),
+        selection: c(80, 73, 69),
+        codeBg: c(29, 32, 33),
+        codeText: c(235, 219, 178),
+        prompt: c(131, 165, 152),
+        line: c(146, 131, 116),
+    },
+    monokai: {
+        bg: c(39, 40, 34),
+        text: c(248, 248, 242),
+        muted: c(117, 113, 94),
+        dim: c(62, 61, 50),
+        accent: c(102, 217, 239),
+        secondary: c(174, 129, 255),
+        success: c(166, 226, 46),
+        warning: c(230, 219, 116),
+        danger: c(249, 38, 114),
+        info: c(161, 239, 228),
+        border: c(62, 61, 50),
+        borderBright: c(74, 74, 61),
+        selection: c(73, 72, 62),
+        codeBg: c(30, 31, 28),
+        codeText: c(248, 248, 242),
+        prompt: c(102, 217, 239),
+        line: c(117, 113, 94),
+    },
+    'clean-dark': {
+        bg: c(11, 12, 15),
+        text: c(218, 218, 220),
+        muted: c(92, 99, 112),
+        dim: c(26, 29, 36),
+        accent: c(90, 162, 255),
+        secondary: c(178, 136, 247),
+        success: c(47, 212, 124),
+        warning: c(242, 181, 68),
+        danger: c(255, 84, 112),
+        info: c(62, 198, 224),
+        border: c(25, 28, 35),
+        borderBright: c(38, 43, 54),
+        selection: c(29, 58, 95),
+        codeBg: c(15, 17, 22),
+        codeText: c(201, 204, 212),
+        prompt: c(90, 162, 255),
+        line: c(56, 63, 76),
+    },
+};

package/dist/src/tui/themes/types.js

@@ -0,0 +1 @@
+export {};