@voybio/ace-swarm 0.1.0

package/dist/tui/commands.js

@@ -0,0 +1,432 @@
+/**
+ * ACE-TUI Command Registry
+ *
+ * KFE (Keys For Everything) command definitions.
+ * Single command vocabulary for human operators, agents, and playbooks.
+ */
+// ── Command registry ─────────────────────────────────────────────────
+export class CommandRegistry {
+    commands = new Map();
+    register(cmd) {
+        this.commands.set(cmd.name, cmd);
+        for (const alias of cmd.aliases) {
+            this.commands.set(alias, cmd);
+        }
+    }
+    get(name) {
+        return this.commands.get(name);
+    }
+    getAll() {
+        const seen = new Set();
+        const result = [];
+        for (const cmd of this.commands.values()) {
+            if (!seen.has(cmd.name)) {
+                seen.add(cmd.name);
+                result.push(cmd);
+            }
+        }
+        return result;
+    }
+    /** Parse and execute a command string */
+    async execute(input, ctx) {
+        const trimmed = input.trim();
+        // Must start with /
+        if (!trimmed.startsWith("/")) {
+            // Not a command — treat as chat input
+            await ctx.tui.sendChatMessage(trimmed);
+            return;
+        }
+        const parts = trimmed.slice(1).split(/\s+/);
+        const cmdName = parts[0]?.toLowerCase();
+        const args = parts.slice(1);
+        if (!cmdName)
+            return;
+        const cmd = this.commands.get(cmdName);
+        if (!cmd) {
+            ctx.tui.showMessage(`Unknown command: /${cmdName}. Type /help for available commands.`, "warn");
+            return;
+        }
+        try {
+            await cmd.handler(args, ctx);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.tui.showMessage(`Error: ${msg}`, "error");
+        }
+    }
+    /** Get completions for a partial command */
+    complete(partial, ctx) {
+        if (!partial.startsWith("/"))
+            return [];
+        const parts = partial.slice(1).split(/\s+/);
+        const cmdName = parts[0]?.toLowerCase();
+        // Completing command name
+        if (parts.length <= 1) {
+            return this.getAll()
+                .filter(c => c.name.startsWith(cmdName ?? ""))
+                .map(c => `/${c.name}`);
+        }
+        // Completing arguments — delegate to command's completeFn
+        const cmd = this.commands.get(cmdName);
+        if (cmd?.completeFn && ctx) {
+            const argPartial = parts.slice(1).join(" ");
+            return cmd.completeFn(argPartial, ctx);
+        }
+        return [];
+    }
+}
+// ── Built-in commands ────────────────────────────────────────────────
+export function registerBuiltinCommands(registry) {
+    // /provider [name] — Switch active provider
+    registry.register({
+        name: "provider",
+        aliases: ["pvd"],
+        description: "Show or switch active provider",
+        usage: "/provider [name]",
+        handler: (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage(`Current provider: ${ctx.tui.getProvider()}`);
+                return;
+            }
+            const ok = ctx.tui.setProvider(args[0]);
+            if (!ok) {
+                ctx.tui.showMessage(`Unknown provider: ${args[0]}. Available: ${ctx.tui.getProviders().join(", ")}`, "warn");
+                return;
+            }
+            const provider = ctx.tui.getProvider();
+            ctx.tui.showMessage(`Provider switched to: ${provider}`);
+        },
+        completeFn: (partial, ctx) => {
+            const needle = partial.trim().toLowerCase();
+            return ctx.tui.getProviders().filter((p) => p.startsWith(needle));
+        },
+    });
+    // /providers — List discovered providers
+    registry.register({
+        name: "providers",
+        aliases: ["pvds"],
+        description: "List discovered providers",
+        usage: "/providers",
+        handler: (args, ctx) => {
+            const providers = ctx.tui.getProviders();
+            const active = ctx.tui.getProvider();
+            const lines = providers.map((p) => (p === active ? `[${p}]` : p));
+            ctx.tui.showMessage(`Providers: ${lines.join(", ")}`);
+        },
+    });
+    // /model <name> — Switch active model
+    registry.register({
+        name: "model",
+        aliases: ["m"],
+        description: "Switch active model",
+        usage: "/model <name>",
+        handler: async (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage(`Current model: ${ctx.tui.getModel()} (${ctx.tui.getProvider()})`);
+                return;
+            }
+            ctx.tui.setModel(args[0]);
+            ctx.tui.showMessage(`Model switched to: ${args[0]}`);
+        },
+        completeFn: (partial, ctx) => {
+            return ctx.tui.searchModels(partial);
+        },
+    });
+    // /models — List available models
+    registry.register({
+        name: "models",
+        aliases: ["ml"],
+        description: "List available models for the active provider",
+        usage: "/models",
+        handler: async (args, ctx) => {
+            const provider = ctx.tui.getProvider();
+            const models = await ctx.tui.getProviderModels(provider);
+            if (models.length === 0) {
+                ctx.tui.showMessage(`No models discovered for provider '${provider}'.`, "warn");
+            }
+            else {
+                ctx.tui.showMessage(`${provider} models (${models.length}): ${models.join(", ")}`);
+            }
+        },
+    });
+    // /pull <name> — Pull an Ollama model
+    registry.register({
+        name: "pull",
+        aliases: [],
+        description: "Pull an Ollama model",
+        usage: "/pull <model-name>",
+        handler: async (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage("Usage: /pull <model-name>  (e.g. /pull llama3.1:8b)", "warn");
+                return;
+            }
+            ctx.tui.showMessage(`Pulling model: ${args[0]}...`);
+            await ctx.tui.pullModel(args[0]);
+        },
+    });
+    // /ollama — Show Ollama status and management hints
+    registry.register({
+        name: "ollama",
+        aliases: ["ol"],
+        description: "Show Ollama status (connection, models, management commands)",
+        usage: "/ollama [check|serve|models|url <url>]",
+        handler: async (args, ctx) => {
+            const sub = args[0]?.toLowerCase();
+            if (sub === "url" && args[1]) {
+                ctx.tui.setConfig("ollama_url", args[1]);
+                ctx.tui.showMessage(`Ollama URL updated to: ${args[1]}. Reconnecting...`);
+                return;
+            }
+            if (sub === "serve") {
+                ctx.tui.showMessage("To start Ollama, run in a separate terminal: ollama serve");
+                return;
+            }
+            // Default: status check
+            const models = await ctx.tui.getOllamaModels();
+            const url = ctx.tui.getConfig("ollama_url") ?? "(not configured)";
+            if (models.length > 0) {
+                const current = ctx.tui.getModel();
+                const modelList = models.slice(0, 8).join(", ");
+                ctx.tui.showMessage(`Ollama OK at ${url} | Current: ${current} | Available (${models.length}): ${modelList}`);
+            }
+            else {
+                ctx.tui.showMessage(`Ollama not reachable at ${url}. Start it: ollama serve | Change URL: /ollama url <url>`, "warn");
+            }
+        },
+        completeFn: () => ["check", "serve", "models", "url"],
+    });
+    // /agent <role> — Start a subagent
+    registry.register({
+        name: "agent",
+        aliases: ["a"],
+        description: "Start a subagent",
+        usage: "/agent <role>",
+        handler: async (args, ctx) => {
+            if (args.length === 0) {
+                const active = ctx.tui.getActiveAgents();
+                ctx.tui.showMessage(`Active agents: ${active.length ? active.join(", ") : "none"}`);
+                return;
+            }
+            await ctx.tui.startAgent(args[0]);
+        },
+        completeFn: (partial, ctx) => {
+            return ctx.tui.getAllAgentRoles().filter(r => r.startsWith(partial));
+        },
+    });
+    // /agents — List agents
+    registry.register({
+        name: "agents",
+        aliases: ["as"],
+        description: "List all agents and their status",
+        usage: "/agents",
+        handler: async (args, ctx) => {
+            const all = ctx.tui.getAllAgentRoles();
+            const active = ctx.tui.getActiveAgents();
+            const lines = all.map(r => {
+                const isActive = active.includes(r);
+                return `${isActive ? "●" : "○"} ${r}`;
+            });
+            ctx.tui.showMessage(lines.join(" | "));
+        },
+    });
+    // /kill <role> — Stop a subagent
+    registry.register({
+        name: "kill",
+        aliases: ["k"],
+        description: "Stop a subagent",
+        usage: "/kill <role>",
+        handler: (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage("Usage: /kill <role>", "warn");
+                return;
+            }
+            ctx.tui.stopAgent(args[0]);
+            ctx.tui.showMessage(`Agent stopped: ${args[0]}`);
+        },
+        completeFn: (partial, ctx) => {
+            return ctx.tui.getActiveAgents().filter(r => r.startsWith(partial));
+        },
+    });
+    // /tasks — Show task board
+    registry.register({
+        name: "tasks",
+        aliases: ["t"],
+        description: "Show task board",
+        usage: "/tasks",
+        handler: (args, ctx) => {
+            ctx.tui.showMessage("Task board displayed on dashboard");
+            ctx.tui.switchTab(0); // Dashboard tab
+        },
+    });
+    // /task <description> — Create a new task
+    registry.register({
+        name: "task",
+        aliases: [],
+        description: "Create a new task",
+        usage: "/task <description>",
+        handler: (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage("Usage: /task <description>", "warn");
+                return;
+            }
+            const desc = args.join(" ");
+            ctx.tui.showMessage(`Task created: ${desc}`);
+        },
+    });
+    // /handoff <from> <to> — Trigger agent handoff
+    registry.register({
+        name: "handoff",
+        aliases: ["ho"],
+        description: "Trigger agent handoff",
+        usage: "/handoff <from-agent> <to-agent>",
+        handler: async (args, ctx) => {
+            if (args.length < 2) {
+                ctx.tui.showMessage("Usage: /handoff <from> <to>", "warn");
+                return;
+            }
+            ctx.tui.showMessage(`Handoff initiated: ${args[0]} → ${args[1]}`);
+        },
+        completeFn: (partial, ctx) => {
+            return ctx.tui.getAllAgentRoles().filter(r => r.startsWith(partial));
+        },
+    });
+    // /status — Show orchestrator status
+    registry.register({
+        name: "status",
+        aliases: ["s"],
+        description: "Show orchestrator status",
+        usage: "/status",
+        handler: (args, ctx) => {
+            const status = ctx.tui.getStatus();
+            const lines = Object.entries(status)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join(" | ");
+            ctx.tui.showMessage(lines);
+        },
+    });
+    // /skill <name> — Load a skill
+    registry.register({
+        name: "skill",
+        aliases: [],
+        description: "Load a skill",
+        usage: "/skill <name>",
+        handler: (args, ctx) => {
+            if (args.length === 0) {
+                ctx.tui.showMessage("Usage: /skill <name>", "warn");
+                return;
+            }
+            ctx.tui.showMessage(`Skill loaded: ${args[0]}`);
+        },
+    });
+    // /skills — List available skills
+    registry.register({
+        name: "skills",
+        aliases: [],
+        description: "List available skills",
+        usage: "/skills",
+        handler: (args, ctx) => {
+            ctx.tui.showMessage("Skills listed on dashboard");
+        },
+    });
+    // /config <key> <value> — Set configuration
+    registry.register({
+        name: "config",
+        aliases: ["cfg"],
+        description: "Set a configuration value",
+        usage: "/config <key> <value>",
+        handler: (args, ctx) => {
+            if (args.length < 1) {
+                ctx.tui.showMessage("Usage: /config <key> [value]", "warn");
+                return;
+            }
+            if (args.length === 1) {
+                const val = ctx.tui.getConfig(args[0]);
+                ctx.tui.showMessage(`${args[0]} = ${val ?? "(not set)"}`);
+            }
+            else {
+                ctx.tui.setConfig(args[0], args.slice(1).join(" "));
+                ctx.tui.showMessage(`Config set: ${args[0]} = ${args.slice(1).join(" ")}`);
+            }
+        },
+        completeFn: () => {
+            return ["provider", "model", "temperature", "top_p", "num_ctx", "num_predict", "theme", "ollama_url"];
+        },
+    });
+    // /theme <dark|light> — Switch theme
+    registry.register({
+        name: "theme",
+        aliases: [],
+        description: "Switch theme",
+        usage: "/theme <dark|light>",
+        handler: (args, ctx) => {
+            const theme = args[0] ?? "dark";
+            ctx.tui.setConfig("theme", theme);
+            ctx.tui.showMessage(`Theme set to: ${theme}`);
+            ctx.tui.refresh();
+        },
+        completeFn: () => ["dark", "light"],
+    });
+    // /chat — Open new chat tab
+    registry.register({
+        name: "chat",
+        aliases: ["c"],
+        description: "Open new chat tab",
+        usage: "/chat",
+        handler: (args, ctx) => {
+            ctx.tui.createChatTab();
+        },
+    });
+    // /logs — Open logs tab
+    registry.register({
+        name: "logs",
+        aliases: ["l"],
+        description: "Open logs tab",
+        usage: "/logs",
+        handler: (args, ctx) => {
+            ctx.tui.createLogTab();
+        },
+    });
+    // /clear — Clear current view
+    registry.register({
+        name: "clear",
+        aliases: ["cls"],
+        description: "Clear current view",
+        usage: "/clear",
+        handler: (args, ctx) => {
+            ctx.tui.clearView();
+        },
+    });
+    // /help — Show available commands
+    registry.register({
+        name: "help",
+        aliases: ["h", "?"],
+        description: "Show available commands",
+        usage: "/help [command]",
+        handler: (args, ctx) => {
+            if (args.length > 0) {
+                const cmd = registry.get(args[0]);
+                if (cmd) {
+                    ctx.tui.showMessage(`${cmd.usage} — ${cmd.description}`);
+                }
+                else {
+                    ctx.tui.showMessage(`Unknown command: ${args[0]}`, "warn");
+                }
+                return;
+            }
+            const cmds = registry.getAll();
+            const lines = cmds.map(c => `/${c.name}`).join("  ");
+            ctx.tui.showMessage(`Commands: ${lines}. Type /help <cmd> for details.`);
+        },
+    });
+    // /quit — Exit TUI
+    registry.register({
+        name: "quit",
+        aliases: ["q", "exit"],
+        description: "Exit TUI",
+        usage: "/quit",
+        handler: (args, ctx) => {
+            ctx.tui.quit();
+        },
+    });
+}
+//# sourceMappingURL=commands.js.map

