@voybio/ace-swarm 0.1.0

package/dist/tui/renderer.js

@@ -0,0 +1,304 @@
+/**
+ * ACE-TUI ANSI Renderer
+ *
+ * Direct terminal rendering via ANSI escape sequences.
+ * Zero dependencies — uses process.stdout.write() exclusively.
+ * Inspired by arttime's rendering approach.
+ */
+// ── ANSI escape sequences ────────────────────────────────────────────
+const ESC = "\x1b";
+const CSI = `${ESC}[`;
+/** Cursor movement */
+export const cursor = {
+    to: (x, y) => `${CSI}${y + 1};${x + 1}H`,
+    up: (n = 1) => `${CSI}${n}A`,
+    down: (n = 1) => `${CSI}${n}B`,
+    right: (n = 1) => `${CSI}${n}C`,
+    left: (n = 1) => `${CSI}${n}D`,
+    hide: `${CSI}?25l`,
+    show: `${CSI}?25h`,
+    save: `${ESC}7`,
+    restore: `${ESC}8`,
+    home: `${CSI}H`,
+};
+/** Screen operations */
+export const screen = {
+    clear: `${CSI}2J`,
+    clearLine: `${CSI}2K`,
+    clearDown: `${CSI}J`,
+    clearRight: `${CSI}K`,
+    altBuffer: `${CSI}?1049h`,
+    mainBuffer: `${CSI}?1049l`,
+    enableMouse: `${CSI}?1003h${CSI}?1006h`,
+    disableMouse: `${CSI}?1003l${CSI}?1006l`,
+};
+/** Style codes */
+export const style = {
+    reset: `${CSI}0m`,
+    bold: `${CSI}1m`,
+    dim: `${CSI}2m`,
+    italic: `${CSI}3m`,
+    underline: `${CSI}4m`,
+    inverse: `${CSI}7m`,
+    strikethrough: `${CSI}9m`,
+};
+export function detectColorLevel() {
+    if (!process.stdout.isTTY)
+        return "none";
+    const ct = process.env.COLORTERM?.toLowerCase();
+    if (ct === "truecolor" || ct === "24bit")
+        return "truecolor";
+    const term = process.env.TERM ?? "";
+    if (term.includes("256color"))
+        return "256";
+    if (term)
+        return "basic";
+    return "none";
+}
+/** 16-color CGA foreground */
+export const fg = {
+    black: `${CSI}30m`,
+    red: `${CSI}31m`,
+    green: `${CSI}32m`,
+    yellow: `${CSI}33m`,
+    blue: `${CSI}34m`,
+    magenta: `${CSI}35m`,
+    cyan: `${CSI}36m`,
+    white: `${CSI}37m`,
+    gray: `${CSI}90m`,
+    brightRed: `${CSI}91m`,
+    brightGreen: `${CSI}92m`,
+    brightYellow: `${CSI}93m`,
+    brightBlue: `${CSI}94m`,
+    brightMagenta: `${CSI}95m`,
+    brightCyan: `${CSI}96m`,
+    brightWhite: `${CSI}97m`,
+};
+/** 16-color CGA background */
+export const bg = {
+    black: `${CSI}40m`,
+    red: `${CSI}41m`,
+    green: `${CSI}42m`,
+    yellow: `${CSI}43m`,
+    blue: `${CSI}44m`,
+    magenta: `${CSI}45m`,
+    cyan: `${CSI}46m`,
+    white: `${CSI}47m`,
+    gray: `${CSI}100m`,
+    brightBlue: `${CSI}104m`,
+    brightCyan: `${CSI}106m`,
+};
+/** 256-color codes */
+export function fg256(n) {
+    return `${CSI}38;5;${n}m`;
+}
+export function bg256(n) {
+    return `${CSI}48;5;${n}m`;
+}
+/** 24-bit RGB colors */
+export function fgRgb(r, g, b) {
+    return `${CSI}38;2;${r};${g};${b}m`;
+}
+export function bgRgb(r, g, b) {
+    return `${CSI}48;2;${r};${g};${b}m`;
+}
+// ── Box drawing characters ───────────────────────────────────────────
+export const box = {
+    // Single-line box
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+    teeRight: "├",
+    teeLeft: "┤",
+    teeDown: "┬",
+    teeUp: "┴",
+    cross: "┼",
+    // Heavy/double
+    heavyHorizontal: "━",
+    heavyVertical: "┃",
+    // Rounded corners
+    roundTopLeft: "╭",
+    roundTopRight: "╮",
+    roundBottomLeft: "╰",
+    roundBottomRight: "╯",
+};
+// ── Symbols ──────────────────────────────────────────────────────────
+export const symbols = {
+    check: "✓",
+    cross: "✗",
+    bullet: "●",
+    hollowBullet: "○",
+    arrow: "→",
+    arrowLeft: "←",
+    arrowUp: "↑",
+    arrowDown: "↓",
+    spinner: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    progress: { filled: "█", partial: "▓", empty: "░" },
+    tab: "▎",
+    activeTab: "▌",
+};
+// ── Text utilities ───────────────────────────────────────────────────
+/** Strip ANSI escape codes from a string (arttime: sed -e 's/\x1b\[[0-9;]*m//g') */
+export function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+/** Get visible width of a string (ANSI-aware) */
+export function visibleWidth(text) {
+    return stripAnsi(text).length;
+}
+/** Truncate text to fit width, add ellipsis if needed */
+export function truncate(text, maxWidth) {
+    const stripped = stripAnsi(text);
+    if (stripped.length <= maxWidth)
+        return text;
+    // For ANSI-containing text, character-by-character approach
+    let visible = 0;
+    let result = "";
+    const chars = [...text];
+    let inEscape = false;
+    for (const char of chars) {
+        if (char === "\x1b") {
+            inEscape = true;
+            result += char;
+            continue;
+        }
+        if (inEscape) {
+            result += char;
+            if (/[a-zA-Z]/.test(char))
+                inEscape = false;
+            continue;
+        }
+        if (visible >= maxWidth - 1) {
+            result += "…";
+            break;
+        }
+        result += char;
+        visible++;
+    }
+    return result + style.reset;
+}
+/** Pad text to exact width (ANSI-aware) */
+export function padRight(text, width) {
+    const w = visibleWidth(text);
+    if (w >= width)
+        return truncate(text, width);
+    return text + " ".repeat(width - w);
+}
+/** Center text in width (ANSI-aware, arttime centering math) */
+export function center(text, width) {
+    const w = visibleWidth(text);
+    if (w >= width)
+        return truncate(text, width);
+    const leftPad = Math.floor((width - w) / 2);
+    const rightPad = width - w - leftPad;
+    return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+// ── High-level rendering ─────────────────────────────────────────────
+/** Write raw string to stdout */
+export function write(s) {
+    process.stdout.write(s);
+}
+/** Write at specific position */
+export function writeAt(x, y, text) {
+    write(cursor.to(x, y) + text);
+}
+/** Draw a horizontal line */
+export function hline(x, y, width, char = box.horizontal) {
+    writeAt(x, y, char.repeat(width));
+}
+/** Draw a vertical line */
+export function vline(x, y, height, char = box.vertical) {
+    for (let i = 0; i < height; i++) {
+        writeAt(x, y + i, char);
+    }
+}
+/** Draw a box with optional title */
+export function drawBox(x, y, width, height, opts) {
+    const tl = opts?.rounded ? box.roundTopLeft : box.topLeft;
+    const tr = opts?.rounded ? box.roundTopRight : box.topRight;
+    const bl = opts?.rounded ? box.roundBottomLeft : box.bottomLeft;
+    const br = opts?.rounded ? box.roundBottomRight : box.bottomRight;
+    const bc = opts?.borderColor ?? "";
+    const reset = bc ? style.reset : "";
+    // Top border
+    let top = `${bc}${tl}${box.horizontal.repeat(width - 2)}${tr}${reset}`;
+    if (opts?.title) {
+        const tc = opts.titleColor ?? fg.brightWhite;
+        const titleText = ` ${opts.title} `;
+        const titleLen = visibleWidth(titleText);
+        if (titleLen < width - 4) {
+            top = `${bc}${tl}${box.horizontal}${tc}${style.bold}${titleText}${style.reset}${bc}${box.horizontal.repeat(width - 3 - titleLen)}${tr}${reset}`;
+        }
+    }
+    writeAt(x, y, top);
+    // Side borders
+    for (let i = 1; i < height - 1; i++) {
+        writeAt(x, y + i, `${bc}${box.vertical}${reset}`);
+        writeAt(x + width - 1, y + i, `${bc}${box.vertical}${reset}`);
+    }
+    // Bottom border
+    writeAt(x, y + height - 1, `${bc}${bl}${box.horizontal.repeat(width - 2)}${br}${reset}`);
+}
+/** Fill a rectangular region with spaces (clear region) */
+export function clearRegion(x, y, width, height) {
+    const blank = " ".repeat(width);
+    for (let i = 0; i < height; i++) {
+        writeAt(x, y + i, blank);
+    }
+}
+/** Draw a progress bar (arttime-inspired) */
+export function progressBar(x, y, width, ratio, opts) {
+    const barWidth = opts?.showPercent ? width - 5 : width;
+    const filled = Math.round(barWidth * Math.max(0, Math.min(1, ratio)));
+    const empty = barWidth - filled;
+    const fc = opts?.filledColor ?? fg.green;
+    const ec = opts?.emptyColor ?? fg.gray;
+    let bar = `${fc}${symbols.progress.filled.repeat(filled)}${ec}${symbols.progress.empty.repeat(empty)}${style.reset}`;
+    if (opts?.showPercent) {
+        bar += ` ${Math.round(ratio * 100).toString().padStart(3)}%`;
+    }
+    writeAt(x, y, bar);
+}
+/** Draw a spinner frame */
+export function spinnerFrame(frame) {
+    return symbols.spinner[frame % symbols.spinner.length];
+}
+/** Get terminal dimensions */
+export function getTermSize() {
+    return {
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    };
+}
+/** Format elapsed time (arttime contextual time display) */
+export function formatElapsed(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    if (min < 60)
+        return `${min}m ${sec}s`;
+    const hr = Math.floor(min / 60);
+    const remMin = min % 60;
+    if (hr < 24)
+        return `${hr}h ${remMin}m`;
+    const days = Math.floor(hr / 24);
+    const remHr = hr % 24;
+    return `${days}d ${remHr}h`;
+}
+/** Format timestamp as HH:MM:SS */
+export function formatTime(date = new Date()) {
+    return date.toLocaleTimeString("en-US", { hour12: false });
+}
+/** Format a number with commas */
+export function formatNumber(n) {
+    if (n < 1000)
+        return n.toString();
+    return n.toLocaleString("en-US");
+}
+//# sourceMappingURL=renderer.js.map

package/dist/tui/tabs.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ACE-TUI Tab Manager
+ *
+ * Manages tabbed views for dashboard, agent outputs, chat sessions, and logs.
+ * Each tab is an isolated view with its own state — arttime hermetic isolation pattern.
+ */
+import type { ChatMessage, ActivityEvent } from "./layout.js";
+export type TabType = "dashboard" | "agent" | "chat" | "logs";
+export interface Tab {
+    id: string;
+    label: string;
+    type: TabType;
+    hasActivity: boolean;
+    closeable: boolean;
+    agentRole?: string;
+    chatMessages?: ChatMessage[];
+    agentOutput?: string[];
+    agentThinking?: string;
+    logEntries?: ActivityEvent[];
+    scrollOffset?: number;
+}
+export declare class TabManager {
+    private tabs;
+    private activeIndex;
+    private nextId;
+    constructor();
+    /** Get all tabs */
+    getTabs(): Tab[];
+    /** Get active tab */
+    getActiveTab(): Tab;
+    /** Get active tab index */
+    getActiveIndex(): number;
+    /** Switch to tab by index */
+    switchTo(index: number): void;
+    /** Switch to next tab */
+    nextTab(): void;
+    /** Switch to previous tab */
+    prevTab(): void;
+    /** Find tab by agent role */
+    findAgentTab(role: string): number;
+    /** Create and return an agent tab */
+    createAgentTab(role: string): Tab;
+    /** Create a new chat tab */
+    createChatTab(): Tab;
+    /** Create a logs tab */
+    createLogTab(): Tab;
+    /** Close the active tab (if closeable) */
+    closeActive(): boolean;
+    /** Close a specific tab by id */
+    closeTab(id: string): boolean;
+    /** Append output to an agent tab */
+    appendAgentOutput(role: string, text: string): void;
+    /** Set agent thinking text */
+    setAgentThinking(role: string, text: string | undefined): void;
+    /** Add a message to a chat tab */
+    addChatMessage(tabId: string, message: ChatMessage): void;
+    /** Get chat messages for active tab */
+    getActiveChatMessages(): ChatMessage[];
+    /** Add a log entry to all log tabs */
+    addLogEntry(entry: ActivityEvent): void;
+    /** Get tab info for layout rendering */
+    getTabInfos(): Array<{
+        id: string;
+        label: string;
+        type: TabType;
+        hasActivity: boolean;
+        agentRole?: string;
+    }>;
+}
+//# sourceMappingURL=tabs.d.ts.map

package/dist/tui/tabs.js

@@ -0,0 +1,208 @@
+/**
+ * ACE-TUI Tab Manager
+ *
+ * Manages tabbed views for dashboard, agent outputs, chat sessions, and logs.
+ * Each tab is an isolated view with its own state — arttime hermetic isolation pattern.
+ */
+// ── Tab manager ──────────────────────────────────────────────────────
+export class TabManager {
+    tabs = [];
+    activeIndex = 0;
+    nextId = 1;
+    constructor() {
+        // Always start with Dashboard tab
+        this.tabs.push({
+            id: "dashboard",
+            label: "Dashboard",
+            type: "dashboard",
+            hasActivity: false,
+            closeable: false,
+        });
+    }
+    /** Get all tabs */
+    getTabs() {
+        return this.tabs;
+    }
+    /** Get active tab */
+    getActiveTab() {
+        return this.tabs[this.activeIndex];
+    }
+    /** Get active tab index */
+    getActiveIndex() {
+        return this.activeIndex;
+    }
+    /** Switch to tab by index */
+    switchTo(index) {
+        if (index >= 0 && index < this.tabs.length) {
+            this.activeIndex = index;
+            this.tabs[index].hasActivity = false;
+        }
+    }
+    /** Switch to next tab */
+    nextTab() {
+        this.switchTo((this.activeIndex + 1) % this.tabs.length);
+    }
+    /** Switch to previous tab */
+    prevTab() {
+        this.switchTo((this.activeIndex - 1 + this.tabs.length) % this.tabs.length);
+    }
+    /** Find tab by agent role */
+    findAgentTab(role) {
+        return this.tabs.findIndex(t => t.type === "agent" && t.agentRole === role);
+    }
+    /** Create and return an agent tab */
+    createAgentTab(role) {
+        // If tab already exists, switch to it
+        const existing = this.findAgentTab(role);
+        if (existing >= 0) {
+            this.switchTo(existing);
+            return this.tabs[existing];
+        }
+        const tab = {
+            id: `agent-${role}-${this.nextId++}`,
+            label: `Agent:${role}`,
+            type: "agent",
+            hasActivity: false,
+            closeable: true,
+            agentRole: role,
+            agentOutput: [],
+            agentThinking: undefined,
+        };
+        this.tabs.push(tab);
+        this.switchTo(this.tabs.length - 1);
+        return tab;
+    }
+    /** Create a new chat tab */
+    createChatTab() {
+        const chatCount = this.tabs.filter(t => t.type === "chat").length;
+        const tab = {
+            id: `chat-${this.nextId++}`,
+            label: chatCount === 0 ? "Chat" : `Chat ${chatCount + 1}`,
+            type: "chat",
+            hasActivity: false,
+            closeable: true,
+            chatMessages: [],
+        };
+        this.tabs.push(tab);
+        this.switchTo(this.tabs.length - 1);
+        return tab;
+    }
+    /** Create a logs tab */
+    createLogTab() {
+        const existing = this.tabs.findIndex(t => t.type === "logs");
+        if (existing >= 0) {
+            this.switchTo(existing);
+            return this.tabs[existing];
+        }
+        const tab = {
+            id: `logs-${this.nextId++}`,
+            label: "Logs",
+            type: "logs",
+            hasActivity: false,
+            closeable: true,
+            logEntries: [],
+        };
+        this.tabs.push(tab);
+        this.switchTo(this.tabs.length - 1);
+        return tab;
+    }
+    /** Close the active tab (if closeable) */
+    closeActive() {
+        const tab = this.tabs[this.activeIndex];
+        if (!tab.closeable)
+            return false;
+        this.tabs.splice(this.activeIndex, 1);
+        if (this.activeIndex >= this.tabs.length) {
+            this.activeIndex = this.tabs.length - 1;
+        }
+        return true;
+    }
+    /** Close a specific tab by id */
+    closeTab(id) {
+        const index = this.tabs.findIndex(t => t.id === id);
+        if (index < 0)
+            return false;
+        if (!this.tabs[index].closeable)
+            return false;
+        this.tabs.splice(index, 1);
+        if (this.activeIndex >= this.tabs.length) {
+            this.activeIndex = Math.max(0, this.tabs.length - 1);
+        }
+        else if (this.activeIndex > index) {
+            this.activeIndex--;
+        }
+        return true;
+    }
+    // ── Agent output management ──────────────────────────────────────
+    /** Append output to an agent tab */
+    appendAgentOutput(role, text) {
+        const index = this.findAgentTab(role);
+        if (index < 0)
+            return;
+        const tab = this.tabs[index];
+        if (!tab.agentOutput)
+            tab.agentOutput = [];
+        tab.agentOutput.push(text);
+        // Cap output buffer (don't hold unlimited history in memory)
+        if (tab.agentOutput.length > 500) {
+            tab.agentOutput = tab.agentOutput.slice(-400);
+        }
+        // Mark activity if not the active tab
+        if (index !== this.activeIndex) {
+            tab.hasActivity = true;
+        }
+    }
+    /** Set agent thinking text */
+    setAgentThinking(role, text) {
+        const index = this.findAgentTab(role);
+        if (index < 0)
+            return;
+        this.tabs[index].agentThinking = text;
+    }
+    // ── Chat message management ──────────────────────────────────────
+    /** Add a message to a chat tab */
+    addChatMessage(tabId, message) {
+        const tab = this.tabs.find(t => t.id === tabId);
+        if (!tab || !tab.chatMessages)
+            return;
+        tab.chatMessages.push(message);
+        // Cap message history
+        if (tab.chatMessages.length > 200) {
+            tab.chatMessages = tab.chatMessages.slice(-150);
+        }
+    }
+    /** Get chat messages for active tab */
+    getActiveChatMessages() {
+        const tab = this.tabs[this.activeIndex];
+        return tab.chatMessages ?? [];
+    }
+    // ── Log management ───────────────────────────────────────────────
+    /** Add a log entry to all log tabs */
+    addLogEntry(entry) {
+        for (const tab of this.tabs) {
+            if (tab.type === "logs") {
+                if (!tab.logEntries)
+                    tab.logEntries = [];
+                tab.logEntries.push(entry);
+                if (tab.logEntries.length > 1000) {
+                    tab.logEntries = tab.logEntries.slice(-800);
+                }
+                const index = this.tabs.indexOf(tab);
+                if (index !== this.activeIndex) {
+                    tab.hasActivity = true;
+                }
+            }
+        }
+    }
+    /** Get tab info for layout rendering */
+    getTabInfos() {
+        return this.tabs.map(t => ({
+            id: t.id,
+            label: t.label,
+            type: t.type,
+            hasActivity: t.hasActivity,
+            agentRole: t.agentRole,
+        }));
+    }
+}
+//# sourceMappingURL=tabs.js.map

package/dist/tui/telemetry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * ACE-TUI Telemetry
+ *
+ * Token counting, throughput measurement, and cost estimation.
+ */
+export interface TelemetrySnapshot {
+    tokensIn: number;
+    tokensOut: number;
+    totalTokens: number;
+    tokensPerSec: number;
+    requestCount: number;
+    avgLatencyMs: number;
+    costEstimate: number;
+    uptime: number;
+    modelName: string;
+    contextUsed: number;
+    contextMax: number;
+}
+export interface RequestTelemetry {
+    startTime: number;
+    endTime: number;
+    promptTokens: number;
+    completionTokens: number;
+    model: string;
+}
+export declare class TelemetryTracker {
+    private tokensIn;
+    private tokensOut;
+    private requestCount;
+    private totalLatencyMs;
+    private startTime;
+    private model;
+    private contextMax;
+    private contextUsed;
+    private recentTokens;
+    private windowMs;
+    constructor();
+    /** Record a completed request */
+    recordRequest(telemetry: RequestTelemetry): void;
+    /** Record incremental tokens (for streaming) */
+    recordTokens(input: number, output: number): void;
+    /** Update context window info */
+    setContext(used: number, max: number): void;
+    setModel(name: string): void;
+    /** Get current snapshot */
+    getSnapshot(): TelemetrySnapshot;
+    /** Reset all counters */
+    reset(): void;
+    private pruneWindow;
+    private calculateThroughput;
+    /** Estimate cost — Ollama is free, but show equivalent cloud cost for reference */
+    private estimateCost;
+}
+/** Rough token count estimation (for when Ollama doesn't return counts) */
+export declare function estimateTokenCount(text: string): number;
+//# sourceMappingURL=telemetry.d.ts.map