@tyvm/knowhow 0.0.9 → 0.0.11

package/ts_build/src/ui/InkChatUI.js

@@ -0,0 +1,792 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React, { useState, useEffect, useRef } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import Spinner from "ink-spinner";
+import { Agents } from "../services/AgentService";
+import { Clients } from "../clients";
+import { FlagsService } from "../services/flags";
+import { formatChatInput } from "../chat";
+import { queryEmbedding, getConfiguredEmbeddingMap } from "../embeddings";
+import { recordAudio, voiceToText } from "../microphone";
+import { Models } from "../ai";
+import { getConfig } from "../config";
+var ChatFlags;
+(function (ChatFlags) {
+    ChatFlags["attach"] = "attach";
+    ChatFlags["agent"] = "agent";
+    ChatFlags["agents"] = "agents";
+    ChatFlags["debug"] = "debug";
+    ChatFlags["multi"] = "multi";
+    ChatFlags["model"] = "model";
+    ChatFlags["search"] = "search";
+    ChatFlags["clear"] = "clear";
+    ChatFlags["provider"] = "provider";
+    ChatFlags["voice"] = "voice";
+    ChatFlags["help"] = "help";
+    ChatFlags["verbose"] = "verbose";
+})(ChatFlags || (ChatFlags = {}));
+var UIMode;
+(function (UIMode) {
+    UIMode["CHAT"] = "chat";
+    UIMode["AGENT_SELECT"] = "agent_select";
+    UIMode["TASK_SELECT"] = "task_select";
+    UIMode["VOICE_RECORD"] = "voice_record";
+    UIMode["AGENT_THREAD"] = "agent_thread";
+})(UIMode || (UIMode = {}));
+const taskRegistry = new Map();
+const ChatModelDefaults = {
+    openai: Models.openai.GPT_4o,
+    anthropic: Models.anthropic.Sonnet4,
+    google: Models.google.Gemini_25_Flash_Preview,
+    xai: Models.xai.Grok3Beta,
+};
+function CostDisplay({ agent }) {
+    const [totalCost, setTotalCost] = useState(0);
+    useEffect(() => {
+        if (!agent) {
+            setTotalCost(0);
+            return;
+        }
+        setTotalCost(agent.getTotalCostUsd());
+        const costUpdateListener = (cost) => {
+            setTotalCost(cost);
+        };
+        agent.agentEvents.on(agent.eventTypes.costUpdate, costUpdateListener);
+        return () => {
+            agent.agentEvents.off(agent.eventTypes.costUpdate, costUpdateListener);
+        };
+    }, [agent]);
+    if (!agent || totalCost === 0)
+        return null;
+    return (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\uD83D\uDCB0 $", totalCost.toFixed(4), " USD"] }) }));
+}
+function CustomTextInput({ value, onChange, onSubmit, placeholder = "", suggestions = [], enabled = true, }) {
+    const [cursor, setCursor] = useState(0);
+    const [suggestionIndex, setSuggestionIndex] = useState(0);
+    const [showSuggestions, setShowSuggestions] = useState(false);
+    useEffect(() => {
+        setCursor(value.length);
+    }, [value]);
+    useEffect(() => {
+        const filteredSuggestions = suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+        setShowSuggestions(value.length > 0 && filteredSuggestions.length > 0);
+        setSuggestionIndex(0);
+    }, [value, suggestions]);
+    useInput((input, key) => {
+        if (!enabled)
+            return;
+        if (key.return) {
+            onSubmit(value);
+            return;
+        }
+        if (key.tab && showSuggestions && suggestions.length > 0) {
+            const filteredSuggestions = suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+            if (filteredSuggestions[suggestionIndex]) {
+                onChange(filteredSuggestions[suggestionIndex]);
+                setShowSuggestions(false);
+            }
+            return;
+        }
+        if (key.upArrow && showSuggestions) {
+            const filteredSuggestions = suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+            setSuggestionIndex(Math.max(0, suggestionIndex - 1));
+            return;
+        }
+        if (key.downArrow && showSuggestions) {
+            const filteredSuggestions = suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+            setSuggestionIndex(Math.min(filteredSuggestions.length - 1, suggestionIndex + 1));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (value.length > 0) {
+                onChange(value.slice(0, -1));
+            }
+            return;
+        }
+        if (key.escape) {
+            setShowSuggestions(false);
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            onChange(value + input);
+        }
+    });
+    const filteredSuggestions = suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: value || placeholder }), _jsx(Text, { color: "gray", children: "\u2502" })] }), showSuggestions && filteredSuggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: "Suggestions (Tab to complete):" }), filteredSuggestions.slice(0, 5).map((suggestion, index) => (_jsxs(Text, { color: index === suggestionIndex ? "cyan" : "gray", bold: index === suggestionIndex, children: [index === suggestionIndex ? "→ " : "  ", suggestion] })))] }))] }));
+}
+function AgentSelect({ agents, onSelect, onCancel }) {
+    const [input, setInput] = useState("");
+    useInput((inputChar, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+    });
+    const handleSubmit = (value) => {
+        if (agents.includes(value)) {
+            onSelect(value);
+        }
+        else {
+            const match = agents.find((agent) => agent.toLowerCase().startsWith(value.toLowerCase()));
+            if (match) {
+                onSelect(match);
+            }
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { borderStyle: "single", borderColor: "cyan", padding: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83E\uDD16 Select Agent" }) }), _jsxs(Box, { padding: 1, children: [_jsx(Text, { color: "white", children: "Available agents:" }), agents.map((agent, index) => (_jsxs(Text, { color: "gray", children: ["\u2022 ", agent] })))] }), _jsxs(Box, { borderStyle: "single", borderColor: "green", padding: 1, children: [_jsx(Text, { color: "green", children: "Agent: " }), _jsx(CustomTextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: "Type agent name...", suggestions: agents })] }), _jsx(Text, { color: "gray", children: "Press Tab to auto-complete, Enter to select, Esc to cancel" })] }));
+}
+function TaskSelect({ tasks, onSelect, onCancel }) {
+    const [input, setInput] = useState("");
+    useInput((inputChar, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+    });
+    const handleSubmit = (value) => {
+        if (tasks.includes(value)) {
+            onSelect(value);
+        }
+        else {
+            const match = tasks.find((task) => task.toLowerCase().includes(value.toLowerCase()));
+            if (match) {
+                onSelect(match);
+            }
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { borderStyle: "single", borderColor: "yellow", padding: 1, children: _jsx(Text, { color: "yellow", bold: true, children: "\uD83D\uDD17 Reattach to Running Task" }) }), _jsxs(Box, { padding: 1, children: [_jsx(Text, { color: "white", children: "Running tasks:" }), tasks.length === 0 ? (_jsx(Text, { color: "gray", children: "No running tasks available" })) : (tasks.map((task, index) => (_jsxs(Text, { color: "gray", children: ["\u2022 ", task.substring(0, 80), "..."] }))))] }), _jsxs(Box, { borderStyle: "single", borderColor: "green", padding: 1, children: [_jsx(Text, { color: "green", children: "Task: " }), _jsx(CustomTextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: "Type task description...", suggestions: tasks })] }), _jsx(Text, { color: "gray", children: "Press Tab to auto-complete, Enter to select, Esc to cancel" })] }));
+}
+function VoiceRecord({ onComplete, onCancel }) {
+    const [isRecording, setIsRecording] = useState(false);
+    const [status, setStatus] = useState("Ready to record");
+    const audioRecorderRef = useRef(null);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (isRecording && audioRecorderRef.current) {
+                audioRecorderRef.current.stop();
+                setIsRecording(false);
+            }
+            onCancel();
+            return;
+        }
+        if (key.return) {
+            if (!isRecording) {
+                startRecording();
+            }
+            else {
+                stopRecording();
+            }
+        }
+    });
+    const startRecording = async () => {
+        try {
+            setStatus("Starting recording...");
+            const recorder = await recordAudio();
+            if (recorder) {
+                audioRecorderRef.current = recorder;
+                setIsRecording(true);
+                setStatus("🔴 Recording... (Press Enter to stop)");
+            }
+        }
+        catch (error) {
+            setStatus(`❌ Failed to start recording: ${error.message}`);
+        }
+    };
+    const stopRecording = async () => {
+        if (!audioRecorderRef.current)
+            return;
+        try {
+            setStatus("🔄 Processing recording...");
+            audioRecorderRef.current.stop();
+            setIsRecording(false);
+            const transcription = await voiceToText();
+            if (transcription) {
+                onComplete(transcription);
+            }
+            else {
+                setStatus("❌ No transcription received");
+            }
+        }
+        catch (error) {
+            setStatus(`❌ Transcription failed: ${error.message}`);
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { borderStyle: "single", borderColor: "magenta", padding: 1, children: _jsx(Text, { color: "magenta", bold: true, children: "\uD83C\uDFA4 Voice Input Mode" }) }), _jsx(Box, { padding: 1, children: _jsx(Text, { color: "white", children: status }) }), _jsx(Box, { padding: 1, children: _jsx(Text, { color: "gray", children: isRecording
+                        ? "Press Enter to stop recording, Esc to cancel"
+                        : "Press Enter to start recording, Esc to cancel" }) })] }));
+}
+export function InkChatUI() {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [inputBuffer, setInputBuffer] = useState("");
+    const removeTaskFromRegistry = (agent) => {
+        const taskKey = Array.from(taskRegistry.keys()).find((key) => taskRegistry.get(key) === agent);
+        if (taskKey)
+            taskRegistry.delete(taskKey);
+    };
+    const [isLoading, setIsLoading] = useState(false);
+    const [inputHistory, setInputHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [uiMode, setUIMode] = useState(UIMode.CHAT);
+    const [showHelp, setShowHelp] = useState(false);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [activeAgent, setActiveAgent] = useState(null);
+    const [agentThread, setAgentThread] = useState([]);
+    const [agentEventListeners, setAgentEventListeners] = useState([]);
+    const [provider, setProvider] = useState("openai");
+    const [model, setModel] = useState(ChatModelDefaults.openai);
+    const [chatHistory, setChatHistory] = useState([]);
+    const [plugins, setPlugins] = useState([]);
+    const [flags, setFlags] = useState(new FlagsService([
+        ChatFlags.agent,
+        ChatFlags.debug,
+        ChatFlags.multi,
+        ChatFlags.voice,
+        ChatFlags.verbose,
+    ], true));
+    const [availableAgents, setAvailableAgents] = useState([]);
+    const [config, setConfig] = useState(null);
+    useEffect(() => {
+        const initializeServices = async () => {
+            try {
+                const appConfig = await getConfig();
+                setConfig(appConfig);
+                setPlugins(appConfig.plugins || ["embeddings", "files", "github"]);
+                await Agents.loadAgentsFromConfig();
+                const agentList = Agents.listAgents();
+                setAvailableAgents(agentList);
+                setMessages([
+                    {
+                        role: "system",
+                        content: "🧠 Welcome to Knowhow Chat UI! Type /help for commands.",
+                    },
+                ]);
+            }
+            catch (error) {
+                console.error("Failed to initialize services:", error);
+                setMessages([
+                    {
+                        role: "system",
+                        content: "⚠️ Warning: Failed to initialize some services.",
+                    },
+                ]);
+            }
+        };
+        initializeServices();
+    }, []);
+    useEffect(() => {
+        if (activeAgent && uiMode === UIMode.AGENT_THREAD) {
+            setupAgentEventListeners(activeAgent);
+        }
+        return () => {
+            cleanupAgentEventListeners();
+        };
+    }, [activeAgent, uiMode]);
+    const setupAgentEventListeners = (agent) => {
+        cleanupAgentEventListeners();
+        const listeners = [];
+        const threadUpdateListener = (messages) => {
+            const convertedMessages = messages.map((msg, index) => ({
+                ...msg,
+                messageId: `${Date.now()}-${index}`,
+                timestamp: Date.now(),
+            }));
+            setAgentThread(convertedMessages);
+        };
+        const toolUsedListener = ({ toolCall, functionResponse }) => {
+            const toolMessage = {
+                role: "tool",
+                content: flags.enabled(ChatFlags.verbose)
+                    ? JSON.stringify(functionResponse, null, 2)
+                    : truncateContent(String(functionResponse), 200),
+                toolName: toolCall.function.name,
+                toolArgs: flags.enabled(ChatFlags.verbose)
+                    ? toolCall.function.arguments
+                    : truncateContent(JSON.stringify(toolCall.function.arguments), 100),
+                isToolCall: true,
+                timestamp: Date.now(),
+                messageId: `tool-${Date.now()}`,
+            };
+            setAgentThread((prev) => [...prev, toolMessage]);
+        };
+        const doneListener = (result) => {
+            setIsLoading(false);
+            const doneMessage = {
+                role: "assistant",
+                content: result || "Agent completed",
+                agentName: agent.name,
+                timestamp: Date.now(),
+                messageId: `done-${Date.now()}`,
+            };
+            setAgentThread((prev) => [...prev, doneMessage]);
+        };
+        agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateListener);
+        agent.agentEvents.on(agent.eventTypes.toolUsed, toolUsedListener);
+        agent.agentEvents.on(agent.eventTypes.done, doneListener);
+        listeners.push(() => agent.agentEvents.off(agent.eventTypes.threadUpdate, threadUpdateListener), () => agent.agentEvents.off(agent.eventTypes.toolUsed, toolUsedListener), () => agent.agentEvents.off(agent.eventTypes.done, doneListener));
+        setAgentEventListeners(listeners);
+    };
+    const cleanupAgentEventListeners = () => {
+        agentEventListeners.forEach((cleanup) => cleanup());
+        setAgentEventListeners([]);
+    };
+    const truncateContent = (content, maxLength) => {
+        if (content.length <= maxLength)
+            return content;
+        return content.substring(0, maxLength) + "...";
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            exit();
+            return;
+        }
+        if (uiMode === UIMode.CHAT) {
+            if (key.upArrow && inputHistory.length > 0) {
+                const newIndex = Math.min(historyIndex + 1, inputHistory.length - 1);
+                setHistoryIndex(newIndex);
+                setInputBuffer(inputHistory[newIndex]);
+                return;
+            }
+            if (key.downArrow) {
+                if (historyIndex > 0) {
+                    const newIndex = historyIndex - 1;
+                    setHistoryIndex(newIndex);
+                    setInputBuffer(inputHistory[newIndex]);
+                }
+                else if (historyIndex === 0) {
+                    setHistoryIndex(-1);
+                    setInputBuffer("");
+                }
+                return;
+            }
+            if (key.pageUp) {
+                setScrollOffset(Math.max(0, scrollOffset - 5));
+                return;
+            }
+            if (key.pageDown) {
+                setScrollOffset(Math.min(messages.length, scrollOffset + 5));
+                return;
+            }
+        }
+    });
+    const addToHistory = (message) => {
+        setInputHistory((prev) => {
+            const newHistory = [message, ...prev.slice(0, 49)];
+            return newHistory;
+        });
+        setHistoryIndex(-1);
+    };
+    const askAI = async (prompt, _provider, _model) => {
+        const client = Clients.clients[_provider];
+        if (!client) {
+            throw new Error(`Provider ${_provider} not found`);
+        }
+        const response = await client.createChatCompletion({
+            model: _model,
+            messages: [{ role: "user", content: prompt }],
+            max_tokens: 2000,
+        });
+        return response.choices[0]?.message?.content || "No response received";
+    };
+    const handleSendMessage = async (message) => {
+        if (!message.trim())
+            return;
+        addToHistory(message);
+        const userMessage = message.trim();
+        if (userMessage.startsWith("/")) {
+            await handleCommand(userMessage);
+            return;
+        }
+        const newMessage = {
+            role: "user",
+            content: userMessage,
+        };
+        if (uiMode === UIMode.AGENT_THREAD && activeAgent) {
+            setAgentThread((prev) => [...prev, newMessage]);
+            const isAgentRunning = Array.from(taskRegistry.values()).includes(activeAgent);
+            if (!isAgentRunning) {
+                setIsLoading(true);
+                try {
+                    const formattedPrompt = await formatChatInput(userMessage, config.plugins, chatHistory);
+                    activeAgent.newTask();
+                    taskRegistry.set(userMessage, activeAgent);
+                    await activeAgent.call(formattedPrompt);
+                }
+                catch (error) {
+                    throw error;
+                }
+            }
+            else {
+                activeAgent.addPendingUserMessage(newMessage);
+            }
+            setInputBuffer("");
+            return;
+        }
+        else {
+            setMessages((prev) => [...prev, newMessage]);
+        }
+        setIsLoading(true);
+        setInputBuffer("");
+        try {
+            const formattedPrompt = await formatChatInput(userMessage, plugins, chatHistory);
+            const interaction = { input: userMessage, output: "" };
+            let response = "";
+            let responseMessage;
+            console.log(flags.enabled(ChatFlags.agent), activeAgent);
+            if (flags.enabled(ChatFlags.agent) && activeAgent) {
+                activeAgent.newTask();
+                taskRegistry.set(userMessage, activeAgent);
+                response = await activeAgent.call(formattedPrompt);
+                responseMessage = {
+                    role: "assistant",
+                    content: response || "Agent completed without output",
+                    agentName: activeAgent.name,
+                };
+                setMessages((prev) => [...prev, responseMessage]);
+            }
+            else {
+                response = await askAI(formattedPrompt, provider, model);
+                responseMessage = {
+                    role: "assistant",
+                    content: response,
+                    agentName: `${provider}/${model}`,
+                };
+                setMessages((prev) => [...prev, responseMessage]);
+            }
+            interaction.output = response;
+            setChatHistory((prev) => [...prev, interaction]);
+        }
+        catch (error) {
+            const errorMessage = {
+                role: "system",
+                content: `❌ Error: ${error.message}`,
+            };
+            if (uiMode === UIMode.AGENT_THREAD) {
+                setAgentThread((prev) => [...prev, errorMessage]);
+            }
+            else {
+                setMessages((prev) => [...prev, errorMessage]);
+            }
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    const handleCommand = async (command) => {
+        const [cmd, ...args] = command.split(" ");
+        const arg = args.join(" ");
+        switch (cmd) {
+            case "/exit":
+                exit();
+                break;
+            case "/clear":
+                if (uiMode === UIMode.AGENT_THREAD) {
+                    setAgentThread([]);
+                }
+                else {
+                    setMessages([]);
+                }
+                setChatHistory([]);
+                break;
+            case "/help":
+                setShowHelp(!showHelp);
+                break;
+            case "/agents":
+                if (availableAgents.length === 0) {
+                    addSystemMessage("No agents available. Check your configuration.");
+                }
+                else {
+                    setUIMode(UIMode.AGENT_SELECT);
+                }
+                break;
+            case "/voice":
+                setUIMode(UIMode.VOICE_RECORD);
+                break;
+            case "/detach":
+                if (uiMode === UIMode.AGENT_THREAD) {
+                    setUIMode(UIMode.CHAT);
+                    addSystemMessage(`🔗 Detached from agent thread`);
+                }
+                else {
+                    addSystemMessage("Not currently in an agent thread");
+                }
+                break;
+            case "/attach":
+                if (uiMode === UIMode.AGENT_THREAD) {
+                    addSystemMessage("Already in an agent thread. Use /detach first.");
+                }
+                else if (taskRegistry.size > 0) {
+                    setUIMode(UIMode.TASK_SELECT);
+                }
+                else {
+                    addSystemMessage("No running tasks available to attach to.");
+                }
+                break;
+            case "/pause":
+                if (activeAgent && uiMode === UIMode.AGENT_THREAD) {
+                    activeAgent.pause();
+                    removeTaskFromRegistry(activeAgent);
+                    addSystemMessage(`⏸️ Paused agent: ${activeAgent.name}`);
+                }
+                else {
+                    addSystemMessage("No active agent to pause");
+                }
+                break;
+            case "/kill":
+                if (activeAgent && uiMode === UIMode.AGENT_THREAD) {
+                    await activeAgent.kill();
+                    for (const [task, agent] of taskRegistry.entries()) {
+                        if (agent === activeAgent)
+                            taskRegistry.delete(task);
+                    }
+                    addSystemMessage(`💀 Killed agent: ${activeAgent.name}`);
+                    setUIMode(UIMode.CHAT);
+                    setActiveAgent(null);
+                }
+                else {
+                    addSystemMessage("No active agent to kill");
+                }
+                break;
+            case "/agent":
+                flags.flip(ChatFlags.agent);
+                const agentStatus = flags.enabled(ChatFlags.agent)
+                    ? "enabled"
+                    : "disabled";
+                addSystemMessage(`🤖 Agent mode ${agentStatus}`);
+                break;
+            case "/provider":
+                if (!arg) {
+                    const providers = Object.keys(Clients.clients);
+                    addSystemMessage(`🔗 Available providers: ${providers.join(", ")}\nCurrent: ${provider}`);
+                }
+                else {
+                    if (Clients.clients[arg]) {
+                        setProvider(arg);
+                        setModel(ChatModelDefaults[arg] || "");
+                        addSystemMessage(`🔗 Provider changed to: ${arg}`);
+                    }
+                    else {
+                        addSystemMessage(`❌ Provider '${arg}' not found`);
+                    }
+                }
+                break;
+            case "/model":
+                if (!arg) {
+                    const models = Clients.getRegisteredModels(provider);
+                    addSystemMessage(`🎯 Available models for ${provider}: ${models.join(", ")}\nCurrent: ${model}`);
+                }
+                else {
+                    const models = Clients.getRegisteredModels(provider);
+                    if (models.includes(arg)) {
+                        setModel(arg);
+                        addSystemMessage(`🎯 Model changed to: ${arg}`);
+                    }
+                    else {
+                        addSystemMessage(`❌ Model '${arg}' not available for ${provider}`);
+                    }
+                }
+                break;
+            case "/debug":
+                flags.flip(ChatFlags.debug);
+                const debugStatus = flags.enabled(ChatFlags.debug)
+                    ? "enabled"
+                    : "disabled";
+                addSystemMessage(`🔍 Debug mode ${debugStatus}`);
+                break;
+            case "/multi":
+                flags.flip(ChatFlags.multi);
+                const multiStatus = flags.enabled(ChatFlags.multi)
+                    ? "enabled"
+                    : "disabled";
+                addSystemMessage(`📝 Multi-line mode ${multiStatus}`);
+                break;
+            case "/verbose":
+                flags.flip(ChatFlags.verbose);
+                const verboseStatus = flags.enabled(ChatFlags.verbose)
+                    ? "enabled"
+                    : "disabled";
+                addSystemMessage(`🔍 Verbose mode ${verboseStatus}`);
+                break;
+            case "/continue":
+                if (activeAgent && uiMode === UIMode.AGENT_THREAD) {
+                    setIsLoading(true);
+                    try {
+                        const response = await activeAgent.call("");
+                    }
+                    catch (error) {
+                        addSystemMessage(`❌ Error continuing agent: ${error.message}`);
+                    }
+                    finally {
+                        setIsLoading(false);
+                    }
+                }
+                else {
+                    addSystemMessage("No active agent thread to continue");
+                }
+                break;
+            case "/search":
+                if (!arg) {
+                    addSystemMessage("Usage: /search <query>");
+                    return;
+                }
+                try {
+                    const embeddingMap = await getConfiguredEmbeddingMap();
+                    const results = await queryEmbedding(arg, Object.values(embeddingMap).flat());
+                    const resultText = results.length > 0
+                        ? results
+                            .map((r) => `• ${r.text.substring(0, 100)}...`)
+                            .join("\n")
+                        : "No results found";
+                    addSystemMessage(`🔍 Search results for "${arg}":\n${resultText}`);
+                }
+                catch (error) {
+                    addSystemMessage(`❌ Search failed: ${error.message}`);
+                }
+                break;
+            default:
+                addSystemMessage(`❌ Unknown command: ${cmd}. Type /help for available commands.`);
+                break;
+        }
+    };
+    const addSystemMessage = (content) => {
+        const message = { role: "system", content };
+        if (uiMode === UIMode.AGENT_THREAD) {
+            setAgentThread((prev) => [...prev, message]);
+        }
+        else {
+            setMessages((prev) => [...prev, message]);
+        }
+    };
+    const handleAgentSelect = (agentName) => {
+        const selectedAgent = Agents.getAgent(agentName);
+        if (selectedAgent) {
+            cleanupAgentEventListeners();
+            setActiveAgent(selectedAgent);
+            setUIMode(UIMode.AGENT_THREAD);
+            flags.enable(ChatFlags.agent);
+            const initialMessage = {
+                role: "system",
+                content: `🤖 Started thread with agent: ${selectedAgent.name}\nUse /detach to leave thread, /pause to pause agent, /kill to terminate agent, /continue to process pending messages`,
+                timestamp: Date.now(),
+                messageId: `init-${Date.now()}`,
+            };
+            setAgentThread([initialMessage]);
+        }
+    };
+    const handleTaskCancel = () => {
+        setUIMode(UIMode.CHAT);
+    };
+    const handleTaskSelect = (taskDescription) => {
+        const selectedAgent = taskRegistry.get(taskDescription);
+        if (selectedAgent) {
+            cleanupAgentEventListeners();
+            setActiveAgent(selectedAgent);
+            setUIMode(UIMode.AGENT_THREAD);
+            setAgentThread([
+                {
+                    role: "system",
+                    content: `🔗 Reattached to agent: ${selectedAgent.name} working on: "${taskDescription.substring(0, 50)}..."\nUse /detach to leave thread, /pause to pause agent, /kill to terminate agent`,
+                },
+            ]);
+        }
+    };
+    const handleVoiceComplete = (text) => {
+        setInputBuffer(text);
+        setUIMode(UIMode.CHAT);
+        addSystemMessage(`🎤 Voice transcription: "${text}"`);
+    };
+    const handleCancel = () => {
+        setUIMode(UIMode.CHAT);
+    };
+    const getDisplayRole = (msg) => {
+        if (msg.role === "system")
+            return "🔧 System";
+        if (msg.role === "user")
+            return "👤 You";
+        if (msg.role === "tool") {
+            return `🔧 ${msg.toolName || "Tool"}`;
+        }
+        if (msg.agentName)
+            return `🤖 ${msg.agentName}`;
+        return "🤖 AI";
+    };
+    const getDisplayColor = (msg) => {
+        if (msg.role === "user")
+            return "green";
+        if (msg.role === "system")
+            return "gray";
+        if (msg.role === "tool")
+            return "yellow";
+        return "blue";
+    };
+    const formatMessageContent = (msg) => {
+        if (msg.role === "tool") {
+            if (msg.toolName) {
+                const argsDisplay = flags.enabled(ChatFlags.verbose)
+                    ? `\nArgs: ${msg.toolArgs}`
+                    : msg.toolArgs
+                        ? ` (${msg.toolArgs})`
+                        : "";
+                const resultDisplay = flags.enabled(ChatFlags.verbose)
+                    ? `\nResult: ${msg.content}`
+                    : msg.content;
+                return `Called ${msg.toolName}${argsDisplay}${flags.enabled(ChatFlags.verbose)
+                    ? resultDisplay
+                    : "\n↳ " + resultDisplay}`;
+            }
+        }
+        else {
+            return msg.content;
+        }
+    };
+    const commands = [
+        "/agent",
+        "/agents",
+        "/attach",
+        "/clear",
+        "/continue",
+        "/verbose",
+        "/debug",
+        "/detach",
+        "/exit",
+        "/help",
+        "/kill",
+        "/model",
+        "/multi",
+        "/pause",
+        "/provider",
+        "/search",
+        "/voice",
+    ];
+    const currentMessages = uiMode === UIMode.AGENT_THREAD ? agentThread : messages;
+    const promptText = () => {
+        switch (uiMode) {
+            case UIMode.AGENT_THREAD:
+                return `🧵 Thread with ${activeAgent?.name}: `;
+            case UIMode.CHAT:
+                return flags.enabled(ChatFlags.agent) && activeAgent
+                    ? `Ask ${activeAgent.name}: `
+                    : "Ask AI: ";
+            default:
+                return "Input: ";
+        }
+    };
+    if (uiMode === UIMode.AGENT_SELECT) {
+        return (_jsx(AgentSelect, { agents: availableAgents, onSelect: handleAgentSelect, onCancel: handleCancel }));
+    }
+    if (uiMode === UIMode.TASK_SELECT) {
+        return (_jsx(TaskSelect, { tasks: Array.from(taskRegistry.keys()), onSelect: handleTaskSelect, onCancel: handleTaskCancel }));
+    }
+    if (uiMode === UIMode.VOICE_RECORD) {
+        return (_jsx(VoiceRecord, { onComplete: handleVoiceComplete, onCancel: handleCancel }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(Box, { borderStyle: "single", borderColor: "blue", padding: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "blue", bold: true, children: ["\uD83E\uDDE0 Knowhow Chat Interface", uiMode === UIMode.AGENT_THREAD && activeAgent && (_jsxs(Text, { color: "cyan", children: [" | \uD83E\uDDF5 Thread: ", activeAgent.name] })), uiMode === UIMode.CHAT && (_jsxs(Text, { color: "gray", children: [" ", "| Provider: ", provider, " Model: ", model] }))] }), ((uiMode === UIMode.AGENT_THREAD && activeAgent) ||
+                            (uiMode === UIMode.CHAT &&
+                                flags.enabled(ChatFlags.agent) &&
+                                activeAgent)) && _jsx(CostDisplay, { agent: activeAgent })] }) }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, padding: 1, children: [currentMessages.slice(scrollOffset).map((msg, index) => (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: getDisplayColor(msg), children: [getDisplayRole(msg), ": ", formatMessageContent(msg)] }) }, `msg-${scrollOffset + index}`))), isLoading && (_jsx(Box, { children: _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " ", uiMode === UIMode.AGENT_THREAD && activeAgent
+                                    ? `${activeAgent.name} is working...`
+                                    : "Processing..."] }) }))] }), _jsxs(Box, { borderStyle: "single", borderColor: "green", padding: 1, children: [_jsxs(Text, { color: "green", children: ["\uD83D\uDCAC ", promptText()] }), _jsx(CustomTextInput, { value: inputBuffer, onChange: setInputBuffer, onSubmit: handleSendMessage, placeholder: flags.enabled(ChatFlags.multi)
+                            ? "Type your message (multi-line enabled)..."
+                            : "Type your message or command...", suggestions: inputBuffer.startsWith("/") ? commands : [], enabled: uiMode === UIMode.CHAT || uiMode === UIMode.AGENT_THREAD })] }), showHelp && (_jsx(Box, { borderStyle: "single", borderColor: "magenta", padding: 1, backgroundColor: "black", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCDA Help & Commands:" }), _jsx(Text, { color: "white", children: "\u2022 /agents - Select and start thread with agent" }), _jsx(Text, { color: "white", children: "\u2022 /agent - Toggle agent mode" }), _jsx(Text, { color: "white", children: "\u2022 /voice - Switch to voice input mode" }), _jsx(Text, { color: "white", children: "\u2022 /detach - Leave current agent thread" }), _jsx(Text, { color: "white", children: "\u2022 /attach - Reattach to a running task" }), _jsx(Text, { color: "white", children: "\u2022 /pause - Pause current agent" }), _jsx(Text, { color: "white", children: "\u2022 /kill - Terminate current agent" }), _jsx(Text, { color: "white", children: "\u2022 /provider [name] - Change AI provider" }), _jsx(Text, { color: "white", children: "\u2022 /model [name] - Change AI model" }), _jsx(Text, { color: "white", children: "\u2022 /search [ query ] - Search embeddings" }), _jsx(Text, { color: "white", children: "\u2022 /clear - Clear chat history" }), _jsx(Text, { color: "white", children: "\u2022 /debug - Toggle debug mode" }), _jsx(Text, { color: "white", children: "\u2022 /multi - Toggle multi-line input" }), _jsx(Text, { color: "white", children: "\u2022 /verbose - Toggle verbose tool output" }), _jsx(Text, { color: "white", children: "\u2022 /continue - Continue agent execution with pending messages" }), _jsx(Text, { color: "white", children: "\u2022 /help - Show/hide this help" }), _jsx(Text, { color: "white", children: "\u2022 /exit - Exit application" }), _jsx(Text, { color: "gray", children: "\u2022 Up/Down: History | PgUp/PgDn: Scroll | Tab: Auto-complete | Ctrl+C: Exit" })] }) }))] }));
+}
+//# sourceMappingURL=InkChatUI.js.map