@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/step-command.test.ts

@@ -1,330 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { executeWorkflow } from "./workflow-executor.ts";
-import type { WorkflowSpec } from "./types.ts";
-import { mockCtx, mockPi, makeSpec } from "./test-helpers.ts";
-
-describe("command steps", () => {
-  it("captures stdout as text output on exit 0", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command",
-      description: "test command step",
-      steps: {
-        run: {
-          command: "echo hello world",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.run.status, "completed");
-    assert.strictEqual(result.steps.run.agent, "command");
-    const output = result.steps.run.output as { text: string };
-    assert.strictEqual(output.text, "hello world");
-    assert.strictEqual(result.steps.run.textOutput, "hello world");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("parses stdout as JSON when output.format is json", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-json",
-      description: "test command JSON output",
-      steps: {
-        run: {
-          command: 'echo \'{"key": "value", "count": 42}\'',
-          output: { format: "json" },
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.run.status, "completed");
-    const output = result.steps.run.output as { key: string; count: number };
-    assert.strictEqual(output.key, "value");
-    assert.strictEqual(output.count, 42);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("fails on non-zero exit code", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-fail",
-      description: "test command failure",
-      steps: {
-        run: {
-          command: "exit 1",
-        },
-        after: {
-          command: "echo should not run",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-    assert.strictEqual(result.steps.run.status, "failed");
-    assert.ok(result.steps.run.error?.includes("Command failed"));
-    assert.ok(result.steps.run.error?.includes("exit 1"));
-    assert.ok(!result.steps.after);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("captures stderr on failure", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-stderr",
-      description: "test command stderr",
-      steps: {
-        run: {
-          command: "echo error-msg >&2; exit 1",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-    assert.ok(result.steps.run.error?.includes("error-msg"));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("resolves ${{ }} expressions in command string", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-expr",
-      description: "test command expressions",
-      input: {
-        type: "object",
-        properties: { greeting: { type: "string" } },
-      },
-      steps: {
-        run: {
-          command: "echo ${{ input.greeting }}",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, { greeting: "howdy" }, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    const output = result.steps.run.output as { text: string };
-    assert.strictEqual(output.text, "howdy");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("persists output to disk", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-persist",
-      description: "test command output persistence",
-      steps: {
-        run: {
-          command: "echo persisted",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.ok(result.steps.run.outputPath);
-    const persisted = JSON.parse(fs.readFileSync(result.steps.run.outputPath!, "utf-8"));
-    assert.strictEqual(persisted.text, "persisted");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("handles empty stdout", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-empty",
-      description: "test command empty stdout",
-      steps: {
-        run: {
-          command: "true",  // exit 0, no output
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.run.status, "completed");
-    const output = result.steps.run.output as { text: string };
-    assert.strictEqual(output.text, "");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("costs nothing (usage.cost === 0)", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-cost",
-      description: "test command zero cost",
-      steps: {
-        run: {
-          command: "echo free",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.steps.run.usage.cost, 0);
-    assert.strictEqual(result.steps.run.usage.turns, 0);
-    assert.strictEqual(result.steps.run.usage.input, 0);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("supports timeout", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-timeout",
-      description: "test command timeout",
-      steps: {
-        run: {
-          command: "sleep 10",
-          timeout: { seconds: 1 },
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-    assert.strictEqual(result.steps.run.status, "failed");
-    assert.ok(result.steps.run.error?.includes("Command failed"));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 15000 });
-
-  it("supports signal cancellation", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const spec: WorkflowSpec = {
-      name: "test-command-signal",
-      description: "test command signal",
-      steps: {
-        run: {
-          command: "sleep 10",
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const controller = new AbortController();
-    // Abort shortly after starting
-    setTimeout(() => controller.abort(), 200);
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      signal: controller.signal,
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 15000 });
-
-  it("persists output to custom path", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-cmd-"));
-    const outputFile = path.join(tmpDir, "custom-output.json");
-    const spec: WorkflowSpec = {
-      name: "test-command-path",
-      description: "test command custom output path",
-      steps: {
-        run: {
-          command: "echo custom",
-          output: { path: outputFile },
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.workflow.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.ok(fs.existsSync(outputFile));
-    const persisted = JSON.parse(fs.readFileSync(outputFile, "utf-8"));
-    assert.strictEqual(persisted.text, "custom");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});

package/src/step-command.ts

@@ -1,132 +0,0 @@
-/**
- * Command step executor — runs a shell command and captures output as data.
- *
- * Unlike gate (which judges pass/fail), command captures stdout as structured
- * or text output for downstream steps. Non-zero exit codes produce a failed result.
- */
-import type { StepResult } from "./types.ts";
-import { zeroUsage, SIGKILL_GRACE_MS } from "./step-shared.ts";
-import { persistStepOutput } from "./output.ts";
-
-/**
- * Execute a command step: runs a shell command, captures stdout as output.
- *
- * The command string is expected to already have ${{ }} expressions resolved
- * before being passed here.
- */
-export async function executeCommand(
-  command: string,
-  stepName: string,
-  options: { cwd: string; signal?: AbortSignal; timeoutMs?: number; runDir?: string; outputPath?: string },
-  outputFormat?: "json" | "text",
-): Promise<StepResult> {
-  const startTime = Date.now();
-  try {
-    const { spawn } = await import("node:child_process");
-    const { stdout, stderr } = await new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
-      const proc = spawn("sh", ["-c", command], {
-        cwd: options.cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: true,
-      });
-
-      let stdout = "";
-      let stderr = "";
-      let settled = false;
-      proc.stdout.on("data", (d: Buffer) => { stdout += d.toString(); });
-      proc.stderr.on("data", (d: Buffer) => { stderr += d.toString(); });
-
-      const killProc = () => {
-        if (!proc.pid) return;
-        try { process.kill(-proc.pid, "SIGTERM"); } catch { /* already dead */ }
-        setTimeout(() => {
-          if (!proc.pid) return;
-          try { process.kill(-proc.pid, "SIGKILL"); } catch { /* already dead */ }
-        }, SIGKILL_GRACE_MS);
-      };
-
-      const onAbort = () => { killProc(); };
-      if (options.signal) {
-        if (options.signal.aborted) { killProc(); }
-        else { options.signal.addEventListener("abort", onAbort, { once: true }); }
-      }
-
-      let timeoutId: ReturnType<typeof setTimeout> | undefined;
-      if (options.timeoutMs) {
-        timeoutId = setTimeout(() => { killProc(); }, options.timeoutMs);
-      }
-
-      proc.on("close", (code) => {
-        if (settled) return;
-        settled = true;
-        if (timeoutId) clearTimeout(timeoutId);
-        if (options.signal) options.signal.removeEventListener("abort", onAbort);
-        if (code === 0) {
-          resolve({ stdout, stderr });
-        } else {
-          const err: any = new Error(`Process exited with code ${code}`);
-          err.status = code;
-          err.stdout = stdout;
-          err.stderr = stderr;
-          reject(err);
-        }
-      });
-
-      proc.on("error", (err) => {
-        if (settled) return;
-        settled = true;
-        if (timeoutId) clearTimeout(timeoutId);
-        if (options.signal) options.signal.removeEventListener("abort", onAbort);
-        reject(err);
-      });
-    });
-
-    // Exit 0: parse output
-    let output: unknown;
-    let textOutput: string | undefined;
-
-    if (outputFormat === "json") {
-      try {
-        output = JSON.parse(stdout);
-      } catch {
-        output = { text: stdout.trim() };
-      }
-      textOutput = stdout.trim();
-    } else {
-      textOutput = stdout.trim();
-      output = { text: textOutput };
-    }
-
-    const result: StepResult = {
-      step: stepName,
-      agent: "command",
-      status: "completed",
-      output,
-      textOutput,
-      usage: zeroUsage(),
-      durationMs: Date.now() - startTime,
-    };
-    if (options.runDir) {
-      result.outputPath = persistStepOutput(options.runDir, stepName, output, textOutput, options.outputPath);
-    }
-    return result;
-  } catch (err: unknown) {
-    const execErr = err as { status?: number; stdout?: string; stderr?: string; message?: string };
-    const exitCode = execErr.status ?? 1;
-    const stderr = execErr.stderr?.trim() ?? "";
-    const stdout = execErr.stdout?.trim() ?? "";
-
-    const result: StepResult = {
-      step: stepName,
-      agent: "command",
-      status: "failed",
-      usage: zeroUsage(),
-      durationMs: Date.now() - startTime,
-      error: `Command failed (exit ${exitCode}): ${stderr || stdout || execErr.message || "unknown error"}`,
-    };
-    if (options.runDir) {
-      persistStepOutput(options.runDir, stepName, { error: result.error, exitCode }, undefined, options.outputPath);
-    }
-    return result;
-  }
-}