@voybio/ace-swarm 0.1.0

package/dist/tui/input.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ACE-TUI Keyboard Input Handler
+ *
+ * Raw mode input processing with key parsing, command routing,
+ * history, and tab completion. KFE (Keys For Everything) pattern.
+ */
+import { EventEmitter } from "node:events";
+export interface KeyEvent {
+    name: string;
+    sequence: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+}
+export type InputMode = "normal" | "command" | "chat" | "search";
+export declare class InputHandler extends EventEmitter {
+    private mode;
+    private buffer;
+    private cursorPos;
+    private history;
+    private historyIndex;
+    private maxHistory;
+    private completionFn;
+    private rl;
+    /** Start listening for keyboard input */
+    start(): void;
+    /** Stop listening */
+    stop(): void;
+    /** Set the current input mode */
+    setMode(mode: InputMode): void;
+    getMode(): InputMode;
+    /** Set tab completion function */
+    setCompletionFn(fn: (partial: string) => string[]): void;
+    /** Get current input buffer */
+    getBuffer(): string;
+    getCursorPos(): number;
+    /** Insert text at current cursor position in command/chat mode */
+    insertText(text: string): void;
+    /** Parse raw input data into key events */
+    private handleData;
+    private handleBackspace;
+    private handleArrowUp;
+    private handleArrowDown;
+    private handleArrowRight;
+    private handleArrowLeft;
+    private handleTabCompletion;
+    private submitBuffer;
+}
+//# sourceMappingURL=input.d.ts.map

package/dist/tui/input.js

