wave-code 0.5.0 → 0.6.2

package/dist/components/Markdown.js

@@ -1,8 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useMemo } from "react";
-import { Box, Text, useStdout } from "ink";
-import { marked } from "marked";
-import { highlight } from "cli-highlight";
+import { Box, Text } from "ink";
+import { Renderer, marked } from "marked";
+import chalk from "chalk";
 const unescapeHtml = (html) => {
     return html
         .replace(/&/g, "&")
@@ -12,124 +12,117 @@ const unescapeHtml = (html) => {
         .replace(/'/g, "'")
         .replace(/'/g, "'");
 };
-const InlineRenderer = ({ tokens }) => {
-    return (_jsx(_Fragment, { children: tokens.map((token, index) => {
-            switch (token.type) {
-                case "text": {
-                    const t = token;
-                    if (t.tokens) {
-                        return _jsx(InlineRenderer, { tokens: t.tokens }, index);
-                    }
-                    return _jsx(Text, { children: unescapeHtml(t.text) }, index);
-                }
-                case "strong":
-                    return (_jsx(Text, { bold: true, children: token.tokens ? (_jsx(InlineRenderer, { tokens: token.tokens })) : (unescapeHtml(token.text)) }, index));
-                case "em":
-                    return (_jsx(Text, { italic: true, children: token.tokens ? (_jsx(InlineRenderer, { tokens: token.tokens })) : (unescapeHtml(token.text)) }, index));
-                case "codespan":
-                    return (_jsx(Text, { color: "yellow", children: unescapeHtml(token.text) }, index));
-                case "link": {
-                    const t = token;
-                    return (_jsxs(Text, { children: [_jsx(Text, { color: "blue", underline: true, children: t.tokens ? (_jsx(InlineRenderer, { tokens: t.tokens })) : (unescapeHtml(t.text)) }), _jsxs(Text, { color: "gray", children: [" (", t.href, ")"] })] }, index));
-                }
-                case "br":
-                    return _jsx(Text, { children: "\n" }, index);
-                case "del":
-                    return (_jsx(Text, { strikethrough: true, children: token.tokens ? (_jsx(InlineRenderer, { tokens: token.tokens })) : (unescapeHtml(token.text)) }, index));
-                default:
-                    return _jsx(Text, { children: token.raw }, index);
-            }
-        }) }));
-};
-const TableRenderer = ({ token }) => {
-    const { stdout } = useStdout();
-    const terminalWidth = (stdout?.columns || 80) - 2;
-    const columnWidths = useMemo(() => {
-        const numCols = token.header.length;
-        const minWidth = 5;
-        const maxColWidth = 40;
-        const widths = token.header.map((h) => Math.min(maxColWidth, Math.max(minWidth, h.text.length)));
-        token.rows.forEach((row) => {
-            row.forEach((cell, i) => {
-                widths[i] = Math.min(maxColWidth, Math.max(widths[i] || minWidth, cell.text.length));
-            });
-        });
-        const paddedWidths = widths.map((w) => w + 2);
-        const totalWidth = paddedWidths.reduce((a, b) => a + b, 0) + numCols + 1;
-        if (totalWidth <= terminalWidth) {
-            return paddedWidths;
-        }
-        // If table is too wide, scale down columns proportionally
-        const availableWidth = terminalWidth - numCols - 1;
-        const scaleFactor = availableWidth / (totalWidth - numCols - 1);
-        return paddedWidths.map((w) => Math.max(minWidth, Math.floor(w * scaleFactor)));
-    }, [token, terminalWidth]);
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "single", borderColor: "gray", width: columnWidths.reduce((a, b) => a + b, 0) + token.header.length + 1, children: [_jsx(Box, { flexDirection: "row", borderStyle: "single", borderBottom: true, borderTop: false, borderLeft: false, borderRight: false, borderColor: "gray", children: token.header.map((cell, i) => (_jsx(Box, { width: columnWidths[i], paddingX: 1, borderStyle: "single", borderLeft: i > 0, borderRight: false, borderTop: false, borderBottom: false, borderColor: "gray", children: _jsx(Text, { bold: true, wrap: "wrap", children: _jsx(InlineRenderer, { tokens: cell.tokens }) }) }, i))) }), token.rows.map((row, rowIndex) => (_jsx(Box, { flexDirection: "row", children: row.map((cell, i) => (_jsx(Box, { width: columnWidths[i], paddingX: 1, borderStyle: "single", borderLeft: i > 0, borderRight: false, borderTop: false, borderBottom: false, borderColor: "gray", children: _jsx(Text, { wrap: "wrap", children: _jsx(InlineRenderer, { tokens: cell.tokens }) }) }, i))) }, rowIndex)))] }));
-};
-const BlockRenderer = ({ tokens }) => {
-    return (_jsx(_Fragment, { children: tokens.map((token, index) => {
-            switch (token.type) {
-                case "heading": {
-                    const t = token;
-                    return (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Text, { bold: true, color: "cyan", children: ["#".repeat(t.depth), " ", _jsx(InlineRenderer, { tokens: t.tokens })] }) }, index));
-                }
-                case "paragraph": {
-                    const t = token;
-                    return (_jsx(Box, { marginBottom: 1, flexDirection: "row", children: _jsx(Text, { children: _jsx(InlineRenderer, { tokens: t.tokens }) }) }, index));
-                }
-                case "code": {
-                    const t = token;
-                    if (t.lang !== undefined) {
-                        const raw = token.raw.endsWith("\n")
-                            ? token.raw.slice(0, -1)
-                            : token.raw;
-                        const lines = raw.split("\n");
-                        const opening = lines[0];
-                        const closing = lines[lines.length - 1];
-                        const content = lines.slice(1, -1).join("\n");
-                        const highlighted = content
-                            ? highlight(unescapeHtml(content), {
-                                language: t.lang,
-                                ignoreIllegals: true,
-                            })
-                            : "";
-                        return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { color: "gray", children: opening }), highlighted && _jsx(Text, { children: highlighted }), _jsx(Text, { color: "gray", children: closing })] }, index));
-                    }
-                    return (_jsx(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: _jsx(Text, { children: unescapeHtml(t.text) }) }, index));
-                }
-                case "list": {
-                    const t = token;
-                    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: t.items.map((item, i) => {
-                            const start = t.start || 1;
-                            return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: "gray", children: t.ordered ? `${start + i}. ` : "• " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: item.tokens.map((itemToken, itemIndex) => {
-                                            if (itemToken.type === "text" ||
-                                                itemToken.type === "paragraph") {
-                                                const it = itemToken;
-                                                return (_jsx(Box, { flexDirection: "row", children: _jsx(Text, { children: _jsx(InlineRenderer, { tokens: it.tokens || [itemToken] }) }) }, itemIndex));
-                                            }
-                                            return (_jsx(BlockRenderer, { tokens: [itemToken] }, itemIndex));
-                                        }) })] }, i));
-                        }) }, index));
-                }
-                case "blockquote": {
-                    const t = token;
-                    return (_jsx(Box, { flexDirection: "column", paddingLeft: 2, borderStyle: "single", borderLeft: true, borderRight: false, borderTop: false, borderBottom: false, borderColor: "gray", marginBottom: 1, children: _jsx(BlockRenderer, { tokens: t.tokens }) }, index));
-                }
-                case "hr":
-                    return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "gray", children: "─".repeat(20) }) }, index));
-                case "table":
-                    return _jsx(TableRenderer, { token: token }, index);
-                case "space":
-                    return null;
-                default:
-                    return (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: token.raw }) }, index));
-            }
-        }) }));
-};
-// Markdown component using custom Ink-based renderer
+class AnsiRenderer extends Renderer {
+    code({ text, lang }) {
+        const prefix = lang ? `\`\`\`${lang}` : "```";
+        const suffix = "```";
+        return `\n${chalk.gray(prefix)}\n${text}\n${chalk.gray(suffix)}\n`;
+    }
+    blockquote({ tokens }) {
+        const body = this.parser.parse(tokens);
+        return ("\n" +
+            body
+                .trim()
+                .split("\n")
+                .map((line) => chalk.gray("> ") + line)
+                .join("\n") +
+            "\n");
+    }
+    heading({ tokens, depth }) {
+        const text = this.parser.parseInline(tokens);
+        const hashes = "#".repeat(depth);
+        return `\n${chalk.cyan(`${hashes} ${text}`)}\n`;
+    }
+    hr() {
+        return `\n${chalk.gray("─".repeat(20))}\n`;
+    }
+    list(token) {
+        const body = token.items
+            .map((item, i) => {
+            const text = this.listitem(item);
+            const prefix = token.ordered
+                ? chalk.gray(`${(token.start || 1) + i}. `)
+                : chalk.gray("• ");
+            const lines = text.split("\n");
+            const firstLine = prefix + lines[0];
+            const restLines = lines
+                .slice(1)
+                .filter((line) => line.length > 0)
+                .map((line) => "  " + line);
+            return [firstLine, ...restLines].join("\n") + "\n";
+        })
+            .join("");
+        return `\n${body}`;
+    }
+    listitem(item) {
+        return `${this.parser.parse(item.tokens).trim()}\n`;
+    }
+    checkbox({ checked }) {
+        return checked ? chalk.green("[x] ") : chalk.gray("[ ] ");
+    }
+    paragraph({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return `\n${text}\n`;
+    }
+    table(token) {
+        const header = token.header.map((cell) => this.tablecell(cell)).join("");
+        const body = token.rows
+            .map((row) => row.map((cell) => this.tablecell(cell)).join("") + "\n")
+            .join("");
+        return `\n${header}\n${body}\n`;
+    }
+    tablerow({ text }) {
+        return text + "\n";
+    }
+    tablecell(token) {
+        const text = token.header ? chalk.bold(token.text) : token.text;
+        return text + " | ";
+    }
+    strong({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return chalk.bold(text);
+    }
+    em({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return chalk.italic(text);
+    }
+    codespan({ text }) {
+        return chalk.yellow(text);
+    }
+    br() {
+        return "\n";
+    }
+    del({ tokens }) {
+        const text = this.parser.parseInline(tokens);
+        return chalk.strikethrough(text);
+    }
+    link({ href, tokens }) {
+        const text = this.parser.parseInline(tokens);
+        const linkText = chalk.blue.underline(text);
+        const hrefText = chalk.gray(`(${href})`);
+        return `${linkText} ${hrefText}`;
+    }
+    image({ href, tokens, text }) {
+        const alt = this.parser.parseInline(tokens) || text;
+        return chalk.gray(`![${alt}](${href})`);
+    }
+    text(token) {
+        return "tokens" in token && token.tokens
+            ? this.parser.parseInline(token.tokens)
+            : unescapeHtml(token.text);
+    }
+}
+const renderer = new AnsiRenderer();
+// Markdown component using custom ANSI renderer
 export const Markdown = React.memo(({ children }) => {
-    const tokens = useMemo(() => marked.lexer(children), [children]);
-    return (_jsx(Box, { flexDirection: "column", children: _jsx(BlockRenderer, { tokens: tokens }) }));
+    const ansiContent = useMemo(() => {
+        return marked.parse(children, {
+            renderer,
+            gfm: true,
+            breaks: true,
+        });
+    }, [children]);
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: ansiContent.trim() }) }));
 });
 // Add display name for debugging
 Markdown.displayName = "Markdown";

