whale-code 6.4.0 → 6.5.1

package/bin/swagmanager-mcp.js

@@ -12,6 +12,7 @@
  *   whale mcp list|add|remove    Manage MCP servers
  *   whale doctor                 Run diagnostics
  *   whale config [key] [value]   View/set configuration
+ *   whale update                  Update to latest version
  *   whale help                   Show this help
  *   (non-TTY stdin)              MCP stdio server for Claude Code / Cursor
  */
@@ -111,6 +112,7 @@ function showHelp() {
   console.log(`    whale doctor${d}           Run diagnostics${r}`);
   console.log(`    whale init${d}             Generate .whale/CLAUDE.md for project${r}`);
   console.log(`    whale config${d}           View/set configuration${r}`);
+  console.log(`    whale db${d}               Local Supabase management${r}`);
   console.log(`    whale serve${d}            Local agent WebSocket server${r}`);
   console.log(`    whale agent${d}            Start local security agent${r}`);
   console.log();
@@ -168,6 +170,24 @@ if (flags.version) {
   process.exit(0);
 }
 
+// ── Background update check (non-blocking, TTY only) ──
+const PACKAGE_NAME = "whale-code";
+async function checkForUpdate() {
+  try {
+    const { execSync } = await import("child_process");
+    const latest = execSync(`npm view ${PACKAGE_NAME} version 2>/dev/null`, { encoding: "utf-8", timeout: 5000 }).trim();
+    if (latest && latest !== PKG_VERSION) {
+      const d = "\x1b[2m", r = "\x1b[0m", c = "\x1b[36m", B = "\x1b[1m";
+      console.log(`\n${d}  Update available: ${r}${c}v${PKG_VERSION}${r}${d} → ${r}${c}${B}v${latest}${r}`);
+      console.log(`${d}  Run ${r}${B}whale update${r}${d} or ${r}${B}npm i -g ${PACKAGE_NAME}@latest${r}\n`);
+    }
+  } catch { /* silent — network or npm not available */ }
+}
+if (process.stdin.isTTY && !flags.print && !flags.version && !flags.help) {
+  // Fire and forget — don't block startup
+  checkForUpdate();
+}
+
 // ── Help ──
 if (flags.help && !subcommand) {
   showHelp();
@@ -305,6 +325,37 @@ switch (command) {
     break;
   }
 
+  case "db": {
+    const { runDbCommand } = await import(join(distDir, "cli", "commands", "db.js"));
+    await runDbCommand(positionals.slice(1));
+    break;
+  }
+
+  case "update":
+  case "upgrade": {
+    const { execSync } = await import("child_process");
+    const d = "\x1b[2m", r = "\x1b[0m", c = "\x1b[36m", g = "\x1b[32m", B = "\x1b[1m";
+
+    console.log(`${d}  Checking for updates...${r}`);
+    try {
+      const latest = execSync(`npm view ${PACKAGE_NAME} version 2>/dev/null`, { encoding: "utf-8", timeout: 10000 }).trim();
+      if (latest === PKG_VERSION) {
+        console.log(`${g}  ✓${r} whale-code v${PKG_VERSION} is already up to date`);
+        process.exit(0);
+      }
+      console.log(`${d}  Updating ${r}v${PKG_VERSION}${d} → ${r}${B}v${latest}${r}`);
+      console.log();
+      execSync(`npm install -g ${PACKAGE_NAME}@latest`, { stdio: "inherit" });
+      console.log();
+      console.log(`${g}  ✓${r} Updated to whale-code v${latest}`);
+    } catch (err) {
+      console.error(`  ✗ Update failed: ${err.message}`);
+      console.error(`    Try: sudo npm install -g ${PACKAGE_NAME}@latest`);
+      process.exit(1);
+    }
+    break;
+  }
+
   case "agent": {
     // Forward remaining args to local-agent CLI
     // Rebuild process.argv so the agent sees: [node, script, subcommand, ...flags]

package/dist/cli/app.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
+import chalk from "chalk";
 import { initErrorLogger, setErrorLoggerUser, captureError } from "./services/error-logger.js";
 import { loadConfig } from "./services/config-store.js";
 export async function renderLogin() {
@@ -32,8 +33,35 @@ export async function renderChat(options) {
         const err = reason instanceof Error ? reason : new Error(String(reason));
         captureError({ error: err, severity: "error", tags: { source: "unhandledRejection" } });
     });
-    const { matrixIntro } = await import("./shared/MatrixIntro.js");
-    await matrixIntro();
+    // Auto-login if not authenticated — seamless browser OAuth
+    const { isLoggedIn } = await import("./services/auth-service.js");
+    if (!isLoggedIn()) {
+        const { signInWithBrowser } = await import("./services/browser-auth.js");
+        const brand = chalk.hex("#6366F1");
+        const dim = chalk.hex("#64748B");
+        const green = chalk.hex("#30D158");
+        console.log();
+        console.log(`  ${brand.bold("◆")} Opening browser to sign in...`);
+        const result = await signInWithBrowser(undefined, {
+            onBrowserOpening: (url) => {
+                console.log(`  ${dim(url)}`);
+                console.log();
+                console.log(`  ${dim("Waiting for authentication...")}`);
+            },
+        });
+        if (!result.success) {
+            console.error(`  ${chalk.red("✗")} ${result.error}`);
+            console.error(`  ${dim("Run")} whale login ${dim("to try again.")}`);
+            process.exit(1);
+        }
+        console.log(`  ${green("✓")} Signed in as ${result.config?.email || "unknown"}`);
+        if (result.config?.store_name) {
+            console.log(`  ${dim("Store:")} ${result.config.store_name}`);
+        }
+        console.log();
+    }
+    // Clear screen — fresh start
+    process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
     // Apply options before starting chat
     if (options?.model || options?.permissionMode) {
         const agentLoop = await import("./services/agent-loop.js");

package/dist/cli/chat/ChatApp.d.ts

@@ -1,9 +1,9 @@
 /**
  * ChatApp — whale code CLI
  *
- * Uses Ink's <Static> for completed messages — written to stdout once,
- * never re-rendered. Only the active area (streaming, tools, input)
- * is managed by Ink's render loop. This prevents scroll bounce when
- * content exceeds the terminal height.
+ * Uses Ink's <Static> for ALL completed messages — written to stdout once,
+ * never re-rendered. Only the active area (running tools, streaming text,
+ * thinking spinner, input) is in Ink's render loop.
+ * This prevents screen overwriting and allows scrolling during generation.
  */
 export declare function ChatApp(): import("react/jsx-runtime").JSX.Element;

package/dist/cli/chat/ChatApp.js

@@ -2,10 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 /**
  * ChatApp — whale code CLI
  *
- * Uses Ink's <Static> for completed messages — written to stdout once,
- * never re-rendered. Only the active area (streaming, tools, input)
- * is managed by Ink's render loop. This prevents scroll bounce when
- * content exceeds the terminal height.
+ * Uses Ink's <Static> for ALL completed messages — written to stdout once,
+ * never re-rendered. Only the active area (running tools, streaming text,
+ * thinking spinner, input) is in Ink's render loop.
+ * This prevents screen overwriting and allows scrolling during generation.
  */
 import { useState, useEffect, useRef, useMemo, useCallback } from "react";
 import { Box, Text, Static, useApp, useInput } from "ink";
@@ -16,12 +16,23 @@ import { ToolIndicator } from "./ToolIndicator.js";
 import { SubagentPanel } from "./SubagentPanel.js";
 import { TeamPanel } from "./TeamPanel.js";
 import { StreamingText } from "./StreamingText.js";
+import { MarkdownText } from "./MarkdownText.js";
 import { ChatInput } from "./ChatInput.js";
+import { StatusBar } from "./StatusBar.js";
 import { StoreSelector } from "./StoreSelector.js";
+import { NodeSelector } from "./NodeSelector.js";
+import { SessionManager } from "./SessionManager.js";
+import { MemoryManager } from "./MemoryManager.js";
+import { NodeManager } from "./NodeManager.js";
 import { ModelSelector } from "./ModelSelector.js";
+import { ThemeSelector } from "./ThemeSelector.js";
 import { RewindViewer, RewindOutcome } from "./RewindViewer.js";
+import { PlanApproval } from "./PlanApproval.js";
 import { RewindManager } from "../services/rewind.js";
+import { interactiveEvents, resolvePlanApproval } from "../services/interactive-tools.js";
 import { colors, symbols } from "../shared/Theme.js";
+import { initTheme, switchTheme } from "../shared/theme-manager.js";
+import { WhaleBanner } from "../shared/WhaleBanner.js";
 import { loadKeybindings, matchesBinding } from "../services/keybinding-manager.js";
 import { loadConfig, updateConfig } from "../services/config-store.js";
 import { createRequire } from "module";
@@ -30,22 +41,6 @@ import { dirname, join } from "path";
 // Extracted hooks
 import { useSlashCommands } from "./hooks/useSlashCommands.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
-// Thinking verbs — rotate randomly each render (Claude Code parity)
-const THINKING_VERBS = [
-    "thinking…",
-    "reasoning…",
-    "considering…",
-    "analyzing…",
-    "evaluating…",
-    "pondering…",
-    "processing…",
-    "reflecting…",
-    "examining…",
-    "working…",
-];
-function randomVerb() {
-    return THINKING_VERBS[Math.floor(Math.random() * THINKING_VERBS.length)];
-}
 const PKG_NAME = "whale-code";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -69,7 +64,16 @@ export function ChatApp() {
     const [serverToolsAvailable, setServerToolsAvailable] = useState(0);
     const [storeSelectMode, setStoreSelectMode] = useState(false);
     const [storeList, setStoreList] = useState([]);
+    const [nodeSelectMode, setNodeSelectMode] = useState(false);
+    const [nodeList, setNodeList] = useState([]);
+    const [sessionManagerMode, setSessionManagerMode] = useState(false);
+    const [sessionList, setSessionList] = useState([]);
+    const [memoryManagerMode, setMemoryManagerMode] = useState(false);
+    const [memoryList, setMemoryList] = useState([]);
+    const [nodeManagerMode, setNodeManagerMode] = useState(false);
+    const [nodeManagerStatus, setNodeManagerStatus] = useState({ registered: false, running: false });
     const [modelSelectMode, setModelSelectMode] = useState(false);
+    const [themeSelectMode, setThemeSelectMode] = useState(false);
     const [currentModel, setCurrentModel] = useState(getModelShortName());
     const [sessionId, setSessionId] = useState(null);
     const [thinkingEnabled, setThinkingEnabled] = useState(() => {
@@ -80,34 +84,57 @@ export function ChatApp() {
             return true;
         }
     });
-    // Stream activity indicator — show spinner when no new content for 800ms+
-    const [streamStale, setStreamStale] = useState(false);
     const lastContentUpdateRef = useRef(Date.now());
-    // Poll-based staleness check — avoids re-renders on every content change
+    // Unified streaming activity — verb cycling + elapsed timer (replaces separate thinking timer + StatusBar verb)
+    const FUN_VERBS = useMemo(() => [
+        "thinking", "pondering", "brewing", "cooking", "rowing", "juggling",
+        "weaving", "crafting", "forging", "sketching", "conjuring", "assembling",
+        "sculpting", "composing", "mixing", "polishing", "building", "wiring",
+        "spinning", "mapping", "plotting", "dreaming", "hurdling", "launching",
+        "surfing", "flying", "grabbing", "lifting", "twisting", "rolling",
+    ], []);
+    const [streamElapsed, setStreamElapsed] = useState(0);
+    const [verbIndex, setVerbIndex] = useState(0);
+    const streamStartRef = useRef(null);
     useEffect(() => {
-        if (!isStreaming) {
-            setStreamStale(false);
-            return;
+        if (isStreaming) {
+            if (!streamStartRef.current)
+                streamStartRef.current = Date.now();
+            setStreamElapsed(0);
+            setVerbIndex(0);
+            const elapsedInterval = setInterval(() => {
+                if (streamStartRef.current) {
+                    setStreamElapsed(Math.floor((Date.now() - streamStartRef.current) / 1000));
+                }
+            }, 1000);
+            const verbInterval = setInterval(() => {
+                setVerbIndex(i => (i + 1) % FUN_VERBS.length);
+            }, 4000);
+            return () => { clearInterval(elapsedInterval); clearInterval(verbInterval); };
         }
-        lastContentUpdateRef.current = Date.now();
-        const interval = setInterval(() => {
-            setStreamStale(Date.now() - lastContentUpdateRef.current > 800);
-        }, 400);
-        return () => clearInterval(interval);
-    }, [isStreaming]);
+        else {
+            streamStartRef.current = null;
+            setStreamElapsed(0);
+            setVerbIndex(0);
+        }
+    }, [isStreaming, FUN_VERBS]);
     // Rewind state
     const [showRewind, setShowRewind] = useState(false);
+    // Plan approval state
+    const [planApproval, setPlanApproval] = useState(null);
     const rewindManagerRef = useRef(new RewindManager());
     const turnIndexRef = useRef(0);
     // Refs
     const conversationRef = useRef([]);
     const abortRef = useRef(null);
     const accTextRef = useRef("");
-    const thinkingVerbRef = useRef(randomVerb());
+    const thinkingChunksRef = useRef(0);
+    const thinkingDoneRef = useRef(false);
     // No timer cleanup needed — unified flush timer is managed inside useAgentLoop,
     // stale polling interval is cleaned up by its own effect.
     // ── Init ──
     useEffect(() => {
+        initTheme();
         const check = canUseAgent();
         if (!check.ready) {
             setError(check.reason || "Run 'whale login' to authenticate.");
@@ -120,8 +147,20 @@ export function ChatApp() {
             getServerToolCount().then((count) => setServerToolsAvailable(count));
             mcpClientManager.connectAll().catch(() => { });
         }
+        // Listen for plan approval requests — push plan content to Static for natural scrolling
+        const handlePlanExited = (data) => {
+            // Push plan content into messages so it renders in the <Static> area
+            const content = data.planContent || "(empty plan)";
+            setMessages(prev => [...prev, {
+                    role: "assistant",
+                    text: `  ${symbols.arrowRight} Plan Review — ${data.planFile}\n\n${content}`,
+                }]);
+            setPlanApproval({ planContent: data.planContent || "", planFile: data.planFile });
+        };
+        interactiveEvents.on("planModeExited", handlePlanExited);
         return () => {
             mcpClientManager.disconnectAll().catch(() => { });
+            interactiveEvents.off("planModeExited", handlePlanExited);
         };
     }, []);
     // ── Keys (configurable via ~/.swagmanager/keybindings.json) ──
@@ -153,24 +192,36 @@ export function ChatApp() {
             });
         }
     });
+    // ESC abort is now handled by ChatInput's onInterrupt prop — stdin stays active
+    // even when disabled, so ESC always reaches the handler.
     // ── Extracted hooks ──
-    const { handleCommand, handleStoreSelect, handleStoreCancel } = useSlashCommands({
+    const { handleCommand, handleStoreSelect, handleStoreCancel, handleNodeSelect, handleNodeCancel, handleSessionSelect, handleMemoryDelete, handleNodeToggle, handleNodeRegister, handleNodeClose, } = useSlashCommands({
         exit, toolsExpanded, serverToolsAvailable, sessionId, thinkingEnabled,
         conversationRef,
         setMessages, setStreamingText, setActiveTools, setTeamState,
         setStoreList, setStoreSelectMode, setModelSelectMode, setCurrentModel,
         setSessionId, setThinkingEnabled, setUserLabel, setServerToolsAvailable,
         setShowRewind,
+        setNodeSelectMode, setNodeList,
+        setSessionManagerMode, setSessionList,
+        setMemoryManagerMode, setMemoryList,
+        setThemeSelectMode,
+        setNodeManagerMode, setNodeManagerStatus,
         rewindCheckpointCount: rewindManagerRef.current.getCheckpointCount(),
         PKG_NAME, PKG_VERSION,
     });
     const { handleSend } = useAgentLoop({
         isStreaming, thinkingEnabled, conversationRef, abortRef,
-        accTextRef, lastContentUpdateRef, thinkingVerbRef,
+        accTextRef, lastContentUpdateRef, thinkingChunksRef, thinkingDoneRef,
         rewindManagerRef, turnIndexRef,
         setMessages, setStreamingText, setIsStreaming, setActiveTools,
         setSubagentActivity, setCompletedSubagents, setTeamState,
     });
+    // ── Plan approval handler ──
+    const handlePlanDecision = useCallback((decision) => {
+        setPlanApproval(null);
+        resolvePlanApproval(decision);
+    }, []);
     // ── Rewind handler ──
     const handleRewind = useCallback((checkpointIndex, outcome) => {
         const rm = rewindManagerRef.current;
@@ -235,27 +286,39 @@ export function ChatApp() {
     // ── Render ──
     const termWidth = process.stdout.columns || 80;
     const contentWidth = Math.max(20, termWidth - 2);
-    const { staticItems, dynamicMessages } = useMemo(() => {
+    // ALL completed messages go to Static — written to stdout once, never re-rendered.
+    // This keeps the dynamic area small (only active tools + streaming + input),
+    // preventing the constant screen overwriting that blocks scrolling.
+    const staticItems = useMemo(() => {
         const items = [{ id: "header", type: "header" }];
-        const cutoff = Math.max(0, messages.length - 1);
-        for (let i = 0; i < cutoff; i++) {
+        for (let i = 0; i < messages.length; i++) {
             items.push({ id: `msg-${i}`, type: "message", msg: messages[i], index: i });
         }
-        const tail = messages.length > 0 ? [messages[messages.length - 1]] : [];
-        return { staticItems: items, dynamicMessages: tail };
+        return items;
     }, [messages]);
     if (error) {
-        return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { children: " " }), _jsx(Text, { color: colors.brand, bold: true, children: "\u25C6 whale code" }), _jsx(Text, { children: " " }), _jsx(Text, { color: colors.error, children: error })] }));
+        return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(WhaleBanner, {}), _jsx(Text, { children: " " }), _jsxs(Text, { color: colors.error, children: ["  ", error] })] }));
     }
     if (!ready) {
         return (_jsx(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: _jsx(Text, { color: colors.tertiary, children: "loading..." }) }));
     }
