whale-code 6.4.0

package/dist/cli/chat/hooks/useAgentLoop.js

@@ -0,0 +1,382 @@
+/**
+ * useAgentLoop — agent loop runner extracted from ChatApp
+ *
+ * All consumers should import from ChatApp (re-export facade).
+ */
+import { useCallback, useRef } from "react";
+import { runAgentLoop } from "../../services/agent-loop.js";
+import { AgentEventEmitter } from "../../services/agent-events.js";
+import { listBackups } from "../../services/file-history.js";
+function randomVerb() {
+    const THINKING_VERBS = [
+        "thinking\u2026", "reasoning\u2026", "considering\u2026", "analyzing\u2026", "evaluating\u2026",
+        "pondering\u2026", "processing\u2026", "reflecting\u2026", "examining\u2026", "working\u2026",
+    ];
+    return THINKING_VERBS[Math.floor(Math.random() * THINKING_VERBS.length)];
+}
+export function useAgentLoop(deps) {
+    const { isStreaming, thinkingEnabled, conversationRef, abortRef, accTextRef, lastContentUpdateRef, thinkingVerbRef, rewindManagerRef, turnIndexRef, setMessages, setStreamingText, setIsStreaming, setActiveTools, setSubagentActivity, setCompletedSubagents, setTeamState, } = deps;
+    // Single ref for the unified flush timer — survives across handleSend calls for cleanup
+    const flushTimerRef = useRef(null);
+    const handleSend = useCallback(async (userMessage, images) => {
+        if (isStreaming)
+            return;
+        setMessages((prev) => [...prev, {
+                role: "user",
+                text: userMessage,
+                images: images?.map(img => img.name),
+            }]);
+        setStreamingText("");
+        setActiveTools([]);
+        setSubagentActivity(new Map());
+        setCompletedSubagents([]);
+        setTeamState(null);
+        setIsStreaming(true);
+        thinkingVerbRef.current = randomVerb();
+        const abort = new AbortController();
+        abortRef.current = abort;
+        accTextRef.current = "";
+        const toolCalls = [];
+        let usage;
+        // ── Unified render batching ──
+        // All events accumulate in local state; ONE 100ms timer flushes all dirty fields.
+        // This replaces 3 separate timers (text: 150ms, tool_output: 250ms, team: 200ms)
+        // and adds batching for previously-unbatched subagent events.
+        const dirty = { text: false, tools: false, team: false, subagents: false };
+        const subagentMap = new Map();
+        const pendingCompleted = [];
+        function markDirty(field) {
+            dirty[field] = true;
+            if (!flushTimerRef.current) {
+                flushTimerRef.current = setTimeout(flushAll, 100);
+            }
+        }
+        function cancelFlush() {
+            if (flushTimerRef.current) {
+                clearTimeout(flushTimerRef.current);
+                flushTimerRef.current = null;
+            }
+        }
+        function flushAll() {
+            flushTimerRef.current = null;
+            if (dirty.text) {
+                setStreamingText(accTextRef.current);
+                dirty.text = false;
+            }
+            if (dirty.tools) {
+                setActiveTools([...toolCalls]);
+                dirty.tools = false;
+            }
+            if (dirty.team) {
+                setTeamState({
+                    name: teamName, tasksCompleted: teamCompleted,
+                    tasksTotal: teamTotal, teammates: new Map(teammateStatus),
+                });
+                dirty.team = false;
+            }
+            if (dirty.subagents) {
+                setSubagentActivity(new Map(subagentMap));
+                if (pendingCompleted.length > 0) {
+                    const batch = pendingCompleted.splice(0);
+                    setCompletedSubagents(prev => [...prev, ...batch]);
+                }
+                dirty.subagents = false;
+            }
+            lastContentUpdateRef.current = Date.now();
+        }
+        const flushText = () => {
+            const text = accTextRef.current;
+            if (text.trim()) {
+                setMessages(prev => [...prev, { role: "assistant", text }]);
+            }
+            accTextRef.current = "";
+            dirty.text = false;
+            setStreamingText("");
+        };
+        const emitter = new AgentEventEmitter();
+        // Team tracking
+        let teamName = "";
+        let teamTotal = 0;
+        let teamCompleted = 0;
+        const teammateStatus = new Map();
+        const unsub = emitter.onEvent((event) => {
+            switch (event.type) {
+                case "text":
+                    accTextRef.current += event.text;
+                    markDirty("text");
+                    break;
+                case "tool_output": {
+                    const idx = toolCalls.findIndex(t => t.name === event.toolName && t.status === "running");
+                    if (idx >= 0) {
+                        const prev = toolCalls[idx].result || "";
+                        const lines = (prev + "\n" + event.line).split("\n");
+                        toolCalls[idx].result = lines.slice(-4).join("\n").trim();
+                        markDirty("tools");
+                    }
+                    break;
+                }
+                case "team_start":
+                    teamName = event.name;
+                    teamTotal = event.taskCount;
+                    teamCompleted = 0;
+                    teammateStatus.clear();
+                    markDirty("team");
+                    break;
+                case "team_task":
+                    if (event.status === "started") {
+                        const existing = teammateStatus.get(event.teammateId);
+                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: event.taskDescription.slice(0, 50) });
+                    }
+                    else if (event.status === "completed") {
+                        teamCompleted++;
+                        const existing = teammateStatus.get(event.teammateId);
+                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: "done" });
+                    }
+                    else if (event.status === "failed") {
+                        // Task failed, but teammate is still alive — show the failure briefly
+                        // as progress, don't permanently mark the teammate as "failed".
+                        // The teammate will claim the next task or send "done" when finished.
+                        const existing = teammateStatus.get(event.teammateId);
+                        teammateStatus.set(event.teammateId, { name: existing?.name || event.teammateId, status: "retrying…" });
+                    }
+                    markDirty("team");
+                    break;
+                case "team_progress":
+                    teammateStatus.set(event.teammateId, { name: event.teammateName || event.teammateId, status: event.message.slice(0, 50) });
+                    markDirty("team");
+                    break;
+                case "team_done":
+                    cancelFlush();
+                    setTeamState(null);
+                    accTextRef.current = "";
+                    setStreamingText("");
+                    break;
+                case "subagent_start":
+                    subagentMap.set(event.id, {
+                        type: event.agentType,
+                        model: event.model,
+                        description: event.description,
+                        turn: 0,
+                        message: "starting\u2026",
+                        tools: [],
+                        startTime: Date.now(),
+                    });
+                    markDirty("subagents");
+                    break;
+                case "subagent_progress": {
+                    const existing = subagentMap.get(event.id);
+                    if (existing) {
+                        subagentMap.set(event.id, {
+                            ...existing,
+                            turn: event.turn || existing.turn,
+                            message: event.message,
+                        });
+                        markDirty("subagents");
+                    }
+                    break;
+                }
+                case "subagent_tool_start": {
+                    const existing = subagentMap.get(event.agentId);
+                    if (existing) {
+                        subagentMap.set(event.agentId, {
+                            ...existing,
+                            tools: [...existing.tools, {
+                                    name: event.toolName,
+                                    status: "running",
+                                    input: event.toolInput,
+                                }],
+                        });
+                        markDirty("subagents");
+                    }
+                    break;
+                }
+                case "subagent_tool_end": {
+                    const existing = subagentMap.get(event.agentId);
+                    if (existing) {
+                        const tools = [...existing.tools];
+                        for (let i = tools.length - 1; i >= 0; i--) {
+                            if (tools[i].name === event.toolName && tools[i].status === "running") {
+                                tools[i] = { ...tools[i], status: event.success ? "success" : "error", durationMs: event.durationMs };
+                                break;
+                            }
+                        }
+                        subagentMap.set(event.agentId, { ...existing, tools });
+                        markDirty("subagents");
+                    }
+                    break;
+                }
+                case "subagent_done": {
+                    const existing = subagentMap.get(event.id);
+                    subagentMap.delete(event.id);
+                    if (existing) {
+                        pendingCompleted.push({
+                            id: event.id,
+                            type: event.agentType,
+                            description: existing.description || "",
+                            toolCount: event.tools.length,
+                            tokens: event.tokens,
+                            durationMs: event.durationMs,
+                            success: event.success,
+                        });
+                    }
+                    markDirty("subagents");
+                    break;
+                }
+                case "done":
+                    cancelFlush();
+                    accTextRef.current = event.text;
+                    break;
+            }
+        });
+        await runAgentLoop({
+            message: userMessage,
+            images: images?.map(img => ({ base64: img.base64, mediaType: img.mediaType })),
+            conversationHistory: conversationRef.current,
+            abortSignal: abort.signal,
+            emitter,
+            thinking: thinkingEnabled,
+            callbacks: {
+                onText: () => { },
+                onToolStart: (name, input) => {
+                    if (input) {
+                        const idx = toolCalls.findIndex(t => t.name === name && t.status === "running" && !t.input);
+                        if (idx >= 0) {
+                            toolCalls[idx].input = input;
+                            setActiveTools([...toolCalls]);
+                            lastContentUpdateRef.current = Date.now();
+                        }
+                        return;
+                    }
+                    flushText();
+                    toolCalls.push({ name, status: "running" });
+                    setActiveTools([...toolCalls]);
+                    lastContentUpdateRef.current = Date.now();
+                },
+                onToolResult: (name, success, result, input, durationMs) => {
+                    cancelFlush();
+                    dirty.tools = false;
+                    const completedTool = {
+                        name,
+                        status: success ? "success" : "error",
+                        result: typeof result === "string" ? result : JSON.stringify(result),
+                        input,
+                        durationMs,
+                    };
+                    const idx = toolCalls.findIndex((t) => t.name === name && t.status === "running");
+                    if (idx >= 0)
+                        toolCalls.splice(idx, 1);
+                    // Track file changes for rewind
+                    if (success && input) {
+                        const FILE_TOOLS = ["write_file", "edit_file", "multi_edit"];
+                        if (FILE_TOOLS.includes(name)) {
+                            try {
+                                const filePath = input.file_path;
+                                if (filePath) {
+                                    // Find the most recent backup for this file from file-history
+                                    const backups = listBackups();
+                                    const fileName = filePath.split("/").pop() || "";
+                                    const backup = backups.find(b => b.name.endsWith(`-${fileName}`));
+                                    const isNewFile = !backup; // No backup means file didn't exist before
+                                    const op = name === "write_file" ? "write"
+                                        : name === "edit_file" ? "edit"
+                                            : "multi_edit";
+                                    rewindManagerRef.current.trackFileChange({
+                                        filePath,
+                                        backupPath: backup?.path || "",
+                                        operation: op,
+                                        isNewFile,
+                                    });
+                                }
+                            }
+                            catch {
+                                // Best effort — don't fail the actual operation
+                            }
+                        }
+                    }
+                    setMessages(prev => {
+                        const last = prev[prev.length - 1];
+                        if (last?.role === "assistant" && !last.text && !last.usage && last.toolCalls?.length) {
+                            const updated = { ...last, toolCalls: [...last.toolCalls, completedTool] };
+                            return [...prev.slice(0, -1), updated];
+                        }
+                        return [...prev, { role: "assistant", text: "", toolCalls: [completedTool] }];
+                    });
+                    setActiveTools([...toolCalls]);
+                    accTextRef.current = "";
+                    setStreamingText("");
+                    lastContentUpdateRef.current = Date.now();
+                },
+                onUsage: (input_tokens, output_tokens, thinking_tokens, model, costUsd, cacheReadTokens, cacheCreationTokens) => {
+                    usage = { input_tokens, output_tokens, thinking_tokens, model, costUsd, cache_read_tokens: cacheReadTokens, cache_creation_tokens: cacheCreationTokens };
+                },
+                onAutoCompact: (before, after, tokensSaved) => {
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  Context auto-compacted: ${before} messages -> ${after} messages (~${(tokensSaved / 1000).toFixed(0)}K tokens freed)`,
+                        }]);
+                },
+                onDone: (finalMessages) => {
+                    unsub();
+                    emitter.destroy();
+                    cancelFlush();
+                    setStreamingText("");
+                    setCompletedSubagents(prevCompleted => {
+                        // Include any pending completed subagents from the batch
+                        const all = [...prevCompleted, ...pendingCompleted.splice(0)];
+                        if (all.length > 0) {
+                            setMessages(prev => [...prev, {
+                                    role: "assistant",
+                                    text: "",
+                                    completedSubagents: all,
+                                }]);
+                        }
+                        return [];
+                    });
+                    const finalText = accTextRef.current;
+                    if (finalText.trim() || usage) {
+                        setMessages((prev) => [...prev, {
+                                role: "assistant",
+                                text: finalText,
+                                usage,
+                            }]);
+                    }
+                    // Record rewind checkpoint for this turn
+                    setMessages(prev => {
+                        const fileChanges = rewindManagerRef.current.getCurrentFileChanges();
+                        const summary = finalText.trim() || "(tool-only turn)";
+                        rewindManagerRef.current.addCheckpoint(turnIndexRef.current, prev.length, summary, fileChanges);
+                        rewindManagerRef.current.commitTurn();
+                        turnIndexRef.current++;
+                        return prev;
+                    });
+                    setStreamingText("");
+                    setActiveTools([]);
+                    setSubagentActivity(new Map());
+                    setTeamState(null);
+                    setIsStreaming(false);
+                    abortRef.current = null;
+                    conversationRef.current = finalMessages;
+                },
+                onError: (err, partialMessages) => {
+                    unsub();
+                    emitter.destroy();
+                    cancelFlush();
+                    if (err !== "Cancelled") {
+                        setMessages((prev) => [...prev, { role: "assistant", text: `\x1b[31m\u2718 Error: ${err}\x1b[0m` }]);
+                    }
+                    setStreamingText("");
+                    setActiveTools([]);
+                    setSubagentActivity(new Map());
+                    setCompletedSubagents([]);
+                    setTeamState(null);
+                    setIsStreaming(false);
+                    abortRef.current = null;
+                    if (partialMessages && partialMessages.length > 0) {
+                        conversationRef.current = partialMessages;
+                    }
+                },
+            },
+        });
+    }, [isStreaming, thinkingEnabled]);
+    return { handleSend };
+}

package/dist/cli/chat/hooks/useSlashCommands.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useSlashCommands — slash command handler extracted from ChatApp
+ *
+ * All consumers should import from ChatApp (re-export facade).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import { type StoreInfo } from "../../services/auth-service.js";
+import type { ChatMessage } from "../MessageList.js";
+export interface SlashCommandDeps {
+    exit: () => void;
+    toolsExpanded: boolean;
+    serverToolsAvailable: number;
+    sessionId: string | null;
+    thinkingEnabled: boolean;
+    conversationRef: React.MutableRefObject<Anthropic.MessageParam[]>;
+    setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>;
+    setStreamingText: React.Dispatch<React.SetStateAction<string>>;
+    setActiveTools: React.Dispatch<React.SetStateAction<any[]>>;
+    setTeamState: React.Dispatch<React.SetStateAction<any>>;
+    setStoreList: React.Dispatch<React.SetStateAction<StoreInfo[]>>;
+    setStoreSelectMode: React.Dispatch<React.SetStateAction<boolean>>;
+    setModelSelectMode: React.Dispatch<React.SetStateAction<boolean>>;
+    setCurrentModel: React.Dispatch<React.SetStateAction<string>>;
+    setSessionId: React.Dispatch<React.SetStateAction<string | null>>;
+    setThinkingEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    setUserLabel: React.Dispatch<React.SetStateAction<string>>;
+    setServerToolsAvailable: React.Dispatch<React.SetStateAction<number>>;
+    setShowRewind: React.Dispatch<React.SetStateAction<boolean>>;
+    rewindCheckpointCount: number;
+    PKG_NAME: string;
+    PKG_VERSION: string;
+}
+export declare function useSlashCommands(deps: SlashCommandDeps): {
+    handleCommand: (command: string) => Promise<void>;
+    handleStoreSelect: (store: StoreInfo) => void;
+    handleStoreCancel: () => void;
+};