wave-code 1.0.10 → 1.1.0

package/src/components/InputBox.tsx

@@ -369,7 +369,9 @@ export const InputBox: React.FC<InputBoxProps> = ({
           showModelSelector ||
           showWorkflowManager || (
             <Box flexDirection="column">
-              {escClearPending && <Text color="gray">再次按 Esc 清空输入</Text>}
+              {escClearPending && (
+                <Text color="gray">Press Esc again to clear input</Text>
+              )}
               <Box
                 borderStyle="single"
                 borderColor="gray"

package/src/components/LoadingIndicator.tsx

@@ -1,11 +1,16 @@
 import React from "react";
 import { Box, Text } from "ink";
+import { streamingTail } from "../utils/streamingText.js";
 
 export interface LoadingIndicatorProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
   isCompacting?: boolean;
   latestTotalTokens?: number;
+  /** Accumulated streaming text from the compaction fork; its last 30
+   * characters render after the compacting hint (same tail style as the
+   * main-loop streaming blocks). */
+  compactionStream?: string;
 }
 
 export const LoadingIndicator = ({
@@ -13,12 +18,13 @@ export const LoadingIndicator = ({
   isCommandRunning = false,
   isCompacting = false,
   latestTotalTokens = 0,
+  compactionStream = "",
 }: LoadingIndicatorProps) => {
   return (
     <Box flexDirection="column">
       {isLoading && !isCompacting && (
         <Box>
-          <Text color="yellow">✻ AI is thinking... </Text>
+          <Text color="yellow">✻ Thinking </Text>
           {latestTotalTokens > 0 && (
             <>
               <Text color="gray" dimColor>
@@ -47,7 +53,15 @@ export const LoadingIndicator = ({
       )}
       {isCommandRunning && <Text color="blue">✻ Command is running...</Text>}
       {isCompacting && (
-        <Text color="magenta">✻ Compacting message history...</Text>
+        <Box>
+          <Text color="magenta">✻ Compacting</Text>
+          {compactionStream && (
+            <Text color="gray" wrap="truncate-end">
+              {" "}
+              {streamingTail(compactionStream)}
+            </Text>
+          )}
+        </Box>
       )}
     </Box>
   );

package/src/components/MessageBlockItem.tsx

@@ -8,6 +8,7 @@ import { CompactDisplay } from "./CompactDisplay.js";
 import { ReasoningDisplay } from "./ReasoningDisplay.js";
 import { Markdown } from "./Markdown.js";
 import { TaskNotificationMessage } from "./TaskNotificationMessage.js";
+import { streamingTail } from "../utils/streamingText.js";
 
 export interface MessageBlockItemProps {
   block: MessageBlock;
@@ -40,10 +41,7 @@ export const MessageBlockItem = ({
             </Text>
           ) : block.stage === "streaming" ? (
             <Text color="gray" wrap="truncate-end">
-              {(() => {
-                const flat = block.content.replace(/\n/g, "\\n");
-                return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
-              })()}
+              {streamingTail(block.content)}
             </Text>
           ) : (
             <Markdown>{block.content}</Markdown>

package/src/components/MessageList.tsx

@@ -1,6 +1,6 @@
-import React from "react";
+import React, { useLayoutEffect, useRef } from "react";
 import os from "os";
-import { Box, Text, Static } from "ink";
+import { Box, Text, Static, useWindowSize } from "ink";
 import type { Message, MessageBlock } from "wave-agent-sdk";
 import { MessageBlockItem } from "./MessageBlockItem.js";
 
@@ -10,22 +10,23 @@ const MAX_MESSAGES_EXPANDED = 10;
 export interface MessageListProps {
   messages: Message[];
   isExpanded?: boolean;
-  forceStatic?: boolean;
   version?: string;
   workdir?: string;
 }
 
 export const MessageList = React.memo(
-  ({
-    messages,
-    isExpanded = false,
-    forceStatic = false,
-    version,
-    workdir,
-  }: MessageListProps) => {
+  ({ messages, isExpanded = false, version, workdir }: MessageListProps) => {
     const maxMessages = isExpanded
       ? MAX_MESSAGES_EXPANDED
       : MAX_MESSAGES_COLLAPSED;
+    // Bound the <Static> history to the terminal width. The static node is
+    // absolutely positioned, so without an explicit width Yoga measures it
+    // against its content: any row whose natural width exceeds the terminal
+    // (e.g. long tool compactParams) widens the node past the viewport, and
+    // the node's height stays at the pre-resize measurement while children
+    // re-layout at the wider width — leaving a block of blank rows between
+    // the last message and the input box on session restore.
+    const { columns } = useWindowSize();
 
     const welcomeMessage = (
       <Box flexDirection="column" paddingTop={1}>
@@ -81,7 +82,6 @@ export const MessageList = React.memo(
         (item.block.type === "text" || item.block.type === "reasoning") &&
         item.block.stage === "end";
       const isDynamic =
-        !forceStatic &&
         !isExpanded &&
         isInLastMessage &&
         !isBlockCompleted &&
@@ -103,11 +103,72 @@ export const MessageList = React.memo(
       ...staticBlocks.map((b) => ({ ...b, isWelcome: false })),
     ];
 
+    // Track the content that was written into the append-only <Static> zone for
+    // each block. Ink's <Static> never updates an already-rendered item, so when
+    // a text/reasoning block reopens (stage "end" -> "streaming") the frozen
+    // prefix stays on screen while the dynamic zone would re-render the FULL
+    // accumulated content — duplicating the first words. Rendering only the
+    // delta (content beyond the frozen prefix) in the dynamic zone avoids the
+    // overlap.
+    const frozenContentRef = useRef(new Map<string, string>());
+    // Mirrors <Static>'s internal index (the previous static items.length) so we
+    // know which static items are actually appended to the terminal output in
+    // this render pass. Only those items get their content frozen.
+    const staticIndexRef = useRef(0);
+
+    useLayoutEffect(() => {
+      staticIndexRef.current = staticItems.length;
+    }, [staticItems.length]);
+
+    // Record the content of static items being appended this pass, and prune
+    // keys for blocks that no longer exist (e.g. rewound or cleared messages).
+    // Only text/reasoning blocks carry content and can reopen (end -> streaming).
+    const currentKeys = new Set<string>();
+    staticItems.forEach((item, position) => {
+      if (item.isWelcome) return;
+      currentKeys.add(item.key);
+      if (
+        position >= staticIndexRef.current &&
+        (item.block!.type === "text" || item.block!.type === "reasoning")
+      ) {
+        frozenContentRef.current.set(item.key, item.block!.content);
+      }
+    });
+    for (const item of dynamicBlocks) {
+      currentKeys.add(item.key);
+    }
+    for (const key of frozenContentRef.current.keys()) {
+      if (!currentKeys.has(key)) {
+        frozenContentRef.current.delete(key);
+      }
+    }
+
+    // Reopened blocks (in the dynamic zone but previously written to static)
+    // must render only the content beyond the frozen prefix, otherwise the
+    // already-displayed prefix appears twice on screen.
+    const dynamicBlocksWithDelta = dynamicBlocks.map((item) => {
+      const frozen = frozenContentRef.current.get(item.key);
+      if (
+        frozen !== undefined &&
+        (item.block.type === "text" || item.block.type === "reasoning") &&
+        item.block.content.length > frozen.length
+      ) {
+        return {
+          ...item,
+          block: {
+            ...item.block,
+            content: item.block.content.slice(frozen.length),
+          },
+        };
+      }
+      return item;
+    });
+
     return (
       <Box flexDirection="column" paddingBottom={1}>
         {/* Static items (Welcome message + Static blocks) */}
         {staticItems.length > 0 && (
-          <Static items={staticItems}>
+          <Static items={staticItems} style={{ width: columns }}>
             {(item) => {
               if (item.isWelcome) {
                 return (
@@ -136,9 +197,9 @@ export const MessageList = React.memo(
         )}
 
         {/* Dynamic blocks */}
-        {dynamicBlocks.length > 0 && (
+        {dynamicBlocksWithDelta.length > 0 && (
           <Box flexDirection="column">
-            {dynamicBlocks.map((item) => (
+            {dynamicBlocksWithDelta.map((item) => (
               <MessageBlockItem
                 key={item.key}
                 block={item.block}

package/src/components/ReasoningDisplay.tsx

@@ -2,6 +2,7 @@ import React from "react";
 import { Box, Text } from "ink";
 import type { ReasoningBlock } from "wave-agent-sdk";
 import { Markdown } from "./Markdown.js";
+import { streamingTail } from "../utils/streamingText.js";
 
 interface ReasoningDisplayProps {
   block: ReasoningBlock;
@@ -32,10 +33,7 @@ export const ReasoningDisplay: React.FC<ReasoningDisplayProps> = ({
           <Text color="white">{content}</Text>
         ) : stage === "streaming" ? (
           <Text color="gray" wrap="truncate-end">
-            {` ${(() => {
-              const flat = content.replace(/\n/g, "\\n");
-              return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
-            })()}`}
+            {` ${streamingTail(content)}`}
           </Text>
         ) : (
           <Markdown>{content}</Markdown>

package/src/components/SessionSelector.tsx

@@ -1,4 +1,4 @@
-import React, { useReducer, useEffect } from "react";
+import React, { useReducer, useEffect, useRef } from "react";
 import { Box, Text, useInput } from "ink";
 import type { SessionMetadata } from "wave-agent-sdk";
 import {
@@ -12,34 +12,87 @@ export interface SessionSelectorProps {
   sessions: SessionItem[];
   onSelect: (sessionId: string) => void;
   onCancel: () => void;
+  /**
+   * Same-repo worktree paths (from `git worktree list`). The Ctrl+W
+   * all-worktrees toggle is only enabled when more than one worktree exists.
+   */
+  worktreePaths?: string[];
+  /** Show each session's project directory at the end of its row. */
+  showProjectPath?: boolean;
+  /** Emitted with the new scope when the user toggles all-projects (Ctrl+A). */
+  onToggleAllProjects?: (showAllProjects: boolean) => void;
+  /** Emitted with the new scope when the user toggles all-worktrees (Ctrl+W). */
+  onToggleAllWorktrees?: (showAllWorktrees: boolean) => void;
 }
 
 export const SessionSelector: React.FC<SessionSelectorProps> = ({
   sessions,
   onSelect,
   onCancel,
+  worktreePaths = [],
+  showProjectPath = false,
+  onToggleAllProjects,
+  onToggleAllWorktrees,
 }) => {
   const [state, dispatch] = useReducer(selectorReducer<SessionItem>, {
     selectedIndex: 0,
     pendingDecision: null,
     items: [],
+    showAllProjects: false,
+    showAllWorktrees: false,
   } as SelectorState<SessionItem>);
 
-  const { selectedIndex, pendingDecision, items } = state;
+  const {
+    selectedIndex,
+    pendingDecision,
+    items,
+    showAllProjects,
+    showAllWorktrees,
+  } = state;
 
   // Sync sessions into reducer state
   useEffect(() => {
     dispatch({ type: "SET_ITEMS", items: sessions });
   }, [sessions]);
 
-  useInput((_input, key) => {
-    dispatch({
-      type: "HANDLE_KEY",
-      key,
-      hasInsert: false,
-    });
+  useInput((input, key) => {
+    // Ctrl+A — toggle all-projects scope (only when the parent supports it)
+    if (key.ctrl && input.toLowerCase() === "a" && onToggleAllProjects) {
+      dispatch({ type: "TOGGLE_ALL_PROJECTS" });
+      return;
+    }
+    // Ctrl+W — toggle all-worktrees scope (only with multiple worktrees)
+    if (
+      key.ctrl &&
+      input.toLowerCase() === "w" &&
+      onToggleAllWorktrees &&
+      worktreePaths.length > 1
+    ) {
+      dispatch({ type: "TOGGLE_ALL_WORKTREES" });
+      return;
+    }
+    dispatch({ type: "HANDLE_KEY", key, hasInsert: false });
   });
 
+  // Report scope toggles to the parent so it can reload the session list.
+  // Skip the initial render — the parent already starts in the default scope.
+  const projectsFirstRender = useRef(true);
+  useEffect(() => {
+    if (projectsFirstRender.current) {
+      projectsFirstRender.current = false;
+      return;
+    }
+    onToggleAllProjects?.(showAllProjects ?? false);
+  }, [showAllProjects, onToggleAllProjects]);
+  const worktreesFirstRender = useRef(true);
+  useEffect(() => {
+    if (worktreesFirstRender.current) {
+      worktreesFirstRender.current = false;
+      return;
+    }
+    onToggleAllWorktrees?.(showAllWorktrees ?? false);
+  }, [showAllWorktrees, onToggleAllWorktrees]);
+
   useEffect(() => {
     if (pendingDecision === "select") {
       if (items.length > 0 && selectedIndex < items.length) {
@@ -82,6 +135,20 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
     startIndex + MAX_VISIBLE_ITEMS,
   );
 
+  const hints = [
+    onToggleAllProjects
+      ? `Ctrl+A ${showAllProjects ? "current directory" : "all projects"}`
+      : null,
+    onToggleAllWorktrees && worktreePaths.length > 1
+      ? `Ctrl+W ${showAllWorktrees ? "current worktree" : "all worktrees"}`
+      : null,
+    "↑↓ select",
+    "Enter confirm",
+    "Esc cancel",
+  ]
+    .filter((hint): hint is string => hint !== null)
+    .join("  ·  ");
+
   return (
     <Box
       flexDirection="column"
@@ -124,8 +191,12 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
                     color={isSelected ? "black" : "white"}
                     wrap="truncate-end"
                   >
-                    {session.id} | {lastActiveAt} | {session.latestTotalTokens}{" "}
-                    tokens
+                    {session.id.slice(0, 8)} | {lastActiveAt} |{" "}
+                    {session.latestTotalTokens} tokens
+                    {session.branch ? ` | [${session.branch}]` : ""}
+                    {showProjectPath && session.workdir
+                      ? ` | ${session.workdir}`
+                      : ""}
                   </Text>
                 </Box>
               </Box>
@@ -150,7 +221,7 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
       )}
 
       <Box>
-        <Text dimColor>↑↓ navigate • Enter to select • Esc to cancel</Text>
+        <Text dimColor>{hints}</Text>
       </Box>
     </Box>
   );

package/src/components/StatusCommand.tsx

@@ -1,12 +1,7 @@
 import React from "react";
 import { Box, Text, useInput } from "ink";
 import { useChat } from "../contexts/useChat.js";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { readNearestPackageJson } from "../utils/readPackageJson.js";
 
 export interface StatusCommandProps {
   onCancel: () => void;
@@ -27,9 +22,7 @@ export const StatusCommand: React.FC<StatusCommandProps> = ({ onCancel }) => {
 
   let version = "unknown";
   try {
-    const pkgPath = path.resolve(__dirname, "../../package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    version = pkg.version;
+    version = readNearestPackageJson().version;
   } catch {
     // Fallback if package.json cannot be read
   }

package/src/components/ToolDisplay.tsx

@@ -3,6 +3,7 @@ import { Box, Text } from "ink";
 import type { ToolBlock } from "wave-agent-sdk";
 import { getLastLines } from "wave-agent-sdk";
 import { DiffDisplay } from "./DiffDisplay.js";
+import { streamingTail } from "../utils/streamingText.js";
 
 interface ToolDisplayProps {
   block: ToolBlock;
@@ -81,10 +82,7 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
           parameters &&
           !compactParams && (
             <Text color="gray" wrap="truncate-end">
-              {` ${(() => {
-                const flat = parameters.replace(/\n/g, "\\n");
-                return flat.length > 30 ? `…${flat.slice(-30)}` : flat;
-              })()}`}
+              {` ${streamingTail(parameters)}`}
             </Text>
           )}
         {/* Display image indicator */}