package/dist/tui/dashboard.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ACE-TUI Dashboard
+ *
+ * Store-first dashboard ingestion over ace-state.zarr.
+ * The TUI never tails compatibility files directly.
+ */
+import { EventEmitter } from "node:events";
+import type { DashboardData } from "./layout.js";
+export declare class DashboardState extends EventEmitter {
+    private workspaceRoot;
+    private readonly storePath;
+    private stopPolling;
+    private tasks;
+    private persistedEvents;
+    private runtimeEvents;
+    private phase;
+    constructor(workspaceRoot: string);
+    startWatching(): void;
+    stopWatching(): void;
+    getData(provider: string, model: string, startTime: number, tokensIn: number, tokensOut: number, tokensPerSec: number, activeAgents: number, totalAgents: number): DashboardData;
+    addEvent(agent: string, message: string): void;
+    private applySnapshot;
+}
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/tui/dashboard.js

@@ -0,0 +1,110 @@
+/**
+ * ACE-TUI Dashboard
+ *
+ * Store-first dashboard ingestion over ace-state.zarr.
+ * The TUI never tails compatibility files directly.
+ */
+import { EventEmitter } from "node:events";
+import { resolve } from "node:path";
+import { pollStore } from "../store/state-reader.js";
+function dedupeEvents(events) {
+    const seen = new Set();
+    const ordered = [];
+    for (const event of events.sort((a, b) => a.timestamp - b.timestamp)) {
+        const key = `${event.timestamp}:${event.agent}:${event.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        ordered.push(event);
+    }
+    return ordered.slice(-500);
+}
+function derivePhase(snapshot) {
+    if (snapshot.jobs.some((job) => String(job.status ?? "") === "running")) {
+        return "Running";
+    }
+    if (snapshot.todos.some((todo) => todo.status === "in_progress")) {
+        return "In Progress";
+    }
+    if (snapshot.todos.some((todo) => todo.status === "blocked")) {
+        return "Blocked";
+    }
+    if (snapshot.handoffs.length > 0) {
+        return "Coordinating";
+    }
+    return "Ready";
+}
+export class DashboardState extends EventEmitter {
+    workspaceRoot;
+    storePath;
+    stopPolling = null;
+    tasks = [];
+    persistedEvents = [];
+    runtimeEvents = [];
+    phase = "Initializing";
+    constructor(workspaceRoot) {
+        super();
+        this.workspaceRoot = workspaceRoot;
+        this.storePath = resolve(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    }
+    startWatching() {
+        if (this.stopPolling)
+            return;
+        this.stopPolling = pollStore(this.storePath, 1000, (snapshot) => {
+            this.applySnapshot(snapshot);
+            this.emit("updated");
+        }, (error) => {
+            this.addEvent("system", `dashboard store refresh failed: ${error.message}`);
+        });
+    }
+    stopWatching() {
+        if (this.stopPolling) {
+            this.stopPolling();
+            this.stopPolling = null;
+        }
+    }
+    getData(provider, model, startTime, tokensIn, tokensOut, tokensPerSec, activeAgents, totalAgents) {
+        return {
+            phase: this.phase,
+            provider,
+            model,
+            activeAgents,
+            totalAgents,
+            startTime,
+            tokensIn,
+            tokensOut,
+            tokensPerSec,
+            tasks: this.tasks,
+            events: dedupeEvents([...this.persistedEvents, ...this.runtimeEvents]).slice(-50),
+        };
+    }
+    addEvent(agent, message) {
+        this.runtimeEvents.push({
+            timestamp: Date.now(),
+            agent,
+            message,
+        });
+        this.runtimeEvents = this.runtimeEvents.slice(-200);
+        this.emit("updated");
+    }
+    applySnapshot(snapshot) {
+        this.tasks = snapshot.todos.map((todo) => ({
+            title: todo.title,
+            done: todo.status === "done",
+            priority: todo.priority,
+        }));
+        const trackerEvents = snapshot.events.map((event) => ({
+            timestamp: event.ts,
+            agent: event.agent ?? "system",
+            message: event.summary,
+        }));
+        const ledgerEvents = snapshot.ledger.map((event) => ({
+            timestamp: event.ts,
+            agent: event.agent ?? "system",
+            message: event.summary,
+        }));
+        this.persistedEvents = dedupeEvents([...trackerEvents, ...ledgerEvents]).slice(-300);
+        this.phase = derivePhase(snapshot);
+    }
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/tui/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * ACE-TUI Main Entry Point
+ *
+ * Wires together all TUI modules and implements TuiController.
+ * This is the process entry when `ace tui` is invoked.
+ */
+import { type TuiController } from "./commands.js";
+export declare class AceTui implements TuiController {
+    private input;
+    private layout;
+    private ollama;
+    private openai;
+    private commands;
+    private telemetry;
+    private tabs;
+    private agentRunner;
+    private dashboard;
+    private chatSessions;
+    private activeChatSession;
+    private provider;
+    private model;
+    private ollamaAvailable;
+    private providers;
+    private modelsByProvider;
+    private dashboardControlIndex;
+    private config;
+    private startTime;
+    private running;
+    private tickTimer;
+    private messageQueue;
+    private workspaceRoot;
+    private providerBaseUrls;
+    constructor(options?: {
+        provider?: string;
+        model?: string;
+        providers?: string[];
+        modelsByProvider?: Record<string, string[]>;
+        baseUrl?: string;
+        ollamaUrl?: string;
+        providerBaseUrls?: Record<string, string>;
+        workspaceRoot?: string;
+        systemPrompt?: string;
+    });
+    start(): Promise<void>;
+    stop(): void;
+    private suspend;
+    private resume;
+    private wireEvents;
+    private handleKey;
+    private isDashboardControlContext;
+    private tryHandleDashboardControlKey;
+    private moveDashboardControl;
+    private adjustDashboardControl;
+    private activateDashboardControl;
+    private cycleProvider;
+    private cycleModel;
+    private getDashboardControls;
+    private fullRender;
+    private renderTabBar;
+    private renderActiveView;
+    private renderStatusBar;
+    private renderInputArea;
+    private getTaskState;
+    private syncTabState;
+    /** 1-second tick for status bar, message expiry */
+    private tick;
+    private normalizeProvider;
+    static defaultSystemPrompt(): string;
+    private ensureProvider;
+    private setProviderBaseUrl;
+    private getProviderBaseUrl;
+    private setProviderModels;
+    private addModelToProvider;
+    private getCachedModels;
+    private findProviderForModel;
+    private refreshOllamaModelCatalog;
+    private checkProviderRuntimeConfig;
+    setProvider(name: string): boolean;
+    getProvider(): string;
+    getProviders(): string[];
+    setModel(name: string): void;
+    getModel(): string;
+    getProviderModels(provider?: string): Promise<string[]>;
+    searchModels(query: string): string[];
+    getOllamaModels(): Promise<string[]>;
+    pullModel(name: string): Promise<void>;
+    startAgent(role: string): Promise<void>;
+    stopAgent(role: string): void;
+    getActiveAgents(): string[];
+    getAllAgentRoles(): string[];
+    switchTab(index: number): void;
+    createChatTab(): void;
+    createLogTab(): void;
+    closeCurrentTab(): void;
+    showMessage(text: string, level?: "info" | "warn" | "error"): void;
+    clearView(): void;
+    refresh(): void;
+    getStatus(): Record<string, unknown>;
+    quit(): void;
+    sendChatMessage(text: string): Promise<void>;
+    setConfig(key: string, value: string): void;
+    getConfig(key: string): string | undefined;
+}
+export declare function runTui(options?: {
+    provider?: string;
+    model?: string;
+    providers?: string[];
+    modelsByProvider?: Record<string, string[]>;
+    baseUrl?: string;
+    ollamaUrl?: string;
+    providerBaseUrls?: Record<string, string>;
+    workspaceRoot?: string;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map