+    // Plan approval no longer full-screen — plan content is pushed to Static (scrollable),
+    // PlanApproval renders as an overlay above the persistent input.
     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [_jsx(Static, { items: staticItems, children: (item) => {
                     if (item.type === "header") {
-                        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: colors.brand, bold: true, children: "\u25C6 whale code" }), userLabel ? _jsxs(Text, { color: colors.dim, children: ["  ", userLabel] }) : null, _jsxs(Text, { color: colors.dim, children: ["  ", currentModel] }), thinkingEnabled ? _jsx(Text, { color: colors.warning, children: "  thinking" }) : null, getPermissionMode() !== "default" && (_jsxs(Text, { color: getPermissionMode() === "yolo" ? colors.error : colors.info, children: ["  ", getPermissionMode()] })), serverToolsAvailable > 0 ? (_jsxs(Text, { color: colors.tertiary, children: ["  ", symbols.dot, " ", serverToolsAvailable, " server tools"] })) : null] }), _jsx(Text, { color: colors.separator, children: "─".repeat(contentWidth) })] }, item.id));
+                        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(WhaleBanner, {}), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["  ", userLabel ? _jsxs(Text, { color: colors.dim, children: [userLabel, "  "] }) : null, _jsx(Text, { color: colors.dim, children: currentModel }), thinkingEnabled ? _jsx(Text, { color: colors.warning, children: "  thinking" }) : null, getPermissionMode() !== "default" && (_jsxs(Text, { color: getPermissionMode() === "yolo" ? colors.error : colors.info, children: ["  ", getPermissionMode()] })), serverToolsAvailable > 0 ? (_jsxs(Text, { color: colors.tertiary, children: ["  ", symbols.dot, " ", serverToolsAvailable, " tools"] })) : null] }), _jsx(Text, { children: " " })] }, item.id));
                     }
                     return _jsx(CompletedMessage, { msg: item.msg, index: item.index, toolsExpanded: toolsExpanded }, item.id);
