wave-agent-sdk 0.17.1 → 0.17.3

package/src/utils/markdownParser.ts

@@ -8,6 +8,7 @@ import {
   SKILL_BASH_MAX_OUTPUT_CHARS,
   PREVIEW_SIZE_BYTES,
 } from "../constants/toolLimits.js";
+import { logger } from "./globalLogger.js";
 
 const execAsync = promisify(exec);
 
@@ -222,6 +223,18 @@ export function truncateOutput(output: string): string {
   return `${preview}\n\n[Output truncated (${output.length} chars). Full output saved to: ${tempFile}]`;
 }
 
+/**
+ * Format a bash command result for inclusion in skill content.
+ * Failed commands (non-zero exit code) are wrapped with an error indicator.
+ */
+function formatBashResult(result: BashCommandResult): string {
+  const output = truncateOutput(result.output);
+  if (result.exitCode !== 0) {
+    return `<error>Command failed (exit code ${result.exitCode}): ${output}</error>`;
+  }
+  return output;
+}
+
 /**
  * Replace bash command placeholders with their outputs.
  * Uses function replacer to avoid $$, $&, $' corruption in shell output.
@@ -238,7 +251,7 @@ export function replaceBashCommandsWithOutput(
   processedContent = processedContent.replace(BLOCK_BASH_REGEX, () => {
     if (commandIndex < results.length) {
       const result = results[commandIndex++];
-      return truncateOutput(result.output);
+      return formatBashResult(result);
     }
     return "";
   });
@@ -247,7 +260,7 @@ export function replaceBashCommandsWithOutput(
   processedContent = processedContent.replace(INLINE_BASH_REGEX, () => {
     if (commandIndex < results.length) {
       const result = results[commandIndex++];
-      return truncateOutput(result.output);
+      return formatBashResult(result);
     }
     return "";
   });
@@ -283,14 +296,19 @@ export async function executeBashCommands(
         message?: string;
         code?: number;
       };
+      const errorOutput = (
+        (execError.stdout || "") +
+        (execError.stderr || "") +
+        (execError.message || "")
+      ).trim();
+      const exitCode = execError.code || 1;
+      logger?.warn(
+        `[Skill bash] Command failed (exit code ${exitCode}): ${command}\n${errorOutput}`,
+      );
       results.push({
         command,
-        output: (
-          (execError.stdout || "") +
-          (execError.stderr || "") +
-          (execError.message || "")
-        ).trim(),
-        exitCode: execError.code || 1,
+        output: errorOutput,
+        exitCode,
       });
     }
   }

package/src/utils/messageOperations.ts

@@ -597,8 +597,8 @@ export function getMessageContent(message: Message): string {
 export interface AddNotificationMessageParams {
   messages: Message[];
   taskId: string;
-  taskType: "shell" | "agent";
-  status: "completed" | "failed" | "killed";
+  taskType: "shell" | "agent" | "workflow";
+  status: "completed" | "failed" | "killed" | "aborted";
   summary: string;
   outputFile?: string;
 }

package/src/utils/notificationXml.ts

@@ -24,11 +24,16 @@ export function parseTaskNotificationXml(
 ): TaskNotificationBlock | null {
   try {
     const taskId = extractTag(xml, "task-id");
-    const taskType = extractTag(xml, "task-type") as "shell" | "agent" | null;
+    const taskType = extractTag(xml, "task-type") as
+      | "shell"
+      | "agent"
+      | "workflow"
+      | null;
     const status = extractTag(xml, "status") as
       | "completed"
       | "failed"
       | "killed"
+      | "aborted"
       | null;
     const summary = extractTag(xml, "summary");
 

package/src/workflow/budgetTracker.ts

@@ -0,0 +1,34 @@
+export class BudgetTracker {
+  private totalSpent = 0;
+
+  constructor(private _total: number | null = null) {}
+
+  addUsage(tokens: number): void {
+    this.totalSpent += tokens;
+  }
+
+  spent(): number {
+    return this.totalSpent;
+  }
+
+  remaining(): number {
+    if (this._total === null) return Infinity;
+    return Math.max(0, this._total - this.totalSpent);
+  }
+
+  isExceeded(): boolean {
+    return this._total !== null && this.totalSpent >= this._total;
+  }
+
+  get total(): number | null {
+    return this._total;
+  }
+
+  toBudgetInfo(): import("./types.js").BudgetInfo {
+    return {
+      total: this._total,
+      spent: () => this.totalSpent,
+      remaining: () => this.remaining(),
+    };
+  }
+}

package/src/workflow/concurrencyLimiter.ts

@@ -0,0 +1,47 @@
+export class ConcurrencyLimiter {
+  private running = 0;
+  private queue: Array<() => void> = [];
+  private readonly maxConcurrency: number;
+  private activeSet = new Set<Promise<unknown>>();
+
+  constructor(maxConcurrency: number) {
+    this.maxConcurrency = Math.max(1, maxConcurrency);
+  }
+
+  async acquire(): Promise<void> {
+    if (this.running < this.maxConcurrency) {
+      this.running++;
+      return;
+    }
+    return new Promise<void>((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+
+  release(): void {
+    this.running--;
+    if (this.queue.length > 0) {
+      this.running++;
+      const next = this.queue.shift()!;
+      next();
+    }
+  }
+
+  track<T>(promise: Promise<T>): Promise<T> {
+    this.activeSet.add(promise);
+    promise.finally(() => this.activeSet.delete(promise));
+    return promise;
+  }
+
+  async drain(): Promise<void> {
+    await Promise.allSettled(this.activeSet);
+  }
+
+  get activeCount(): number {
+    return this.running;
+  }
+
+  get pendingCount(): number {
+    return this.queue.length;
+  }
+}

package/src/workflow/journal.ts

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { JournalLine } from "./types.js";
+
+export class Journal {
+  private entries: JournalLine[] = [];
+  private stream: fs.WriteStream | null = null;
+
+  constructor(public readonly filePath: string) {}
+
+  async init(): Promise<void> {
+    // Ensure directory exists
+    await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });
+    // Create append-only write stream
+    this.stream = fs.createWriteStream(this.filePath, { flags: "a" });
+  }
+
+  append(entry: JournalLine): void {
+    this.entries.push(entry);
+    if (this.stream && !this.stream.destroyed && !this.stream.writableEnded) {
+      this.stream.write(JSON.stringify(entry) + "\n");
+    }
+  }
+
+  appendLog(message: string): void {
+    this.append({ type: "log", message });
+  }
+
+  getCachedResult(agentIndex: number): unknown | undefined {
+    const agentEntries = this.entries.filter(
+      (e): e is import("./types.js").JournalEntry => !("type" in e),
+    );
+    // Check if this agent was marked as failed
+    const failedEntry = this.entries.find(
+      (e): e is import("./types.js").AgentFailedEntry =>
+        "type" in e && e.type === "agent_failed" && e.agentIndex === agentIndex,
+    );
+    if (failedEntry) {
+      return undefined; // Failed agents don't have cached results
+    }
+    if (agentIndex < agentEntries.length) {
+      return agentEntries[agentIndex].result;
+    }
+    return undefined;
+  }
+
+  get length(): number {
+    return this.entries.length;
+  }
+
+  /** Count of agent entries (excluding log entries) */
+  get agentEntryCount(): number {
+    return this.entries.filter(
+      (e): e is import("./types.js").JournalEntry => !("type" in e),
+    ).length;
+  }
+
+  /** Remove the agent_failed entry for a given agent index (for retry support) */
+  removeFailedEntry(agentIndex: number): void {
+    this.entries = this.entries.filter(
+      (e) =>
+        !(
+          "type" in e &&
+          e.type === "agent_failed" &&
+          e.agentIndex === agentIndex
+        ),
+    );
+  }
+
+  async close(): Promise<void> {
+    const s = this.stream;
+    this.stream = null;
+    if (s) {
+      await new Promise<void>((resolve) => {
+        s.end(() => resolve());
+      });
+    }
+  }
+
+  static async load(filePath: string): Promise<Journal> {
+    const journal = new Journal(filePath);
+    try {
+      const content = await fs.promises.readFile(filePath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          journal.entries.push(JSON.parse(trimmed));
+        }
+      }
+    } catch {
+      // File doesn't exist yet — empty journal
+    }
+    return journal;
+  }
+}

