wave-agent-sdk 1.0.10 → 1.1.1

package/dist/utils/markdownParser.js

@@ -5,6 +5,7 @@ import { join } from "path";
 import { tmpdir } from "os";
 import { SKILL_BASH_MAX_OUTPUT_CHARS, PREVIEW_SIZE_BYTES, } from "../constants/toolLimits.js";
 import { logger } from "./globalLogger.js";
+import { resolveShellPath } from "./shellResolver.js";
 const execAsync = promisify(exec);
 /**
  * Parse YAML frontmatter from markdown content
@@ -198,12 +199,29 @@ export function replaceBashCommandsWithOutput(content, results) {
  */
 export async function executeBashCommands(commands, workdir, timeout = 30000) {
     const results = [];
-    for (const command of commands) {
+    for (const originalCommand of commands) {
+        let command = originalCommand;
+        const execOptions = {
+            cwd: workdir,
+            timeout,
+        };
+        // Skill templates (e.g. !`gh pr view ... 2>/dev/null || echo '{}'`) use
+        // bash-only syntax. On Windows, child_process.exec defaults to cmd.exe,
+        // where `/dev/null` fails with a localized "path not found" error whose
+        // GBK bytes get mis-decoded as UTF-8 (mojibake). Run through Git Bash
+        // when available (same contract as the bash tool); otherwise force the
+        // UTF-8 codepage so cmd's own messages decode correctly.
+        if (process.platform === "win32") {
+            const bashPath = resolveShellPath();
+            if (bashPath) {
+                execOptions.shell = bashPath;
+            }
+            else {
+                command = `chcp 65001 >NUL && ${command}`;
+            }
+        }
         try {
-            const { stdout, stderr } = await execAsync(command, {
-                cwd: workdir,
-                timeout,
-            });
+            const { stdout, stderr } = await execAsync(command, execOptions);
             results.push({
                 command,
                 output: (stdout + (stderr || "")).trim(),

package/dist/utils/path.d.ts

@@ -25,3 +25,12 @@ export declare function getDisplayPath(filePath: string, workdir: string): strin
  * Returns the path as-is on non-Windows platforms.
  */
 export declare function toPosixPath(p: string): string;
+/**
+ * Convert a POSIX-style path to a native Windows path. Git Bash / MSYS shells
+ * print POSIX paths (e.g. `pwd -P` outputs `/c/Users/foo`), which Node.js on
+ * Windows would otherwise resolve against the current drive root (e.g. `/c/...`
+ * becomes `C:\c\...`) and fail with ENOENT. Handles `/c/...` (MSYS2/Git Bash),
+ * `/cygdrive/c/...` and `//server/share` (UNC) forms. Returns the path as-is on
+ * non-Windows platforms.
+ */
+export declare function toWindowsPath(p: string): string;

package/dist/utils/path.js

@@ -61,3 +61,35 @@ export function getDisplayPath(filePath, workdir) {
 export function toPosixPath(p) {
     return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
 }
+/**
+ * Convert a POSIX-style path to a native Windows path. Git Bash / MSYS shells
+ * print POSIX paths (e.g. `pwd -P` outputs `/c/Users/foo`), which Node.js on
+ * Windows would otherwise resolve against the current drive root (e.g. `/c/...`
+ * becomes `C:\c\...`) and fail with ENOENT. Handles `/c/...` (MSYS2/Git Bash),
+ * `/cygdrive/c/...` and `//server/share` (UNC) forms. Returns the path as-is on
+ * non-Windows platforms.
+ */
+export function toWindowsPath(p) {
+    if (process.platform !== "win32")
+        return p;
+    // UNC paths: //server/share -> \\server\share
+    if (p.startsWith("//")) {
+        return p.replace(/\//g, "\\");
+    }
+    // /cygdrive/c/... -> C:\...
+    const cygdriveMatch = p.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+    if (cygdriveMatch) {
+        const driveLetter = cygdriveMatch[1].toUpperCase();
+        const rest = p.slice(("/cygdrive/" + cygdriveMatch[1]).length);
+        return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    // /c/... (MSYS2/Git Bash) -> C:\...
+    const driveMatch = p.match(/^\/([A-Za-z])(\/|$)/);
+    if (driveMatch) {
+        const driveLetter = driveMatch[1].toUpperCase();
+        const rest = p.slice(2);
+        return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    // Already Windows or relative — just flip slashes
+    return p.replace(/\//g, "\\");
+}

package/dist/utils/skillParser.js

@@ -147,7 +147,6 @@ export function validateSkillMetadata(metadata) {
     // Import SKILL_DEFAULTS dynamically to avoid circular imports
     const NAME_PATTERN = /^[a-z0-9-]+$/;
     const MAX_NAME_LENGTH = 64;
-    const MAX_DESCRIPTION_LENGTH = 1024;
     const MIN_DESCRIPTION_LENGTH = 1;
     // Validate name
     if (!metadata.name) {
@@ -161,7 +160,8 @@ export function validateSkillMetadata(metadata) {
             errors.push("Skill name must contain only lowercase letters, numbers, and hyphens");
         }
     }
-    // Validate description
+    // Validate description (no length limit, aligned with Claude Code which
+    // truncates long descriptions at render time instead of rejecting the skill)
     if (!metadata.description) {
         errors.push("Skill description is required");
     }
@@ -169,9 +169,6 @@ export function validateSkillMetadata(metadata) {
         if (metadata.description.length < MIN_DESCRIPTION_LENGTH) {
             errors.push(`Skill description must be at least ${MIN_DESCRIPTION_LENGTH} character`);
         }
-        if (metadata.description.length > MAX_DESCRIPTION_LENGTH) {
-            errors.push(`Skill description must be ${MAX_DESCRIPTION_LENGTH} characters or less`);
-        }
     }
     return errors;
 }
@@ -194,7 +191,7 @@ export function formatSkillError(skillPath, errors) {
         "  1. Ensure SKILL.md has valid YAML frontmatter (---...---)",
         "  2. Include required fields: name and description",
         "  3. Use lowercase letters, numbers, and hyphens only for name",
-        "  4. Keep name under 64 characters and description under 1024 characters",
+        "  4. Keep name under 64 characters",
     ].join("\n");
     return `${header}\n${errorList}\n\n${suggestions}`;
 }

package/dist/utils/tokenCalculation.d.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "../types/index.js";
+import type { Message, Usage } from "../types/index.js";
 /**
  * Calculate comprehensive total tokens including cache-related tokens
  *
@@ -23,3 +23,21 @@ export declare function calculateComprehensiveTotalTokens(usage: Usage): number;
 export declare function extractLatestTotalTokens(messages: Array<{
     usage?: Usage;
 }>): number;
+/**
+ * Estimate the full context size of a message list for pre-request
+ * auto-compaction checks (aligned with Claude Code's tokenCountWithEstimation).
+ *
+ * Anchors on the most recent message carrying real usage (the last API
+ * response): that response's total_tokens (OpenAI-compatible semantics —
+ * already includes cache hits) plus a rough character-based estimate for
+ * every message added after it. Falls back to a pure character estimate
+ * when no usage anchor exists yet (e.g. the first request of a session).
+ */
+export declare function estimateContextTokens(messages: Message[]): number;
+/**
+ * Rough per-message token estimate over all message blocks.
+ * Used to estimate the messages added since the last usage-bearing response.
+ * Image blocks are ignored (images are stripped before compaction) and file
+ * history snapshots live on disk, so their content is not in the context.
+ */
+export declare function roughTokenCountForMessages(messages: Message[]): number;

package/dist/utils/tokenCalculation.js

@@ -1,3 +1,4 @@
+import { estimateTokens } from "./tokenEstimate.js";
 /**
  * Calculate comprehensive total tokens including cache-related tokens
  *
@@ -34,3 +35,66 @@ export function extractLatestTotalTokens(messages) {
     }
     return 0; // No usage data found
 }
+/**
+ * Estimate the full context size of a message list for pre-request
+ * auto-compaction checks (aligned with Claude Code's tokenCountWithEstimation).
+ *
+ * Anchors on the most recent message carrying real usage (the last API
+ * response): that response's total_tokens (OpenAI-compatible semantics —
+ * already includes cache hits) plus a rough character-based estimate for
+ * every message added after it. Falls back to a pure character estimate
+ * when no usage anchor exists yet (e.g. the first request of a session).
+ */
+export function estimateContextTokens(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const usage = messages[i].usage;
+        if (usage) {
+            return (usage.total_tokens + roughTokenCountForMessages(messages.slice(i + 1)));
+        }
+    }
+    return roughTokenCountForMessages(messages);
+}
+/**
+ * Rough per-message token estimate over all message blocks.
+ * Used to estimate the messages added since the last usage-bearing response.
+ * Image blocks are ignored (images are stripped before compaction) and file
+ * history snapshots live on disk, so their content is not in the context.
+ */
+export function roughTokenCountForMessages(messages) {
+    let total = 0;
+    for (const message of messages) {
+        for (const block of message.blocks) {
+            switch (block.type) {
+                case "text":
+                case "reasoning":
+                case "error":
+                case "compact":
+                    total += estimateTokens(block.content);
+                    break;
+                case "tool":
+                    if (block.parameters) {
+                        total += estimateTokens(block.parameters, "json");
+                    }
+                    if (block.result) {
+                        total += estimateTokens(block.result);
+                    }
+                    break;
+                case "bang":
+                    if (block.command) {
+                        total += estimateTokens(block.command);
+                    }
+                    if (block.output) {
+                        total += estimateTokens(block.output);
+                    }
+                    break;
+                case "task_notification":
+                    total += estimateTokens(block.summary);
+                    break;
+                case "image":
+                case "file_history":
+                    break;
+            }
+        }
+    }
+    return total;
+}

package/dist/utils/windowsPaths.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Windows path conversion utilities for Git Bash (POSIX shell) execution.
+ *
+ * Hook commands on Windows are executed via Git Bash instead of cmd.exe
+ * (cmd.exe does not strip quotes from arguments after the first token, so
+ * `node "C:\path\script.js"` silently fails — see issue #1773). Git Bash
+ * cannot resolve Windows paths like `C:\Users\foo`: backslashes are treated
+ * as escape characters and the drive letter breaks POSIX semantics. These
+ * helpers convert Windows paths to the POSIX form Git Bash expects
+ * (`C:\Users\foo` → `/c/Users/foo`), matching Claude Code's
+ * `windowsPathToPosixPath`.
+ */
+/**
+ * Convert a single Windows path to POSIX form for Git Bash:
+ *   - `C:\Users\foo`  → `/c/Users/foo`
+ *   - `C:/Users/foo`  → `/c/Users/foo`
+ *   - `\\server\share` → `//server/share` (UNC preserved)
+ *   - Already POSIX or relative paths are returned with slashes flipped.
+ */
+export declare function windowsPathToPosixPath(p: string): string;
+/**
+ * Convert every Windows absolute path inside a shell command string to POSIX
+ * form so Git Bash can parse it. Handles both quoted paths (which may contain
+ * spaces, e.g. `node "C:\Program Files\script.js"`) and bare paths
+ * (`cd C:\path\x`). Drive letters preceded by another alphanumeric character
+ * (e.g. URLs like `http://`) are left untouched.
+ */
+export declare function toPosixCommand(command: string): string;

package/dist/utils/windowsPaths.js

@@ -0,0 +1,47 @@
+/**
+ * Windows path conversion utilities for Git Bash (POSIX shell) execution.
+ *
+ * Hook commands on Windows are executed via Git Bash instead of cmd.exe
+ * (cmd.exe does not strip quotes from arguments after the first token, so
+ * `node "C:\path\script.js"` silently fails — see issue #1773). Git Bash
+ * cannot resolve Windows paths like `C:\Users\foo`: backslashes are treated
+ * as escape characters and the drive letter breaks POSIX semantics. These
+ * helpers convert Windows paths to the POSIX form Git Bash expects
+ * (`C:\Users\foo` → `/c/Users/foo`), matching Claude Code's
+ * `windowsPathToPosixPath`.
+ */
+/**
+ * Convert a single Windows path to POSIX form for Git Bash:
+ *   - `C:\Users\foo`  → `/c/Users/foo`
+ *   - `C:/Users/foo`  → `/c/Users/foo`
+ *   - `\\server\share` → `//server/share` (UNC preserved)
+ *   - Already POSIX or relative paths are returned with slashes flipped.
+ */
+export function windowsPathToPosixPath(p) {
+    // UNC paths: \\server\share -> //server/share
+    if (p.startsWith("\\\\")) {
+        return p.replace(/\\/g, "/");
+    }
+    // Drive letter paths: C:\Users\foo -> /c/Users/foo
+    const match = p.match(/^([A-Za-z]):[\\/]/);
+    if (match) {
+        const driveLetter = match[1].toLowerCase();
+        return `/${driveLetter}${p.slice(2).replace(/\\/g, "/")}`;
+    }
+    // Already POSIX or relative — just flip slashes
+    return p.replace(/\\/g, "/");
+}
+/**
+ * Convert every Windows absolute path inside a shell command string to POSIX
+ * form so Git Bash can parse it. Handles both quoted paths (which may contain
+ * spaces, e.g. `node "C:\Program Files\script.js"`) and bare paths
+ * (`cd C:\path\x`). Drive letters preceded by another alphanumeric character
+ * (e.g. URLs like `http://`) are left untouched.
+ */
+export function toPosixCommand(command) {
+    // Quoted paths first (may contain spaces) — keep the surrounding quotes.
+    let converted = command.replace(/"([A-Za-z]):[\\/][^"]*"/g, (quoted) => `"${windowsPathToPosixPath(quoted.slice(1, -1))}"`);
+    // Bare (unquoted) paths.
+    converted = converted.replace(/(?<![A-Za-z0-9])([A-Za-z]):[\\/][^\s"']*/g, (match) => windowsPathToPosixPath(match));
+    return converted;
+}

package/dist/utils/worktreeSession.d.ts

@@ -22,4 +22,10 @@ export interface WorktreeSession {
     repoRoot: string;
     /** The HEAD commit of the original branch at worktree creation time */
     originalHeadCommit?: string;
+    /**
+     * True when this worktree was created by a WorktreeCreate hook (not by git).
+     * Deletion delegates to the WorktreeRemove hook; wave never runs
+     * `git worktree remove` for hook-based worktrees (aligned with Claude Code).
+     */
+    hookBased?: boolean;
 }

package/dist/utils/worktreeUtils.d.ts

@@ -41,6 +41,13 @@ export declare function createWorktree(name: string, cwd: string, options?: {
 export declare function performPostCreationSetup(worktreePath: string, repoRoot: string): Promise<void>;
 /**
  * Remove a git worktree and its branch.
+ *
+ * Removal is best-effort: `git worktree remove --force` deletes the worktree
+ * metadata before the working directory, and on Windows its recursive deletion
+ * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
+ * too long", leaving an orphan directory. When git fails we fall back to
+ * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
+ * metadata. Failures are logged but never block branch deletion.
  */
 export declare function removeWorktree(info: WorktreeInfo): void;
 /**

package/dist/utils/worktreeUtils.js

@@ -498,32 +498,77 @@ export async function performPostCreationSetup(worktreePath, repoRoot) {
     await copyLocalSettingsToWorktree(repoRoot, worktreePath);
     await copyWorktreeIncludeFiles(repoRoot, worktreePath);
 }
+/**
+ * On Windows, prefix an absolute path with the extended-length marker (`\\?\`)
+ * so recursive removal bypasses the 260-char MAX_PATH limit. POSIX paths are
+ * returned unchanged.
+ */
+function toExtendedLengthPath(worktreePath) {
+    if (process.platform !== "win32") {
+        return worktreePath;
+    }
+    const absolute = path.win32.resolve(worktreePath);
+    if (absolute.startsWith("\\\\?\\")) {
+        return absolute;
+    }
+    if (absolute.startsWith("\\\\")) {
+        // UNC path: \\server\share -> \\?\UNC\server\share
+        return `\\\\?\\UNC\\${absolute.slice(2)}`;
+    }
+    return `\\\\?\\${absolute}`;
+}
 /**
  * Remove a git worktree and its branch.
+ *
+ * Removal is best-effort: `git worktree remove --force` deletes the worktree
+ * metadata before the working directory, and on Windows its recursive deletion
+ * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
+ * too long", leaving an orphan directory. When git fails we fall back to
+ * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
+ * metadata. Failures are logged but never block branch deletion.
  */
 export function removeWorktree(info) {
     const repoRoot = info.repoRoot;
+    // Get current branch in worktree before removing
+    let currentBranch;
+    try {
+        currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd: info.path,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        // Ignore errors
+    }
+    // Remove worktree
     try {
-        // Get current branch in worktree before removing
-        let currentBranch;
-        try {
-            currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-                cwd: info.path,
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
-        }
-        catch {
-            // Ignore errors
-        }
-        // Remove worktree
         execFileSync("git", ["worktree", "remove", "--force", info.path], {
             cwd: repoRoot,
             stdio: ["ignore", "pipe", "pipe"],
         });
-        // Delete worktree branch
+    }
+    catch (error) {
+        logger.warn("git worktree remove failed, falling back to fs.rmSync:", {
+            error: error instanceof Error ? error.message : String(error),
+            worktreePath: info.path,
+        });
+        try {
+            fs.rmSync(toExtendedLengthPath(info.path), {
+                recursive: true,
+                force: true,
+            });
+        }
+        catch (rmError) {
+            logger.error("Failed to remove worktree or branch:", {
+                error: rmError instanceof Error ? rmError.message : String(rmError),
+                worktreePath: info.path,
+            });
+        }
+        // git removes worktree metadata before the working directory; prune any
+        // leftovers in case git failed before deleting them.
         try {
-            execFileSync("git", ["branch", "-D", info.branch], {
+            execFileSync("git", ["worktree", "prune"], {
                 cwd: repoRoot,
                 stdio: ["ignore", "pipe", "pipe"],
             });
@@ -531,33 +576,36 @@ export function removeWorktree(info) {
         catch {
             // Ignore errors
         }
-        // Delete current branch if different and not protected
-        if (currentBranch &&
-            currentBranch !== info.branch &&
-            currentBranch !== "HEAD") {
-            const defaultRemoteBranch = getDefaultRemoteBranch(repoRoot);
-            const defaultBranchName = defaultRemoteBranch.split("/").pop();
-            if (currentBranch !== defaultBranchName &&
-                currentBranch !== "main" &&
-                currentBranch !== "master") {
-                try {
-                    execFileSync("git", ["branch", "-D", currentBranch], {
-                        cwd: repoRoot,
-                        stdio: ["ignore", "pipe", "pipe"],
-                    });
-                }
-                catch {
-                    // Ignore errors
-                }
-            }
-        }
     }
-    catch (error) {
-        logger.error("Failed to remove worktree or branch:", {
-            error: error instanceof Error ? error.message : String(error),
-            worktreePath: info.path,
+    // Delete worktree branch
+    try {
+        execFileSync("git", ["branch", "-D", info.branch], {
+            cwd: repoRoot,
+            stdio: ["ignore", "pipe", "pipe"],
         });
-        throw error;
+    }
+    catch {
+        // Ignore errors
+    }
+    // Delete current branch if different and not protected
+    if (currentBranch &&
+        currentBranch !== info.branch &&
+        currentBranch !== "HEAD") {
+        const defaultRemoteBranch = getDefaultRemoteBranch(repoRoot);
+        const defaultBranchName = defaultRemoteBranch.split("/").pop();
+        if (currentBranch !== defaultBranchName &&
+            currentBranch !== "main" &&
+            currentBranch !== "master") {
+            try {
+                execFileSync("git", ["branch", "-D", currentBranch], {
+                    cwd: repoRoot,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+            }
+            catch {
+                // Ignore errors
+            }
+        }
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.10",
+  "version": "1.1.1",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",
@@ -63,11 +63,10 @@
     "@vitest/coverage-v8": "^4.1.7",
     "rimraf": "^6.1.2",
     "tsc-alias": "^1.8.16",
-    "tsx": "^4.20.4",
     "vitest": "^4.1.7"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "license": "MIT",
   "scripts": {
@@ -76,6 +75,9 @@
     "watch": "tsc -p tsconfig.build.json --watch & tsc-alias -p tsconfig.build.json --watch",
     "test": "vitest run --reporter=dot",
     "test:coverage": "vitest run --coverage --reporter=dot",
+    "test:unit": "vitest run --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
+    "test:unit:coverage": "vitest run --coverage --reporter=dot --exclude 'tests/integration/**' --exclude '**/*.integration.test.ts'",
+    "test:integration": "vitest run --reporter=dot tests/integration .integration.test",
     "lint": "eslint --cache",
     "format": "prettier --write ."
   }