package/dist/components/MessageItem.d.ts

@@ -4,5 +4,5 @@ export interface MessageItemProps {
     isExpanded: boolean;
     shouldShowHeader: boolean;
 }
-export declare const MessageItem: ({ message, isExpanded, shouldShowHeader, }: MessageItemProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const MessageItem: ({ message, isExpanded }: MessageItemProps) => import("react/jsx-runtime").JSX.Element | null;
 //# sourceMappingURL=MessageItem.d.ts.map

package/dist/components/MessageItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageItem.d.ts","sourceRoot":"","sources":["../../src/components/MessageItem.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAU9C,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,WAAW,GAAI,4CAIzB,gBAAgB,mDAyElB,CAAC"}
+{"version":3,"file":"MessageItem.d.ts","sourceRoot":"","sources":["../../src/components/MessageItem.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAQ9C,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,WAAW,GAAI,yBAAyB,gBAAgB,mDAoEpE,CAAC"}

package/dist/components/MessageItem.js

@@ -2,14 +2,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { MessageSource } from "wave-agent-sdk";
 import { CommandOutputDisplay } from "./CommandOutputDisplay.js";
-import { ToolResultDisplay } from "./ToolResultDisplay.js";
-import { MemoryDisplay } from "./MemoryDisplay.js";
+import { ToolDisplay } from "./ToolDisplay.js";
 import { CompressDisplay } from "./CompressDisplay.js";
-import { SubagentBlock } from "./SubagentBlock.js";
 import { ReasoningDisplay } from "./ReasoningDisplay.js";
 import { Markdown } from "./Markdown.js";
-export const MessageItem = ({ message, isExpanded, shouldShowHeader, }) => {
+export const MessageItem = ({ message, isExpanded }) => {
     if (message.blocks.length === 0)
         return null;
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, marginTop: 1, children: [shouldShowHeader && (_jsx(Box, { children: _jsx(Text, { color: message.role === "user" ? "cyan" : "green", bold: true, children: message.role === "user" ? "👤 You" : "🤖 Assistant" }) })), _jsx(Box, { flexDirection: "column", gap: 1, children: message.blocks.map((block, blockIndex) => (_jsxs(Box, { children: [block.type === "text" && block.content.trim() && (_jsxs(Box, { children: [block.customCommandContent && (_jsxs(Text, { color: "cyan", bold: true, children: ["\u26A1", " "] })), block.source === MessageSource.HOOK && (_jsxs(Text, { color: "magenta", bold: true, children: ["\uD83D\uDD17", " "] })), _jsx(Markdown, { children: block.content })] })), block.type === "error" && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["\u274C Error: ", block.content] }) })), block.type === "command_output" && (_jsx(CommandOutputDisplay, { block: block, isExpanded: isExpanded })), block.type === "tool" && (_jsx(ToolResultDisplay, { block: block, isExpanded: isExpanded })), block.type === "image" && (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "\uD83D\uDCF7 Image" }), block.imageUrls && block.imageUrls.length > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: [" ", "(", block.imageUrls.length, ")"] }))] })), block.type === "memory" && _jsx(MemoryDisplay, { block: block }), block.type === "compress" && (_jsx(CompressDisplay, { block: block, isExpanded: isExpanded })), block.type === "subagent" && _jsx(SubagentBlock, { block: block }), block.type === "reasoning" && _jsx(ReasoningDisplay, { block: block })] }, blockIndex))) })] }));
+    return (_jsx(Box, { flexDirection: "column", gap: 1, marginTop: 1, children: _jsx(Box, { flexDirection: "column", gap: 1, children: message.blocks.map((block, blockIndex) => (_jsxs(Box, { children: [block.type === "text" && block.content.trim() && (_jsxs(Box, { children: [block.customCommandContent && (_jsx(Text, { color: "cyan", bold: true, children: "\u26A1" })), block.source === MessageSource.HOOK && (_jsx(Text, { color: "magenta", bold: true, children: "\uD83D\uDD17" })), message.role === "user" ? (_jsx(Text, { backgroundColor: "gray", color: "white", children: block.content })) : (_jsx(Markdown, { children: block.content }))] })), block.type === "error" && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["\u274C Error: ", block.content] }) })), block.type === "command_output" && (_jsx(CommandOutputDisplay, { block: block, isExpanded: isExpanded })), block.type === "tool" && (_jsx(ToolDisplay, { block: block, isExpanded: isExpanded })), block.type === "image" && (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "\uD83D\uDCF7 Image" }), block.imageUrls && block.imageUrls.length > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: [" ", "(", block.imageUrls.length, ")"] }))] })), block.type === "compress" && (_jsx(CompressDisplay, { block: block, isExpanded: isExpanded })), block.type === "reasoning" && _jsx(ReasoningDisplay, { block: block })] }, blockIndex))) }) }));
 };

