wave-code 0.0.5 → 0.0.6

package/src/hooks/useInputManager.ts

@@ -11,6 +11,7 @@ export const useInputManager = (
   callbacks: Partial<InputManagerCallbacks> = {},
 ) => {
   const managerRef = useRef<InputManager | null>(null);
+  const [isManagerReady, setIsManagerReady] = useState(false);
 
   // React state that mirrors InputManager state
   const [inputText, setInputText] = useState("");
@@ -65,10 +66,13 @@ export const useInputManager = (
           setShowMcpManager(show);
         },
         onImagesStateChange: setAttachedImages,
+        onShowBashManager: () => setShowBashManager(true),
+        onShowMcpManager: () => setShowMcpManager(true),
         ...callbacks,
       });
 
       managerRef.current = manager;
+      setIsManagerReady(true);
     } else {
       // Update callbacks on existing manager
       managerRef.current.updateCallbacks({
@@ -93,6 +97,8 @@ export const useInputManager = (
           setShowMcpManager(show);
         },
         onImagesStateChange: setAttachedImages,
+        onShowBashManager: () => setShowBashManager(true),
+        onShowMcpManager: () => setShowMcpManager(true),
         ...callbacks,
       });
     }
@@ -253,9 +259,12 @@ export const useInputManager = (
     managerRef.current?.activateMemoryTypeSelector(message);
   }, []);
 