-                } }), dynamicMessages.map((msg) => (_jsx(CompletedMessage, { msg: msg, index: messages.length - 1, toolsExpanded: toolsExpanded }, `dynamic-${messages.length - 1}`))), teamState ? (_jsx(TeamPanel, { team: teamState })) : (_jsxs(_Fragment, { children: [isStreaming && !streamingText && activeTools.length === 0 && (_jsxs(Box, { marginLeft: 2, marginY: 1, children: [_jsx(Text, { color: colors.brand, children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: colors.dim, children: ["  ", thinkingVerbRef.current] })] })), activeTools.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: activeTools.map((tc, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(ToolIndicator, { id: `live-${tc.name}-${i}`, name: tc.name, status: tc.status, input: tc.input, expanded: toolsExpanded }), tc.name === "task" && tc.status === "running" && (subagentActivity.size > 0 || completedSubagents.length > 0) && (_jsx(SubagentPanel, { running: subagentActivity, completed: completedSubagents }))] }, `live-${tc.name}-${i}`))) })), streamingText && (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsx(StreamingText, { text: streamingText }), streamStale && (_jsx(Box, { marginTop: 0, children: _jsx(Text, { color: colors.brand, children: _jsx(Spinner, { type: "dots" }) }) }))] }))] })), showRewind ? (_jsx(RewindViewer, { checkpoints: rewindManagerRef.current.getCheckpoints(), onRewind: handleRewind, onCancel: () => setShowRewind(false) })) : storeSelectMode ? (_jsx(StoreSelector, { stores: storeList, currentStoreId: loadConfig().store_id || "", onSelect: handleStoreSelect, onCancel: handleStoreCancel })) : modelSelectMode ? (_jsx(ModelSelector, { currentModel: currentModel, onSelect: (model) => {
+                } }), teamState ? (_jsx(TeamPanel, { team: teamState })) : (_jsxs(_Fragment, { children: [isStreaming && (_jsxs(Box, { marginLeft: 2, marginTop: 1, marginBottom: 1, children: [_jsx(Text, { color: colors.brand, children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { color: colors.dim, children: ["  ", FUN_VERBS[verbIndex]] }), streamElapsed > 0 && (_jsxs(Text, { color: colors.quaternary, children: ["  ", streamElapsed < 60 ? `${streamElapsed}s` : `${Math.floor(streamElapsed / 60)}:${(streamElapsed % 60).toString().padStart(2, "0")}`] }))] })), activeTools.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: activeTools.map((tc, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(ToolIndicator, { id: `live-${tc.name}-${i}`, name: tc.name, status: tc.status, result: tc.result, input: tc.input, expanded: toolsExpanded, progress: tc.progress }), tc.name === "task" && tc.status === "running" && (subagentActivity.size > 0 || completedSubagents.length > 0) && (_jsx(SubagentPanel, { running: subagentActivity, completed: completedSubagents }))] }, `live-${tc.name}-${i}`))) })), toolsExpanded && !isStreaming && (() => {
+                        // Find collapsed tool results from the last assistant turn
+                        const lastAssistant = [...messages].reverse().find(m => m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0);
+                        if (!lastAssistant?.toolCalls)
+                            return null;
+                        const collapsed = lastAssistant.toolCalls.filter(tc => tc.result && tc.status === "success" && tc.result.split("\n").length > 12);
+                        if (collapsed.length === 0)
+                            return null;
+                        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: colors.tertiary, children: ["─".repeat(Math.min(60, (process.stdout.columns || 80) - 6)), " ^O close"] }), collapsed.map((tc, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: colors.info, bold: true, children: tc.name }), _jsx(MarkdownText, { text: tc.result })] }, i))), _jsx(Text, { color: colors.tertiary, children: "─".repeat(Math.min(60, (process.stdout.columns || 80) - 6)) })] }));
+                    })(), streamingText && (_jsx(Box, { marginLeft: 2, flexDirection: "column", children: _jsx(StreamingText, { text: streamingText }) }))] })), showRewind && (_jsx(RewindViewer, { checkpoints: rewindManagerRef.current.getCheckpoints(), onRewind: handleRewind, onCancel: () => setShowRewind(false) })), sessionManagerMode && (_jsx(SessionManager, { sessions: sessionList, onSelect: handleSessionSelect, onCancel: () => setSessionManagerMode(false) })), memoryManagerMode && (_jsx(MemoryManager, { memories: memoryList, onDelete: handleMemoryDelete, onCancel: () => setMemoryManagerMode(false) })), nodeManagerMode && (_jsx(NodeManager, { initialStatus: nodeManagerStatus, onToggle: handleNodeToggle, onRegister: handleNodeRegister, onClose: handleNodeClose })), storeSelectMode && (_jsx(StoreSelector, { stores: storeList, currentStoreId: loadConfig().store_id || "", onSelect: handleStoreSelect, onCancel: handleStoreCancel })), nodeSelectMode && (_jsx(NodeSelector, { nodes: nodeList, onSelect: handleNodeSelect, onCancel: handleNodeCancel })), modelSelectMode && (_jsx(ModelSelector, { currentModel: currentModel, onSelect: (model) => {
                     setModelSelectMode(false);
                     setModel(model.value);
                     setCurrentModel(model.value);
@@ -263,5 +326,12 @@ export function ChatApp() {
                             role: "assistant",
                             text: `  ${symbols.check} Model: ${model.label}  (${model.modelId})`,
                         }]);
-                }, onCancel: () => setModelSelectMode(false) })) : (_jsx(ChatInput, { onSubmit: handleSend, onCommand: handleCommand, disabled: isStreaming, agentName: "whale code" }))] }));
+                }, onCancel: () => setModelSelectMode(false) })), themeSelectMode && (_jsx(ThemeSelector, { onSelect: (preset) => {
+                    setThemeSelectMode(false);
+                    switchTheme(preset.id);
+                    setMessages((prev) => [...prev, {
+                            role: "assistant",
+                            text: `  ${symbols.check} Theme: ${preset.label}`,
+                        }]);
+                }, onCancel: () => setThemeSelectMode(false) })), planApproval && (_jsx(PlanApproval, { planFile: planApproval.planFile, onDecision: handlePlanDecision })), _jsx(ChatInput, { onSubmit: handleSend, onCommand: handleCommand, disabled: isStreaming || !!planApproval, agentName: "whale code", onInterrupt: () => abortRef.current?.abort() }), _jsx(StatusBar, { permissionMode: getPermissionMode(), model: currentModel, thinkingEnabled: thinkingEnabled, serverTools: serverToolsAvailable, isStreaming: isStreaming, toolsExpanded: toolsExpanded })] }));
 }

package/dist/cli/chat/ChatInput.d.ts

@@ -24,16 +24,23 @@ export interface FileAttachment {
     path: string;
     name: string;
 }
-export interface SlashCommand {
-    name: string;
-    description: string;
+export interface ContextAttachment {
+    id: string;
+    type: string;
+    title: string;
+    subtitle?: string;
+    icon: string;
+    sourceApp: string;
+    data: Record<string, unknown>;
+    timestamp: string;
 }
-export declare const SLASH_COMMANDS: SlashCommand[];
+export type { SlashCommand } from "./SlashMenu.js";
+export declare const SLASH_COMMANDS: import("./SlashMenu.js").SlashCommand[];
 interface ChatInputProps {
     onSubmit: (message: string, images?: ImageAttachment[]) => void;
     onCommand: (command: string) => void;
     disabled: boolean;
     agentName?: string;
+    onInterrupt?: () => void;
 }
-export declare function ChatInput({ onSubmit, onCommand, disabled, agentName }: ChatInputProps): import("react/jsx-runtime").JSX.Element;
-export {};
+export declare function ChatInput({ onSubmit, onCommand, disabled, agentName, onInterrupt }: ChatInputProps): import("react/jsx-runtime").JSX.Element;