package/dist/components/MessageList.d.ts

@@ -4,9 +4,8 @@ export interface MessageListProps {
     messages: Message[];
     isLoading?: boolean;
     isCommandRunning?: boolean;
-    isCompressing?: boolean;
-    latestTotalTokens?: number;
     isExpanded?: boolean;
+    forceStaticLastMessage?: boolean;
 }
-export declare const MessageList: React.MemoExoticComponent<({ messages, isLoading, isCommandRunning, isCompressing, latestTotalTokens, isExpanded, }: MessageListProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const MessageList: React.MemoExoticComponent<({ messages, isLoading, isCommandRunning, isExpanded, forceStaticLastMessage, }: MessageListProps) => import("react/jsx-runtime").JSX.Element>;
 //# sourceMappingURL=MessageList.d.ts.map

package/dist/components/MessageList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageList.d.ts","sourceRoot":"","sources":["../../src/components/MessageList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,uHAQnB,gBAAgB,6CAwIpB,CAAC"}
+{"version":3,"file":"MessageList.d.ts","sourceRoot":"","sources":["../../src/components/MessageList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAS9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,eAAO,MAAM,WAAW,6GAOnB,gBAAgB,6CAkGpB,CAAC"}

package/dist/components/MessageList.js

@@ -1,38 +1,55 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
 import { Box, Text, Static } from "ink";
+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 const MessageList = React.memo(({ messages, isLoading = false, isCommandRunning = false, isCompressing = false, latestTotalTokens = 0, isExpanded = false, }) => {
+export const MessageList = React.memo(({ messages, isLoading = false, isCommandRunning = false, isExpanded = false, forceStaticLastMessage = false, }) => {
     // Empty message state
     if (messages.length === 0) {
-        return (_jsx(Box, { flexDirection: "column", paddingY: 1, children: _jsx(Text, { color: "gray", children: "Welcome to WAVE Code Assistant!" }) }));
+        return (_jsx(Box, { flexDirection: "column", gap: 1, children: _jsx(Box, { flexDirection: "column", paddingY: 1, children: _jsx(Text, { color: "gray", children: "Welcome to WAVE Code Assistant!" }) }) }));
     }
     // Limit messages when expanded to prevent long rendering times
     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;
     const dynamicMessages = shouldRenderLastDynamic && displayMessages.length > 0
         ? [displayMessages[displayMessages.length - 1]]
         : [];
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [omittedCount > 0 && (_jsx(Box, { children: _jsxs(Text, { color: "gray", dimColor: true, children: ["... ", omittedCount, " earlier message", omittedCount !== 1 ? "s" : "", " ", "omitted (showing latest ", maxExpandedMessages, ")"] }) })), _jsx(Static, { items: staticMessages, children: (message, key) => {
+    return (_jsxs(Box, { flexDirection: "column", paddingBottom: 1, children: [_jsx(Static, { items: staticMessages, children: (message, key) => {
                     // Get previous message
                     const previousMessage = key > 0 ? staticMessages[key - 1] : undefined;
                     return (_jsx(MessageItem, { message: message, shouldShowHeader: previousMessage?.role !== message.role, isExpanded: isExpanded }, key));
                 } }), dynamicMessages.map((message, index) => {
                 const messageIndex = staticMessages.length + index;
                 const previousMessage = messageIndex > 0 ? displayMessages[messageIndex - 1] : undefined;
-                return (_jsx(Box, { marginTop: -1, children: _jsx(MessageItem, { message: message, shouldShowHeader: previousMessage?.role !== message.role, isExpanded: isExpanded }) }, `dynamic-${index}`));
-            }), (isLoading || isCommandRunning || isCompressing) && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\uD83D\uDCAD AI is thinking... " }), _jsxs(Text, { color: "gray", dimColor: true, children: ["|", " "] }), _jsx(Text, { color: "red", bold: true, children: "Esc" }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "to abort"] })] })), isCommandRunning && (_jsx(Text, { color: "blue", children: "\uD83D\uDE80 Command is running..." })), isCompressing && (_jsx(Text, { color: "magenta", children: "\uD83D\uDDDC\uFE0F Compressing message history..." }))] })), messages.length > 0 && (_jsx(Box, { children: _jsxs(Box, { justifyContent: "space-between", width: "100%", children: [_jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["Messages ", messages.length, latestTotalTokens > 0 && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [" ", "|", " "] }), _jsx(Text, { color: "blue", bold: true, children: latestTotalTokens.toLocaleString() }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "tokens"] })] }))] }) }), _jsxs(Text, { color: "gray", dimColor: true, children: [_jsx(Text, { color: "cyan", children: "Ctrl+O" }), " Toggle", " ", isExpanded ? "Collapse" : "Expand"] })] }) }))] }));
+                return (_jsx(Box, { children: _jsx(MessageItem, { message: message, shouldShowHeader: previousMessage?.role !== message.role, isExpanded: isExpanded }) }, `dynamic-${index}`));
+            })] }));
 });
 // Add display name for debugging
 MessageList.displayName = "MessageList";

package/dist/components/PlanDisplay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlanDisplay.d.ts","sourceRoot":"","sources":["../../src/components/PlanDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAIvC,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA+BlD,CAAC"}
+{"version":3,"file":"PlanDisplay.d.ts","sourceRoot":"","sources":["../../src/components/PlanDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAQlD,CAAC"}

package/dist/components/PlanDisplay.js

@@ -1,14 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { Box, Text, useStdout } from "ink";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "ink";
 import { Markdown } from "./Markdown.js";
-export const PlanDisplay = ({ 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;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { flexDirection: "column", height: isOverflowing ? maxHeight : undefined, overflow: "hidden", children: _jsx(Markdown, { children: plan }) }), isOverflowing && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", dimColor: true, children: ["... (plan truncated, ", lines.length, " lines total)"] }) }))] }));
+export const PlanDisplay = ({ plan }) => {
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(Box, { flexDirection: "column", children: _jsx(Markdown, { children: plan }) }) }));
 };

package/dist/components/RewindCommand.d.ts

@@ -4,6 +4,10 @@ export interface RewindCommandProps {
     messages: Message[];
     onSelect: (index: number) => void;
     onCancel: () => void;
+    getFullMessageThread?: () => Promise<{
+        messages: Message[];
+        sessionIds: string[];
+    }>;
 }
 export declare const RewindCommand: React.FC<RewindCommandProps>;
 //# sourceMappingURL=RewindCommand.d.ts.map

package/dist/components/RewindCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RewindCommand.d.ts","sourceRoot":"","sources":["../../src/components/RewindCommand.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,gBAAgB,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAuGtD,CAAC"}
+{"version":3,"file":"RewindCommand.d.ts","sourceRoot":"","sources":["../../src/components/RewindCommand.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,gBAAgB,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC;QACnC,QAAQ,EAAE,OAAO,EAAE,CAAC;QACpB,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC,CAAC;CACJ;AAED,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAwItD,CAAC"}

package/dist/components/RewindCommand.js

@@ -1,12 +1,26 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from "react";
+import React, { useState } from "react";
 import { Box, Text, useInput } from "ink";
-export const RewindCommand = ({ messages, onSelect, onCancel, }) => {
+export const RewindCommand = ({ messages: initialMessages, onSelect, onCancel, getFullMessageThread, }) => {
+    const [messages, setMessages] = useState(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 }))
         .filter(({ msg }) => msg.role === "user");
     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) {
@@ -27,6 +41,9 @@ export const RewindCommand = ({ messages, onSelect, onCancel, }) => {
             return;
         }
     });
+    if (isLoading) {
+        return (_jsx(Box, { flexDirection: "column", paddingX: 1, borderStyle: "single", borderColor: "cyan", borderLeft: false, borderRight: false, children: _jsx(Text, { color: "cyan", children: "Loading full message thread..." }) }));
+    }
     if (checkpoints.length === 0) {
         return (_jsxs(Box, { flexDirection: "column", paddingX: 1, borderStyle: "single", borderColor: "yellow", borderLeft: false, borderRight: false, children: [_jsx(Text, { color: "yellow", children: "No user messages found to rewind to." }), _jsx(Text, { dimColor: true, children: "Press Escape to cancel" })] }));
     }
@@ -38,5 +55,5 @@ export const RewindCommand = ({ messages, onSelect, onCancel, }) => {
                         .join(" ")
                         .substring(0, 60);
                     return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? "black" : "white", backgroundColor: isSelected ? "cyan" : undefined, children: [isSelected ? "▶ " : "  ", "[", checkpoint.index, "]", " ", content || "(No text content)", index === checkpoints.length - 1 ? " (Latest)" : ""] }) }, checkpoint.index));
