@voybio/ace-swarm 0.1.0

package/dist/tui/chat.js

@@ -0,0 +1,368 @@
+/**
+ * ACE-TUI Chat Panel
+ *
+ * Interactive chat with provider-aware streaming.
+ * Supports streaming responses, token counting, and conversation history.
+ */
+import { diagnoseChatRuntimeConfig, } from "./openai-compatible.js";
+import { estimateTokenCount } from "./telemetry.js";
+import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { ModelBridge } from "../model-bridge.js";
+export class ChatSession extends EventEmitter {
+    clients;
+    telemetry;
+    messages = [];
+    displayMessages = [];
+    provider;
+    model;
+    streaming = false;
+    activeStreamProvider = null;
+    currentStreamText = "";
+    systemPrompt;
+    temperature;
+    topP;
+    numCtx;
+    workspaceRoot;
+    aceToolsMode;
+    aceRole;
+    aceTier;
+    maxTurns;
+    aceBridge;
+    activeAceBridge = false;
+    providerBaseUrls;
+    constructor(clients, telemetry, options) {
+        super();
+        this.clients = clients;
+        this.telemetry = telemetry;
+        this.provider = normalizeProvider(options.provider);
+        this.model = options.model;
+        this.providerBaseUrls = { ...(options.providerBaseUrls ?? {}) };
+        this.systemPrompt = options.systemPrompt;
+        this.temperature = options.temperature ?? 0.7;
+        this.topP = options.topP ?? 0.9;
+        this.numCtx = options.numCtx ?? 8192;
+        this.workspaceRoot = options.workspaceRoot ? resolve(options.workspaceRoot) : undefined;
+        this.aceToolsMode = options.aceTools ?? "auto";
+        this.aceRole = options.aceRole?.trim() || "orchestrator";
+        this.aceTier = options.aceTier;
+        this.maxTurns = options.maxTurns ?? 6;
+        this.aceBridge = options.bridge ?? new ModelBridge(clients);
+        // Add system prompt if provided
+        if (this.systemPrompt) {
+            this.messages.push({ role: "system", content: this.systemPrompt });
+            this.displayMessages.push({
+                role: "system",
+                content: `System prompt loaded (${this.systemPrompt.length} chars)`,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    /** Get display messages for rendering */
+    getDisplayMessages() {
+        return this.displayMessages;
+    }
+    /** Is currently streaming a response? */
+    isStreaming() {
+        return this.streaming;
+    }
+    /** Get current model */
+    getModel() {
+        return this.model;
+    }
+    /** Get current provider */
+    getProvider() {
+        return this.provider;
+    }
+    /** Change provider */
+    setProvider(provider) {
+        const normalized = normalizeProvider(provider);
+        if (normalized === this.provider)
+            return;
+        this.provider = normalized;
+        this.displayMessages.push({
+            role: "system",
+            content: `Provider switched to: ${normalized}`,
+            timestamp: Date.now(),
+        });
+        this.emit("updated");
+    }
+    /** Change model */
+    setModel(model) {
+        const trimmed = model.trim();
+        if (!trimmed || trimmed === this.model)
+            return;
+        this.model = trimmed;
+        this.displayMessages.push({
+            role: "system",
+            content: `Model switched to: ${trimmed}`,
+            timestamp: Date.now(),
+        });
+        this.emit("updated");
+    }
+    /** Send a user message and stream the response */
+    async sendMessage(text) {
+        if (this.streaming) {
+            this.emit("error", "Already streaming a response. Wait or press Ctrl+C to interrupt.");
+            return;
+        }
+        // Add user message
+        this.messages.push({ role: "user", content: text });
+        this.displayMessages.push({
+            role: "user",
+            content: text,
+            timestamp: Date.now(),
+            tokens: estimateTokenCount(text),
+        });
+        this.emit("updated");
+        // Start streaming response
+        this.streaming = true;
+        this.currentStreamText = "";
+        const streamProvider = this.provider;
+        const streamModel = this.model;
+        this.activeStreamProvider = streamProvider;
+        const startTime = Date.now();
+        try {
+            if (this.shouldUseAceBridge()) {
+                await this.runAceBridge(text, startTime, streamProvider, streamModel);
+                return;
+            }
+            for await (const chunk of this.streamResponse(streamProvider, streamModel)) {
+                if (!this.streaming)
+                    break; // interrupted
+                if (chunk.text.length > 0) {
+                    this.currentStreamText += chunk.text;
+                    this.emit("stream_chunk", chunk.text, this.currentStreamText);
+                }
+                // Record token telemetry
+                if (chunk.done) {
+                    const promptTokens = chunk.promptTokens ?? estimateTokenCount(text);
+                    const completionTokens = chunk.completionTokens ?? estimateTokenCount(this.currentStreamText);
+                    this.telemetry.recordRequest({
+                        startTime,
+                        endTime: Date.now(),
+                        promptTokens,
+                        completionTokens,
+                        model: streamModel,
+                    });
+                    if (typeof chunk.evalDurationNs === "number" && chunk.evalDurationNs > 0) {
+                        const evalSec = chunk.evalDurationNs / 1_000_000_000;
+                        const tokPerSec = completionTokens / evalSec;
+                        this.emit("telemetry", { tokPerSec, promptTokens, completionTokens });
+                    }
+                }
+            }
+            // Finalize the assistant message
+            this.messages.push({ role: "assistant", content: this.currentStreamText });
+            this.displayMessages.push({
+                role: "assistant",
+                content: this.currentStreamText,
+                timestamp: Date.now(),
+                tokens: estimateTokenCount(this.currentStreamText),
+            });
+        }
+        catch (err) {
+            if (err?.name === "AbortError") {
+                // User interrupted
+                this.displayMessages.push({
+                    role: "system",
+                    content: "[Interrupted]",
+                    timestamp: Date.now(),
+                });
+            }
+            else {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.displayMessages.push({
+                    role: "system",
+                    content: `Error: ${msg}`,
+                    timestamp: Date.now(),
+                });
+                this.emit("error", msg);
+            }
+        }
+        finally {
+            this.streaming = false;
+            this.activeStreamProvider = null;
+            this.activeAceBridge = false;
+            this.currentStreamText = "";
+            this.emit("updated");
+            this.emit("stream_done");
+        }
+    }
+    /** Interrupt current stream */
+    interrupt() {
+        if (!this.streaming)
+            return;
+        const activeProvider = this.activeStreamProvider ?? this.provider;
+        this.streaming = false;
+        if (this.activeAceBridge) {
+            this.aceBridge.interrupt();
+            return;
+        }
+        if (activeProvider === "ollama") {
+            this.clients.ollama.abort();
+            return;
+        }
+        this.clients.openai.abort();
+    }
+    /** Clear conversation history */
+    clear() {
+        this.messages = [];
+        this.displayMessages = [];
+        if (this.systemPrompt) {
+            this.messages.push({ role: "system", content: this.systemPrompt });
+            this.displayMessages.push({
+                role: "system",
+                content: "Conversation cleared. System prompt retained.",
+                timestamp: Date.now(),
+            });
+        }
+        this.emit("updated");
+    }
+    /** Get conversation for export/save */
+    getConversation() {
+        return [...this.messages];
+    }
+    async *streamResponse(provider, model) {
+        if (provider === "ollama") {
+            const stream = this.clients.ollama.chat({
+                model,
+                messages: this.messages,
+                stream: true,
+                options: {
+                    temperature: this.temperature,
+                    top_p: this.topP,
+                    num_ctx: this.numCtx,
+                },
+            });
+            for await (const chunk of stream) {
+                yield {
+                    text: chunk.message?.content ?? "",
+                    done: Boolean(chunk.done),
+                    promptTokens: chunk.prompt_eval_count,
+                    completionTokens: chunk.eval_count,
+                    evalDurationNs: chunk.eval_duration,
+                };
+            }
+            return;
+        }
+        const diagnosis = diagnoseChatRuntimeConfig(provider, model, {
+            baseUrl: this.providerBaseUrls[provider],
+        });
+        if (!diagnosis.ok && diagnosis.missing.length === 0) {
+            throw new Error(diagnosis.message);
+        }
+        const stream = this.clients.openai.chat({
+            provider,
+            model,
+            messages: this.messages,
+            temperature: this.temperature,
+            topP: this.topP,
+        });
+        for await (const chunk of stream) {
+            yield {
+                text: chunk.text,
+                done: chunk.done,
+                promptTokens: chunk.promptTokens,
+                completionTokens: chunk.completionTokens,
+            };
+        }
+    }
+    shouldUseAceBridge() {
+        if (this.aceToolsMode === "off")
+            return false;
+        if (!this.workspaceRoot)
+            return false;
+        if (!existsSync(resolve(this.workspaceRoot, ".agents", "ACE", "agent-state", "TASK.md"))) {
+            return false;
+        }
+        return true;
+    }
+    buildBridgeTask() {
+        const recentConversation = this.messages
+            .filter((message) => message.role !== "system")
+            .slice(-6)
+            .map((message) => `${message.role}: ${message.content}`)
+            .join("\n");
+        return recentConversation || "user: continue";
+    }
+    pushSystemMessage(content) {
+        this.displayMessages.push({
+            role: "system",
+            content,
+            timestamp: Date.now(),
+        });
+        this.emit("updated");
+    }
+    async runAceBridge(text, startTime, streamProvider, streamModel) {
+        if (!this.workspaceRoot) {
+            throw new Error("ACE bridge requires a workspace root.");
+        }
+        this.activeAceBridge = true;
+        let bridgeOutput = "";
+        const result = await this.aceBridge.run({
+            task: this.buildBridgeTask(),
+            role: this.aceRole,
+            workspace: this.workspaceRoot,
+            tier: this.aceTier ?? (this.aceRole === "orchestrator" ? "compressed" : "brief"),
+            maxTurns: this.maxTurns,
+            provider: streamProvider,
+            model: streamModel,
+            numCtx: this.numCtx,
+            onThinking: (thinking) => {
+                this.pushSystemMessage(`Thinking: ${thinking}`);
+            },
+            onToolCall: (tool, args) => {
+                this.pushSystemMessage(`Tool call: ${tool} ${safeStringify(args)}`);
+                this.emit("tool_call", tool, args);
+            },
+            onToolResult: (tool, toolResult) => {
+                this.pushSystemMessage(`Tool ${toolResult.ok ? "ok" : "error"}: ${tool} — ${toolResult.summary}`);
+                this.emit("tool_result", tool, toolResult);
+            },
+            onOutput: (output) => {
+                bridgeOutput = output;
+            },
+        });
+        const assistantText = bridgeOutput.trim() || result.summary.trim() || "ACE bridge completed.";
+        this.messages.push({ role: "assistant", content: assistantText });
+        this.displayMessages.push({
+            role: "assistant",
+            content: assistantText,
+            timestamp: Date.now(),
+            tokens: estimateTokenCount(assistantText),
+        });
+        if (result.status === "needs_input") {
+            this.pushSystemMessage("[Awaiting operator follow-up]");
+        }
+        this.telemetry.recordRequest({
+            startTime,
+            endTime: Date.now(),
+            promptTokens: estimateTokenCount(text),
+            completionTokens: estimateTokenCount(assistantText),
+            model: streamModel,
+        });
+    }
+}
+function normalizeProvider(input) {
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "openai")
+        return "codex";
+    if (normalized === "anthropic")
+        return "claude";
+    if (normalized === "google")
+        return "gemini";
+    if (["llamacpp", "llama-cpp", "llama.cpp"].includes(normalized))
+        return "llama.cpp";
+    return normalized || "ollama";
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return "{}";
+    }
+}
+//# sourceMappingURL=chat.js.map

package/dist/tui/commands.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ACE-TUI Command Registry
+ *
+ * KFE (Keys For Everything) command definitions.
+ * Single command vocabulary for human operators, agents, and playbooks.
+ */
+export interface CommandDef {
+    name: string;
+    aliases: string[];
+    description: string;
+    usage: string;
+    handler: (args: string[], ctx: CommandContext) => Promise<void> | void;
+    completeFn?: (partial: string, ctx: CommandContext) => string[];
+}
+export interface CommandContext {
+    tui: TuiController;
+}
+/** Interface that the TUI main module must implement for commands to interact with it */
+export interface TuiController {
+    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 class CommandRegistry {
+    private commands;
+    register(cmd: CommandDef): void;
+    get(name: string): CommandDef | undefined;
+    getAll(): CommandDef[];
+    /** Parse and execute a command string */
+    execute(input: string, ctx: CommandContext): Promise<void>;
+    /** Get completions for a partial command */
+    complete(partial: string, ctx?: CommandContext): string[];
+}
+export declare function registerBuiltinCommands(registry: CommandRegistry): void;
+//# sourceMappingURL=commands.d.ts.map