wave-code 0.12.1 → 0.12.3

package/src/contexts/useChat.tsx

@@ -5,6 +5,7 @@ import React, {
   useRef,
   useEffect,
   useState,
+  useMemo,
 } from "react";
 import { useInput } from "ink";
 import { useAppConfig } from "./useAppConfig.js";
@@ -22,8 +23,10 @@ import {
   AgentCallbacks,
   type ToolPermissionContext,
   OPERATION_CANCELLED_BY_USER,
+  cloneMessage,
 } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
+import { throttle } from "../utils/throttle.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
 
@@ -109,8 +112,6 @@ export interface ChatContextType {
     messages: Message[];
     sessionIds: string[];
   }>;
-  wasLastDetailsTooTall: number;
-  setWasLastDetailsTooTall: React.Dispatch<React.SetStateAction<number>>;
   // Status metadata
   getGatewayConfig: () => import("wave-agent-sdk").GatewayConfig;
   getModelConfig: () => import("wave-agent-sdk").ModelConfig;
@@ -156,10 +157,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [isExpanded, setIsExpanded] = useState(false);
   const isExpandedRef = useRef(isExpanded);
 
-  useEffect(() => {
-    isExpandedRef.current = isExpanded;
-  }, [isExpanded]);
-
   const [isTaskListVisible, setIsTaskListVisible] = useState(true);
 
   const [queuedMessages, setQueuedMessages] = useState<
@@ -170,9 +167,31 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     }>
   >([]);
 
-  // AI State
   const [messages, setMessages] = useState<Message[]>([]);
 
+  const throttledSetMessages = useMemo(
+    () =>
+      throttle(() => {
+        if (!isExpandedRef.current && agentRef.current) {
+          setMessages([...agentRef.current.messages]);
+        }
+      }, 300),
+    [],
+  );
+
+  useEffect(() => {
+    isExpandedRef.current = isExpanded;
+    if (isExpanded) {
+      throttledSetMessages.cancel();
+    }
+  }, [isExpanded, throttledSetMessages]);
+
+  useEffect(() => {
+    return () => {
+      throttledSetMessages.cancel();
+    };
+  }, [throttledSetMessages]);
+
   const [isLoading, setIsLoading] = useState(false);
   const [latestTotalTokens, setlatestTotalTokens] = useState(0);
   const [sessionId, setSessionId] = useState("");
@@ -259,8 +278,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     [],
   );
 
-  // Confirmation too tall state
-  const [wasLastDetailsTooTall, setWasLastDetailsTooTall] = useState(0);
   const allowBypassInCycle =
     !!bypassPermissions || initialPermissionMode === "bypassPermissions";
 
@@ -298,9 +315,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     const initializeAgent = async () => {
       const callbacks: AgentCallbacks = {
         onMessagesChange: () => {
-          if (!isExpandedRef.current && agentRef.current) {
-            setMessages([...agentRef.current.messages]);
-          }
+          throttledSetMessages();
         },
         onServersChange: (servers) => {
           setMcpServers([...servers]);
@@ -415,6 +430,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     worktreeSession,
     model,
     initialPermissionMode,
+    throttledSetMessages,
   ]);
 
   // Cleanup on unmount
@@ -471,7 +487,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           if (command) {
             setIsCommandRunning(true);
             try {
-              await agentRef.current?.executeBashCommand(command);
+              await agentRef.current?.bang(command);
             } finally {
               setIsCommandRunning(false);
             }
@@ -661,13 +677,16 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       // Clear terminal screen when expanded state changes
       setIsExpanded((prev) => {
         const newExpanded = !prev;
+        isExpandedRef.current = newExpanded;
         if (newExpanded) {
           // Transitioning to EXPANDED: Freeze the current view
+          // Cancel any pending throttled updates to avoid overwriting the frozen state
+          throttledSetMessages.cancel();
           // Deep copy the last message to ensure it doesn't update if the agent is still writing to it
           setMessages((currentMessages) => {
             if (currentMessages.length === 0) return currentMessages;
             const lastMessage = currentMessages[currentMessages.length - 1];
-            const frozenLastMessage = JSON.parse(JSON.stringify(lastMessage));
+            const frozenLastMessage = cloneMessage(lastMessage);
             return [...currentMessages.slice(0, -1), frozenLastMessage];
           });
         } else {
@@ -739,8 +758,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     rewindId,
     handleRewindSelect,
     getFullMessageThread,
-    wasLastDetailsTooTall,
-    setWasLastDetailsTooTall,
+
     getGatewayConfig,
     getModelConfig,
     workingDirectory,

package/src/utils/logger.ts

@@ -10,6 +10,7 @@
 
 import * as fs from "fs";
 import { Chalk } from "chalk";
+import { getLastLines } from "wave-agent-sdk";
 import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
 
 const chalk = new Chalk({ level: 3 });
@@ -269,19 +270,14 @@ const truncateLogFileIfNeeded = (config: LogCleanupConfig): void => {
     // If file size exceeds limit, truncate file
     if (stats.size > config.maxFileSize) {
       const content = fs.readFileSync(logFile, "utf8");
-      const lines = content.split("\n");
-
-      // Keep the last specified number of lines
-      const keepLines = Math.min(config.keepLines, lines.length);
-      const truncatedContent = lines.slice(-keepLines).join("\n");
+      const truncatedContent = getLastLines(content, config.keepLines);
 
       // Write truncated content
       fs.writeFileSync(logFile, truncatedContent);
 
       // Record truncation operation
-      const removedLines = lines.length - keepLines;
       logger.debug(
-        `Log file truncated: removed ${removedLines} lines, kept last ${keepLines} lines`,
+        `Log file truncated: file size ${stats.size} exceeded limit ${config.maxFileSize}, kept last ${config.keepLines} lines`,
       );
     }
   } catch (error) {

package/src/utils/throttle.ts

@@ -0,0 +1,75 @@
+export interface ThrottleOptions {
+  leading?: boolean;
+  trailing?: boolean;
+}
+
+export interface ThrottledFunction<T extends (...args: unknown[]) => void> {
+  (...args: Parameters<T>): void;
+  cancel: () => void;
+  flush: () => void;
+}
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds.
+ */
+export function throttle<T extends (...args: unknown[]) => void>(
+  func: T,
+  wait: number,
+  options: ThrottleOptions = { leading: true, trailing: true },
+): ThrottledFunction<T> {
+  let timeoutId: NodeJS.Timeout | null = null;
+  let lastArgs: Parameters<T> | null = null;
+  let lastCallTime = 0;
+
+  const invokeFunc = () => {
+    if (lastArgs) {
+      func(...lastArgs);
+      lastCallTime = Date.now();
+      lastArgs = null;
+    }
+  };
+
+  const throttled = (...args: Parameters<T>) => {
+    const now = Date.now();
+    const remaining = wait - (now - lastCallTime);
+
+    lastArgs = args;
+
+    if (remaining <= 0 || remaining > wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (options.leading !== false || lastCallTime !== 0) {
+        invokeFunc();
+      } else {
+        lastCallTime = now;
+      }
+    } else if (!timeoutId && options.trailing !== false) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        invokeFunc();
+      }, remaining);
+    }
+  };
+
+  throttled.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+    lastCallTime = 0;
+  };
+
+  throttled.flush = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    invokeFunc();
+  };
+
+  return throttled as ThrottledFunction<T>;
+}