wave-agent-sdk 0.0.6 → 0.0.8

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.6",
+  "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 ."