wave-agent-sdk 0.0.7 → 0.0.8

package/dist/utils/messageOperations.js

@@ -1,14 +1,17 @@
+import { MessageSource } from "../types/index.js";
 import { readFileSync } from "fs";
 import { extname } from "path";
+import { logger } from "./globalLogger.js";
 /**
  * Extract text content from user messages in the messages array
+ * Excludes messages with source HOOK to prevent hook-generated content from entering user history
  */
 export const extractUserInputHistory = (messages) => {
     return messages
         .filter((message) => message.role === "user")
         .map((message) => {
-        // Extract all text block content and merge
-        const textBlocks = message.blocks.filter((block) => block.type === "text");
+        // Extract text block content, excluding HOOK-sourced blocks
+        const textBlocks = message.blocks.filter((block) => block.type === "text" && block.source !== MessageSource.HOOK);
         return textBlocks
             .map((block) => block.content)
             .join(" ")
@@ -50,8 +53,8 @@ export const convertImageToBase64 = (imagePath) => {
         const base64String = imageBuffer.toString("base64");
         return `data:${mimeType};base64,${base64String}`;
     }
-    catch {
-        // logger.error(`Failed to convert image to base64: ${imagePath}`, error);
+    catch (error) {
+        logger.error(`Failed to convert image to base64: ${imagePath}`, error);
         // Return an error placeholder or throw error
         return `data:image/png;base64,`; // Empty base64, avoid program crash
     }
@@ -82,7 +85,7 @@ export const addUserMessageToMessages = ({ messages, content, images, customComm
     return [...messages, userMessage];
 };
 // Add assistant message (support one-time addition of answer and tool calls)
-export const addAssistantMessageToMessages = (messages, content, toolCalls, usage) => {
+export const addAssistantMessageToMessages = (messages, content, toolCalls, usage, metadata) => {
     const blocks = [];
     // If there's answer content, add text block
     if (content) {
@@ -97,7 +100,7 @@ export const addAssistantMessageToMessages = (messages, content, toolCalls, usag
                 result: "",
                 id: toolCall.id || "",
                 name: toolCall.function?.name || "",
-                isRunning: false,
+                stage: "start",
             });
         });
     }
@@ -105,6 +108,7 @@ export const addAssistantMessageToMessages = (messages, content, toolCalls, usag
         role: "assistant",
         blocks,
         usage, // Include usage data if provided
+        ...(metadata ? { metadata: { ...metadata } } : {}),
     };
     return [...messages, initialAssistantMessage];
 };
@@ -126,7 +130,7 @@ export const addDiffBlockToMessage = ({ messages, path, diffResult, }) => {
     return newMessages;
 };
 // Update Tool Block of the last assistant message
-export const updateToolBlockInMessage = ({ messages, id, parameters, result, success, error, isRunning, name, shortResult, images, compactParams, }) => {
+export const updateToolBlockInMessage = ({ messages, id, parameters, result, success, error, stage, name, shortResult, images, compactParams, parametersChunk, }) => {
     const newMessages = [...messages];
     // Find the last assistant message
     for (let i = newMessages.length - 1; i >= 0; i--) {
@@ -145,26 +149,30 @@ export const updateToolBlockInMessage = ({ messages, id, parameters, result, suc
                         toolBlock.success = success;
                     if (error !== undefined)
                         toolBlock.error = error;
-                    if (isRunning !== undefined)
-                        toolBlock.isRunning = isRunning;
+                    if (stage !== undefined)
+                        toolBlock.stage = stage;
                     if (compactParams !== undefined)
                         toolBlock.compactParams = compactParams;
+                    if (parametersChunk !== undefined)
+                        toolBlock.parametersChunk = parametersChunk;
                 }
             }
-            else if (result !== undefined) {
+            else {
                 // If existing block not found, create new one
+                // This handles cases where we're streaming tool parameters before execution
                 newMessages[i].blocks.push({
                     type: "tool",
                     parameters: parameters,
-                    result: result,
+                    result: result || "",
                     shortResult: shortResult,
                     images: images, // Add image data
                     id: id,
                     name: name || "unknown",
                     success: success,
                     error: error,
-                    isRunning: isRunning ?? false,
+                    stage: stage ?? "start",
                     compactParams: compactParams,
+                    parametersChunk: parametersChunk,
                 });
             }
             break;
@@ -334,7 +342,7 @@ export const completeCommandInMessage = ({ messages, command, exitCode, }) => {
     }
     return newMessages;
 };
-export const addSubagentBlockToMessage = ({ messages, subagentId, subagentName, status, subagentMessages = [], }) => {
+export const addSubagentBlockToMessage = ({ messages, subagentId, subagentName, status, sessionId, configuration, }) => {
     const newMessages = [...messages];
     // Find the last assistant message or create one
     let lastAssistantMessage = newMessages[newMessages.length - 1];
@@ -352,7 +360,8 @@ export const addSubagentBlockToMessage = ({ messages, subagentId, subagentName,
         subagentId,
         subagentName,
         status,
-        messages: subagentMessages,
+        sessionId,
+        configuration,
     });
     return newMessages;
 };
@@ -367,8 +376,8 @@ export const updateSubagentBlockInMessage = (messages, subagentId, updates) => {
                     if (updates.status !== undefined) {
                         block.status = updates.status;
                     }
-                    if (updates.messages !== undefined) {
-                        block.messages = updates.messages;
+                    if (updates.sessionId !== undefined) {
+                        block.sessionId = updates.sessionId;
                     }
                     return newMessages;
                 }

package/dist/utils/pathEncoder.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Path encoding utility for converting working directory paths to filesystem-safe names
+ * Handles cross-platform directory name encoding for project-based session organization
+ */
+/**
+ * Project directory information
+ */
+export interface ProjectDirectory {
+    readonly originalPath: string;
+    readonly encodedName: string;
+    readonly encodedPath: string;
+    readonly pathHash?: string;
+    readonly isSymbolicLink: boolean;
+}
+/**
+ * Path encoding configuration options
+ */
+export interface PathEncodingOptions {
+    maxLength?: number;
+    pathSeparatorReplacement?: string;
+    spaceReplacement?: string;
+    invalidCharReplacement?: string;
+    preserveCase?: boolean;
+    hashLength?: number;
+}
+/**
+ * Platform-specific filesystem constraints
+ */
+export interface FilesystemConstraints {
+    readonly maxDirectoryNameLength: number;
+    readonly maxPathLength: number;
+    readonly invalidCharacters: string[];
+    readonly reservedNames: string[];
+    readonly caseSensitive: boolean;
+}
+/**
+ * Path validation result
+ */
+export interface PathValidationResult {
+    readonly isValid: boolean;
+    readonly errors: string[];
+    readonly warnings: string[];
+    readonly suggestedFix?: string;
+}
+/**
+ * PathEncoder class for converting working directory paths to filesystem-safe names
+ */
+export declare class PathEncoder {
+    private readonly options;
+    private readonly constraints;
+    constructor(options?: PathEncodingOptions);
+    /**
+     * Encode a working directory path to a filesystem-safe directory name
+     */
+    encode(originalPath: string): Promise<string>;
+    /**
+     * Synchronously encode a path to a filesystem-safe directory name
+     * Note: Does not resolve symbolic links - use encode() for full path resolution
+     */
+    encodeSync(pathToEncode: string): string;
+    /**
+     * Decode an encoded directory name back to original path (limited functionality)
+     * Note: This is best-effort as encoding is lossy
+     */
+    decode(encodedName: string): Promise<string | null>;
+    /**
+     * Synchronously decode an encoded directory name back to original path (limited functionality)
+     * Note: This is best-effort as encoding is lossy
+     */
+    decodeSync(encodedName: string): string | null;
+    /**
+     * Resolve symbolic links and normalize path before encoding
+     */
+    resolvePath(path: string): Promise<string>;
+    /**
+     * Create project directory entity from original path
+     */
+    createProjectDirectory(originalPath: string, baseSessionDir: string): Promise<ProjectDirectory>;
+    /**
+     * Validate that an encoded name is filesystem-safe
+     */
+    validateEncodedName(encodedName: string): boolean;
+    /**
+     * Handle encoding collisions by generating unique names
+     */
+    resolveCollision(baseName: string, existingNames: Set<string>): string;
+    /**
+     * Get platform-specific filesystem constraints
+     */
+    private getFilesystemConstraints;
+    /**
+     * Generate hash for collision resolution
+     */
+    private generateHash;
+    /**
+     * Expand tilde (~) to home directory
+     */
+    private expandTilde;
+}
+/**
+ * Default PathEncoder instance
+ */
+export declare const pathEncoder: PathEncoder;
+//# sourceMappingURL=pathEncoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/pathEncoder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwB;gBAExC,OAAO,GAAE,mBAAwB;IAY7C;;OAEG;IACG,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAMnD;;;OAGG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAyCxC;;;OAGG;IACG,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzD;;;OAGG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAgC9C;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBhD;;OAEG;IACG,sBAAsB,CAC1B,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,gBAAgB,CAAC;IA0C5B;;OAEG;IACH,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IA+BjD;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM;IAqBtE;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsDhC;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,WAAW;CAMpB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,aAAoB,CAAC"}

package/dist/utils/pathEncoder.js

@@ -0,0 +1,272 @@
+/**
+ * Path encoding utility for converting working directory paths to filesystem-safe names
+ * Handles cross-platform directory name encoding for project-based session organization
+ */
+import { resolve, join } from "path";
+import { createHash } from "crypto";
+import { realpath, mkdir } from "fs/promises";
+import { homedir, platform } from "os";
+/**
+ * PathEncoder class for converting working directory paths to filesystem-safe names
+ */
+export class PathEncoder {
+    constructor(options = {}) {
+        this.options = {
+            maxLength: options.maxLength ?? 200,
+            pathSeparatorReplacement: options.pathSeparatorReplacement ?? "-",
+            spaceReplacement: options.spaceReplacement ?? "_",
+            invalidCharReplacement: options.invalidCharReplacement ?? "_",
+            preserveCase: options.preserveCase ?? false,
+            hashLength: options.hashLength ?? 8,
+        };
+        this.constraints = this.getFilesystemConstraints();
+    }
+    /**
+     * Encode a working directory path to a filesystem-safe directory name
+     */
+    async encode(originalPath) {
+        // Resolve symbolic links and normalize path
+        const resolvedPath = await this.resolvePath(originalPath);
+        return this.encodeSync(resolvedPath);
+    }
+    /**
+     * Synchronously encode a path to a filesystem-safe directory name
+     * Note: Does not resolve symbolic links - use encode() for full path resolution
+     */
+    encodeSync(pathToEncode) {
+        // Convert to safe directory name
+        let encoded = pathToEncode;
+        // Remove leading slash to avoid empty directory names
+        if (encoded.startsWith("/")) {
+            encoded = encoded.substring(1);
+        }
+        // Replace path separators with hyphens
+        encoded = encoded.replace(/[/\\]/g, this.options.pathSeparatorReplacement);
+        // Replace spaces with underscores
+        encoded = encoded.replace(/\s+/g, this.options.spaceReplacement);
+        // Replace invalid characters with underscores
+        const escapedChars = this.constraints.invalidCharacters
+            .map((c) => `\\${c}`)
+            .join("");
+        const invalidChars = new RegExp(`[${escapedChars}]`, "g");
+        encoded = encoded.replace(invalidChars, this.options.invalidCharReplacement);
+        // Convert to lowercase unless preserveCase is true
+        if (!this.options.preserveCase) {
+            encoded = encoded.toLowerCase();
+        }
+        // Handle length limit with hash
+        if (encoded.length > this.options.maxLength) {
+            const hash = this.generateHash(pathToEncode, this.options.hashLength);
+            const maxBaseLength = this.options.maxLength - this.options.hashLength - 1; // -1 for separator
+            encoded = `${encoded.substring(0, maxBaseLength)}-${hash}`;
+        }
+        return encoded;
+    }
+    /**
+     * Decode an encoded directory name back to original path (limited functionality)
+     * Note: This is best-effort as encoding is lossy
+     */
+    async decode(encodedName) {
+        return this.decodeSync(encodedName);
+    }
+    /**
+     * Synchronously decode an encoded directory name back to original path (limited functionality)
+     * Note: This is best-effort as encoding is lossy
+     */
+    decodeSync(encodedName) {
+        // This is a simplified version - full reversal is not always possible
+        // due to lossy encoding (case changes, character replacements, hashing)
+        // Check if this has a hash suffix
+        const hashPattern = new RegExp(`-[a-f0-9]{${this.options.hashLength}}$`);
+        if (hashPattern.test(encodedName)) {
+            // Cannot reliably decode hashed paths
+            return null;
+        }
+        // Attempt basic reversal
+        let decoded = encodedName;
+        // Reverse path separator replacement
+        decoded = decoded.replace(new RegExp(this.options.pathSeparatorReplacement, "g"), "/");
+        // Reverse space replacement
+        decoded = decoded.replace(new RegExp(this.options.spaceReplacement, "g"), " ");
+        // Add leading slash
+        decoded = `/${decoded}`;
+        return decoded;
+    }
+    /**
+     * Resolve symbolic links and normalize path before encoding
+     */
+    async resolvePath(path) {
+        try {
+            // Expand tilde to home directory
+            const expandedPath = this.expandTilde(path);
+            // Resolve to absolute path
+            const absolutePath = resolve(expandedPath);
+            // Resolve symbolic links
+            const resolvedPath = await realpath(absolutePath);
+            return resolvedPath;
+        }
+        catch (error) {
+            throw new Error(`Failed to resolve path "${path}": ${error}`);
+        }
+    }
+    /**
+     * Create project directory entity from original path
+     */
+    async createProjectDirectory(originalPath, baseSessionDir) {
+        // Resolve the original path and check for symbolic links
+        const expandedPath = this.expandTilde(originalPath);
+        const absolutePath = resolve(expandedPath);
+        let resolvedPath;
+        let isSymbolicLink = false;
+        try {
+            resolvedPath = await realpath(absolutePath);
+            isSymbolicLink = resolvedPath !== absolutePath;
+        }
+        catch {
+            // If realpath fails, use the absolute path
+            resolvedPath = absolutePath;
+        }
+        // Encode the resolved path
+        const encodedName = await this.encode(resolvedPath);
+        const encodedPath = join(baseSessionDir, encodedName);
+        // Generate hash if encoding resulted in truncation
+        let pathHash;
+        if (resolvedPath.length > this.options.maxLength) {
+            pathHash = this.generateHash(resolvedPath, this.options.hashLength);
+        }
+        // Ensure the encoded directory exists
+        try {
+            await mkdir(encodedPath, { recursive: true });
+        }
+        catch {
+            // Ignore errors if directory already exists
+        }
+        return {
+            originalPath: resolvedPath,
+            encodedName,
+            encodedPath,
+            pathHash,
+            isSymbolicLink,
+        };
+    }
+    /**
+     * Validate that an encoded name is filesystem-safe
+     */
+    validateEncodedName(encodedName) {
+        // Check length
+        if (encodedName.length > this.constraints.maxDirectoryNameLength) {
+            return false;
+        }
+        // Check for invalid characters
+        for (const char of this.constraints.invalidCharacters) {
+            if (encodedName.includes(char)) {
+                return false;
+            }
+        }
+        // Check for reserved names
+        const lowerName = encodedName.toLowerCase();
+        if (this.constraints.reservedNames.some((reserved) => reserved.toLowerCase() === lowerName)) {
+            return false;
+        }
+        // Check for empty or dots-only names
+        if (!encodedName.trim() || /^\.+$/.test(encodedName)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Handle encoding collisions by generating unique names
+     */
+    resolveCollision(baseName, existingNames) {
+        if (!existingNames.has(baseName)) {
+            return baseName;
+        }
+        // Try numbered suffixes first
+        for (let i = 1; i <= 999; i++) {
+            const candidate = `${baseName}-${i}`;
+            if (!existingNames.has(candidate)) {
+                return candidate;
+            }
+        }
+        // If all numbered suffixes are taken, use hash
+        const hash = this.generateHash(baseName + Date.now(), this.options.hashLength);
+        return `${baseName}-${hash}`;
+    }
+    /**
+     * Get platform-specific filesystem constraints
+     */
+    getFilesystemConstraints() {
+        const currentPlatform = platform();
+        switch (currentPlatform) {
+            case "win32":
+                return {
+                    maxDirectoryNameLength: 255,
+                    maxPathLength: 260,
+                    invalidCharacters: ["<", ">", ":", '"', "|", "?", "*"],
+                    reservedNames: [
+                        "CON",
+                        "PRN",
+                        "AUX",
+                        "NUL",
+                        "COM1",
+                        "COM2",
+                        "COM3",
+                        "COM4",
+                        "COM5",
+                        "COM6",
+                        "COM7",
+                        "COM8",
+                        "COM9",
+                        "LPT1",
+                        "LPT2",
+                        "LPT3",
+                        "LPT4",
+                        "LPT5",
+                        "LPT6",
+                        "LPT7",
+                        "LPT8",
+                        "LPT9",
+                    ],
+                    caseSensitive: false,
+                };
+            case "darwin":
+                return {
+                    maxDirectoryNameLength: 255,
+                    maxPathLength: 1024,
+                    invalidCharacters: [":"],
+                    reservedNames: [],
+                    caseSensitive: false, // HFS+ is case-insensitive by default
+                };
+            default: // Linux and other Unix-like systems
+                return {
+                    maxDirectoryNameLength: 255,
+                    maxPathLength: 4096,
+                    invalidCharacters: ["\0"],
+                    reservedNames: [],
+                    caseSensitive: true,
+                };
+        }
+    }
+    /**
+     * Generate hash for collision resolution
+     */
+    generateHash(input, length) {
+        return createHash("sha256")
+            .update(input)
+            .digest("hex")
+            .substring(0, length);
+    }
+    /**
+     * Expand tilde (~) to home directory
+     */
+    expandTilde(path) {
+        if (path.startsWith("~/") || path === "~") {
+            return path.replace(/^~/, homedir());
+        }
+        return path;
+    }
+}
+/**
+ * Default PathEncoder instance
+ */
+export const pathEncoder = new PathEncoder();

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

@@ -1 +1 @@
-{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+KD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAmBlC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}
+{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+KD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAmBlC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}

package/dist/utils/subagentParser.js

@@ -1,5 +1,6 @@
 import { readFileSync, readdirSync, statSync } from "fs";
 import { join, extname } from "path";
+import { logger } from "./globalLogger.js";
 /**
  * Parse YAML frontmatter from markdown file content
  */
@@ -120,7 +121,7 @@ function scanSubagentDirectory(dirPath, scope) {
                 }
                 catch (parseError) {
                     // Log error but continue with other files
-                    console.warn(`Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    logger.warn(`Warning: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
                 }
             }
         }

package/dist/utils/tokenCalculation.d.ts

@@ -0,0 +1,26 @@
+import type { Usage } from "../types/index.js";
+/**
+ * Calculate comprehensive total tokens including cache-related tokens
+ *
+ * This function computes the true total token cost by including:
+ * - Base total_tokens (prompt + completion)
+ * - Cache read tokens (cost savings indicator)
+ * - Cache creation tokens (cache investment)
+ *
+ * For accurate cost tracking with Claude models that support cache control.
+ *
+ * @param usage - Usage statistics from AI operation
+ * @returns Comprehensive total including all cache-related tokens
+ */
+export declare function calculateComprehensiveTotalTokens(usage: Usage): number;
+/**
+ * Extract the latest total tokens from the last message with usage data
+ * Uses comprehensive calculation that includes cache tokens for accurate tracking
+ *
+ * @param messages - Array of messages to search
+ * @returns Comprehensive total tokens from the most recent usage data, or 0 if none found
+ */
+export declare function extractLatestTotalTokens(messages: Array<{
+    usage?: Usage;
+}>): number;
+//# sourceMappingURL=tokenCalculation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenCalculation.d.ts","sourceRoot":"","sources":["../../src/utils/tokenCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAMtE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC,GACjC,MAAM,CAUR"}

package/dist/utils/tokenCalculation.js

@@ -0,0 +1,36 @@
+/**
+ * Calculate comprehensive total tokens including cache-related tokens
+ *
+ * This function computes the true total token cost by including:
+ * - Base total_tokens (prompt + completion)
+ * - Cache read tokens (cost savings indicator)
+ * - Cache creation tokens (cache investment)
+ *
+ * For accurate cost tracking with Claude models that support cache control.
+ *
+ * @param usage - Usage statistics from AI operation
+ * @returns Comprehensive total including all cache-related tokens
+ */
+export function calculateComprehensiveTotalTokens(usage) {
+    const baseTokens = usage.total_tokens;
+    const cacheReadTokens = usage.cache_read_input_tokens || 0;
+    const cacheCreateTokens = usage.cache_creation_input_tokens || 0;
+    return baseTokens + cacheReadTokens + cacheCreateTokens;
+}
+/**
+ * Extract the latest total tokens from the last message with usage data
+ * Uses comprehensive calculation that includes cache tokens for accurate tracking
+ *
+ * @param messages - Array of messages to search
+ * @returns Comprehensive total tokens from the most recent usage data, or 0 if none found
+ */
+export function extractLatestTotalTokens(messages) {
+    // Find the last message with usage data (iterate backwards for efficiency)
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.usage) {
+            return calculateComprehensiveTotalTokens(message.usage);
+        }
+    }
+    return 0; // No usage data found
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -21,12 +21,15 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.18.2",
     "@vscode/ripgrep": "^1.15.14",
+    "chokidar": "^5.0.0",
     "diff": "^8.0.2",
     "glob": "^11.0.3",
     "minimatch": "^10.0.3",
-    "openai": "^5.12.2"
+    "openai": "^5.12.2",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
+    "@types/uuid": "^11.0.0",
     "rimraf": "^6.0.1",
     "tsc-alias": "^1.8.16",
     "tsx": "^4.20.4",
@@ -39,7 +42,7 @@
   "scripts": {
     "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 ."