@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/tui/rows.js

@@ -0,0 +1,247 @@
+import { wrapText, truncate } from './text.js';
+import { renderMarkdown } from './components/markdown.js';
+// Rendered rows for finalized messages are immutable (they never re-wrap while
+// streaming) but re-created by the app every frame. Cache them per message so
+// the per-token redraw only re-wraps the live streaming message — this removes
+// the markdown/hljs churn that made the transcript fluctuate and lag.
+const MESSAGE_CACHE_MAX = 300;
+const messageCache = new Map();
+// Zero-width and format characters (U+200B–U+200D, U+2060, U+FEFF) that some
+// providers pad model output with. They have no visual width, so a markdown
+// line made only of them would otherwise render as a stray accent `•`.
+const INVISIBLE = /[\u200b-\u200d\u2060\ufeff]/g;
+/** Strip ANSI escapes and zero-width formatting chars — the visible text. */
+function visibleText(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '').replace(INVISIBLE, '');
+}
+export function rowsFromMessages(messages, theme, opts) {
+    const rows = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const isStreaming = msg.id === opts.streamingId;
+        const mr = isStreaming
+            ? messageRows({ ...msg, content: revealSlice(msg.content, opts.revealChars) }, theme, opts)
+            : messageRowsCached(msg, theme, opts);
+        rows.push(...mr);
+        if (i < messages.length - 1) {
+            rows.push({ id: `${msg.id}-gap`, text: '' });
+        }
+    }
+    return rows;
+}
+function messageRowsCached(msg, theme, opts) {
+    const key = messageCacheKey(msg, opts, theme.name);
+    const hit = messageCache.get(key);
+    if (hit)
+        return hit;
+    const rows = messageRows(msg, theme, opts);
+    if (messageCache.size >= MESSAGE_CACHE_MAX) {
+        const first = messageCache.keys().next().value;
+        if (first !== undefined)
+            messageCache.delete(first);
+    }
+    messageCache.set(key, rows);
+    return rows;
+}
+function messageCacheKey(msg, opts, themeName) {
+    return [
+        msg.id,
+        msg.content.length,
+        opts.width,
+        opts.thinkingDefaultOpen ? 1 : 0,
+        msg.reasoningOpen ? 1 : 0,
+        msg.diffsOpen ? 1 : 0,
+        msg.isPlan ? 1 : 0,
+        msg.toolCalls?.length ?? 0,
+        msg.diffs?.length ?? 0,
+        themeName,
+    ].join(':');
+}
+function revealSlice(content, revealChars) {
+    if (revealChars == null || revealChars >= content.length)
+        return content;
+    const slice = content.slice(0, revealChars);
+    const last = slice.charCodeAt(slice.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        return slice.slice(0, -1);
+    return slice;
+}
+function messageRows(msg, theme, opts) {
+    switch (msg.role) {
+        case 'user':
+            return userRows(msg, theme, opts);
+        case 'assistant':
+            return assistantRows(msg, theme, opts);
+        case 'system':
+            return systemRows(msg, theme, opts);
+        default:
+            return userRows({ ...msg, content: `[${msg.role}] ${msg.content}` }, theme, opts);
+    }
+}
+// ---------------------------------------------------------------------------
+// User — Codex style: `›` + dim text, wrapped continuation lines.
+// ---------------------------------------------------------------------------
+function userRows(msg, theme, opts) {
+    const accent = theme.table.sgr(theme.styles['accent']);
+    const dim = theme.table.sgr(theme.styles['dim']);
+    const reset = '\x1b[0m';
+    const innerW = Math.max(8, opts.width - 2);
+    const wrapped = wrapText(msg.content, innerW);
+    const rows = [];
+    for (let i = 0; i < wrapped.length; i++) {
+        const line = wrapped[i];
+        const prefix = i === 0 ? `${accent}›${reset} ` : `${dim}  ${reset}`;
+        rows.push({
+            id: `${msg.id}-u${i}`,
+            text: `${prefix}${dim}${line}${reset}`,
+        });
+    }
+    if (rows.length === 0)
+        rows.push({ id: `${msg.id}-u0`, text: `${accent}›${reset}` });
+    return rows;
+}
+// ---------------------------------------------------------------------------
+// Assistant — `•` body, thinking block, tool lines, streaming marker.
+// ---------------------------------------------------------------------------
+function assistantRows(msg, theme, opts) {
+    const accent = theme.table.sgr(theme.styles['accent']);
+    const muted = theme.table.sgr(theme.styles['muted']);
+    const dim = theme.table.sgr(theme.styles['dim']);
+    const reset = '\x1b[0m';
+    const danger = theme.table.sgr(theme.styles['danger']);
+    const toolDone = theme.table.sgr(theme.styles['toolDone']);
+    const rows = [];
+    if (msg.isPlan) {
+        rows.push({
+            id: `${msg.id}-plan-head`,
+            text: `${toolDone}PLAN${reset} ${muted}proposed (approve with /run · reject with /reject)${reset}`,
+        });
+    }
+    if (msg.reasoning && msg.reasoning.length > 0) {
+        const open = opts.thinkingDefaultOpen ?? msg.reasoningOpen ?? false;
+        const tokenCount = tokenEstimate(msg.reasoning);
+        const indicator = open ? '▾' : '▸';
+        rows.push({
+            id: `${msg.id}-th`,
+            text: `${muted}${indicator} thinking · ~${tokenCount} tokens (ctrl+t)${reset}`,
+        });
+        if (open) {
+            const innerW = Math.max(8, opts.width - 4);
+            for (const line of wrapText(msg.reasoning, innerW)) {
+                rows.push({ id: `${msg.id}-th-${rows.length}`, text: `${muted}  ${line}${reset}` });
+            }
+        }
+    }
+    if (msg.content) {
+        const md = renderMarkdown(msg.content, { theme, width: Math.max(8, opts.width - 2) });
+        for (let i = 0; i < md.length; i++) {
+            const line = md[i];
+            // Skip lines with no visible glyphs (blank or zero-width padding) so
+            // they never surface as bare `•` bullets while the turn streams in.
+            if (visibleText(line).trim() === '')
+                continue;
+            const prefix = rows.length === 0 && i === 0 ? `${accent}•${reset} ` : `${dim}  ${reset}`;
+            rows.push({ id: `${msg.id}-c${i}`, text: `${prefix}${line}${reset}` });
+        }
+    }
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const tc of msg.toolCalls) {
+            rows.push(...toolRows(tc, theme, opts, `${msg.id}-tc`));
+        }
+    }
+    if (msg.diffs && msg.diffs.length > 0) {
+        const total = msg.diffs.reduce((n, d) => n + d.added, 0);
+        const removed = msg.diffs.reduce((n, d) => n + d.removed, 0);
+        const state = msg.diffsOpen ? '▾' : '▸';
+        rows.push({
+            id: `${msg.id}-diff-head`,
+            text: `${toolDone}${state}${reset} ${muted}${msg.diffs.length} file(s) changed · +${total} −${removed} · ctrl+d to ${msg.diffsOpen ? 'hide' : 'review'}${reset}`,
+        });
+        if (msg.diffsOpen) {
+            const innerW = Math.max(8, opts.width - 4);
+            for (const d of msg.diffs) {
+                rows.push({
+                    id: `${msg.id}-diff-file-${d.path}`,
+                    text: `${accent}◗ ${d.path}${reset} ${muted}(+${d.added} −${d.removed})${reset}`,
+                });
+                for (const line of d.diff.split('\n')) {
+                    if (line.startsWith('+++') || line.startsWith('---') || line.startsWith('@@')) {
+                        rows.push({ id: `${msg.id}-diff-${d.path}-${rows.length}`, text: `${dim}${line}${reset}` });
+                    }
+                    else if (line.startsWith('+')) {
+                        rows.push({ id: `${msg.id}-diff-${d.path}-${rows.length}`, text: `${toolDone}${truncate(line, innerW)}${reset}` });
+                    }
+                    else if (line.startsWith('-')) {
+                        rows.push({ id: `${msg.id}-diff-${d.path}-${rows.length}`, text: `${danger}${truncate(line, innerW)}${reset}` });
+                    }
+                    else {
+                        rows.push({ id: `${msg.id}-diff-${d.path}-${rows.length}`, text: `${dim}${truncate(line, innerW)}${reset}` });
+                    }
+                    if (rows.length > 500) {
+                        rows.push({ id: `${msg.id}-diff-trunc`, text: `${muted}… diff elided (too large)${reset}` });
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (msg.streaming) {
+        rows.push({ id: `${msg.id}-streaming`, text: `${dim}…${reset}` });
+    }
+    if (rows.length === 0 && visibleText(msg.content).trim() === '') {
+        rows.push({ id: `${msg.id}-empty`, text: `${muted}•${reset}` });
+    }
+    return rows;
+}
+function toolRows(tc, theme, opts, baseId) {
+    const reset = '\x1b[0m';
+    const icon = tc.status === 'done'
+        ? { sgr: theme.table.sgr(theme.styles['toolDone']), ch: '✓' }
+        : tc.status === 'error'
+            ? { sgr: theme.table.sgr(theme.styles['toolError']), ch: '✗' }
+            : tc.status === 'running'
+                ? { sgr: theme.table.sgr(theme.styles['toolRunning']), ch: '●' }
+                : { sgr: theme.table.sgr(theme.styles['toolPending']), ch: '○' };
+    const accent = theme.table.sgr(theme.styles['accent']);
+    const dim = theme.table.sgr(theme.styles['dim']);
+    const innerW = Math.max(8, opts.width - 4);
+    const duration = tc.durationMs != null ? ` · ${tc.durationMs}ms` : '';
+    const name = truncate(tc.name, Math.max(6, innerW - 24), '…');
+    const argsPreview = truncate(tc.args.replace(/\s+/g, ' ').trim(), Math.max(4, innerW - name.length - 6), '…');
+    const rows = [
+        {
+            id: `${baseId}-${tc.id}-head`,
+            text: `${accent}•${reset} ${icon.sgr}${icon.ch}${reset} ${dim}${name}${reset}  ${argsPreview}${dim}${duration}${reset}`,
+        },
+    ];
+    if (tc.result) {
+        const clean = tc.result.replace(INVISIBLE, '').replace(/\s+/g, ' ').trim();
+        if (clean) {
+            const preview = truncate(clean, innerW, '…');
+            rows.push({ id: `${baseId}-${tc.id}-result`, text: `${dim}  ${preview}${reset}` });
+        }
+    }
+    return rows;
+}
+// ---------------------------------------------------------------------------
+// System / notes & errors — `ℹ` info lines.
+// ---------------------------------------------------------------------------
+function systemRows(msg, theme, opts) {
+    const style = msg.error ? 'danger' : 'info';
+    const sgr = theme.table.sgr(theme.styles[style]);
+    const reset = '\x1b[0m';
+    const innerW = Math.max(8, opts.width - 4);
+    const prefix = `ℹ `;
+    const wrapped = wrapText(msg.content, innerW);
+    const rows = [];
+    for (let i = 0; i < wrapped.length; i++) {
+        const line = wrapped[i];
+        const raw = i === 0 ? `${sgr}${prefix}${line}${reset}` : `${sgr}   ${line}${reset}`;
+        rows.push({ id: `${msg.id}-s${i}`, text: raw });
+    }
+    return rows;
+}
+function tokenEstimate(text) {
+    const n = Math.ceil(text.length / 4);
+    return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`;
+}

package/dist/src/tui/scheduler.js

@@ -0,0 +1,32 @@
+/**
+ * Frame scheduler — batches redraws to ~30 fps to avoid jank under fast streaming.
+ */
+const FRAME_INTERVAL_MS = 33;
+let renderFn = null;
+let framePending = false;
+let lastFrameTime = 0;
+function flush() {
+    framePending = false;
+    lastFrameTime = Date.now();
+    renderFn?.();
+}
+export function setRenderCallback(fn) {
+    renderFn = fn;
+}
+export function requestFrame() {
+    if (framePending)
+        return;
+    framePending = true;
+    const now = Date.now();
+    const elapsed = now - lastFrameTime;
+    const delay = Math.max(0, FRAME_INTERVAL_MS - elapsed);
+    setTimeout(flush, delay);
+}
+export function cancelFrame() {
+    framePending = false;
+}
+/** Immediate flush bypassing scheduler (for resize, key events, etc.). */
+export function flushNow() {
+    cancelFrame();
+    flush();
+}

package/dist/src/tui/store.js

@@ -0,0 +1,127 @@
+import { InputState } from './components/input.js';
+/**
+ * Mutable UI state shared between the imperative agent/bus wiring and the Ink
+ * component tree. The React side mirrors it: components re-read these fields
+ * every time `refresh()` fires rather than duplicating event handling.
+ */
+/** Options shown in the centered permission overlay. Index 0 = allow. */
+export const ASK_OPTIONS = ['Allow', 'Deny'];
+const SLASH_COMMANDS = [
+    { cmd: '/model', desc: '[id]  select model' },
+    { cmd: '/provider', desc: '<id>  switch provider' },
+    { cmd: '/theme', desc: '<name>  switch theme' },
+    { cmd: '/plan', desc: '<task>  propose a plan (approve with /run)' },
+    { cmd: '/run', desc: 'execute the proposed plan' },
+    { cmd: '/skills', desc: 'list project skills' },
+    { cmd: '/yolo', desc: 'auto-approve tools' },
+    { cmd: '/clear', desc: 'clear transcript' },
+    { cmd: '/agents', desc: 'toggle agent dock (orchestrate)' },
+    { cmd: '/help', desc: 'show this help' },
+    { cmd: '/exit', desc: 'quit' },
+];
+// Word-to-word reveal pacing. Servers stream sentence-sized chunks; the reveal
+// cursor films their contents out at a steady character rate, word-aligned, so
+// output reads "word by word" instead of "sentence by sentence".
+const REVEAL_CPS = 30; // chars/sec baseline (~6-8 words/sec) — brisk typing feel
+const REVEAL_LAG_CAP = 400; // caught-up threshold -> above it, drain 3x faster
+export class AppStore {
+    messages = [];
+    streaming = false;
+    route = null;
+    input = new InputState();
+    pendingAsk = null;
+    inputTokens = 0;
+    outputTokens = 0;
+    scrollOffset = 0;
+    cancelArmed = false;
+    greeted = false;
+    version = '';
+    cwd = '';
+    models = [];
+    modelPicker = { open: false, index: 0 };
+    agents = new Map();
+    dockOpen = false;
+    yolo = false;
+    theme = null;
+    thinkingDefaultOpen = true;
+    plan = null;
+    /** True while a plan proposal is streaming. */
+    planningTurn = false;
+    /** Project skills available via /skills. */
+    skills = [];
+    /** Reveal cursor (JS chars) for the streaming message; null = show all. */
+    revealChars = null;
+    listeners = new Set();
+    refresh = () => {
+        for (const l of [...this.listeners]) {
+            try {
+                l();
+            }
+            catch {
+                // never let a listener break the agent loop
+            }
+        }
+    };
+    onRender(l) {
+        this.listeners.add(l);
+        return () => {
+            this.listeners.delete(l);
+        };
+    }
+    findStreaming() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const m = this.messages[i];
+            if (m?.role === 'assistant' && (m.streaming || this.streaming))
+                return m;
+        }
+        return undefined;
+    }
+    /** Start word-by-word reveal for a new assistant turn. */
+    beginStream() {
+        this.revealChars = 0;
+    }
+    /** Show the full streamed content immediately (turn finished/cancelled). */
+    revealAll() {
+        this.revealChars = null;
+    }
+    /**
+     * Advance the reveal cursor by a paced, word-aligned tick. Returns true if
+     * the display position moved (callers refresh only then).
+     */
+    advanceReveal(dtMs = 120) {
+        if (this.revealChars == null)
+            return false;
+        const tail = this.findStreaming();
+        if (!tail)
+            return false;
+        const len = tail.content.length;
+        if (this.revealChars >= len)
+            return false;
+        const lag = len - this.revealChars;
+        const cps = lag > REVEAL_LAG_CAP ? REVEAL_CPS * 3 : REVEAL_CPS;
+        const budget = Math.max(1, Math.floor((cps * dtMs) / 1000));
+        const target = Math.min(len, this.revealChars + budget);
+        const nextGap = tail.content.slice(target).search(/\s/);
+        const end = nextGap === -1 ? len : target + nextGap + 1;
+        if (end <= this.revealChars)
+            return false;
+        this.revealChars = end;
+        return true;
+    }
+    slashQuery() {
+        const buf = this.input.currentBuffer();
+        if (!buf.startsWith('/'))
+            return '';
+        const token = buf.split(/\s+/).pop() ?? '';
+        return token;
+    }
+    slashMatches() {
+        const q = this.slashQuery().toLowerCase();
+        if (!q || q === '/')
+            return SLASH_COMMANDS;
+        return SLASH_COMMANDS.filter((c) => c.cmd.toLowerCase().startsWith(q));
+    }
+    static slashCommands() {
+        return SLASH_COMMANDS;
+    }
+}

package/dist/src/tui/style.js

@@ -0,0 +1,151 @@
+import { PALETTES } from './themes/palettes.js';
+export function rgbToInt(r, g, b) {
+    return (r << 16) | (g << 8) | b;
+}
+export function intToRgb(v) {
+    return [(v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff];
+}
+export function sgrFor(style) {
+    const parts = [];
+    if (style.fg != null) {
+        const [r, g, b] = intToRgb(style.fg);
+        parts.push(`38;2;${r};${g};${b}`);
+    }
+    if (style.bg != null) {
+        const [r, g, b] = intToRgb(style.bg);
+        parts.push(`48;2;${r};${g};${b}`);
+    }
+    if (style.bold)
+        parts.push('1');
+    if (style.dim)
+        parts.push('2');
+    if (style.italic)
+        parts.push('3');
+    if (style.underline)
+        parts.push('4');
+    if (style.inverse)
+        parts.push('7');
+    if (style.strikethrough)
+        parts.push('9');
+    if (parts.length === 0)
+        return '';
+    return `\x1b[${parts.join(';')}m`;
+}
+export const RESET = '\x1b[0m';
+export class StyleTable {
+    ids = new Map();
+    sgrCache = new Map();
+    sgrToId = new Map();
+    styles = [{}];
+    counter = 0;
+    constructor() {
+        this.ids.set('[plain]', 0);
+        this.sgrCache.set(0, '');
+        this.sgrToId.set('', 0);
+    }
+    add(style) {
+        const key = JSON.stringify(style);
+        const existing = this.ids.get(key);
+        if (existing != null)
+            return existing;
+        const id = ++this.counter;
+        this.ids.set(key, id);
+        this.sgrCache.set(id, sgrFor(style));
+        this.styles[id] = style;
+        return id;
+    }
+    sgr(id) {
+        return this.sgrCache.get(id) ?? '';
+    }
+    style(id) {
+        return this.styles[id];
+    }
+    /** Map an SGR code body back to a style index (for blitting ANSI text). */
+    styleIdForSgr(code) {
+        const cached = this.sgrToId.get(code);
+        if (cached != null)
+            return cached;
+        const id = this.add(parseSgr(code));
+        this.sgrToId.set(code, id);
+        return id;
+    }
+}
+/**
+ * Parse a set of SGR parameter codes into a Style.
+ * Input is the code body without the ESC[ or trailing 'm', e.g. "1;38;2;90;162;255".
+ */
+export function parseSgr(code) {
+    const style = {};
+    const parts = code.split(';').filter((p) => p !== '');
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        const n = parseInt(p, 10);
+        if (Number.isNaN(n))
+            continue;
+        if (n === 0)
+            Object.keys(style).forEach((k) => delete style[k]);
+        else if (n === 1)
+            style.bold = true;
+        else if (n === 2)
+            style.dim = true;
+        else if (n === 3)
+            style.italic = true;
+        else if (n === 4)
+            style.underline = true;
+        else if (n === 7)
+            style.inverse = true;
+        else if (n === 9)
+            style.strikethrough = true;
+        else if ((n === 38 || n === 48) && parts[i + 1] === '2') {
+            const r = parseInt(parts[i + 2] ?? '0', 10);
+            const g = parseInt(parts[i + 3] ?? '0', 10);
+            const b = parseInt(parts[i + 4] ?? '0', 10);
+            const v = rgbToInt(r, g, b);
+            style[n === 38 ? 'fg' : 'bg'] = v;
+            i += 4;
+        }
+    }
+    return style;
+}
+export function buildTheme(name) {
+    const palette = PALETTES[name] ?? PALETTES['tokyonight'];
+    const table = new StyleTable();
+    const s = (style) => table.add(style);
+    // No color backgrounds: rows inherit the terminal's own background. The
+    // cursor uses reverse-video so it stays visible without a solid color.
+    const fx = (style) => style;
+    const styles = {
+        text: s(fx({ fg: palette.text })),
+        muted: s(fx({ fg: palette.muted })),
+        dim: s(fx({ fg: palette.dim })),
+        accent: s(fx({ fg: palette.accent })),
+        accentBright: s(fx({ fg: palette.accent, bold: true })),
+        secondary: s(fx({ fg: palette.secondary })),
+        success: s(fx({ fg: palette.success })),
+        warning: s(fx({ fg: palette.warning })),
+        danger: s(fx({ fg: palette.danger })),
+        info: s(fx({ fg: palette.info })),
+        border: s(fx({ fg: palette.border })),
+        borderBright: s(fx({ fg: palette.borderBright })),
+        selection: s({ inverse: true }),
+        code: s(fx({ fg: palette.codeText })),
+        codeBg: s({}),
+        heading: s(fx({ fg: palette.accent, bold: true })),
+        bold: s({ bold: true }),
+        link: s(fx({ fg: palette.info, underline: true })),
+        strike: s(fx({ fg: palette.muted, strikethrough: true })),
+        quote: s(fx({ fg: palette.muted, italic: true })),
+        inlineCode: s({ fg: palette.accent }),
+        prompt: s(fx({ fg: palette.prompt, bold: true })),
+        userBubble: s({}),
+        error: s(fx({ fg: palette.danger })),
+        toolPending: s(fx({ fg: palette.muted })),
+        toolRunning: s(fx({ fg: palette.info })),
+        toolDone: s(fx({ fg: palette.success })),
+        toolError: s(fx({ fg: palette.danger })),
+        thinking: s(fx({ fg: palette.muted, italic: true })),
+        bg: s({}),
+        pad: s({}),
+    };
+    return { name, label: name, palette, table, styles };
+}