wave-agent-sdk 0.7.1 → 0.8.0

package/src/utils/gitUtils.ts

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import * as fsSync from "node:fs";
+import { execSync } from "node:child_process";
 
 /**
  * Check if a directory is a git repository
@@ -22,3 +23,77 @@ export function isGitRepository(dirPath: string): string {
     return "No";
   }
 }
+
+/**
+ * Get the root directory of the git repository
+ * @param cwd Working directory
+ * @returns Repository root path
+ */
+export function getGitRepoRoot(cwd: string): string {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return cwd;
+  }
+}
+
+/**
+ * Get the default remote branch (e.g., origin/main)
+ * @param cwd Working directory
+ * @returns Default remote branch name
+ */
+export function getDefaultRemoteBranch(cwd: string): string {
+  try {
+    const head = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return head.replace("refs/remotes/", "");
+  } catch {
+    // Fallback to origin/main if origin/HEAD is not set
+    return "origin/main";
+  }
+}
+
+/**
+ * Check if there are uncommitted changes in the working directory
+ * @param cwd Working directory
+ * @returns True if there are uncommitted changes
+ */
+export function hasUncommittedChanges(cwd: string): boolean {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if there are new commits in the current branch that are not in the base branch
+ * @param cwd Working directory
+ * @param baseBranch Base branch name (e.g., origin/main)
+ * @returns True if there are new commits
+ */
+export function hasNewCommits(cwd: string, baseBranch?: string): boolean {
+  try {
+    const range = baseBranch ? `${baseBranch}..HEAD` : "@{u}..HEAD";
+    const log = execSync(`git log ${range} --oneline`, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return log.length > 0;
+  } catch {
+    return false;
+  }
+}

package/src/utils/markdownParser.ts

@@ -1,6 +1,10 @@
 import { readFileSync } from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
 import type { CustomSlashCommandConfig } from "../types/index.js";
 
+const execAsync = promisify(exec);
+
 interface ParsedMarkdownFile {
   content: string;
   config?: CustomSlashCommandConfig;
@@ -176,3 +180,46 @@ export function replaceBashCommandsWithOutput(
 
   return processedContent;
 }
+
+/**
+ * Execute bash commands and return results
+ */
+export async function executeBashCommands(
+  commands: string[],
+  workdir: string,
+  timeout: number = 30000,
+): Promise<BashCommandResult[]> {
+  const results: BashCommandResult[] = [];
+
+  for (const command of commands) {
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: workdir,
+        timeout,
+      });
+      results.push({
+        command,
+        output: (stdout + (stderr || "")).trim(),
+        exitCode: 0,
+      });
+    } catch (error: unknown) {
+      const execError = error as {
+        stdout?: string;
+        stderr?: string;
+        message?: string;
+        code?: number;
+      };
+      results.push({
+        command,
+        output: (
+          (execError.stdout || "") +
+          (execError.stderr || "") +
+          (execError.message || "")
+        ).trim(),
+        exitCode: execError.code || 1,
+      });
+    }
+  }
+
+  return results;
+}

package/src/utils/messageOperations.ts

@@ -53,21 +53,22 @@ export interface AddErrorBlockParams {
   error: string;
 }
 