-                }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u2022 Enter to rewind \u2022 Esc to cancel" }) }), _jsx(Box, { children: _jsx(Text, { color: "red", dimColor: true, children: "\u26A0\uFE0F Warning: This will delete all subsequent messages and revert file changes." }) })] }));
+                }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u2022 Enter to rewind \u2022 Esc to cancel" }) }), _jsx(Box, { children: _jsx(Text, { color: "red", dimColor: true, children: "\u26A0\uFE0F Warning: This will delete all subsequent messages and revert file and task list changes." }) })] }));
 };

package/dist/components/TaskList.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+export declare const TaskList: React.FC;
+//# sourceMappingURL=TaskList.d.ts.map

package/dist/components/TaskList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskList.d.ts","sourceRoot":"","sources":["../../src/components/TaskList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAoD5B,CAAC"}

package/dist/components/TaskList.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useChat } from "../contexts/useChat.js";
+import { Box, Text } from "ink";
+import { useTasks } from "../hooks/useTasks.js";
+export const TaskList = () => {
+    const tasks = useTasks();
+    const { isTaskListVisible } = useChat();
+    if (tasks.length === 0 || !isTaskListVisible) {
+        return null;
+    }
+    const getStatusIcon = (status, isBlocked) => {
+        if (isBlocked) {
+            return _jsx(Text, { color: "red", children: "\uD83D\uDD12" });
+        }
+        switch (status) {
+            case "pending":
+                return _jsx(Text, { color: "gray", children: "\u25A1" });
+            case "in_progress":
+                return _jsx(Text, { color: "yellow", children: "\u25A0" });
+            case "completed":
+                return _jsx(Text, { color: "green", children: "\u2713" });
+            case "deleted":
+                return _jsx(Text, { color: "red", children: "\u2715" });
+            default:
+                return _jsx(Text, { color: "gray", children: "?" });
+        }
+    };
+    return (_jsx(Box, { flexDirection: "column", children: 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 (_jsxs(Box, { gap: 1, children: [getStatusIcon(task.status, isBlocked), _jsx(Text, { dimColor: isDimmed, children: fullText })] }, task.id));
+        }) }));
+};

