wave-code 0.0.5 → 0.0.8

package/src/managers/InputManager.ts

@@ -1,5 +1,9 @@
 import { FileItem } from "../components/FileSelector.js";
-import { searchFiles as searchFilesUtil } from "../utils/fileSearch.js";
+import {
+  searchFiles as searchFilesUtil,
+  PermissionMode,
+  Logger,
+} from "wave-agent-sdk";
 import { readClipboardImage } from "../utils/clipboard.js";
 import type { Key } from "ink";
 
@@ -42,6 +46,8 @@ export interface InputManagerCallbacks {
   onSaveMemory?: (message: string, type: "project" | "user") => Promise<void>;
   onAbortMessage?: () => void;
   onResetHistoryNavigation?: () => void;
+  onPermissionModeChange?: (mode: PermissionMode) => void;
+  logger?: Logger;
 }
 
 export class InputManager {
@@ -93,18 +99,26 @@ export class InputManager {
   private showBashManager: boolean = false;
   private showMcpManager: boolean = false;
 
+  // Permission mode state
+  private permissionMode: PermissionMode = "default";
+
   // Flag to prevent handleInput conflicts when selector selection occurs
   private selectorJustUsed: boolean = false;
 
   private callbacks: InputManagerCallbacks;
+  private logger?: Logger;
 
   constructor(callbacks: InputManagerCallbacks = {}) {
     this.callbacks = callbacks;
+    this.logger = callbacks.logger;
   }
 
   // Update callbacks
   updateCallbacks(callbacks: Partial<InputManagerCallbacks>) {
     this.callbacks = { ...this.callbacks, ...callbacks };
+    if (callbacks.logger) {
+      this.logger = callbacks.logger;
+    }
   }
 
   // Core input methods
@@ -487,6 +501,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 +530,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 +660,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 +696,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,
+      );
     }
   }
 
@@ -831,6 +868,29 @@ export class InputManager {
     this.callbacks.onMcpManagerStateChange?.(show);
   }
 
