wave-agent-sdk 1.0.9 → 1.1.0

package/dist/services/hook.js

@@ -7,6 +7,8 @@
  */
 import { spawn } from "child_process";
 import { generateSessionFilePath } from "./session.js";
+import { resolveShellPath } from "../utils/shellResolver.js";
+import { toPosixCommand } from "../utils/windowsPaths.js";
 // =============================================================================
 // Hook Execution Functions
 // =============================================================================
@@ -56,10 +58,10 @@ async function buildHookJsonInput(context) {
     if (context.subagentType !== undefined) {
         jsonInput.subagent_type = context.subagentType;
     }
-    // Add name field for WorktreeCreate events
+    // Add name field for WorktreeCreate events (aligned with Claude Code)
     if (context.event === "WorktreeCreate") {
-        if (context.worktreeName !== undefined) {
-            jsonInput.name = context.worktreeName;
+        if (context.name !== undefined) {
+            jsonInput.name = context.name;
         }
     }
     // Add worktree_path field for WorktreeRemove events
@@ -133,11 +135,43 @@ export async function executeCommand(command, context, options) {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
-        // Parse command for shell execution
+        // Parse command for shell execution.
+        //
+        // Windows uses Git Bash (POSIX shell) instead of cmd.exe: cmd.exe's `/c`
+        // does not strip quotes from arguments after the first token, so commands
+        // like `node "C:\path\script.js"` silently fail (issue #1773). Git Bash
+        // parses quotes correctly, and Windows paths in the command are converted
+        // to POSIX form first (Git Bash resolves `/c/Users/...` and translates it
+        // back to a Windows path when spawning native executables like node.exe).
+        // Falls back to cmd.exe when no Git Bash is installed.
         const isWindows = process.platform === "win32";
-        const shell = isWindows ? "cmd.exe" : "/bin/sh";
-        const shellFlag = isWindows ? "/c" : "-c";
-        const childProcess = spawn(shell, [shellFlag, command], {
+        const bashPath = isWindows ? resolveShellPath() : undefined;
+        let shell;
+        let shellFlag;
+        let finalCommand;
+        if (bashPath) {
+            shell = bashPath;
+            shellFlag = "-c";
+            finalCommand = toPosixCommand(command);
+            // Windows .sh scripts aren't directly executable — run them via bash
+            // when the command itself is a .sh file (e.g. `${WAVE_PLUGIN_ROOT}/x.sh`).
+            const trimmed = finalCommand.trim();
+            const firstToken = trimmed.match(/^("([^"]*)"|'([^']*)'|\S+)/)?.[0] ?? "";
+            if (firstToken.endsWith(".sh") && !trimmed.startsWith("bash ")) {
+                finalCommand = `bash ${finalCommand}`;
+            }
+        }
+        else if (isWindows) {
+            shell = "cmd.exe";
+            shellFlag = "/c";
+            finalCommand = command;
+        }
+        else {
+            shell = "/bin/sh";
+            shellFlag = "-c";
+            finalCommand = command;
+        }
+        const childProcess = spawn(shell, [shellFlag, finalCommand], {
             stdio: ["pipe", "pipe", "pipe"],
             cwd: context.projectDir,
             env: {

package/dist/services/initializationService.js

@@ -127,27 +127,6 @@ export class InitializationService {
         catch (error) {
             logger?.warn("SessionStart hooks execution failed:", error);
         }
-        // Trigger WorktreeCreate hook if this is a new worktree
-        if (agentOptions.isNewWorktree && hookManager) {
-            try {
-                logger?.info(`Triggering WorktreeCreate hook for ${agentOptions.worktreeName}...`);
-                const hookResults = await hookManager.executeHooks("WorktreeCreate", {
-                    event: "WorktreeCreate",
-                    projectDir: workdir,
-                    timestamp: new Date(),
-                    sessionId: messageManager.getSessionId(),
-                    transcriptPath: messageManager.getTranscriptPath(),
-                    cwd: workdir,
-                    worktreeName: agentOptions.worktreeName,
-                    env: Object.fromEntries(Object.entries(configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)),
-                });
-                // Process hook results
-                hookManager.processHookResults("WorktreeCreate", hookResults, messageManager);
-            }
-            catch (error) {
-                logger?.warn("WorktreeCreate hooks execution failed:", error);
-            }
-        }
         // Resolve and validate configuration after loading settings.json
         resolveAndValidateConfig();
         // Initialize auto-memory directory

package/dist/services/jsonlHandler.d.ts

@@ -10,6 +10,20 @@ import type { SessionFilename } from "../types/session.js";
 export interface JsonlWriteOptions {
     atomic?: boolean;
 }
+/**
+ * Creation-time metadata persisted in the session file's header line
+ * (`{"type":"metadata",...}`). The header is append-only — written once on
+ * session creation and never rewritten — so only fields that are fixed at
+ * creation time belong here.
+ */
+export interface SessionMetadataHeader {
+    /** Real working directory (the encoded project dir name is lossy for paths containing "-"). */
+    workdir?: string;
+    /** ISO 8601 creation timestamp. */
+    createdAt?: string;
+    /** Git branch at creation time (`git branch --show-current`), when the directory is a git repo. */
+    gitBranch?: string;
+}
 /**
  * JSONL handler class for message persistence operations
  */
@@ -17,9 +31,20 @@ export declare class JsonlHandler {
     private readonly defaultWriteOptions;
     constructor();
     /**
-     * Create a new session file (simplified - no metadata header)
+     * Create a new session file.
+     *
+     * When `metadata` is provided, the first line is a metadata header
+     * recording creation-time facts about the session:
+     * `{"type":"metadata","workdir":...,"createdAt":...,"gitBranch":...}`. The
+     * encoded project dir name is lossy for paths containing "-", so persisting
+     * the real path lets session listing show it without decoding; `createdAt`
+     * and `gitBranch` similarly avoid lossy/fabricated reconstruction later.
+     * The header carries no `timestamp`, so message readers filter it out
+     * naturally.
+     *
+     * Legacy callers that omit `metadata` still get an empty file.
      */
-    createSession(filePath: string): Promise<void>;
+    createSession(filePath: string, metadata?: SessionMetadataHeader): Promise<void>;
     /**
      * Append a single message to JSONL file
      */
@@ -40,6 +65,16 @@ export declare class JsonlHandler {
      * Get the last message from JSONL file using efficient file reading (simplified)
      */
     getLastMessage(filePath: string): Promise<Message | null>;
+    /**
+     * Read the creation-time metadata from the session file's header line.
+     *
+     * Newer session files start with a `{"type":"metadata",...}` line (see
+     * `createSession`). Legacy files have no header.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The persisted metadata, or null when the file has no header
+     */
+    readMetadata(filePath: string): Promise<SessionMetadataHeader | null>;
     /**
      * Validate messages before writing
      */

package/dist/services/jsonlHandler.js

@@ -4,7 +4,7 @@
  */
 import { appendFile, readFile, writeFile, stat, mkdir } from "fs/promises";
 import { dirname } from "path";
-import { getLastLine } from "../utils/fileUtils.js";
+import { getLastLine, readFirstNLines } from "../utils/fileUtils.js";
 /**
  * JSONL handler class for message persistence operations
  */
@@ -15,13 +15,26 @@ export class JsonlHandler {
         };
     }
     /**
-     * Create a new session file (simplified - no metadata header)
+     * Create a new session file.
+     *
+     * When `metadata` is provided, the first line is a metadata header
+     * recording creation-time facts about the session:
+     * `{"type":"metadata","workdir":...,"createdAt":...,"gitBranch":...}`. The
+     * encoded project dir name is lossy for paths containing "-", so persisting
+     * the real path lets session listing show it without decoding; `createdAt`
+     * and `gitBranch` similarly avoid lossy/fabricated reconstruction later.
+     * The header carries no `timestamp`, so message readers filter it out
+     * naturally.
+     *
+     * Legacy callers that omit `metadata` still get an empty file.
      */
-    async createSession(filePath) {
+    async createSession(filePath, metadata) {
         // Ensure directory exists
         await this.ensureDirectory(dirname(filePath));
-        // Create empty file (no metadata line needed)
-        await writeFile(filePath, "", "utf8");
+        const content = metadata && Object.keys(metadata).length > 0
+            ? `${JSON.stringify({ type: "metadata", ...metadata })}\n`
+            : "";
+        await writeFile(filePath, content, "utf8");
     }
     /**
      * Append a single message to JSONL file
@@ -83,11 +96,14 @@ export class JsonlHandler {
                 return [];
             }
             const allMessages = [];
-            // Parse all messages (no metadata line to skip)
+            // Parse all messages, skipping the metadata header line (if any)
             for (let i = 0; i < lines.length; i++) {
                 const line = lines[i];
                 try {
                     const message = JSON.parse(line);
+                    // Metadata header line: not a message, skip
+                    if (message.type === "metadata")
+                        continue;
                     if (message.timestamp)
                         allMessages.push(message);
                 }
@@ -127,6 +143,10 @@ export class JsonlHandler {
             }
             try {
                 const parsed = JSON.parse(lastLine);
+                // A file whose only line is the metadata header has no messages yet
+                if (parsed.type === "metadata") {
+                    return null;
+                }
                 return parsed;
             }
             catch (error) {
@@ -137,6 +157,35 @@ export class JsonlHandler {
             throw new Error(`Failed to get last message from "${filePath}": ${error}`);
         }
     }
+    /**
+     * Read the creation-time metadata from the session file's header line.
+     *
+     * Newer session files start with a `{"type":"metadata",...}` line (see
+     * `createSession`). Legacy files have no header.
+     *
+     * @param filePath - Path to the session JSONL file
+     * @returns The persisted metadata, or null when the file has no header
+     */
+    async readMetadata(filePath) {
+        try {
+            const lines = await readFirstNLines(filePath, 1);
+            if (lines.length === 0) {
+                return null;
+            }
+            const header = JSON.parse(lines[0]);
+            if (header?.type === "metadata") {
+                return {
+                    workdir: header.workdir,
+                    createdAt: header.createdAt,
+                    gitBranch: header.gitBranch,
+                };
+            }
+        }
+        catch {
+            // Unreadable or invalid first line — treat as a legacy file
+        }
+        return null;
+    }
     /**
      * Validate messages before writing
      */

package/dist/services/session.d.ts

@@ -33,6 +33,8 @@ export interface SessionMetadata {
     lastActiveAt: Date;
     latestTotalTokens: number;
     firstMessage?: string;
+    /** Git branch at session creation time (from the metadata header). */
+    branch?: string;
 }
 /**
  * Generate a new session ID using Node.js native crypto.randomUUID()
@@ -123,11 +125,31 @@ export declare function listSessions(workdir: string): Promise<SessionMetadata[]
  */
 export declare function listSessionsFromJsonl(workdir: string): Promise<SessionMetadata[]>;
 /**
- * List all sessions across all project directories
+ * List all sessions across all project directories.
  *
- * @returns Promise that resolves to array of session metadata objects
- */
-export declare function listAllSessions(): Promise<SessionMetadata[]>;
+ * When `worktreePaths` is provided, only project directories that match a
+ * same-repo git worktree (plus the current working directory's own project
+ * dir) are scanned — used by the `wave -r` picker's worktree aggregation
+ * (`Ctrl+W`). When omitted, every project directory under the sessions dir
+ * is scanned (all-projects mode, `Ctrl+A`).
+ *
+ * No time-based filtering is applied — all sessions whose files still exist
+ * are listed, regardless of how long ago they were last active.
+ *
+ * @param options.worktreePaths - Absolute paths of same-repo worktrees
+ *   (from `git worktree list`). When provided, scanning is limited to
+ *   matching project directories.
+ * @param options.workdir - Current working directory. Its own project dir is
+ *   always included in worktree mode so sessions created from a subdirectory
+ *   inside a worktree are not missed.
+ * @returns Promise that resolves to array of session metadata objects,
+ *   deduplicated by sessionId (newest lastActiveAt wins), sorted by
+ *   lastActiveAt descending.
+ */
+export declare function listAllSessions(options?: {
+    worktreePaths?: string[];
+    workdir?: string;
+}): Promise<SessionMetadata[]>;
 /**
  * Clean up expired sessions older than 14 days based on file modification time
  *
@@ -161,6 +183,15 @@ export declare function cleanupMetaOnlySessions(): Promise<number>;
  * @returns Promise that resolves to true if session exists, false otherwise
  */
 export declare function sessionExistsInJsonl(sessionId: string, workdir: string, sessionType?: "main" | "subagent"): Promise<boolean>;
+/**
+ * Get the content of the first non-meta message in a session file
+ * For user role: get text block content
+ * For assistant role: get compact block content
+ * Skips meta messages (isMeta: true) to find the first meaningful message
+ * @param filePath - Path to the session JSONL file
+ * @returns Promise that resolves to the first non-meta message content or null if not found
+ */
+export declare function getFirstMessageContentFromFile(filePath: string): Promise<string | null>;
 /**
  * Get the content of the first non-meta message in a session
  * For user role: get text block content