-export interface AddCommandOutputParams {
+export interface AddBangParams {
   messages: Message[];
   command: string;
 }
 
-export interface UpdateCommandOutputParams {
+export interface UpdateBangParams {
   messages: Message[];
   command: string;
   output: string;
 }
 
-export interface CompleteCommandParams {
+export interface CompleteBangParams {
   messages: Message[];
   command: string;
   exitCode: number;
+  output?: string;
 }
 
 /**
@@ -295,16 +296,16 @@ export const addErrorBlockToMessage = ({
   return newMessages;
 };
 
-// Add command output block to message list
-export const addCommandOutputMessage = ({
+// Add bang block to message list
+export const addBangMessage = ({
   messages,
   command,
-}: AddCommandOutputParams): Message[] => {
+}: AddBangParams): Message[] => {
   const outputMessage: Message = {
     role: "user",
     blocks: [
       {
-        type: "command_output",
+        type: "bang",
         command,
         output: "",
         isRunning: true,
@@ -316,24 +317,22 @@ export const addCommandOutputMessage = ({
   return [...messages, outputMessage];
 };
 
-// Update output content of command output block
-export const updateCommandOutputInMessage = ({
+// Update output content of bang block
+export const updateBangInMessage = ({
   messages,
   command,
   output,
-}: UpdateCommandOutputParams): Message[] => {
+}: UpdateBangParams): Message[] => {
   const newMessages = [...messages];
-  // Find the last user message with a command_output block for this command
+  // Find the last user message with a bang block for this command
   for (let i = newMessages.length - 1; i >= 0; i--) {
     const msg = newMessages[i];
     if (msg.role === "user") {
       const commandBlock = msg.blocks.find(
         (block) =>
-          block.type === "command_output" &&
-          block.command === command &&
-          block.isRunning,
+          block.type === "bang" && block.command === command && block.isRunning,
       );
-      if (commandBlock && commandBlock.type === "command_output") {
+      if (commandBlock && commandBlock.type === "bang") {
         commandBlock.output = output.trim();
         break;
       }
@@ -342,26 +341,28 @@ export const updateCommandOutputInMessage = ({
   return newMessages;
 };
 
-// Complete command execution, update exit status
-export const completeCommandInMessage = ({
+// Complete bang execution, update exit status
+export const completeBangInMessage = ({
   messages,
   command,
   exitCode,
-}: CompleteCommandParams): Message[] => {
+  output,
+}: CompleteBangParams): Message[] => {
   const newMessages = [...messages];
-  // Find the last user message with a command_output block for this command
+  // Find the last user message with a bang block for this command
   for (let i = newMessages.length - 1; i >= 0; i--) {
     const msg = newMessages[i];
     if (msg.role === "user") {
       const commandBlock = msg.blocks.find(
         (block) =>
-          block.type === "command_output" &&
-          block.command === command &&
-          block.isRunning,
+          block.type === "bang" && block.command === command && block.isRunning,
       );
-      if (commandBlock && commandBlock.type === "command_output") {
+      if (commandBlock && commandBlock.type === "bang") {
         commandBlock.isRunning = false;
         commandBlock.exitCode = exitCode;
+        if (output !== undefined) {
+          commandBlock.output = output.trim();
+        }
         break;
       }
     }
@@ -370,20 +371,49 @@ export const completeCommandInMessage = ({
 };
 
 /**
- * Removes the last user message from the messages array
+ * Helper to count tool blocks in messages
+ */
+export function countToolBlocks(messages: Message[]): number {
+  let toolCount = 0;
+  messages.forEach((msg) => {
+    msg.blocks.forEach((block) => {
+      if (block.type === "tool") {
+        toolCount++;
+      }
+    });
+  });
+  return toolCount;
+}
+
+/**
+ * Remove the last user message from the conversation
  * Used for hook error handling when the user prompt needs to be erased
  */
 export const removeLastUserMessage = (messages: Message[]): Message[] => {
   const newMessages = [...messages];
-
-  // Find the index of the last user message
   for (let i = newMessages.length - 1; i >= 0; i--) {
     if (newMessages[i].role === "user") {
-      // Remove the user message at index i
       newMessages.splice(i, 1);
       break;
     }
   }
-
   return newMessages;
 };
+
+/**
+ * Helper to format tool and token summary
+ */
+export function formatToolTokenSummary(
+  toolCount: number,
+  tokens: number,
+): string {
+  if (toolCount === 0) {
+    return "";
+  }
+  let summary = `(${toolCount} tools`;
+  if (tokens > 0) {
+    summary += ` | ${tokens.toLocaleString()} tokens`;
+  }
+  summary += ")";
+  return summary;
+}

package/src/utils/nameGenerator.ts

@@ -69,10 +69,11 @@ const nouns = [
 ];
 
 /**
- * Generates a random English name (adjective-noun)
+ * Generates a random English name (adjective-adjective-noun)
  */
 export function generateRandomName(seed?: string): string {
-  let adjIndex: number;
+  let adj1Index: number;
+  let adj2Index: number;
   let nounIndex: number;
 
   if (seed) {
@@ -82,14 +83,17 @@ export function generateRandomName(seed?: string): string {
       hash = (hash << 5) - hash + seed.charCodeAt(i);
       hash |= 0; // Convert to 32bit integer
     }
-    adjIndex = Math.abs(hash) % adjectives.length;
+    adj1Index = Math.abs(hash) % adjectives.length;
+    adj2Index = Math.abs(hash >> 4) % adjectives.length;
     nounIndex = Math.abs(hash >> 8) % nouns.length;
   } else {
-    adjIndex = Math.floor(Math.random() * adjectives.length);
+    adj1Index = Math.floor(Math.random() * adjectives.length);
+    adj2Index = Math.floor(Math.random() * adjectives.length);
     nounIndex = Math.floor(Math.random() * nouns.length);
   }
 
-  const adj = adjectives[adjIndex];
+  const adj1 = adjectives[adj1Index];
+  const adj2 = adjectives[adj2Index];
   const noun = nouns[nounIndex];
-  return `${adj}-${noun}`;
+  return `${adj1}-${adj2}-${noun}`;
 }

package/src/utils/skillParser.ts

@@ -57,11 +57,40 @@ export function parseSkillFile(
       ? "project"
       : "personal";
 
+    // Extract allowed tools
+    let allowedTools: string[] | undefined;
+    const rawAllowedTools = result.frontmatter["allowed-tools"];
+    if (Array.isArray(rawAllowedTools)) {
+      allowedTools = rawAllowedTools.map((t) => String(t).trim());
+    } else if (typeof rawAllowedTools === "string") {
+      allowedTools = rawAllowedTools
+        .split(",")
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+    }
+
+    // Extract disable-model-invocation
+    const disableModelInvocation =
+      result.frontmatter["disable-model-invocation"] === true ||
+      result.frontmatter["disable-model-invocation"] === "true";
+
+    // Extract user-invocable (default to true)
+    const userInvocable =
+      result.frontmatter["user-invocable"] === undefined ||
+      result.frontmatter["user-invocable"] === true ||
+      result.frontmatter["user-invocable"] === "true";
+
     result.skillMetadata = {
       name: result.frontmatter.name,
       description: result.frontmatter.description,
       type: skillType,
       skillPath,
+      allowedTools,
+      context: result.frontmatter.context,
+      agent: result.frontmatter.agent,
+      model: result.frontmatter.model as string | undefined,
+      disableModelInvocation,
+      userInvocable,
     };
 
     // Validate metadata if requested
@@ -88,10 +117,29 @@ function parseYamlFrontmatter(yamlContent: string): SkillFrontmatter {
 
   try {
     const lines = yamlContent.split("\n");
+    let currentKey: string | null = null;
+
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
 
+      // Check for list item
+      if (trimmed.startsWith("-") && currentKey) {
+        const value = trimmed
+          .substring(1)
+          .trim()
+          .replace(/^["']|["']$/g, "");
+        if (value) {
+          const existing = frontmatter[currentKey];
+          if (Array.isArray(existing)) {
+            (existing as string[]).push(value);
+          } else {
+            frontmatter[currentKey] = [value];
+          }
+        }
+        continue;
+      }
+
       const colonIndex = trimmed.indexOf(":");
       if (colonIndex === -1) continue;
 
@@ -101,8 +149,12 @@ function parseYamlFrontmatter(yamlContent: string): SkillFrontmatter {
         .trim()
         .replace(/^["']|["']$/g, "");
 
+      currentKey = key;
       if (key && value) {
         frontmatter[key] = value;
+      } else if (key) {
+        // Key with no value on the same line, might be a list
+        frontmatter[key] = [];
       }
     }
   } catch {

package/dist/managers/backgroundBashManager.d.ts

@@ -1,27 +0,0 @@
-import type { BackgroundShell } from "../types/index.js";
-export interface BackgroundBashManagerCallbacks {
-    onShellsChange?: (shells: BackgroundShell[]) => void;
-}
-export interface BackgroundBashManagerOptions {
-    callbacks?: BackgroundBashManagerCallbacks;
-    workdir: string;
-}
-export declare class BackgroundBashManager {
-    private shells;
-    private nextId;
-    private callbacks;
-    private workdir;
-    constructor(options: BackgroundBashManagerOptions);
-    private notifyShellsChange;
-    startShell(command: string, timeout?: number): string;
-    getShell(id: string): BackgroundShell | undefined;
-    getAllShells(): BackgroundShell[];
-    getOutput(id: string, filter?: string): {
-        stdout: string;
-        stderr: string;
-        status: string;
-    } | null;
-    killShell(id: string): boolean;
-    cleanup(): void;
-}
-//# sourceMappingURL=backgroundBashManager.d.ts.map

package/dist/managers/backgroundBashManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backgroundBashManager.d.ts","sourceRoot":"","sources":["../../src/managers/backgroundBashManager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,8BAA8B;IAC7C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,CAAC,EAAE,8BAA8B,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,4BAA4B;IAKjD,OAAO,CAAC,kBAAkB;IAInB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAuErD,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIjD,YAAY,IAAI,eAAe,EAAE;IAIjC,SAAS,CACd,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,MAAM,GACd;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiCrD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAmD9B,OAAO,IAAI,IAAI;CAUvB"}

package/dist/managers/backgroundBashManager.js

@@ -1,169 +0,0 @@
-import { spawn } from "child_process";
-import { logger } from "../utils/globalLogger.js";
-import { stripAnsiColors } from "../utils/stringUtils.js";
-export class BackgroundBashManager {
-    constructor(options) {
-        this.shells = new Map();
-        this.nextId = 1;
-        this.callbacks = options.callbacks || {};
-        this.workdir = options.workdir;
-    }
-    notifyShellsChange() {
-        this.callbacks.onShellsChange?.(Array.from(this.shells.values()));
-    }
-    startShell(command, timeout) {
-        const id = `bash_${this.nextId++}`;
-        const startTime = Date.now();
-        const child = spawn(command, {
-            shell: true,
-            stdio: "pipe",
-            cwd: this.workdir,
-            env: {
-                ...process.env,
-            },
-        });
-        const shell = {
-            id,
-            type: "shell",
-            process: child,
-            command,
-            startTime,
-            status: "running",
-            stdout: "",
-            stderr: "",
-        };
-        this.shells.set(id, shell);
-        this.notifyShellsChange();
-        // Set up timeout if specified
-        let timeoutHandle;
-        if (timeout && timeout > 0) {
-            timeoutHandle = setTimeout(() => {
-                if (shell.status === "running") {
-                    this.killShell(id);
-                }
-            }, timeout);
-        }
-        child.stdout?.on("data", (data) => {
-            shell.stdout += stripAnsiColors(data.toString());
-            this.notifyShellsChange();
-        });
-        child.stderr?.on("data", (data) => {
-            shell.stderr += stripAnsiColors(data.toString());
-            this.notifyShellsChange();
-        });
-        child.on("exit", (code) => {
-            if (timeoutHandle) {
-                clearTimeout(timeoutHandle);
-            }
-            shell.status = "completed";
-            shell.exitCode = code ?? 0;
-            shell.runtime = Date.now() - startTime;
-            this.notifyShellsChange();
-        });
-        child.on("error", (error) => {
-            if (timeoutHandle) {
-                clearTimeout(timeoutHandle);
-            }
-            shell.status = "completed";
-            shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
-            shell.exitCode = 1;
-            shell.runtime = Date.now() - startTime;
-            this.notifyShellsChange();
-        });
-        return id;
-    }
-    getShell(id) {
-        return this.shells.get(id);
-    }
-    getAllShells() {
-        return Array.from(this.shells.values());
-    }
-    getOutput(id, filter) {
-        const shell = this.shells.get(id);
-        if (!shell) {
-            return null;
-        }
-        let stdout = shell.stdout;
-        let stderr = shell.stderr;
-        // Apply regex filter if provided
-        if (filter) {
-            try {
-                const regex = new RegExp(filter);
-                stdout = stdout
-                    .split("\n")
-                    .filter((line) => regex.test(line))
-                    .join("\n");
-                stderr = stderr
-                    .split("\n")
-                    .filter((line) => regex.test(line))
-                    .join("\n");
-            }
-            catch (error) {
-                logger.warn(`Invalid filter regex: ${filter}`, error);
-            }
-        }
-        return {
-            stdout,
-            stderr,
-            status: shell.status,
-        };
-    }
-    killShell(id) {
-        const shell = this.shells.get(id);
-        if (!shell || shell.status !== "running") {
-            return false;
-        }
-        try {
-            // Try to kill process group first
-            if (shell.process.pid) {
-                process.kill(-shell.process.pid, "SIGTERM");
-                // Force kill after timeout
-                setTimeout(() => {
-                    if (shell.status === "running" &&
-                        shell.process.pid &&
-                        !shell.process.killed) {
-                        try {
-                            process.kill(-shell.process.pid, "SIGKILL");
-                        }
-                        catch (error) {
-                            logger.error("Failed to force kill process:", error);
-                        }
-                    }
-                }, 1000);
-            }
-            shell.status = "killed";
-            shell.runtime = Date.now() - shell.startTime;
-            this.notifyShellsChange();
-            return true;
-        }
-        catch {
-            // Fallback to direct process kill
-            try {
-                shell.process.kill("SIGTERM");
-                setTimeout(() => {
-                    if (!shell.process.killed) {
-                        shell.process.kill("SIGKILL");
-                    }
-                }, 1000);
-                shell.status = "killed";
-                shell.runtime = Date.now() - shell.startTime;
-                this.notifyShellsChange();
-                return true;
-            }
-            catch (directKillError) {
-                logger.error("Failed to kill child process:", directKillError);
-                return false;
-            }
-        }
-    }
-    cleanup() {
-        // Kill all running shells
-        for (const [id, shell] of this.shells) {
-            if (shell.status === "running") {
-                this.killShell(id);
-            }
-        }
-        this.shells.clear();
-        this.notifyShellsChange();
-    }
-}