+  // Permission mode methods
+  getPermissionMode(): PermissionMode {
+    return this.permissionMode;
+  }
+
+  setPermissionMode(mode: PermissionMode): void {
+    this.permissionMode = mode;
+  }
+
+  cyclePermissionMode(): void {
+    const modes: PermissionMode[] = ["default", "acceptEdits"];
+    const currentIndex = modes.indexOf(this.permissionMode);
+    const nextIndex =
+      currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
+    const nextMode = modes[nextIndex];
+    this.logger?.debug("Cycling permission mode", {
+      from: this.permissionMode,
+      to: nextMode,
+    });
+    this.permissionMode = nextMode;
+    this.callbacks.onPermissionModeChange?.(this.permissionMode);
+  }
+
   // Handle submit logic
   async handleSubmit(
     attachedImages: Array<{ id: number; path: string; mimeType: string }>,
@@ -884,20 +944,26 @@ export class InputManager {
 
   // Handle selector input (when any selector is active)
   handleSelectorInput(input: string, key: Key): boolean {
-    if (key.backspace || key.delete) {
+    if (key.backspace || (key.delete && !this.showBashHistorySelector)) {
       if (this.cursorPosition > 0) {
         this.deleteCharAtCursor((newInput, newCursorPosition) => {
           // Check for special character deletion
           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 +975,7 @@ export class InputManager {
       !("alt" in key && key.alt) &&
       !key.meta &&
       !key.return &&
+      !key.tab &&
       !key.escape &&
       !key.leftArrow &&
       !key.rightArrow &&
@@ -1058,6 +1125,13 @@ export class InputManager {
       return true;
     }
 
+    // Handle Shift+Tab for permission mode cycling
+    if (key.tab && key.shift) {
+      this.logger?.debug("Shift+Tab detected, cycling permission mode");
+      this.cyclePermissionMode();
+      return true;
+    }
+
     // Check if any selector is active
     if (
       this.showFileSelector ||

package/src/print-cli.ts

@@ -1,15 +1,37 @@
 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;
+  bypassPermissions?: 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,
+    bypassPermissions,
+  } = options;
 
   if (
     (!message || message.trim() === "") &&
@@ -23,14 +45,102 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
   }
 
   let agent: Agent;
+  let isReasoning = false;
+  let isContent = false;
+  const subagentReasoningStates = new Map<string, boolean>();
+  const subagentContentStates = new Map<string, boolean>();
 
   // Setup callbacks for agent
   const callbacks: AgentCallbacks = {
-    onAssistantMessageAdded: (content?: string) => {
-      // Only output the content field, not tool calls
-      if (content) {
-        console.log(content);
+    onAssistantMessageAdded: () => {
+      isReasoning = false;
+      isContent = false;
+      // Assistant message started - no content to output yet
+      process.stdout.write("\n");
+    },
+    onAssistantReasoningUpdated: (chunk: string) => {
+      if (!isReasoning) {
+        process.stdout.write("💭 Reasoning:\n");
+        isReasoning = true;
+      }
+      process.stdout.write(chunk);
+    },
+    onAssistantContentUpdated: (chunk: string) => {
+      if (isReasoning && !isContent) {
+        process.stdout.write("\n\n📝 Response:\n");
+        isContent = true;
+      }
+      // 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: (subagentId: string) => {
+      subagentReasoningStates.set(subagentId, false);
+      subagentContentStates.set(subagentId, false);
+      // Subagent assistant message started - add indentation
+      process.stdout.write("\n   ");
+    },
+    onSubagentAssistantReasoningUpdated: (
+      subagentId: string,
+      chunk: string,
+    ) => {
+      if (!subagentReasoningStates.get(subagentId)) {
+        process.stdout.write("💭 Reasoning: ");
+        subagentReasoningStates.set(subagentId, true);
+      }
+      process.stdout.write(chunk);
+    },
+    onSubagentAssistantContentUpdated: (subagentId: string, chunk: string) => {
+      if (
+        subagentReasoningStates.get(subagentId) &&
+        !subagentContentStates.get(subagentId)
+      ) {
+        process.stdout.write("\n   📝 Response: ");
+        subagentContentStates.set(subagentId, true);
       }
+      // 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`);
     },
   };
 
@@ -40,7 +150,8 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       callbacks,
       restoreSessionId,
       continueLastSession,
-      logger,
+      permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+      // 保持流式模式以获得更好的命令行用户体验
     });
 
     // Send message if provided and not empty
@@ -49,29 +160,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/toolParameterTransforms.ts

@@ -0,0 +1,104 @@
+/**
+ * Tool parameter transformation utilities for UI rendering
+ * Forces type judgment based on tool name using type assertions
+ */
+
+import {
+  type Change,
+  type WriteToolParameters,
+  type EditToolParameters,
+  type MultiEditToolParameters,
+} from "wave-agent-sdk";
+import { logger } from "./logger.js";
+
+/**
+ * Parse tool block parameters
+ */
+function parseToolParameters(parameters: string): unknown {
+  if (!parameters) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(parameters);
+  } catch (error) {
+    logger.warn("Failed to parse tool parameters:", error);
+    return {};
+  }
+}
+
+/**
+ * Transform Write tool parameters to changes
+ */
+export function transformWriteParameters(
+  parameters: WriteToolParameters,
+): Change[] {
+  return [
+    {
+      oldContent: "", // No previous content for write operations
+      newContent: parameters.content,
+    },
+  ];
+}
+
+/**
+ * Transform Edit tool parameters to changes
+ */
+export function transformEditParameters(
+  parameters: EditToolParameters,
+): Change[] {
+  return [
+    {
+      oldContent: parameters.old_string,
+      newContent: parameters.new_string,
+    },
+  ];
+}
+
+/**
+ * Transform MultiEdit tool parameters to changes
+ */
+export function transformMultiEditParameters(
+  parameters: MultiEditToolParameters,
+): Change[] {
+  return parameters.edits.map((edit) => ({
+    oldContent: edit.old_string,
+    newContent: edit.new_string,
+  }));
+}
+
+/**
+ * Transform tool block parameters into standardized Change[] array for diff display
+ * Forces type judgment based on tool name using type assertions
+ */
+export function transformToolBlockToChanges(
+  toolName: string,
+  parameters: string,
+): Change[] {
+  try {
+    if (!toolName) {
+      return [];
+    }
+
+    const parsedParams = parseToolParameters(parameters);
+
+    switch (toolName) {
+      case "Write":
+        return transformWriteParameters(parsedParams as WriteToolParameters);
+
+      case "Edit":
+        return transformEditParameters(parsedParams as EditToolParameters);
+
+      case "MultiEdit":
+        return transformMultiEditParameters(
+          parsedParams as MultiEditToolParameters,
+        );
+
+      default:
+        return [];
+    }
+  } catch (error) {
+    logger.warn("Failed to transform tool block to changes:", error);
+    return [];
+  }
+}

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`,
     );

package/dist/components/DiffViewer.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import type { DiffBlock } from "wave-agent-sdk";
-interface DiffViewerProps {
-    block: DiffBlock;
-    isExpanded?: boolean;
-}
-export declare const DiffViewer: React.FC<DiffViewerProps>;
-export {};
-//# sourceMappingURL=DiffViewer.d.ts.map

package/dist/components/DiffViewer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DiffViewer.d.ts","sourceRoot":"","sources":["../../src/components/DiffViewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,UAAU,eAAe;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAwCD,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAgRhD,CAAC"}