wave-code 1.0.0 → 1.0.1

package/src/components/ChatInterface.tsx

@@ -1,6 +1,7 @@
-import React, { useState, useRef, useEffect } from "react";
+import React, { useState, useRef, useEffect, useCallback } from "react";
 import { Box, useStdout, measureElement, Static } from "ink";
 import type { DOMElement } from "ink";
+import { authService } from "wave-agent-sdk";
 import { MessageList } from "./MessageList.js";
 import { InputBox } from "./InputBox.js";
 import { LoadingIndicator } from "./LoadingIndicator.js";
@@ -37,9 +38,7 @@ export const ChatInterface: React.FC = () => {
     workdir,
     remountKey,
     requestRemount,
-    isGoalActive,
-    goalElapsed,
-    isGoalEvaluating,
+    getGatewayConfig,
   } = useChat();
 
   const displayMessages = messages;
@@ -49,6 +48,26 @@ export const ChatInterface: React.FC = () => {
   const terminalHeight = stdout?.rows ?? 24;
   const chatInterfaceRef = useRef<DOMElement>(null);
 
+  // Compute whether the user has any usable auth/direct-API config,
+  // so the welcome page can prompt /login when neither is present.
+  const computeAuthState = useCallback((): boolean => {
+    if (authService.isSSOAuthenticated()) return true;
+    const gateway = getGatewayConfig();
+    return Boolean(gateway.apiKey || gateway.baseURL);
+  }, [getGatewayConfig]);
+
+  const [hasAuth, setHasAuth] = useState<boolean>(computeAuthState);
+
+  // Keep the /login hint in sync with auth state changes (login/logout).
+  useEffect(() => {
+    const unsubscribe = authService.onAuthChange(() => {
+      setHasAuth(computeAuthState());
+    });
+    return unsubscribe;
+  }, [computeAuthState]);
+
+  const showLoginHint = !hasAuth;
+
   // Handle forceStatic mode for overflow and request remount when exiting
   useEffect(() => {
     if (isConfirmationVisible && chatInterfaceRef.current) {
@@ -79,19 +98,16 @@ export const ChatInterface: React.FC = () => {
         version={version}
         workdir={workdir}
         forceStatic={forceStatic}
+        showLoginHint={showLoginHint}
       />
 
       {!isConfirmationVisible && !isExpanded && (
         <>
-          {(isLoading ||
-            isCommandRunning ||
-            isCompacting ||
-            isGoalEvaluating) && (
+          {(isLoading || isCommandRunning || isCompacting) && (
             <LoadingIndicator
               isLoading={isLoading}
               isCommandRunning={isCommandRunning}
               isCompacting={isCompacting}
-              isGoalEvaluating={isGoalEvaluating}
               latestTotalTokens={latestTotalTokens}
             />
           )}
@@ -101,7 +117,6 @@ export const ChatInterface: React.FC = () => {
             isLoading={isLoading}
             isCommandRunning={isCommandRunning}
             isCompacting={isCompacting}
-            isGoalEvaluating={isGoalEvaluating}
             sendMessage={sendMessage}
             abortMessage={abortMessage}
             mcpServers={mcpServers}
@@ -111,8 +126,6 @@ export const ChatInterface: React.FC = () => {
             hasSlashCommand={hasSlashCommand}
             latestTotalTokens={latestTotalTokens}
             maxInputTokens={maxInputTokens}
-            isGoalActive={isGoalActive}
-            goalElapsed={goalElapsed}
           />
         </>
       )}

package/src/components/InputBox.tsx

@@ -32,7 +32,6 @@ export interface InputBoxProps {
   isLoading?: boolean;
   isCommandRunning?: boolean;
   isCompacting?: boolean;
-  isGoalEvaluating?: boolean;
   workdir?: string;
   sendMessage?: (
     message: string,
@@ -50,16 +49,12 @@ export interface InputBoxProps {
   // Token usage
   latestTotalTokens?: number;
   maxInputTokens?: number;
-  // Goal state
-  isGoalActive?: boolean;
-  goalElapsed?: string;
 }
 
 export const InputBox: React.FC<InputBoxProps> = ({
   isLoading,
   isCommandRunning,
   isCompacting,
-  isGoalEvaluating,
   sendMessage = () => {},
   abortMessage = () => {},
   mcpServers = [],
@@ -69,8 +64,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
   hasSlashCommand = () => false,
   latestTotalTokens = 0,
   maxInputTokens = 200000,
-  isGoalActive,
-  goalElapsed,
 }) => {
   const {
     permissionMode: chatPermissionMode,
@@ -84,13 +77,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 +93,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 +162,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
     onAskBtw: askBtw,
     onClearMessages: clearMessages,
     onCompact: compact,
-    onGoalCommand: goalCommand,
     onHasSlashCommand: hasSlashCommand,
     onAbortMessage: abortMessage,
     onBackgroundCurrentTask: backgroundCurrentTask,
@@ -192,6 +179,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 +343,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
         <WorkflowManager onCancel={() => setShowWorkflowManager(false)} />
       )}
 
-      {btwState.question
+      {btwState.question || btwState.answer
         ? null
         : showBackgroundTaskManager ||
           showMcpManager ||
@@ -384,8 +378,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
               <StatusLine
                 permissionMode={permissionMode}
                 isShellCommand={isShellCommand}
-                isGoalActive={isGoalActive}
-                goalElapsed={goalElapsed}
                 latestTotalTokens={latestTotalTokens}
                 maxInputTokens={maxInputTokens}
               />

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/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/MessageList.tsx

@@ -13,6 +13,7 @@ export interface MessageListProps {
   forceStatic?: boolean;
   version?: string;
   workdir?: string;
+  showLoginHint?: boolean;
 }
 
 export const MessageList = React.memo(
@@ -22,6 +23,7 @@ export const MessageList = React.memo(
     forceStatic = false,
     version,
     workdir,
+    showLoginHint = false,
   }: MessageListProps) => {
     const maxMessages = isExpanded
       ? MAX_MESSAGES_EXPANDED
@@ -135,6 +137,10 @@ export const MessageList = React.memo(
           </Static>
         )}
 
+        {/* Login hint — rendered in the dynamic area (not Static) so it can
+            disappear in real time when the user authenticates. */}
+        {showLoginHint && <Text color="gray">Type /login to authenticate</Text>}
+
         {/* Dynamic blocks */}
         {dynamicBlocks.length > 0 && (
           <Box flexDirection="column">

package/src/components/StatusLine.tsx

@@ -4,8 +4,6 @@ import { Box, Text } from "ink";
 export interface StatusLineProps {
   permissionMode: string;
   isShellCommand: boolean;
-  isGoalActive?: boolean;
-  goalElapsed?: string;
   latestTotalTokens?: number;
   maxInputTokens?: number;
 }
@@ -13,8 +11,6 @@ export interface StatusLineProps {
 export const StatusLine: React.FC<StatusLineProps> = ({
   permissionMode,
   isShellCommand,
-  isGoalActive,
-  goalElapsed,
   latestTotalTokens = 0,
   maxInputTokens = 200000,
 }) => {
@@ -34,12 +30,6 @@ export const StatusLine: React.FC<StatusLineProps> = ({
         </Text>
       ) : (
         <Box>
-          {isGoalActive && (
-            <Text color="gray">
-              <Text color="cyan">◎ /goal</Text> active{" "}
-              {goalElapsed && <Text>({goalElapsed})</Text>} |{" "}
-            </Text>
-          )}
           <Text color="gray">
             Mode:{" "}
             <Text

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: () => {},
-  },
 ];