package/src/workflow/progressReporter.ts

@@ -0,0 +1,141 @@
+import type {
+  WorkflowPhaseState,
+  WorkflowMeta,
+  WorkflowProgressEvent,
+} from "./types.js";
+
+export class ProgressReporter {
+  private phases: WorkflowPhaseState[] = [];
+  private currentPhaseIndex = -1;
+  private agentCounter = 0;
+  private listeners: Array<(event: WorkflowProgressEvent) => void> = [];
+  private runId: string;
+
+  constructor(
+    private meta: WorkflowMeta,
+    runId?: string,
+  ) {
+    this.runId = runId || "";
+    // Pre-initialize phases from meta so they appear even if the script
+    // doesn't call phase() explicitly
+    if (meta.phases?.length) {
+      for (const p of meta.phases) {
+        this.phases.push({
+          title: p.title,
+          agentCount: 0,
+          tokens: 0,
+          elapsed: 0,
+          startTime: Date.now(),
+        });
+      }
+      // Default to the first phase so agentStarted/agentCompleted
+      // track into it even without an explicit phase() call
+      this.currentPhaseIndex = 0;
+    }
+  }
+
+  setPhase(title: string): void {
+    // Emit phase_completed for the previous phase
+    if (this.currentPhaseIndex >= 0) {
+      this.emit({
+        type: "phase_completed",
+        phaseIndex: this.currentPhaseIndex,
+      });
+    }
+
+    const existing = this.phases.findIndex((p) => p.title === title);
+    if (existing >= 0) {
+      this.currentPhaseIndex = existing;
+    } else {
+      this.phases.push({
+        title,
+        agentCount: 0,
+        tokens: 0,
+        elapsed: 0,
+        startTime: Date.now(),
+      });
+      this.currentPhaseIndex = this.phases.length - 1;
+    }
+
+    this.emit({
+      type: "phase_started",
+      phaseIndex: this.currentPhaseIndex,
+    });
+  }
+
+  agentStarted(): void {
+    this.agentCounter++;
+    if (this.currentPhaseIndex >= 0) {
+      this.phases[this.currentPhaseIndex].agentCount++;
+    }
+    this.emit({
+      type: "agent_started",
+      phaseIndex: this.currentPhaseIndex,
+      agentIndex: this.agentCounter - 1,
+    });
+  }
+
+  agentCompleted(tokens: number): void {
+    if (this.currentPhaseIndex >= 0) {
+      this.phases[this.currentPhaseIndex].tokens += tokens;
+      this.phases[this.currentPhaseIndex].elapsed =
+        Date.now() - this.phases[this.currentPhaseIndex].startTime;
+    }
+    this.emit({
+      type: "agent_completed",
+      phaseIndex: this.currentPhaseIndex,
+      agentIndex: this.agentCounter - 1,
+    });
+  }
+
+  agentFailed(agentIndex: number): void {
+    this.emit({
+      type: "agent_failed",
+      phaseIndex: this.currentPhaseIndex,
+      agentIndex,
+    });
+  }
+
+  formatSummary(): string {
+    const phaseInfo =
+      this.currentPhaseIndex >= 0
+        ? `Phase ${this.currentPhaseIndex + 1}/${this.phases.length}: ${this.phases[this.currentPhaseIndex].title}`
+        : "Initializing";
+    const totalTokens = this.phases.reduce((sum, p) => sum + p.tokens, 0);
+    const elapsed = this.phases.reduce((sum, p) => sum + p.elapsed, 0);
+    return `${phaseInfo} | ${this.agentCounter} agents | ${(totalTokens / 1000).toFixed(1)}k tokens | ${Math.round(elapsed / 1000)}s`;
+  }
+
+  getPhaseStates(): WorkflowPhaseState[] {
+    return [...this.phases];
+  }
+
+  get totalAgents(): number {
+    return this.agentCounter;
+  }
+
+  get totalTokens(): number {
+    return this.phases.reduce((sum, p) => sum + p.tokens, 0);
+  }
+
+  onEvent(listener: (event: WorkflowProgressEvent) => void): void {
+    this.listeners.push(listener);
+  }
+
+  private emit(
+    event: Omit<WorkflowProgressEvent, "runId" | "timestamp">,
+  ): void {
+    const fullEvent: WorkflowProgressEvent = {
+      ...event,
+      runId: this.runId,
+      timestamp: Date.now(),
+    };
+    for (const listener of this.listeners) {
+      try {
+        listener(fullEvent);
+      } catch {
+        // Swallow listener errors
+      }
+    }
+  }
+}