-  const handleMemoryTypeSelect = useCallback((type: "project" | "user") => {
-    managerRef.current?.handleMemoryTypeSelect(type);
-  }, []);
+  const handleMemoryTypeSelect = useCallback(
+    async (type: "project" | "user") => {
+      await managerRef.current?.handleMemoryTypeSelect(type);
+    },
+    [],
+  );
 
   const handleCancelMemoryTypeSelect = useCallback(() => {
     managerRef.current?.handleCancelMemoryTypeSelect();
@@ -296,6 +305,11 @@ export const useInputManager = (
     managerRef.current?.setCursorPosition(position);
   }, []);
 
+  // Complex handlers that combine multiple operations
+  const handleBashHistoryExecuteAndSend = useCallback((command: string) => {
+    managerRef.current?.handleBashHistoryExecuteAndSend(command);
+  }, []);
+
   return {
     // State
     inputText,
@@ -315,6 +329,7 @@ export const useInputManager = (
     showBashManager,
     showMcpManager,
     attachedImages,
+    isManagerReady,
 
     // Methods
     insertTextAtCursor,
@@ -409,6 +424,9 @@ export const useInputManager = (
       managerRef.current?.clearLongTextMap();
     }, []),
 
+    // Complex handlers combining multiple operations
+    handleBashHistoryExecuteAndSend,
+
     // Main input handler
     handleInput: useCallback(
       async (

package/src/index.ts

@@ -1,7 +1,7 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { startCli } from "./cli.js";
-import { listSessions } from "wave-agent-sdk";
+import { listSessions, getSessionFilePath } from "wave-agent-sdk";
 
 // Export main function for external use
 export async function main() {
@@ -21,6 +21,10 @@ export async function main() {
       description: "Print response without interactive mode",
       type: "string",
     })
+    .option("show-stats", {
+      description: "Show timing and usage statistics in print mode",
+      type: "boolean",
+    })
     .option("list-sessions", {
       description: "List all available sessions",
       type: "boolean",
@@ -31,7 +35,10 @@ export async function main() {
     .example("$0 --restore session_123", "Restore specific session")
     .example("$0 --continue", "Continue from last session")
     .example("$0 --print 'Hello'", "Send message in print mode")
-    .example("$0 -p 'Hello'", "Send message in print mode (short)")
+    .example(
+      "$0 -p 'Hello' --show-stats",
+      "Send message in print mode with statistics",
+    )
     .example("$0 --list-sessions", "List all available sessions")
     .help("h")
     .parseAsync();
@@ -53,9 +60,11 @@ export async function main() {
       for (const session of sessions) {
         const startedAt = new Date(session.startedAt).toLocaleString();
         const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+        const filePath = await getSessionFilePath(session.id, session.workdir);
 
         console.log(`ID: ${session.id}`);
         console.log(`  Workdir: ${session.workdir}`);
+        console.log(`  File Path: ${filePath}`);
         console.log(`  Started: ${startedAt}`);
         console.log(`  Last Active: ${lastActiveAt}`);
         console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
@@ -76,6 +85,7 @@ export async function main() {
       restoreSessionId: argv.restore,
       continueLastSession: argv.continue,
       message: argv.print,
+      showStats: argv.showStats,
     });
   }
 

package/src/managers/InputManager.ts

@@ -487,6 +487,16 @@ export class InputManager {
     return command; // Return command to execute
   }
 
+  handleBashHistoryExecuteAndSend(command: string): void {
+    const commandToExecute = this.handleBashHistoryExecute(command);
+    // Clear input box and execute command, ensure command starts with !
+    const bashCommand = commandToExecute.startsWith("!")
+      ? commandToExecute
+      : `!${commandToExecute}`;
+    this.clearInput();
+    this.callbacks.onSendMessage?.(bashCommand);
+  }
+
   checkForExclamationDeletion(cursorPosition: number): boolean {
     if (
       this.showBashHistorySelector &&
@@ -506,13 +516,18 @@ export class InputManager {
     this.callbacks.onMemoryTypeSelectorStateChange?.(true, message);
   }
 
-  handleMemoryTypeSelect(type: "project" | "user"): void {
-    // Note: type parameter will be used in future for different handling logic
-    console.debug(`Memory type selected: ${type}`);
+  async handleMemoryTypeSelect(type: "project" | "user"): Promise<void> {
+    const currentMessage = this.inputText.trim();
+    if (currentMessage.startsWith("#")) {
+      await this.callbacks.onSaveMemory?.(currentMessage, type);
+    }
+    // Close the selector
     this.showMemoryTypeSelector = false;
     this.memoryMessage = "";
-
     this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
+
+    // Clear input box
+    this.clearInput();
   }
 
   handleCancelMemoryTypeSelect(): void {
@@ -631,6 +646,29 @@ export class InputManager {
     };
   }
 
+  // Update search queries for active selectors
+  private updateSearchQueriesForActiveSelectors(
+    inputText: string,
+    cursorPosition: number,
+  ): void {
+    if (this.showFileSelector && this.atPosition >= 0) {
+      const queryStart = this.atPosition + 1;
+      const queryEnd = cursorPosition;
+      const newQuery = inputText.substring(queryStart, queryEnd);
+      this.updateFileSearchQuery(newQuery);
+    } else if (this.showCommandSelector && this.slashPosition >= 0) {
+      const queryStart = this.slashPosition + 1;
+      const queryEnd = cursorPosition;
+      const newQuery = inputText.substring(queryStart, queryEnd);
+      this.updateCommandSearchQuery(newQuery);
+    } else if (this.showBashHistorySelector && this.exclamationPosition >= 0) {
+      const queryStart = this.exclamationPosition + 1;
+      const queryEnd = cursorPosition;
+      const newQuery = inputText.substring(queryStart, queryEnd);
+      this.updateBashHistorySearchQuery(newQuery);
+    }
+  }
+
   // Handle special character input that might trigger selectors
   handleSpecialCharInput(char: string): void {
     if (char === "@") {
@@ -644,25 +682,10 @@ export class InputManager {
       // Memory message detection will be handled in submit
     } else {
       // Update search queries for active selectors
-      if (this.showFileSelector && this.atPosition >= 0) {
-        const queryStart = this.atPosition + 1;
-        const queryEnd = this.cursorPosition;
-        const newQuery = this.inputText.substring(queryStart, queryEnd);
-        this.updateFileSearchQuery(newQuery);
-      } else if (this.showCommandSelector && this.slashPosition >= 0) {
-        const queryStart = this.slashPosition + 1;
-        const queryEnd = this.cursorPosition;
-        const newQuery = this.inputText.substring(queryStart, queryEnd);
-        this.updateCommandSearchQuery(newQuery);
-      } else if (
-        this.showBashHistorySelector &&
-        this.exclamationPosition >= 0
-      ) {
-        const queryStart = this.exclamationPosition + 1;
-        const queryEnd = this.cursorPosition;
-        const newQuery = this.inputText.substring(queryStart, queryEnd);
-        this.updateBashHistorySearchQuery(newQuery);
-      }
+      this.updateSearchQueriesForActiveSelectors(
+        this.inputText,
+        this.cursorPosition,
+      );
     }
   }
 
@@ -891,13 +914,19 @@ export class InputManager {
           this.checkForAtDeletion(newCursorPosition);
           this.checkForSlashDeletion(newCursorPosition);
           this.checkForExclamationDeletion(newCursorPosition);
+
+          // Update search queries using the same logic as character input
+          this.updateSearchQueriesForActiveSelectors(
+            newInput,
+            newCursorPosition,
+          );
         });
       }
       return true;
     }
 
-    // Arrow keys and Enter should be handled by selector components
-    if (key.upArrow || key.downArrow || key.return) {
+    // Arrow keys, Enter and Tab should be handled by selector components
+    if (key.upArrow || key.downArrow || key.return || key.tab) {
       // Let selector component handle these keys, but prevent further processing
       // by returning true (indicating we've handled the input)
       return true;
@@ -909,6 +938,7 @@ export class InputManager {
       !("alt" in key && key.alt) &&
       !key.meta &&
       !key.return &&
+      !key.tab &&
       !key.escape &&
       !key.leftArrow &&
       !key.rightArrow &&

package/src/print-cli.ts

@@ -1,15 +1,35 @@
 import { Agent, AgentCallbacks } from "wave-agent-sdk";
-import { logger } from "./utils/logger.js";
 import { displayUsageSummary } from "./utils/usageSummary.js";
 
 export interface PrintCliOptions {
   restoreSessionId?: string;
   continueLastSession?: boolean;
   message?: string;
+  showStats?: boolean;
+}
+
+function displayTimingInfo(startTime: Date, showStats: boolean): void {
+  // Skip timing info in test environment or if stats are disabled
+  if (process.env.NODE_ENV === "test" || process.env.VITEST || !showStats) {
+    return;
+  }
+
+  const endTime = new Date();
+  const duration = endTime.getTime() - startTime.getTime();
+
+  process.stdout.write(`\n\n📅 Start time: ${startTime.toISOString()}\n`);
+  process.stdout.write(`📅 End time: ${endTime.toISOString()}\n`);
+  process.stdout.write(`⏱️  Duration: ${duration}ms\n`);
 }
 
 export async function startPrintCli(options: PrintCliOptions): Promise<void> {
-  const { restoreSessionId, continueLastSession, message } = options;
+  const startTime = new Date();
+  const {
+    restoreSessionId,
+    continueLastSession,
+    message,
+    showStats = false,
+  } = options;
 
   if (
     (!message || message.trim() === "") &&
@@ -26,12 +46,64 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
 
   // Setup callbacks for agent
   const callbacks: AgentCallbacks = {
-    onAssistantMessageAdded: (content?: string) => {
-      // Only output the content field, not tool calls
-      if (content) {
-        console.log(content);
+    onAssistantMessageAdded: () => {
+      // Assistant message started - no content to output yet
+      process.stdout.write("\n");
+    },
+    onAssistantContentUpdated: (chunk: string) => {
+      // FR-001: Stream content updates for real-time display - output only the new chunk
+      process.stdout.write(chunk);
+    },
+
+    // Tool block callback - display tool name when tool starts
+    onToolBlockUpdated: (params) => {
+      // Print tool name only during 'running' stage (happens once per tool call)
+      if (params.stage === "running" && params.name) {
+        process.stdout.write(`\n🔧 ${params.name}`);
+        if (params.compactParams) {
+          process.stdout.write(` ${params.compactParams}`);
+        }
+        process.stdout.write(`\n`);
       }
     },
+
+    // Subagent block callbacks
+    onSubAgentBlockAdded: (subagentId: string, parameters) => {
+      // Display subagent creation with indentation
+      process.stdout.write(
+        `\n🤖 Subagent [${parameters.subagent_type}]: ${parameters.description}\n`,
+      );
+    },
+    onSubAgentBlockUpdated: (subagentId: string, status) => {
+      // Display subagent status updates
+      const statusIconMap = {
+        active: "🔄",
+        completed: "✅",
+        error: "❌",
+        aborted: "⚠️",
+      } as const;
+
+      const statusIcon = statusIconMap[status] ?? "🔄";
+      process.stdout.write(`   ${statusIcon} Subagent status: ${status}\n`);
+    },
+    // Subagent message callbacks
+    onSubagentAssistantMessageAdded: () => {
+      // Subagent assistant message started - add indentation
+      process.stdout.write("\n   ");
+    },
+    onSubagentAssistantContentUpdated: (_subagentId: string, chunk: string) => {
+      // Stream subagent content with indentation - output only the new chunk
+      process.stdout.write(chunk);
+    },
+    onSubagentUserMessageAdded: (_subagentId: string, params) => {
+      // Display subagent user messages with indentation
+      process.stdout.write(`\n   👤 User: ${params.content}\n`);
+    },
+    // Error block callback
+    onErrorBlockAdded: (error: string) => {
+      // Display error blocks with distinct formatting
+      process.stdout.write(`\n❌ Error: ${error}\n`);
+    },
   };
 
   try {
@@ -40,7 +112,6 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       callbacks,
       restoreSessionId,
       continueLastSession,
-      logger,
     });
 
     // Send message if provided and not empty
@@ -49,29 +120,40 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     }
 
     // Display usage summary before exit
-    try {
-      const usages = agent.usages;
-      const sessionFilePath = agent.sessionFilePath;
-      displayUsageSummary(usages, sessionFilePath);
-    } catch {
-      // Silently ignore usage summary errors
+    if (showStats) {
+      try {
+        const usages = agent.usages;
+        const sessionFilePath = agent.sessionFilePath;
+        displayUsageSummary(usages, sessionFilePath);
+      } catch {
+        // Silently ignore usage summary errors
+      }
     }
 
+    // Display timing information
+    displayTimingInfo(startTime, showStats);
+
     // Destroy agent and exit after sendMessage completes
-    agent.destroy();
+    await agent.destroy();
     process.exit(0);
   } catch (error) {
     console.error("Failed to send message:", error);
     if (agent!) {
       // Display usage summary even on error
-      try {
-        const usages = agent.usages;
-        const sessionFilePath = agent.sessionFilePath;
-        displayUsageSummary(usages, sessionFilePath);
-      } catch {
-        // Silently ignore usage summary errors
+      if (showStats) {
+        try {
+          const usages = agent.usages;
+          const sessionFilePath = agent.sessionFilePath;
+          displayUsageSummary(usages, sessionFilePath);
+        } catch {
+          // Silently ignore usage summary errors
+        }
       }
-      agent.destroy();
+
+      // Display timing information even on error
+      displayTimingInfo(startTime, showStats);
+
+      await agent.destroy();
     }
     process.exit(1);
   }

package/src/utils/usageSummary.ts

@@ -12,6 +12,13 @@ export interface TokenSummary {
     agent_calls: number;
     compressions: number;
   };
+  // Cache-related tokens (for Claude models)
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_creation?: {
+    ephemeral_5m_input_tokens: number;
+    ephemeral_1h_input_tokens: number;
+  };
 }
 
 /**
@@ -45,6 +52,36 @@ export function calculateTokenSummary(
     summary.completion_tokens += usage.completion_tokens;
     summary.total_tokens += usage.total_tokens;
 
+    // Handle cache tokens if present and non-zero
+    if (usage.cache_read_input_tokens && usage.cache_read_input_tokens > 0) {
+      summary.cache_read_input_tokens =
+        (summary.cache_read_input_tokens || 0) + usage.cache_read_input_tokens;
+    }
+    if (
+      usage.cache_creation_input_tokens &&
+      usage.cache_creation_input_tokens > 0
+    ) {
+      summary.cache_creation_input_tokens =
+        (summary.cache_creation_input_tokens || 0) +
+        usage.cache_creation_input_tokens;
+    }
+    if (
+      usage.cache_creation &&
+      (usage.cache_creation.ephemeral_5m_input_tokens > 0 ||
+        usage.cache_creation.ephemeral_1h_input_tokens > 0)
+    ) {
+      if (!summary.cache_creation) {
+        summary.cache_creation = {
+          ephemeral_5m_input_tokens: 0,
+          ephemeral_1h_input_tokens: 0,
+        };
+      }
+      summary.cache_creation.ephemeral_5m_input_tokens +=
+        usage.cache_creation.ephemeral_5m_input_tokens || 0;
+      summary.cache_creation.ephemeral_1h_input_tokens +=
+        usage.cache_creation.ephemeral_1h_input_tokens || 0;
+    }
+
     // Track operation types
     if (usage.operation_type === "agent") {
       summary.operations.agent_calls += 1;
@@ -93,6 +130,11 @@ export function displayUsageSummary(
   let totalTokens = 0;
   let totalAgentCalls = 0;
   let totalCompressions = 0;
+  let totalCacheRead = 0;
+  let totalCacheCreation = 0;
+  let totalCache5m = 0;
+  let totalCache1h = 0;
+  let hasCacheData = false;
 
   for (const [, summary] of Object.entries(summaries)) {
     console.log(`Model: ${summary.model}`);
@@ -101,6 +143,52 @@ export function displayUsageSummary(
       `  Completion tokens: ${summary.completion_tokens.toLocaleString()}`,
     );
     console.log(`  Total tokens: ${summary.total_tokens.toLocaleString()}`);
+
+    // Display cache information if available
+    if (
+      summary.cache_read_input_tokens ||
+      summary.cache_creation_input_tokens ||
+      summary.cache_creation
+    ) {
+      hasCacheData = true;
+      console.log("  Cache Usage:");
+
+      if (
+        summary.cache_read_input_tokens &&
+        summary.cache_read_input_tokens > 0
+      ) {
+        console.log(
+          `    Read from cache: ${summary.cache_read_input_tokens.toLocaleString()} tokens`,
+        );
+        totalCacheRead += summary.cache_read_input_tokens;
+      }
+
+      if (
+        summary.cache_creation_input_tokens &&
+        summary.cache_creation_input_tokens > 0
+      ) {
+        console.log(
+          `    Created cache: ${summary.cache_creation_input_tokens.toLocaleString()} tokens`,
+        );
+        totalCacheCreation += summary.cache_creation_input_tokens;
+      }
+
+      if (summary.cache_creation) {
+        if (summary.cache_creation.ephemeral_5m_input_tokens > 0) {
+          console.log(
+            `    5m cache: ${summary.cache_creation.ephemeral_5m_input_tokens.toLocaleString()} tokens`,
+          );
+          totalCache5m += summary.cache_creation.ephemeral_5m_input_tokens;
+        }
+        if (summary.cache_creation.ephemeral_1h_input_tokens > 0) {
+          console.log(
+            `    1h cache: ${summary.cache_creation.ephemeral_1h_input_tokens.toLocaleString()} tokens`,
+          );
+          totalCache1h += summary.cache_creation.ephemeral_1h_input_tokens;
+        }
+      }
+    }
+
     console.log(
       `  Operations: ${summary.operations.agent_calls} agent calls, ${summary.operations.compressions} compressions`,
     );
@@ -118,6 +206,27 @@ export function displayUsageSummary(
     console.log(`  Prompt tokens: ${totalPrompt.toLocaleString()}`);
     console.log(`  Completion tokens: ${totalCompletion.toLocaleString()}`);
     console.log(`  Total tokens: ${totalTokens.toLocaleString()}`);
+
+    if (hasCacheData) {
+      console.log("  Cache Usage:");
+      if (totalCacheRead > 0) {
+        console.log(
+          `    Read from cache: ${totalCacheRead.toLocaleString()} tokens`,
+        );
+      }
+      if (totalCacheCreation > 0) {
+        console.log(
+          `    Created cache: ${totalCacheCreation.toLocaleString()} tokens`,
+        );
+      }
+      if (totalCache5m > 0) {
+        console.log(`    5m cache: ${totalCache5m.toLocaleString()} tokens`);
+      }
+      if (totalCache1h > 0) {
+        console.log(`    1h cache: ${totalCache1h.toLocaleString()} tokens`);
+      }
+    }
+
     console.log(
       `  Operations: ${totalAgentCalls} agent calls, ${totalCompressions} compressions`,
     );