wave-code 0.0.5 → 0.0.8

package/dist/managers/InputManager.js

@@ -1,4 +1,4 @@
-import { searchFiles as searchFilesUtil } from "../utils/fileSearch.js";
+import { searchFiles as searchFilesUtil, } from "wave-agent-sdk";
 import { readClipboardImage } from "../utils/clipboard.js";
 export class InputManager {
     constructor(callbacks = {}) {
@@ -40,13 +40,19 @@ export class InputManager {
         // Additional UI state
         this.showBashManager = false;
         this.showMcpManager = false;
+        // Permission mode state
+        this.permissionMode = "default";
         // Flag to prevent handleInput conflicts when selector selection occurs
         this.selectorJustUsed = false;
         this.callbacks = callbacks;
+        this.logger = callbacks.logger;
     }
     // Update callbacks
     updateCallbacks(callbacks) {
         this.callbacks = { ...this.callbacks, ...callbacks };
+        if (callbacks.logger) {
+            this.logger = callbacks.logger;
+        }
     }
     // Core input methods
     getInputText() {
@@ -313,6 +319,15 @@ export class InputManager {
         this.callbacks.onBashHistorySelectorStateChange?.(false, "", -1);
         return command; // Return command to execute
     }
+    handleBashHistoryExecuteAndSend(command) {
+        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) {
         if (this.showBashHistorySelector &&
             cursorPosition <= this.exclamationPosition) {
@@ -327,12 +342,17 @@ export class InputManager {
         this.memoryMessage = message;
         this.callbacks.onMemoryTypeSelectorStateChange?.(true, message);
     }
-    handleMemoryTypeSelect(type) {
-        // Note: type parameter will be used in future for different handling logic
-        console.debug(`Memory type selected: ${type}`);
+    async handleMemoryTypeSelect(type) {
+        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() {
         this.showMemoryTypeSelector = false;
@@ -430,6 +450,27 @@ export class InputManager {
             message: this.memoryMessage,
         };
     }
+    // Update search queries for active selectors
+    updateSearchQueriesForActiveSelectors(inputText, cursorPosition) {
+        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) {
         if (char === "@") {
@@ -447,25 +488,7 @@ export class InputManager {
         }
         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);
         }
     }
     // Long text compression methods
@@ -602,6 +625,25 @@ export class InputManager {
         this.showMcpManager = show;
         this.callbacks.onMcpManagerStateChange?.(show);
     }
+    // Permission mode methods
+    getPermissionMode() {
+        return this.permissionMode;
+    }
+    setPermissionMode(mode) {
+        this.permissionMode = mode;
+    }
+    cyclePermissionMode() {
+        const modes = ["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, isLoading = false, isCommandRunning = false) {
         // Prevent submission during loading or command execution
@@ -638,19 +680,21 @@ export class InputManager {
     }
     // Handle selector input (when any selector is active)
     handleSelectorInput(input, key) {
-        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;
@@ -660,6 +704,7 @@ export class InputManager {
             !("alt" in key && key.alt) &&
             !key.meta &&
             !key.return &&
+            !key.tab &&
             !key.escape &&
             !key.leftArrow &&
             !key.rightArrow &&
@@ -773,6 +818,12 @@ export class InputManager {
             this.callbacks.onAbortMessage?.();
             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 ||
             this.showCommandSelector ||

package/dist/print-cli.d.ts

@@ -2,6 +2,8 @@ export interface PrintCliOptions {
     restoreSessionId?: string;
     continueLastSession?: boolean;
     message?: string;
+    showStats?: boolean;
+    bypassPermissions?: boolean;
 }
 export declare function startPrintCli(options: PrintCliOptions): Promise<void>;
 //# sourceMappingURL=print-cli.d.ts.map

package/dist/print-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"print-cli.d.ts","sourceRoot":"","sources":["../src/print-cli.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAmE3E"}
+{"version":3,"file":"print-cli.d.ts","sourceRoot":"","sources":["../src/print-cli.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAgBD,wBAAsB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA8K3E"}

package/dist/print-cli.js

@@ -1,8 +1,19 @@
 import { Agent } from "wave-agent-sdk";
-import { logger } from "./utils/logger.js";
 import { displayUsageSummary } from "./utils/usageSummary.js";
+function displayTimingInfo(startTime, showStats) {
+    // 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) {
-    const { restoreSessionId, continueLastSession, message } = options;
+    const startTime = new Date();
+    const { restoreSessionId, continueLastSession, message, showStats = false, bypassPermissions, } = options;
     if ((!message || message.trim() === "") &&
         !continueLastSession &&
         !restoreSessionId) {
@@ -10,13 +21,91 @@ export async function startPrintCli(options) {
         process.exit(1);
     }
     let agent;
+    let isReasoning = false;
+    let isContent = false;
+    const subagentReasoningStates = new Map();
+    const subagentContentStates = new Map();
     // Setup callbacks for agent
     const callbacks = {
-        onAssistantMessageAdded: (content) => {
-            // 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) => {
+            if (!isReasoning) {
+                process.stdout.write("💭 Reasoning:\n");
+                isReasoning = true;
+            }
+            process.stdout.write(chunk);
+        },
+        onAssistantContentUpdated: (chunk) => {
+            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, parameters) => {
+            // Display subagent creation with indentation
+            process.stdout.write(`\n🤖 Subagent [${parameters.subagent_type}]: ${parameters.description}\n`);
+        },
+        onSubAgentBlockUpdated: (subagentId, status) => {
+            // Display subagent status updates
+            const statusIconMap = {
+                active: "🔄",
+                completed: "✅",
+                error: "❌",
+                aborted: "⚠️",
+            };
+            const statusIcon = statusIconMap[status] ?? "🔄";
+            process.stdout.write(`   ${statusIcon} Subagent status: ${status}\n`);
+        },
+        // Subagent message callbacks
+        onSubagentAssistantMessageAdded: (subagentId) => {
+            subagentReasoningStates.set(subagentId, false);
+            subagentContentStates.set(subagentId, false);
+            // Subagent assistant message started - add indentation
+            process.stdout.write("\n   ");
+        },
+        onSubagentAssistantReasoningUpdated: (subagentId, chunk) => {
+            if (!subagentReasoningStates.get(subagentId)) {
+                process.stdout.write("💭 Reasoning: ");
+                subagentReasoningStates.set(subagentId, true);
             }
+            process.stdout.write(chunk);
+        },
+        onSubagentAssistantContentUpdated: (subagentId, chunk) => {
+            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, params) => {
+            // Display subagent user messages with indentation
+            process.stdout.write(`\n   👤 User: ${params.content}\n`);
+        },
+        // Error block callback
+        onErrorBlockAdded: (error) => {
+            // Display error blocks with distinct formatting
+            process.stdout.write(`\n❌ Error: ${error}\n`);
         },
     };
     try {
@@ -25,38 +114,47 @@ export async function startPrintCli(options) {
             callbacks,
             restoreSessionId,
             continueLastSession,
-            logger,
+            permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+            // 保持流式模式以获得更好的命令行用户体验
         });
         // Send message if provided and not empty
         if (message && message.trim() !== "") {
             await agent.sendMessage(message);
         }
         // 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/dist/utils/toolParameterTransforms.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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";
+/**
+ * Transform Write tool parameters to changes
+ */
+export declare function transformWriteParameters(parameters: WriteToolParameters): Change[];
+/**
+ * Transform Edit tool parameters to changes
+ */
+export declare function transformEditParameters(parameters: EditToolParameters): Change[];
+/**
+ * Transform MultiEdit tool parameters to changes
+ */
+export declare function transformMultiEditParameters(parameters: MultiEditToolParameters): Change[];
+/**
+ * Transform tool block parameters into standardized Change[] array for diff display
+ * Forces type judgment based on tool name using type assertions
+ */
+export declare function transformToolBlockToChanges(toolName: string, parameters: string): Change[];
+//# sourceMappingURL=toolParameterTransforms.d.ts.map

package/dist/utils/toolParameterTransforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolParameterTransforms.d.ts","sourceRoot":"","sources":["../../src/utils/toolParameterTransforms.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC7B,MAAM,gBAAgB,CAAC;AAmBxB;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,mBAAmB,GAC9B,MAAM,EAAE,CAOV;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,kBAAkB,GAC7B,MAAM,EAAE,CAOV;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,uBAAuB,GAClC,MAAM,EAAE,CAKV;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,CA2BV"}

package/dist/utils/toolParameterTransforms.js

@@ -0,0 +1,77 @@
+/**
+ * Tool parameter transformation utilities for UI rendering
+ * Forces type judgment based on tool name using type assertions
+ */
+import { logger } from "./logger.js";
+/**
+ * Parse tool block parameters
+ */
+function parseToolParameters(parameters) {
+    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) {
+    return [
+        {
+            oldContent: "", // No previous content for write operations
+            newContent: parameters.content,
+        },
+    ];
+}
+/**
+ * Transform Edit tool parameters to changes
+ */
+export function transformEditParameters(parameters) {
+    return [
+        {
+            oldContent: parameters.old_string,
+            newContent: parameters.new_string,
+        },
+    ];
+}
+/**
+ * Transform MultiEdit tool parameters to changes
+ */
+export function transformMultiEditParameters(parameters) {
+    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, parameters) {
+    try {
+        if (!toolName) {
+            return [];
+        }
+        const parsedParams = parseToolParameters(parameters);
+        switch (toolName) {
+            case "Write":
+                return transformWriteParameters(parsedParams);
+            case "Edit":
+                return transformEditParameters(parsedParams);
+            case "MultiEdit":
+                return transformMultiEditParameters(parsedParams);
+            default:
+                return [];
+        }
+    }
+    catch (error) {
+        logger.warn("Failed to transform tool block to changes:", error);
+        return [];
+    }
+}

package/dist/utils/usageSummary.d.ts

@@ -11,6 +11,12 @@ export interface TokenSummary {
         agent_calls: number;
         compressions: number;
     };
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_creation?: {
+        ephemeral_5m_input_tokens: number;
+        ephemeral_1h_input_tokens: number;
+    };
 }
 /**
  * Calculate token usage summary by model from usage array

package/dist/utils/usageSummary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usageSummary.d.ts","sourceRoot":"","sources":["../../src/utils/usageSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,KAAK,EAAE,GACd,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CA2C9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,EAAE,EACf,eAAe,CAAC,EAAE,MAAM,GACvB,IAAI,CAgDN"}
+{"version":3,"file":"usageSummary.d.ts","sourceRoot":"","sources":["../../src/utils/usageSummary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,cAAc,CAAC,EAAE;QACf,yBAAyB,EAAE,MAAM,CAAC;QAClC,yBAAyB,EAAE,MAAM,CAAC;KACnC,CAAC;CACH;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,KAAK,EAAE,GACd,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAyE9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,EAAE,EACf,eAAe,CAAC,EAAE,MAAM,GACvB,IAAI,CAwHN"}

package/dist/utils/usageSummary.js

@@ -23,6 +23,31 @@ export function calculateTokenSummary(usages) {
         summary.prompt_tokens += usage.prompt_tokens;
         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;
@@ -59,11 +84,43 @@ export function displayUsageSummary(usages, sessionFilePath) {
     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}`);
         console.log(`  Prompt tokens: ${summary.prompt_tokens.toLocaleString()}`);
         console.log(`  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`);
         console.log();
         totalPrompt += summary.prompt_tokens;
@@ -77,6 +134,21 @@ export function displayUsageSummary(usages, sessionFilePath) {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "keywords": [
     "ai",
@@ -24,20 +24,24 @@
     "README.md"
   ],
   "dependencies": {
-    "ink": "^6.0.1",
+    "chalk": "^5.6.2",
+    "diff": "^8.0.2",
+    "glob": "^13.0.0",
+    "ink": "^6.5.1",
+    "marked": "^11.2.0",
+    "marked-terminal": "^7.3.0",
     "react": "^19.1.0",
     "yargs": "^17.7.2",
-    "diff": "^8.0.2",
-    "glob": "^11.0.3",
-    "wave-agent-sdk": "0.0.7"
+    "wave-agent-sdk": "0.0.10"
   },
   "devDependencies": {
+    "@types/marked-terminal": "^6.1.1",
     "@types/react": "^19.1.8",
     "@types/yargs": "^17.0.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "ink-testing-library": "^4.0.0",
-    "rimraf": "^6.0.1",
+    "rimraf": "^6.1.2",
     "tsc-alias": "^1.8.16",
     "tsx": "^4.20.4",
     "vitest": "^3.2.4"
@@ -46,13 +50,14 @@
     "react": ">=18.0.0"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=22.0.0"
   },
   "license": "MIT",
   "scripts": {
+    "wave": "tsx src/index.ts",
     "build": "rimraf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
     "type-check": "tsc --noEmit --incremental",
-    "dev": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
+    "watch": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
     "test": "vitest run",
     "lint": "eslint --cache",
     "format": "prettier --write ."