wave-code 0.4.0 → 0.6.1

package/src/components/RewindCommand.tsx

@@ -6,13 +6,30 @@ export interface RewindCommandProps {
   messages: Message[];
   onSelect: (index: number) => void;
   onCancel: () => void;
+  getFullMessageThread?: () => Promise<{
+    messages: Message[];
+    sessionIds: string[];
+  }>;
 }
 
 export const RewindCommand: React.FC<RewindCommandProps> = ({
-  messages,
+  messages: initialMessages,
   onSelect,
   onCancel,
+  getFullMessageThread,
 }) => {
+  const [messages, setMessages] = useState<Message[]>(initialMessages);
+  const [isLoading, setIsLoading] = useState(!!getFullMessageThread);
+
+  React.useEffect(() => {
+    if (getFullMessageThread) {
+      getFullMessageThread().then(({ messages: fullMessages }) => {
+        setMessages(fullMessages);
+        setIsLoading(false);
+      });
+    }
+  }, [getFullMessageThread]);
+
   // Filter user messages as checkpoints
   const checkpoints = messages
     .map((msg, index) => ({ msg, index }))
@@ -20,6 +37,11 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
 
   const [selectedIndex, setSelectedIndex] = useState(checkpoints.length - 1);
 
+  // Update selectedIndex when checkpoints change (after loading full thread)
+  React.useEffect(() => {
+    setSelectedIndex(checkpoints.length - 1);
+  }, [checkpoints.length]);
+
   useInput((input, key) => {
     if (key.return) {
       if (checkpoints.length > 0 && selectedIndex >= 0) {
@@ -44,6 +66,21 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
     }
   });
 
+  if (isLoading) {
+    return (
+      <Box
+        flexDirection="column"
+        paddingX={1}
+        borderStyle="single"
+        borderColor="cyan"
+        borderLeft={false}
+        borderRight={false}
+      >
+        <Text color="cyan">Loading full message thread...</Text>
+      </Box>
+    );
+  }
+
   if (checkpoints.length === 0) {
     return (
       <Box

package/src/components/SubagentBlock.tsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useMemo } from "react";
 import { Box, Text } from "ink";
 import type { SubagentBlock as SubagentBlockType } from "wave-agent-sdk";
 import { useChat } from "../contexts/useChat.js";
@@ -9,10 +9,21 @@ interface SubagentBlockProps {
 }
 
 export const SubagentBlock: React.FC<SubagentBlockProps> = ({ block }) => {
-  const { subagentMessages } = useChat();
+  const { subagentMessages, subagentLatestTokens } = useChat();
 
   // Get messages for this subagent from context
-  const messages = subagentMessages[block.subagentId] || [];
+  const messages = useMemo(
+    () => subagentMessages[block.subagentId] || [],
+    [subagentMessages, block.subagentId],
+  );
+
+  // Get latest turn tokens for this subagent
+  const latestTurnTokens = subagentLatestTokens[block.subagentId] || 0;
+
+  // If the subagent is running in the background, don't show the block
+  if (block.runInBackground) {
+    return null;
+  }
 
   // Status indicator mapping
   const getStatusIndicator = (status: SubagentBlockType["status"]) => {
@@ -58,7 +69,7 @@ export const SubagentBlock: React.FC<SubagentBlockProps> = ({ block }) => {
     return { tools: tools.reverse(), totalToolCount }; // Reverse to show oldest first, newest last
   };
 
-  const { tools: lastTwoTools, totalToolCount } = getLastTwoTools();
+  const { tools: lastTwoTools } = getLastTwoTools();
 
   // Get the last text message content if completed
   const getLastTextMessage = () => {
@@ -88,9 +99,7 @@ export const SubagentBlock: React.FC<SubagentBlockProps> = ({ block }) => {
       borderStyle="classic"
       borderColor="magenta"
       paddingX={1}
-      paddingY={0}
       flexDirection="column"
-      marginBottom={1}
     >
       {/* Header Section */}
       <Box flexDirection="row" gap={1}>
@@ -102,26 +111,31 @@ export const SubagentBlock: React.FC<SubagentBlockProps> = ({ block }) => {
           </Text>
           <Text color="gray" dimColor>
             {" "}
-            ({messages.length} messages)
+            ({messages.length} messages
+            {latestTurnTokens > 0 && (
+              <>
+                {" | "}
+                <Text color="blue" bold>
+                  {latestTurnTokens.toLocaleString()}
+                </Text>
+                {" tokens"}
+              </>
+            )}
+            )
           </Text>
         </Box>
       </Box>
 
       {/* Last Text Message Section */}
       {lastTextMessage && (
-        <Box marginTop={1}>
+        <Box>
           <Markdown>{lastTextMessage}</Markdown>
         </Box>
       )}
 
       {/* Tool Names Section - Vertical List */}
       {block.status !== "completed" && lastTwoTools.length > 0 && (
-        <Box flexDirection="column" marginTop={1} gap={1}>
-          {totalToolCount > 2 && (
-            <Text color="gray" dimColor>
-              ...
-            </Text>
-          )}
+        <Box flexDirection="column">
           {lastTwoTools.map((tool, index) => (
             <Box key={index} flexDirection="row">
               <Text color="magenta">🔧 </Text>

package/src/components/TaskList.tsx

@@ -0,0 +1,70 @@
+import React from "react";
+import { useChat } from "../contexts/useChat.js";
+import { Box, Text, useStdout } from "ink";
+import { useTasks } from "../hooks/useTasks.js";
+
+export const TaskList: React.FC = () => {
+  const tasks = useTasks();
+  const { isTaskListVisible } = useChat();
+  const { stdout } = useStdout();
+  const terminalWidth = stdout?.columns ?? 80;
+  const maxSubjectWidth = Math.max(20, terminalWidth - 10);
+
+  if (tasks.length === 0 || !isTaskListVisible) {
+    return null;
+  }
+
+  const getStatusIcon = (status: string, isBlocked: boolean) => {
+    if (isBlocked) {
+      return <Text color="red">🔒</Text>;
+    }
+    switch (status) {
+      case "pending":
+        return <Text color="gray">○</Text>;
+      case "in_progress":
+        return <Text color="yellow">●</Text>;
+      case "completed":
+        return <Text color="green">✓</Text>;
+      case "deleted":
+        return <Text color="red">✕</Text>;
+      default:
+        return <Text color="gray">?</Text>;
+    }
+  };
+
+  const truncate = (text: string, maxWidth: number) => {
+    if (text.length <= maxWidth) {
+      return text;
+    }
+    return text.slice(0, maxWidth - 3) + "...";
+  };
+
+  return (
+    <Box flexDirection="column">
+      {tasks.map((task) => {
+        const isDimmed =
+          task.status === "completed" || task.status === "deleted";
+        const isBlocked = task.blockedBy && task.blockedBy.length > 0;
+        const blockingTaskIds = isBlocked
+          ? task.blockedBy.map((id) => `#${id}`)
+          : [];
+
+        const blockedByText =
+          isBlocked && blockingTaskIds.length > 0
+            ? ` (Blocked by: ${blockingTaskIds.join(", ")})`
+            : "";
+
+        const fullText = `${task.subject}${blockedByText}`;
+
+        return (
+          <Box key={task.id} gap={1}>
+            {getStatusIcon(task.status, isBlocked)}
+            <Text dimColor={isDimmed}>
+              {truncate(fullText, maxSubjectWidth)}
+            </Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+};

package/src/components/ToolResultDisplay.tsx

@@ -44,6 +44,9 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
 
   const toolName = name ? String(name) : "Tool";
 
+  const isBackgroundable =
+    stage === "running" && (toolName === "Bash" || toolName === "Task");
+
   // Get shortResult, if not available show last 5 lines of result
   const getShortResult = () => {
     if (block.shortResult) {
@@ -65,7 +68,7 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
   const shortResult = getShortResult();
 
   return (
-    <Box flexDirection="column" gap={1}>
+    <Box flexDirection="column">
       <Box>
         <Text color="magenta">🔧 </Text>
         <Text color="white">{toolName}</Text>
@@ -76,6 +79,7 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
         <Text color={getStatusColor()}> {getStatusText()}</Text>
         {/* Display image indicator */}
         {hasImages() && <Text color="blue"> {getImageIndicator()}</Text>}
+        {isBackgroundable && <Text color="gray"> [Ctrl-B] Background</Text>}
       </Box>
 
       {/* Display shortResult in collapsed state */}
@@ -87,7 +91,7 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
           flexDirection="column"
         >
           {shortResult.split("\n").map((line, index) => (
-            <Text key={index} color="white">
+            <Text key={index} color="gray">
               {line}
             </Text>
           ))}

package/src/contexts/useChat.tsx

@@ -11,7 +11,8 @@ import { useAppConfig } from "./useAppConfig.js";
 import type {
   Message,
   McpServerStatus,
-  BackgroundShell,
+  BackgroundTask,
+  Task,
   SlashCommand,
   PermissionDecision,
   PermissionMode,
@@ -30,9 +31,10 @@ export interface ChatContextType {
   isLoading: boolean;
   isCommandRunning: boolean;
   isCompressing: boolean;
-  userInputHistory: string[];
   // Message display state
   isExpanded: boolean;
+  isTaskListVisible: boolean;
+  setIsTaskListVisible: (visible: boolean) => void;
   // AI functionality
   sessionId: string;
   sendMessage: (
@@ -41,23 +43,24 @@ export interface ChatContextType {
   ) => Promise<void>;
   abortMessage: () => void;
   latestTotalTokens: number;
-  // Memory functionality
-  saveMemory: (message: string, type: "project" | "user") => Promise<void>;
   // MCP functionality
   mcpServers: McpServerStatus[];
   connectMcpServer: (serverName: string) => Promise<boolean>;
   disconnectMcpServer: (serverName: string) => Promise<boolean>;
-  // Background bash shells
-  backgroundShells: BackgroundShell[];
-  getBackgroundShellOutput: (
-    shellId: string,
+  // Background tasks
+  backgroundTasks: BackgroundTask[];
+  // Session tasks
+  sessionTasks: Task[];
+  getBackgroundTaskOutput: (
+    taskId: string,
   ) => { stdout: string; stderr: string; status: string } | null;
-  killBackgroundShell: (shellId: string) => boolean;
+  stopBackgroundTask: (taskId: string) => boolean;
   // Slash Command functionality
   slashCommands: SlashCommand[];
   hasSlashCommand: (commandId: string) => boolean;
   // Subagent messages
   subagentMessages: Record<string, Message[]>;
+  subagentLatestTokens: Record<string, number>;
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
@@ -78,9 +81,17 @@ export interface ChatContextType {
   hideConfirmation: () => void;
   handleConfirmationDecision: (decision: PermissionDecision) => void;
   handleConfirmationCancel: () => void;
+  // Background current task
+  backgroundCurrentTask: () => void;
   // Rewind functionality
   rewindId: number;
   handleRewindSelect: (index: number) => Promise<void>;
+  getFullMessageThread: () => Promise<{
+    messages: Message[];
+    sessionIds: string[];
+  }>;
+  wasLastDetailsTooTall: number;
+  setWasLastDetailsTooTall: React.Dispatch<React.SetStateAction<number>>;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -108,6 +119,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   // Message Display State
   const [isExpanded, setIsExpanded] = useState(false);
+  const [isTaskListVisible, setIsTaskListVisible] = useState(true);
 
   // AI State
   const [messages, setMessages] = useState<Message[]>([]);
@@ -116,15 +128,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [sessionId, setSessionId] = useState("");
   const [isCommandRunning, setIsCommandRunning] = useState(false);
   const [isCompressing, setIsCompressing] = useState(false);
-  const [userInputHistory, setUserInputHistory] = useState<string[]>([]);
 
   // MCP State
   const [mcpServers, setMcpServers] = useState<McpServerStatus[]>([]);
 
-  // Background bash shells state
-  const [backgroundShells, setBackgroundShells] = useState<BackgroundShell[]>(
-    [],
-  );
+  // Background tasks state
+  const [backgroundTasks, setBackgroundTasks] = useState<BackgroundTask[]>([]);
+  // Session tasks state
+  const [sessionTasks, setSessionTasks] = useState<Task[]>([]);
 
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
@@ -133,6 +144,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [subagentMessages, setSubagentMessages] = useState<
     Record<string, Message[]>
   >({});
+  const [subagentLatestTokens, setSubagentLatestTokens] = useState<
+    Record<string, number>
+  >({});
 
   // Permission state
   const [permissionMode, setPermissionModeState] =
@@ -171,6 +185,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Rewind state
   const [rewindId, setRewindId] = useState(0);
 
+  // Confirmation too tall state
+  const [wasLastDetailsTooTall, setWasLastDetailsTooTall] = useState(0);
+
   const agentRef = useRef<Agent | null>(null);
 
   // Permission confirmation methods with queue support
@@ -209,29 +226,36 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           setMcpServers([...servers]);
         },
         onSessionIdChange: (sessionId) => {
-          process.stdout.write("\x1Bc", () => {
-            setSessionId(sessionId);
-          });
+          setSessionId(sessionId);
         },
         onLatestTotalTokensChange: (tokens) => {
           setlatestTotalTokens(tokens);
         },
-        onUserInputHistoryChange: (history) => {
-          setUserInputHistory([...history]);
-        },
         onCompressionStateChange: (isCompressingState) => {
           setIsCompressing(isCompressingState);
         },
-        onShellsChange: (shells) => {
-          setBackgroundShells([...shells]);
+        onTasksChange: (tasks) => {
+          setBackgroundTasks([...tasks]);
+        },
+        onSessionTasksChange: (tasks) => {
+          setSessionTasks([...tasks]);
         },
-        onSubagentMessagesChange: (subagentId, messages) => {
+        onSubagentMessagesChange: (subagentId: string, messages: Message[]) => {
           logger.debug("onSubagentMessagesChange", subagentId, messages.length);
           setSubagentMessages((prev) => ({
             ...prev,
             [subagentId]: [...messages],
           }));
         },
+        onSubagentLatestTotalTokensChange: (
+          subagentId: string,
+          tokens: number,
+        ) => {
+          setSubagentLatestTokens((prev) => ({
+            ...prev,
+            [subagentId]: tokens,
+          }));
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
         },
@@ -283,7 +307,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setlatestTotalTokens(agent.latestTotalTokens);
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompressing(agent.isCompressing);
-        setUserInputHistory(agent.userInputHistory);
         setPermissionModeState(agent.getPermissionMode());
 
         // Get initial MCP servers state
@@ -338,16 +361,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       if (!hasTextContent && !hasImageAttachments) return;
 
       try {
-        // Handle memory mode - check if it's a memory message (starts with # and only one line)
-        if (content.startsWith("#") && !content.includes("\n")) {
-          const memoryText = content.substring(1).trim();
-          if (!memoryText) return;
-
-          // In memory mode, don't add user message, only wait for user to choose memory type then add assistant message
-          // Don't auto-save, wait for user to choose memory type
-          return;
-        }
-
         // Handle bash mode - check if it's a bash command (starts with ! and only one line)
         if (content.startsWith("!") && !content.includes("\n")) {
           const command = content.substring(1).trim();
@@ -394,14 +407,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     agentRef.current?.abortMessage();
   }, []);
 
-  // Memory save function - delegate to Agent
-  const saveMemory = useCallback(
-    async (message: string, type: "project" | "user") => {
-      await agentRef.current?.saveMemory(message, type);
-    },
-    [],
-  );
-
   // Permission management methods
   const setPermissionMode = useCallback((mode: PermissionMode) => {
     setPermissionModeState((prev) => {
@@ -422,15 +427,15 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     return (await agentRef.current?.disconnectMcpServer(serverName)) ?? false;
   }, []);
 
-  // Background bash management methods - delegate to Agent
-  const getBackgroundShellOutput = useCallback((shellId: string) => {
+  // Background task management methods - delegate to Agent
+  const getBackgroundTaskOutput = useCallback((taskId: string) => {
     if (!agentRef.current) return null;
-    return agentRef.current.getBackgroundShellOutput(shellId);
+    return agentRef.current.getBackgroundTaskOutput(taskId);
   }, []);
 
-  const killBackgroundShell = useCallback((shellId: string) => {
+  const stopBackgroundTask = useCallback((taskId: string) => {
     if (!agentRef.current) return false;
-    return agentRef.current.killBackgroundShell(shellId);
+    return agentRef.current.stopBackgroundTask(taskId);
   }, []);
 
   const hasSlashCommand = useCallback((commandId: string) => {
@@ -482,33 +487,44 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hideConfirmation();
   }, [currentConfirmation, hideConfirmation]);
 
+  const backgroundCurrentTask = useCallback(() => {
+    agentRef.current?.backgroundCurrentTask();
+  }, []);
+
   const handleRewindSelect = useCallback(async (index: number) => {
     if (agentRef.current) {
       try {
         await agentRef.current.truncateHistory(index);
 
         // Clear terminal screen after rewind
-        process.stdout.write("\x1Bc", () => {
-          setRewindId((prev) => prev + 1);
-        });
+        setRewindId((prev) => prev + 1);
       } catch (error) {
         logger.error("Failed to rewind:", error);
       }
     }
   }, []);
 
+  const getFullMessageThread = useCallback(async () => {
+    if (agentRef.current) {
+      return await agentRef.current.getFullMessageThread();
+    }
+    return { messages: [], sessionIds: [] };
+  }, []);
+
   // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
   useInput((input, key) => {
     if (key.ctrl && input === "o") {
       // Clear terminal screen when expanded state changes
-      process.stdout.write("\x1Bc", () => {
-        setIsExpanded((prev) => {
-          const newExpanded = !prev;
-          return newExpanded;
-        });
+      setIsExpanded((prev) => {
+        const newExpanded = !prev;
+        return newExpanded;
       });
     }
 
+    if (key.ctrl && input === "t") {
+      setIsTaskListVisible((prev) => !prev);
+    }
+
     // Handle ESC key to cancel confirmation
     if (key.escape && isConfirmationVisible) {
       handleConfirmationCancel();
@@ -519,23 +535,25 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     messages,
     isLoading,
     isCommandRunning,
-    userInputHistory,
     isExpanded,
+    isTaskListVisible,
+    setIsTaskListVisible,
     sessionId,
     sendMessage,
     abortMessage,
     latestTotalTokens,
     isCompressing,
-    saveMemory,
     mcpServers,
     connectMcpServer,
     disconnectMcpServer,
-    backgroundShells,
-    getBackgroundShellOutput,
-    killBackgroundShell,
+    backgroundTasks,
+    sessionTasks,
+    getBackgroundTaskOutput,
+    stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
     subagentMessages,
+    subagentLatestTokens,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,
@@ -544,8 +562,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hideConfirmation,
     handleConfirmationDecision,
     handleConfirmationCancel,
+    backgroundCurrentTask,
     rewindId,
     handleRewindSelect,
+    getFullMessageThread,
+    wasLastDetailsTooTall,
+    setWasLastDetailsTooTall,
   };
 
   return (