package/dist/components/ToolDisplay.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { ToolBlock } from "wave-agent-sdk";
+interface ToolDisplayProps {
+    block: ToolBlock;
+    isExpanded?: boolean;
+}
+export declare const ToolDisplay: React.FC<ToolDisplayProps>;
+export {};
+//# sourceMappingURL=ToolDisplay.d.ts.map

package/dist/components/ToolDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolDisplay.d.ts","sourceRoot":"","sources":["../../src/components/ToolDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD,UAAU,gBAAgB;IACxB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CA+HlD,CAAC"}

package/dist/components/ToolDisplay.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { DiffDisplay } from "./DiffDisplay.js";
+export const ToolDisplay = ({ block, isExpanded = false, }) => {
+    const { parameters, result, compactParams, stage, success, error, name } = block;
+    // Directly use compactParams
+    // (no change needed as we destructured it above)
+    const getStatusColor = () => {
+        if (stage === "running")
+            return "yellow";
+        if (success)
+            return "green";
+        if (error || success === false)
+            return "red";
+        return "gray"; // Unknown state or no state information
+    };
+    const hasImages = () => {
+        return block.images && block.images.length > 0;
+    };
+    const getImageIndicator = () => {
+        if (!hasImages())
+            return "";
+        const imageCount = block.images.length;
+        return imageCount === 1 ? "🖼️" : `🖼️×${imageCount}`;
+    };
+    const toolName = name ? String(name) : "Tool";
+    // Get shortResult, if not available show last 5 lines of result
+    const getShortResult = () => {
+        if (block.shortResult) {
+            return block.shortResult;
+        }
+        // If no shortResult but has result, return last 5 lines
+        if (block.result) {
+            const lines = block.result.split("\n");
+            if (lines.length > 5) {
+                return lines.slice(-5).join("\n");
+            }
+            return block.result;
+        }
+        return null;
+    };
+    const shortResult = getShortResult();
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: getStatusColor(), children: "\u25CF " }), _jsx(Text, { color: "white", children: toolName })] }), !isExpanded && compactParams && (_jsxs(Text, { color: "gray", children: [" ", compactParams] })), hasImages() && _jsxs(Text, { color: "blue", children: [" ", getImageIndicator()] })] }), !isExpanded && shortResult && !error && (_jsx(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: shortResult.split("\n").map((line, index) => (_jsx(Text, { color: "gray", children: line }, index))) })), isExpanded && parameters && (_jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Parameters:" }), _jsx(Text, { color: "gray", children: parameters })] })), isExpanded && result && (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "green", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Result:" }), _jsx(Text, { color: "white", children: result })] }) })), error && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", typeof error === "string" ? error : String(error)] }) })), stage === "end" && success && (_jsx(DiffDisplay, { toolName: name, parameters: parameters }))] }));
+};