wave-code 1.0.0 → 1.0.2

package/src/components/InputBox.tsx

@@ -14,6 +14,7 @@ import { PluginManagerShell } from "./PluginManagerShell.js";
 import { ModelSelector } from "./ModelSelector.js";
 import { WorkflowManager } from "./WorkflowManager.js";
 import { StatusLine } from "./StatusLine.js";
+import { Notifications } from "./Notifications.js";
 import { BtwDisplay } from "./BtwDisplay.js";
 import { useInputManager } from "../hooks/useInputManager.js";
 import { useChat } from "../contexts/useChat.js";
@@ -32,7 +33,6 @@ export interface InputBoxProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
   isCompacting?: boolean;
-  isGoalEvaluating?: boolean;
   workdir?: string;
   sendMessage?: (
     message: string,
@@ -50,16 +50,14 @@ export interface InputBoxProps {
   // Token usage
   latestTotalTokens?: number;
   maxInputTokens?: number;
-  // Goal state
-  isGoalActive?: boolean;
-  goalElapsed?: string;
+  // Login hint
+  showLoginHint?: boolean;
 }
 
 export const InputBox: React.FC<InputBoxProps> = ({
   isLoading,
   isCommandRunning,
   isCompacting,
-  isGoalEvaluating,
   sendMessage = () => {},
   abortMessage = () => {},
   mcpServers = [],
@@ -69,8 +67,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
   hasSlashCommand = () => false,
   latestTotalTokens = 0,
   maxInputTokens = 200000,
-  isGoalActive,
-  goalElapsed,
+  showLoginHint = false,
 }) => {
   const {
     permissionMode: chatPermissionMode,
@@ -84,13 +81,13 @@ export const InputBox: React.FC<InputBoxProps> = ({
     askBtw,
     clearMessages,
     compact,
-    goalCommand,
     currentModel,
     configuredModels,
     setModel,
     recreateAgent,
     recallQueuedMessage,
     queuedMessages,
+    setIsBtwActive,
   } = useChat();
 
   // Ref to hold setInputText so queue callbacks can access it before useInputManager returns
@@ -100,12 +97,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
 
   // Idle means no AI work in flight. Esc double-press clear only applies when
   // idle; while busy, Esc keeps its abort semantics.
-  const isIdle = !(
-    isLoading ||
-    isCommandRunning ||
-    isCompacting ||
-    isGoalEvaluating
-  );
+  const isIdle = !(isLoading || isCommandRunning || isCompacting);
 
   const onRecallQueuedMessage = useCallback(() => {
     const msg = recallQueuedMessage();
@@ -174,7 +166,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
     onAskBtw: askBtw,
     onClearMessages: clearMessages,
     onCompact: compact,
-    onGoalCommand: goalCommand,
     onHasSlashCommand: hasSlashCommand,
     onAbortMessage: abortMessage,
     onBackgroundCurrentTask: backgroundCurrentTask,
@@ -192,6 +183,13 @@ export const InputBox: React.FC<InputBoxProps> = ({
     setInputTextRef.current = setInputText;
   }, [setInputText]);
 
+  // Sync the btw overlay's visibility to ChatContext so siblings (TaskList)
+  // can hide while the side-question is on display (aligned with Claude Code,
+  // which suppresses the expanded task list while a local-jsx command shows).
+  useEffect(() => {
+    setIsBtwActive(btwState.question !== "" || btwState.answer !== undefined);
+  }, [btwState.question, btwState.answer, setIsBtwActive]);
+
   // Sync permission mode from useChat to InputManager
   useEffect(() => {
     setPermissionMode(chatPermissionMode);
@@ -349,7 +347,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
         <WorkflowManager onCancel={() => setShowWorkflowManager(false)} />
       )}
 
-      {btwState.question
+      {btwState.question || btwState.answer
         ? null
         : showBackgroundTaskManager ||
           showMcpManager ||
@@ -381,14 +379,17 @@ export const InputBox: React.FC<InputBoxProps> = ({
                   )}
                 </Text>
               </Box>
-              <StatusLine
-                permissionMode={permissionMode}
-                isShellCommand={isShellCommand}
-                isGoalActive={isGoalActive}
-                goalElapsed={goalElapsed}
-                latestTotalTokens={latestTotalTokens}
-                maxInputTokens={maxInputTokens}
-              />
+              <Box justifyContent="space-between">
+                <StatusLine
+                  permissionMode={permissionMode}
+                  isShellCommand={isShellCommand}
+                />
+                <Notifications
+                  latestTotalTokens={latestTotalTokens}
+                  maxInputTokens={maxInputTokens}
+                  showLoginHint={showLoginHint}
+                />
+              </Box>
             </Box>
           )}
     </Box>

package/src/components/LoadingIndicator.tsx

@@ -5,7 +5,6 @@ export interface LoadingIndicatorProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
   isCompacting?: boolean;
-  isGoalEvaluating?: boolean;
   latestTotalTokens?: number;
 }
 
@@ -13,12 +12,11 @@ export const LoadingIndicator = ({
   isLoading = false,
   isCommandRunning = false,
   isCompacting = false,
-  isGoalEvaluating = false,
   latestTotalTokens = 0,
 }: LoadingIndicatorProps) => {
   return (
     <Box flexDirection="column">
-      {isLoading && !isCompacting && !isGoalEvaluating && (
+      {isLoading && !isCompacting && (
         <Box>
           <Text color="yellow">✻ AI is thinking... </Text>
           {latestTotalTokens > 0 && (
@@ -51,7 +49,6 @@ export const LoadingIndicator = ({
       {isCompacting && (
         <Text color="magenta">✻ Compacting message history...</Text>
       )}
-      {isGoalEvaluating && <Text color="cyan">✻ Evaluating goal...</Text>}
     </Box>
   );
 };

package/src/components/LoginCommand.tsx

@@ -80,7 +80,9 @@ export const LoginCommand: React.FC<LoginCommandProps> = ({ onCancel }) => {
   const handleEnter = async () => {
     if (isLoadingRef.current) return;
 
-    const isAuthenticated = authService.isSSOAuthenticated();
+    // A stale-but-present SSO token still counts as logged in; it refreshes
+    // lazily on the next API call. Enter toggles logout only when a token exists.
+    const isAuthenticated = Boolean(authService.getSSOToken());
     if (isAuthenticated) {
       await authService.clearAuth();
       setMessage("Logged out successfully");
@@ -123,7 +125,7 @@ export const LoginCommand: React.FC<LoginCommandProps> = ({ onCancel }) => {
     }
   };
 
-  const isAuthenticated = authService.isSSOAuthenticated();
+  const isAuthenticated = Boolean(authService.getSSOToken());
   const token = authService.getSSOToken();
   const serverUrl = authService.getServerUrl();
 

package/src/components/Markdown.tsx

@@ -1,8 +1,9 @@
 import React, { useMemo } from "react";
-import { Box, Text } from "ink";
+import { Box, Text, useStdout } from "ink";
 import { Renderer, marked, type Tokens } from "marked";
 import chalk from "chalk";
 import { highlightToAnsi } from "../utils/highlightUtils.js";
+import { renderMarkdownTable } from "../utils/markdownTable.js";
 
 export interface MarkdownProps {
   children: string;
@@ -19,6 +20,10 @@ const unescapeHtml = (html: string) => {
 };
 
 class AnsiRenderer extends Renderer<string> {
+  constructor(private readonly columns: number) {
+    super();
+  }
+
   override code({ text, lang }: Tokens.Code): string {
     const prefix = lang ? `\`\`\`${lang}` : "```";
     const suffix = "```";
@@ -82,20 +87,10 @@ class AnsiRenderer extends Renderer<string> {
   }
 
   override table(token: Tokens.Table): string {
-    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`;
-  }
-
-  override tablerow({ text }: Tokens.TableRow): string {
-    return text + "\n";
-  }
-
-  override tablecell(token: Tokens.TableCell): string {
-    const text = token.header ? chalk.bold(token.text) : token.text;
-    return text + " | ";
+    const table = renderMarkdownTable(token, this.columns, (tokens) =>
+      this.parser.parseInline(tokens),
+    );
+    return `\n${table}\n`;
   }
 
   override strong({ tokens }: Tokens.Strong): string {
@@ -140,17 +135,19 @@ class AnsiRenderer extends Renderer<string> {
   }
 }
 
-const renderer = new AnsiRenderer();
+const createRenderer = (columns: number) => new AnsiRenderer(columns);
 
 // Markdown component using custom ANSI renderer
 export const Markdown = React.memo(({ children }: MarkdownProps) => {
+  const { stdout } = useStdout();
+  const columns = stdout?.columns ?? 80;
   const ansiContent = useMemo(() => {
     return marked.parse(children, {
-      renderer,
+      renderer: createRenderer(columns),
       gfm: true,
       breaks: true,
     }) as string;
-  }, [children]);
+  }, [children, columns]);
 
   return (
     <Box flexDirection="column">

package/src/components/Notifications.tsx

@@ -0,0 +1,31 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+export interface NotificationsProps {
+  latestTotalTokens?: number;
+  maxInputTokens?: number;
+  showLoginHint?: boolean;
+}
+
+export const Notifications: React.FC<NotificationsProps> = ({
+  latestTotalTokens = 0,
+  maxInputTokens = 200000,
+  showLoginHint = false,
+}) => {
+  const percentage =
+    latestTotalTokens > 0
+      ? Math.min(Math.round((latestTotalTokens / maxInputTokens) * 100), 100)
+      : 0;
+
+  const contextColor =
+    percentage > 95 ? "red" : percentage > 80 ? "yellow" : "gray";
+
+  return (
+    <Box gap={1}>
+      {showLoginHint && <Text color="gray">Type /login to authenticate</Text>}
+      {percentage > 0 && (
+        <Text color={contextColor}>{percentage}% context</Text>
+      )}
+    </Box>
+  );
+};

package/src/components/StatusLine.tsx

@@ -4,62 +4,35 @@ import { Box, Text } from "ink";
 export interface StatusLineProps {
   permissionMode: string;
   isShellCommand: boolean;
-  isGoalActive?: boolean;
-  goalElapsed?: string;
-  latestTotalTokens?: number;
-  maxInputTokens?: number;
 }
 
 export const StatusLine: React.FC<StatusLineProps> = ({
   permissionMode,
   isShellCommand,
-  isGoalActive,
-  goalElapsed,
-  latestTotalTokens = 0,
-  maxInputTokens = 200000,
 }) => {
-  const percentage =
-    latestTotalTokens > 0
-      ? Math.min(Math.round((latestTotalTokens / maxInputTokens) * 100), 100)
-      : 0;
-
-  const contextColor =
-    percentage > 95 ? "red" : percentage > 80 ? "yellow" : "gray";
-
   return (
-    <Box paddingRight={1} justifyContent="space-between" width="100%">
+    <Box>
       {isShellCommand ? (
         <Text color="gray">
           Shell: <Text color="yellow">Run shell command</Text>
         </Text>
       ) : (
-        <Box>
-          {isGoalActive && (
-            <Text color="gray">
-              <Text color="cyan">◎ /goal</Text> active{" "}
-              {goalElapsed && <Text>({goalElapsed})</Text>} |{" "}
-            </Text>
-          )}
-          <Text color="gray">
-            Mode:{" "}
-            <Text
-              color={
-                permissionMode === "plan"
-                  ? "yellow"
-                  : permissionMode === "bypassPermissions"
-                    ? "red"
-                    : "cyan"
-              }
-              bold={permissionMode === "bypassPermissions"}
-            >
-              {permissionMode}
-            </Text>{" "}
-            (Shift+Tab to cycle)
-          </Text>
-        </Box>
-      )}
-      {percentage > 0 && (
-        <Text color={contextColor}>{percentage}% context</Text>
+        <Text color="gray">
+          Mode:{" "}
+          <Text
+            color={
+              permissionMode === "plan"
+                ? "yellow"
+                : permissionMode === "bypassPermissions"
+                  ? "red"
+                  : "cyan"
+            }
+            bold={permissionMode === "bypassPermissions"}
+          >
+            {permissionMode}
+          </Text>{" "}
+          (Shift+Tab to cycle)
+        </Text>
       )}
     </Box>
   );

package/src/components/TaskList.tsx

@@ -91,7 +91,7 @@ function getDisplayLimit(rows: number | undefined): number {
 
 export const TaskList: React.FC = () => {
   const tasks = useTasks();
-  const { isTaskListVisible } = useChat();
+  const { isTaskListVisible, isBtwActive } = useChat();
   const { stdout } = useStdout();
 
   const completionTimestampsRef = React.useRef<Map<string, number>>(new Map());
@@ -188,6 +188,7 @@ export const TaskList: React.FC = () => {
   if (
     tasks.length === 0 ||
     !isTaskListVisible ||
+    isBtwActive ||
     autoHidden ||
     (allCompleted && !hadIncompleteRef.current)
   ) {

package/src/components/ToolDisplay.tsx

@@ -9,6 +9,22 @@ interface ToolDisplayProps {
   isExpanded?: boolean;
 }
 
+// Status dot color for a tool block. In-flight stages (start/streaming/running)
+// never show red — the outcome isn't known until the tool reaches "end".
+// An explicit error overrides everything.
+export const getToolStatusColor = (
+  stage: ToolBlock["stage"],
+  success?: boolean,
+  error?: string | Error,
+): string => {
+  if (error) return "red";
+  if (stage === "start" || stage === "streaming") return "gray";
+  if (stage === "running") return "yellow";
+  if (success) return "green";
+  if (success === false) return "red";
+  return "gray"; // Unknown state or no state information
+};
+
 export const ToolDisplay: React.FC<ToolDisplayProps> = ({
   block,
   isExpanded = false,
@@ -19,12 +35,7 @@ export const ToolDisplay: React.FC<ToolDisplayProps> = ({
   // 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 getStatusColor = () => getToolStatusColor(stage, success, error);
 
   const hasImages = () => {
     return block.images && block.images.length > 0;

package/src/constants/commands.ts

@@ -80,10 +80,4 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "Compact conversation history to reduce context usage",
     handler: () => {},
   },
-  {
-    id: "goal",
-    name: "goal",
-    description: "Set, check, or clear an autonomous goal for the session",
-    handler: () => {},
-  },
 ];