@@ -0,0 +1,336 @@
+/**
+ * ACE-TUI Keyboard Input Handler
+ *
+ * Raw mode input processing with key parsing, command routing,
+ * history, and tab completion. KFE (Keys For Everything) pattern.
+ */
+import { EventEmitter } from "node:events";
+// ── Input handler ────────────────────────────────────────────────────
+export class InputHandler extends EventEmitter {
+    mode = "normal";
+    buffer = "";
+    cursorPos = 0;
+    history = [];
+    historyIndex = -1;
+    maxHistory = 1000; // arttime: 1000 unique values
+    completionFn = null;
+    rl = null;
+    /** Start listening for keyboard input */
+    start() {
+        if (!process.stdin.isTTY)
+            return;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (data) => this.handleData(data));
+    }
+    /** Stop listening */
+    stop() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        this.rl?.close();
+    }
+    /** Set the current input mode */
+    setMode(mode) {
+        this.mode = mode;
+        this.buffer = "";
+        this.cursorPos = 0;
+        this.historyIndex = -1;
+        this.emit("mode", mode);
+    }
+    getMode() {
+        return this.mode;
+    }
+    /** Set tab completion function */
+    setCompletionFn(fn) {
+        this.completionFn = fn;
+    }
+    /** Get current input buffer */
+    getBuffer() {
+        return this.buffer;
+    }
+    getCursorPos() {
+        return this.cursorPos;
+    }
+    /** Insert text at current cursor position in command/chat mode */
+    insertText(text) {
+        if (!text)
+            return;
+        if (this.mode !== "command" && this.mode !== "chat")
+            return;
+        this.buffer =
+            this.buffer.substring(0, this.cursorPos) + text + this.buffer.substring(this.cursorPos);
+        this.cursorPos += text.length;
+        this.emit("buffer", this.buffer, this.cursorPos);
+    }
+    /** Parse raw input data into key events */
+    handleData(data) {
+        // Parse escape sequences
+        for (let i = 0; i < data.length; i++) {
+            const ch = data[i];
+            const code = ch.charCodeAt(0);
+            // Ctrl+C — interrupt
+            if (code === 3) {
+                this.emit("key", { name: "c", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Ctrl+D — exit
+            if (code === 4) {
+                this.emit("key", { name: "d", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Ctrl+Z — suspend
+            if (code === 26) {
+                this.emit("key", { name: "z", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Ctrl+N — new chat
+            if (code === 14) {
+                this.emit("key", { name: "n", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Ctrl+R — refresh
+            if (code === 18) {
+                this.emit("key", { name: "r", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Ctrl+L — clear
+            if (code === 12) {
+                this.emit("key", { name: "l", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
+            // Tab
+            if (code === 9) {
+                if ((this.mode === "command" || this.mode === "chat") && this.buffer.length > 0) {
+                    this.handleTabCompletion();
+                }
+                else {
+                    this.emit("key", { name: "tab", sequence: ch, ctrl: false, meta: false, shift: false });
+                }
+                continue;
+            }
+            // Shift+Tab (reverse)
+            if (data.substring(i, i + 3) === "\x1b[Z") {
+                this.emit("key", { name: "tab", sequence: "\x1b[Z", ctrl: false, meta: false, shift: true });
+                i += 2;
+                continue;
+            }
+            // Enter
+            if (code === 13 || code === 10) {
+                if (this.mode === "command" || this.mode === "chat") {
+                    this.submitBuffer();
+                }
+                else {
+                    this.emit("key", { name: "return", sequence: ch, ctrl: false, meta: false, shift: false });
+                }
+                continue;
+            }
+            // Backspace
+            if (code === 127 || code === 8) {
+                if (this.mode === "command" || this.mode === "chat") {
+                    this.handleBackspace();
+                }
+                else {
+                    this.emit("key", { name: "backspace", sequence: ch, ctrl: false, meta: false, shift: false });
+                }
+                continue;
+            }
+            // Escape sequences
+            if (ch === "\x1b" && i + 1 < data.length) {
+                // Alt+number for tab switching
+                if (data[i + 1] >= "1" && data[i + 1] <= "9") {
+                    this.emit("key", {
+                        name: data[i + 1],
+                        sequence: data.substring(i, i + 2),
+                        ctrl: false,
+                        meta: true,
+                        shift: false,
+                    });
+                    i++;
+                    continue;
+                }
+                // Arrow keys & special keys
+                if (data[i + 1] === "[") {
+                    const seq = data.substring(i, i + 4);
+                    if (seq.startsWith("\x1b[A")) {
+                        this.handleArrowUp();
+                        i += 2;
+                        continue;
+                    }
+                    if (seq.startsWith("\x1b[B")) {
+                        this.handleArrowDown();
+                        i += 2;
+                        continue;
+                    }
+                    if (seq.startsWith("\x1b[C")) {
+                        this.handleArrowRight();
+                        i += 2;
+                        continue;
+                    }
+                    if (seq.startsWith("\x1b[D")) {
+                        this.handleArrowLeft();
+                        i += 2;
+                        continue;
+                    }
+                    // Home
+                    if (seq.startsWith("\x1b[H")) {
+                        this.cursorPos = 0;
+                        this.emit("buffer", this.buffer, this.cursorPos);
+                        i += 2;
+                        continue;
+                    }
+                    // End
+                    if (seq.startsWith("\x1b[F")) {
+                        this.cursorPos = this.buffer.length;
+                        this.emit("buffer", this.buffer, this.cursorPos);
+                        i += 2;
+                        continue;
+                    }
+                    // Skip other escape sequences
+                    let j = i + 2;
+                    while (j < data.length && !/[a-zA-Z~]/.test(data[j]))
+                        j++;
+                    i = j;
+                    continue;
+                }
+                // Escape key alone
+                if (i + 1 === data.length || data[i + 1] === "\x1b") {
+                    this.emit("key", { name: "escape", sequence: ch, ctrl: false, meta: false, shift: false });
+                    continue;
+                }
+                i++; // skip non-recognized escape
+                continue;
+            }
+            // Slash enters command mode
+            if (ch === "/" && this.mode === "normal") {
+                this.setMode("command");
+                this.buffer = "/";
+                this.cursorPos = 1;
+                this.emit("buffer", this.buffer, this.cursorPos);
+                continue;
+            }
+            // Regular character — add to buffer in command/chat mode
+            if (this.mode === "command" || this.mode === "chat") {
+                this.insertText(ch);
+                continue;
+            }
+            // Normal mode — emit as key event
+            this.emit("key", {
+                name: ch,
+                sequence: ch,
+                ctrl: false,
+                meta: false,
+                shift: ch >= "A" && ch <= "Z",
+            });
+        }
+    }
+    handleBackspace() {
+        if (this.cursorPos > 0) {
+            this.buffer =
+                this.buffer.substring(0, this.cursorPos - 1) + this.buffer.substring(this.cursorPos);
+            this.cursorPos--;
+            // If buffer is empty and we were in command mode, back to normal
+            if (this.buffer === "" && this.mode === "command") {
+                this.setMode("normal");
+            }
+            this.emit("buffer", this.buffer, this.cursorPos);
+        }
+    }
+    handleArrowUp() {
+        if (this.mode === "command" || this.mode === "chat") {
+            if (this.history.length > 0 && this.historyIndex < this.history.length - 1) {
+                this.historyIndex++;
+                this.buffer = this.history[this.history.length - 1 - this.historyIndex];
+                this.cursorPos = this.buffer.length;
+                this.emit("buffer", this.buffer, this.cursorPos);
+            }
+        }
+        else {
+            this.emit("key", { name: "up", sequence: "\x1b[A", ctrl: false, meta: false, shift: false });
+        }
+    }
+    handleArrowDown() {
+        if (this.mode === "command" || this.mode === "chat") {
+            if (this.historyIndex > 0) {
+                this.historyIndex--;
+                this.buffer = this.history[this.history.length - 1 - this.historyIndex];
+                this.cursorPos = this.buffer.length;
+            }
+            else if (this.historyIndex === 0) {
+                this.historyIndex = -1;
+                this.buffer = this.mode === "command" ? "/" : "";
+                this.cursorPos = this.buffer.length;
+            }
+            this.emit("buffer", this.buffer, this.cursorPos);
+        }
+        else {
+            this.emit("key", { name: "down", sequence: "\x1b[B", ctrl: false, meta: false, shift: false });
+        }
+    }
+    handleArrowRight() {
+        if ((this.mode === "command" || this.mode === "chat") && this.cursorPos < this.buffer.length) {
+            this.cursorPos++;
+            this.emit("buffer", this.buffer, this.cursorPos);
+        }
+        else if (this.mode === "normal") {
+            this.emit("key", { name: "right", sequence: "\x1b[C", ctrl: false, meta: false, shift: false });
+        }
+    }
+    handleArrowLeft() {
+        if ((this.mode === "command" || this.mode === "chat") && this.cursorPos > 0) {
+            this.cursorPos--;
+            this.emit("buffer", this.buffer, this.cursorPos);
+        }
+        else if (this.mode === "normal") {
+            this.emit("key", { name: "left", sequence: "\x1b[D", ctrl: false, meta: false, shift: false });
+        }
+    }
+    handleTabCompletion() {
+        if (!this.completionFn)
+            return;
+        const completions = this.completionFn(this.buffer);
+        if (completions.length === 1) {
+            this.buffer = completions[0] + " ";
+            this.cursorPos = this.buffer.length;
+            this.emit("buffer", this.buffer, this.cursorPos);
+        }
+        else if (completions.length > 1) {
+            this.emit("completions", completions);
+        }
+    }
+    submitBuffer() {
+        const input = this.buffer.trim();
+        if (!input)
+            return;
+        // Add to history (deduplicated, capped at maxHistory)
+        const existingIdx = this.history.indexOf(input);
+        if (existingIdx !== -1)
+            this.history.splice(existingIdx, 1);
+        this.history.push(input);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+        if (this.mode === "command") {
+            this.emit("command", input);
+        }
+        else if (this.mode === "chat" && input.startsWith("/")) {
+            // Chat mode supports slash commands directly; prefix with '//' to send a literal leading slash.
+            if (input.startsWith("//")) {
+                this.emit("chat_input", input.slice(1));
+            }
+            else {
+                this.emit("command", input);
+            }
+        }
+        else {
+            this.emit("chat_input", input);
+        }
+        this.buffer = "";
+        this.cursorPos = 0;
+        this.historyIndex = -1;
+        this.setMode("normal");
+    }
+}
+//# sourceMappingURL=input.js.map

package/dist/tui/layout.d.ts

@@ -0,0 +1,116 @@
+/**
+ * ACE-TUI Layout Manager
+ *
+ * Screen zone management with dynamic resize handling.
+ * Arttime-inspired: defined zones for each UI element.
+ */
+import { type ColorLevel } from "./renderer.js";
+export interface Zone {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LayoutZones {
+    tabBar: Zone;
+    main: Zone;
+    statusBar: Zone;
+    inputLine: Zone;
+}
+export interface StatusBarState {
+    taskState: "idle" | "running" | "blocked" | "overdue";
+    provider: string;
+    model: string;
+    tokensIn: number;
+    tokensOut: number;
+    startTime: number;
+    taskName?: string;
+    agentName?: string;
+}
+export interface TabInfo {
+    id: string;
+    label: string;
+    type: "dashboard" | "agent" | "chat" | "logs";
+    hasActivity: boolean;
+    agentRole?: string;
+}
+export interface DashboardControlItem {
+    key: string;
+    label: string;
+    value: string;
+}
+export interface DashboardControlState {
+    focused: boolean;
+    selectedIndex: number;
+    items: DashboardControlItem[];
+}
+export declare class LayoutManager {
+    private zones;
+    private cols;
+    private rows;
+    private colorLevel;
+    private tabs;
+    private activeTab;
+    constructor(colorLevel?: ColorLevel);
+    /** Recalculate zones on terminal resize */
+    handleResize(): void;
+    private computeZones;
+    getZones(): LayoutZones;
+    getMainZone(): Zone;
+    getCols(): number;
+    getRows(): number;
+    setTabs(tabs: TabInfo[]): void;
+    setActiveTab(index: number): void;
+    getActiveTab(): number;
+    renderTabBar(): void;
+    renderStatusBar(state: StatusBarState): void;
+    renderInputLine(buffer: string, cursorPos: number, mode: string, prompt?: string): void;
+    renderDashboard(data: DashboardData, controls?: DashboardControlState): void;
+    private renderStatusPanel;
+    private renderControlStrip;
+    private renderTasksPanel;
+    private renderActivityLog;
+    renderChatView(messages: ChatMessage[]): void;
+    /** Render streaming text at the bottom of chat */
+    renderStreamChunk(text: string, line: number): void;
+    renderAgentView(agentName: string, output: string[], thinking?: string): void;
+    private agentColor;
+    private wrapText;
+    private wrapInputText;
+    /** Full screen initialization */
+    initScreen(): void;
+    /** Full screen teardown */
+    destroyScreen(): void;
+    /** Full redraw (arttime: called on resume from suspend) */
+    fullRedraw(): void;
+}
+export interface DashboardData {
+    phase: string;
+    provider: string;
+    model: string;
+    activeAgents: number;
+    totalAgents: number;
+    startTime: number;
+    tokensIn: number;
+    tokensOut: number;
+    tokensPerSec: number;
+    tasks: TaskItem[];
+    events: ActivityEvent[];
+}
+export interface TaskItem {
+    title: string;
+    done: boolean;
+    priority?: string;
+}
+export interface ActivityEvent {
+    timestamp: number;
+    agent: string;
+    message: string;
+}
+export interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp?: number;
+    tokens?: number;
+}
+//# sourceMappingURL=layout.d.ts.map