wave-code 0.5.0 → 0.6.2

package/src/components/MessageList.tsx

@@ -1,15 +1,20 @@
 import React from "react";
 import { Box, Text, Static } from "ink";
 import type { Message } from "wave-agent-sdk";
+import {
+  TASK_CREATE_TOOL_NAME,
+  TASK_GET_TOOL_NAME,
+  TASK_UPDATE_TOOL_NAME,
+  TASK_LIST_TOOL_NAME,
+} from "wave-agent-sdk";
 import { MessageItem } from "./MessageItem.js";
 
 export interface MessageListProps {
   messages: Message[];
   isLoading?: boolean;
   isCommandRunning?: boolean;
-  isCompressing?: boolean;
-  latestTotalTokens?: number;
   isExpanded?: boolean;
+  forceStaticLastMessage?: boolean;
 }
 
 export const MessageList = React.memo(
@@ -17,15 +22,16 @@ export const MessageList = React.memo(
     messages,
     isLoading = false,
     isCommandRunning = false,
-    isCompressing = false,
-    latestTotalTokens = 0,
     isExpanded = false,
+    forceStaticLastMessage = false,
   }: MessageListProps) => {
     // Empty message state
     if (messages.length === 0) {
       return (
-        <Box flexDirection="column" paddingY={1}>
-          <Text color="gray">Welcome to WAVE Code Assistant!</Text>
+        <Box flexDirection="column" gap={1}>
+          <Box flexDirection="column" paddingY={1}>
+            <Text color="gray">Welcome to WAVE Code Assistant!</Text>
+          </Box>
         </Box>
       );
     }
@@ -34,15 +40,43 @@ export const MessageList = React.memo(
     const maxExpandedMessages = 20;
     const shouldLimitMessages =
       isExpanded && messages.length > maxExpandedMessages;
+
+    // Filter out task management tools and empty messages
+    const taskMgmtTools = [
+      TASK_CREATE_TOOL_NAME,
+      TASK_GET_TOOL_NAME,
+      TASK_UPDATE_TOOL_NAME,
+      TASK_LIST_TOOL_NAME,
+    ];
+    const filteredMessages = messages
+      .map((message) => ({
+        ...message,
+        blocks: message.blocks.filter(
+          (block) =>
+            !(
+              block.type === "tool" &&
+              typeof block.name === "string" &&
+              taskMgmtTools.includes(block.name)
+            ),
+        ),
+      }))
+      .filter((message) => message.blocks.length > 0);
+
     const displayMessages = shouldLimitMessages
-      ? messages.slice(-maxExpandedMessages)
-      : messages;
-    const omittedCount = shouldLimitMessages
-      ? messages.length - maxExpandedMessages
-      : 0;
+      ? filteredMessages.slice(-maxExpandedMessages)
+      : filteredMessages;
 
     // Compute which messages to render statically vs dynamically
-    const shouldRenderLastDynamic = isLoading || isCommandRunning;
+    const lastMessage = displayMessages[displayMessages.length - 1];
+    const hasNonEndTool = lastMessage?.blocks.some(
+      (block) => block.type === "tool" && block.stage !== "end",
+    );
+    const hasRunningCommand = lastMessage?.blocks.some(
+      (block) => block.type === "command_output" && block.isRunning,
+    );
+    const shouldRenderLastDynamic =
+      !forceStaticLastMessage &&
+      (isLoading || isCommandRunning || hasNonEndTool || hasRunningCommand);
     const staticMessages = shouldRenderLastDynamic
       ? displayMessages.slice(0, -1)
       : displayMessages;
@@ -52,17 +86,7 @@ export const MessageList = React.memo(
         : [];
 
     return (
-      <Box flexDirection="column" gap={1}>
-        {/* Show omitted message count when limiting */}
-        {omittedCount > 0 && (
-          <Box>
-            <Text color="gray" dimColor>
-              ... {omittedCount} earlier message{omittedCount !== 1 ? "s" : ""}{" "}
-              omitted (showing latest {maxExpandedMessages})
-            </Text>
-          </Box>
-        )}
-
+      <Box flexDirection="column" paddingBottom={1}>
         {/* Static messages */}
         <Static items={staticMessages}>
           {(message, key) => {
@@ -86,7 +110,7 @@ export const MessageList = React.memo(
           const previousMessage =
             messageIndex > 0 ? displayMessages[messageIndex - 1] : undefined;
           return (
-            <Box key={`dynamic-${index}`} marginTop={-1}>
+            <Box key={`dynamic-${index}`}>
               <MessageItem
                 message={message}
                 shouldShowHeader={previousMessage?.role !== message.role}
@@ -95,64 +119,6 @@ export const MessageList = React.memo(
             </Box>
           );
         })}
-
-        {(isLoading || isCommandRunning || isCompressing) && (
-          <Box flexDirection="column" gap={1}>
-            {isLoading && (
-              <Box>
-                <Text color="yellow">💭 AI is thinking... </Text>
-                <Text color="gray" dimColor>
-                  |{" "}
-                </Text>
-                <Text color="red" bold>
-                  Esc
-                </Text>
-                <Text color="gray" dimColor>
-                  {" "}
-                  to abort
-                </Text>
-              </Box>
-            )}
-            {isCommandRunning && (
-              <Text color="blue">🚀 Command is running...</Text>
-            )}
-            {isCompressing && (
-              <Text color="magenta">🗜️ Compressing message history...</Text>
-            )}
-          </Box>
-        )}
-
-        {/* Bottom info and shortcut key hints */}
-        {messages.length > 0 && (
-          <Box>
-            <Box justifyContent="space-between" width="100%">
-              <Box>
-                <Text color="gray">
-                  Messages {messages.length}
-                  {latestTotalTokens > 0 && (
-                    <>
-                      <Text color="gray" dimColor>
-                        {" "}
-                        |{" "}
-                      </Text>
-                      <Text color="blue" bold>
-                        {latestTotalTokens.toLocaleString()}
-                      </Text>
-                      <Text color="gray" dimColor>
-                        {" "}
-                        tokens
-                      </Text>
-                    </>
-                  )}
-                </Text>
-              </Box>
-              <Text color="gray" dimColor>
-                <Text color="cyan">Ctrl+O</Text> Toggle{" "}
-                {isExpanded ? "Collapse" : "Expand"}
-              </Text>
-            </Box>
-          </Box>
-        )}
       </Box>
     );
   },

package/src/components/PlanDisplay.tsx

@@ -1,5 +1,5 @@
-import React, { useMemo } from "react";
-import { Box, Text, useStdout } from "ink";
+import React from "react";
+import { Box } from "ink";
 import { Markdown } from "./Markdown.js";
 
 interface PlanDisplayProps {
@@ -7,35 +7,12 @@ interface PlanDisplayProps {
   isExpanded?: boolean;
 }
 
-export const PlanDisplay: React.FC<PlanDisplayProps> = ({
-  plan,
-  isExpanded = false,
-}) => {
-  const { stdout } = useStdout();
-  const maxHeight = useMemo(() => {
-    // Similar to DiffDisplay.tsx maxHeight calculation
-    return Math.max(5, (stdout?.rows || 24) - 25);
-  }, [stdout?.rows]);
-
-  const lines = useMemo(() => plan.split("\n"), [plan]);
-  const isOverflowing = !isExpanded && lines.length > maxHeight;
-
+export const PlanDisplay: React.FC<PlanDisplayProps> = ({ plan }) => {
   return (
     <Box flexDirection="column" marginTop={1}>
-      <Box
-        flexDirection="column"
-        height={isOverflowing ? maxHeight : undefined}
-        overflow="hidden"
-      >
+      <Box flexDirection="column">
         <Markdown>{plan}</Markdown>
       </Box>
-      {isOverflowing && (
-        <Box marginTop={1}>
-          <Text color="yellow" dimColor>
-            ... (plan truncated, {lines.length} lines total)
-          </Text>
-        </Box>
-      )}
     </Box>
   );
 };

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
@@ -106,7 +143,7 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
       <Box>
         <Text color="red" dimColor>
           ⚠️ Warning: This will delete all subsequent messages and revert file
-          changes.
+          and task list changes.
         </Text>
       </Box>
     </Box>

package/src/components/TaskList.tsx

@@ -0,0 +1,58 @@
+import React from "react";
+import { useChat } from "../contexts/useChat.js";
+import { Box, Text } from "ink";
+import { useTasks } from "../hooks/useTasks.js";
+
+export const TaskList: React.FC = () => {
+  const tasks = useTasks();
+  const { isTaskListVisible } = useChat();
+
+  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>;
+    }
+  };
+
+  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}>{fullText}</Text>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+};

package/src/components/{ToolResultDisplay.tsx → ToolDisplay.tsx}

@@ -3,12 +3,12 @@ import { Box, Text } from "ink";
 import type { ToolBlock } from "wave-agent-sdk";
 import { DiffDisplay } from "./DiffDisplay.js";
 
-interface ToolResultDisplayProps {
+interface ToolDisplayProps {
   block: ToolBlock;
   isExpanded?: boolean;
 }
 
-export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
+export const ToolDisplay: React.FC<ToolDisplayProps> = ({
   block,
   isExpanded = false,
 }) => {
@@ -25,13 +25,6 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
     return "gray"; // Unknown state or no state information
   };
 
-  const getStatusText = () => {
-    if (stage === "running") return "🔄";
-    if (success) return "";
-    if (error || success === false) return "❌";
-    return ""; // Don't display text for unknown state
-  };
-
   const hasImages = () => {
     return block.images && block.images.length > 0;
   };
@@ -44,9 +37,6 @@ 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) {
@@ -68,18 +58,18 @@ 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>
+        <Box flexShrink={0}>
+          <Text color={getStatusColor()}>● </Text>
+          <Text color="white">{toolName}</Text>
+        </Box>
         {/* Display compactParams in collapsed state */}
         {!isExpanded && compactParams && (
           <Text color="gray"> {compactParams}</Text>
         )}
-        <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 */}
@@ -91,7 +81,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>
           ))}