package/src/workflow/runState.ts

@@ -0,0 +1,65 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { WorkflowRun } from "./types.js";
+
+/**
+ * Persists WorkflowRun state to <runDir>/run-state.json.
+ * Enables run recovery across process restarts.
+ */
+export class RunStateStore {
+  constructor(private baseDir: string) {}
+
+  /** Persist a run's state to disk */
+  async save(run: WorkflowRun): Promise<void> {
+    const runDir = path.join(this.baseDir, run.runId);
+    await fs.promises.mkdir(runDir, { recursive: true });
+    const statePath = path.join(runDir, "run-state.json");
+    // Omit non-serializable fields
+    const { completionPromise, ...serializable } = run;
+    void completionPromise;
+    await fs.promises.writeFile(
+      statePath,
+      JSON.stringify(serializable, null, 2),
+      "utf-8",
+    );
+  }
+
+  /** Load a single run's state from disk */
+  async load(runId: string): Promise<WorkflowRun | null> {
+    const statePath = path.join(this.baseDir, runId, "run-state.json");
+    try {
+      const content = await fs.promises.readFile(statePath, "utf-8");
+      return JSON.parse(content) as WorkflowRun;
+    } catch {
+      return null;
+    }
+  }
+
+  /** List all persisted run IDs */
+  async listRuns(): Promise<string[]> {
+    try {
+      const entries = await fs.promises.readdir(this.baseDir, {
+        withFileTypes: true,
+      });
+      const runIds: string[] = [];
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith("wf_")) {
+          const statePath = path.join(
+            this.baseDir,
+            entry.name,
+            "run-state.json",
+          );
+          try {
+            await fs.promises.access(statePath);
+            runIds.push(entry.name);
+          } catch {
+            // Directory exists but no run-state.json — skip
+          }
+        }
+      }
+      return runIds;
+    } catch {
+      return [];
+    }
+  }
+}