@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/block-validation.test.ts

@@ -1,350 +0,0 @@
-/**
- * Tests for post-step block validation with filesystem diff.
- */
-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 { snapshotBlockFiles, validateChangedBlocks } from "@davidorex/pi-project/src/block-validation.ts";
-import { executeWorkflow } from "./workflow-executor.ts";
-import type { WorkflowSpec } from "./types.ts";
-import { mockCtx, mockPi } from "./test-helpers.ts";
-
-// ── Unit tests for snapshotBlockFiles / validateChangedBlocks ──
-
-describe("snapshotBlockFiles", () => {
-  it("returns empty map when .project/ does not exist", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-snap-"));
-    const result = snapshotBlockFiles(tmpDir);
-    assert.strictEqual(result.size, 0);
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("snapshots .json files in .project/", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-snap-"));
-    const wfDir = path.join(tmpDir, ".project");
-    fs.mkdirSync(wfDir, { recursive: true });
-    fs.writeFileSync(path.join(wfDir, "gaps.json"), "{}");
-    fs.writeFileSync(path.join(wfDir, "decisions.json"), "[]");
-    fs.writeFileSync(path.join(wfDir, "readme.txt"), "not json"); // should be ignored
-
-    const result = snapshotBlockFiles(tmpDir);
-    assert.strictEqual(result.size, 2);
-    assert.ok(result.has(path.join(wfDir, "gaps.json")));
-    assert.ok(result.has(path.join(wfDir, "decisions.json")));
-    assert.ok(!result.has(path.join(wfDir, "readme.txt")));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});
-
-describe("validateChangedBlocks", () => {
-  it("does nothing when no files changed", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-val-"));
-    const wfDir = path.join(tmpDir, ".project");
-    fs.mkdirSync(wfDir, { recursive: true });
-    fs.writeFileSync(path.join(wfDir, "gaps.json"), "{}");
-
-    const before = snapshotBlockFiles(tmpDir);
-    // No changes — should not throw
-    assert.doesNotThrow(() => validateChangedBlocks(tmpDir, before));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("skips changed files with no matching schema", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-val-"));
-    const wfDir = path.join(tmpDir, ".project");
-    fs.mkdirSync(wfDir, { recursive: true });
-
-    const before = snapshotBlockFiles(tmpDir);
-
-    // Create a new file with no schema
-    fs.writeFileSync(path.join(wfDir, "no-schema.json"), '{"data": true}');
-
-    // Should not throw — no schema to validate against
-    assert.doesNotThrow(() => validateChangedBlocks(tmpDir, before));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("validates changed file against its schema — passes", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-val-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Create schema
-    fs.writeFileSync(path.join(schemasDir, "test-block.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["name"],
-      properties: { name: { type: "string" } },
-    }));
-
-    const before = snapshotBlockFiles(tmpDir);
-
-    // Create a valid block file
-    fs.writeFileSync(path.join(wfDir, "test-block.json"), JSON.stringify({ name: "valid" }));
-
-    assert.doesNotThrow(() => validateChangedBlocks(tmpDir, before));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("throws on validation failure", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-val-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Create schema requiring name as string
-    fs.writeFileSync(path.join(schemasDir, "test-block.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["name"],
-      properties: { name: { type: "string" } },
-    }));
-
-    const before = snapshotBlockFiles(tmpDir);
-
-    // Create an invalid block file (name should be string, not number)
-    fs.writeFileSync(path.join(wfDir, "test-block.json"), JSON.stringify({ name: 123 }));
-
-    assert.throws(
-      () => validateChangedBlocks(tmpDir, before),
-      (err: unknown) => err instanceof Error && err.message.includes("Block validation failed"),
-    );
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("detects modified files (not just new files)", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-val-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Create schema
-    fs.writeFileSync(path.join(schemasDir, "data.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["value"],
-      properties: { value: { type: "number" } },
-    }));
-
-    // Create valid initial file
-    const blockPath = path.join(wfDir, "data.json");
-    fs.writeFileSync(blockPath, JSON.stringify({ value: 42 }));
-
-    const before = snapshotBlockFiles(tmpDir);
-
-    // Modify the file to be invalid (need to ensure mtime changes)
-    // Use a tiny delay or touch the file
-    const newContent = JSON.stringify({ value: "not a number" });
-    // Force mtime change by writing with a slight delay
-    const origMtime = fs.statSync(blockPath).mtimeMs;
-    fs.writeFileSync(blockPath, newContent);
-    // If mtime didn't change (same millisecond), force it
-    const newMtime = fs.statSync(blockPath).mtimeMs;
-    if (newMtime === origMtime) {
-      fs.utimesSync(blockPath, new Date(), new Date(Date.now() + 1000));
-    }
-
-    assert.throws(
-      () => validateChangedBlocks(tmpDir, before),
-      (err: unknown) => err instanceof Error && err.message.includes("Block validation failed"),
-    );
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});
-
-// ── Integration tests: block validation in workflow executor ──
-
-describe("post-step block validation in executor", () => {
-  it("step that does not modify .project/ passes normally", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-exec-"));
-    const spec: WorkflowSpec = {
-      name: "bv-no-change",
-      description: "step without block changes",
-      steps: {
-        compute: {
-          transform: { mapping: { result: 42 } },
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.project.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.compute.status, "completed");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("step that writes valid data to a .project/ block passes", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-exec-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Create schema
-    fs.writeFileSync(path.join(schemasDir, "result.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["status"],
-      properties: { status: { type: "string" } },
-    }));
-
-    // Use a command step that writes a valid block file
-    const spec: WorkflowSpec = {
-      name: "bv-valid-write",
-      description: "step writes valid block",
-      steps: {
-        writeBlock: {
-          command: `echo '{"status": "ok"}' > ${path.join(wfDir, "result.json")}`,
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.project.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.writeBlock.status, "completed");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("step that writes invalid data to a .project/ block fails", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-exec-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Create schema requiring status as string
-    fs.writeFileSync(path.join(schemasDir, "result.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["status"],
-      properties: { status: { type: "string" } },
-    }));
-
-    // Command step writes invalid data (status is number, not string)
-    const spec: WorkflowSpec = {
-      name: "bv-invalid-write",
-      description: "step writes invalid block",
-      steps: {
-        writeBlock: {
-          command: `echo '{"status": 123}' > ${path.join(wfDir, "result.json")}`,
-        },
-        shouldNotRun: {
-          transform: { mapping: { ran: true } },
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.project.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-    assert.strictEqual(result.steps.writeBlock.status, "failed");
-    assert.ok(result.steps.writeBlock.error?.includes("Block validation failed"));
-    // Fail-fast: next step should not run
-    assert.ok(!result.steps.shouldNotRun);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("changed .project/ file with no matching schema is skipped", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-exec-"));
-    const wfDir = path.join(tmpDir, ".project");
-    fs.mkdirSync(wfDir, { recursive: true });
-    // No schemas directory at all
-
-    // Command writes a JSON file with no schema
-    const spec: WorkflowSpec = {
-      name: "bv-no-schema",
-      description: "step writes block with no schema",
-      steps: {
-        writeBlock: {
-          command: `echo '{"anything": "goes"}' > ${path.join(wfDir, "custom.json")}`,
-        },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.project.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.steps.writeBlock.status, "completed");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("validates multiple changed block files in one step", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bv-exec-"));
-    const wfDir = path.join(tmpDir, ".project");
-    const schemasDir = path.join(wfDir, "schemas");
-    fs.mkdirSync(schemasDir, { recursive: true });
-
-    // Schema for file-a: requires name as string
-    fs.writeFileSync(path.join(schemasDir, "file-a.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["name"],
-      properties: { name: { type: "string" } },
-    }));
-    // Schema for file-b: requires count as number
-    fs.writeFileSync(path.join(schemasDir, "file-b.schema.json"), JSON.stringify({
-      type: "object",
-      required: ["count"],
-      properties: { count: { type: "number" } },
-    }));
-
-    // Write valid file-a, invalid file-b
-    const cmd = [
-      `echo '{"name": "ok"}' > ${path.join(wfDir, "file-a.json")}`,
-      `echo '{"count": "not-a-number"}' > ${path.join(wfDir, "file-b.json")}`,
-    ].join(" && ");
-
-    const spec: WorkflowSpec = {
-      name: "bv-multi",
-      description: "step writes multiple blocks",
-      steps: {
-        writeBlocks: { command: cmd },
-      },
-      source: "project",
-      filePath: path.join(tmpDir, "test.project.yaml"),
-    };
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "default" }),
-    });
-
-    assert.strictEqual(result.status, "failed");
-    assert.strictEqual(result.steps.writeBlocks.status, "failed");
-    assert.ok(result.steps.writeBlocks.error?.includes("file-b.json"));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});

package/src/checkpoint.test.ts

@@ -1,237 +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 { findIncompleteRun, validateResumeCompatibility, computeResumePoint, formatIncompleteRun } from "./checkpoint.ts";
-import { writeState } from "./state.ts";
-import type { ExecutionState } from "./types.ts";
-import { makeSpec } from "./test-helpers.ts";
-
-describe("findIncompleteRun", () => {
-  it("returns null when no runs directory exists", () => {
-    const result = findIncompleteRun("/nonexistent", "test-workflow");
-    assert.strictEqual(result, null);
-  });
-
-  it("returns null when all runs are completed", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-ckpt-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const runDir = path.join(tmpDir, ".workflows", "runs", "test", "runs", "test-20260314-120000-abcd");
-    fs.mkdirSync(runDir, { recursive: true });
-    writeState(runDir, { input: {}, steps: {}, status: "completed" });
-
-    const result = findIncompleteRun(tmpDir, "test");
-    assert.strictEqual(result, null);
-  });
-
-  it("finds a run with status 'running' (interrupted)", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-ckpt-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const runDir = path.join(tmpDir, ".workflows", "runs", "test", "runs", "test-20260314-120000-abcd");
-    fs.mkdirSync(runDir, { recursive: true });
-
-    const state: ExecutionState = {
-      input: { path: "/src" },
-      steps: {
-        explore: {
-          step: "explore", agent: "explorer", status: "completed",
-          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
-          durationMs: 1000, textOutput: "found stuff",
-        },
-      },
-      status: "running",
-    };
-    writeState(runDir, state);
-
-    const result = findIncompleteRun(tmpDir, "test");
-    assert.ok(result);
-    assert.strictEqual(result.runId, "test-20260314-120000-abcd");
-    assert.deepStrictEqual(result.completedSteps, ["explore"]);
-    assert.strictEqual(result.failedStep, undefined);
-  });
-
-  it("finds a run with status 'failed'", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-ckpt-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const runDir = path.join(tmpDir, ".workflows", "runs", "test", "runs", "test-20260314-120000-abcd");
-    fs.mkdirSync(runDir, { recursive: true });
-
-    const state: ExecutionState = {
-      input: {},
-      steps: {
-        step1: {
-          step: "step1", agent: "a", status: "completed",
-          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-          durationMs: 0,
-        },
-        step2: {
-          step: "step2", agent: "b", status: "failed",
-          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-          durationMs: 0, error: "timeout",
-        },
-      },
-      status: "failed",
-    };
-    writeState(runDir, state);
-
-    const result = findIncompleteRun(tmpDir, "test");
-    assert.ok(result);
-    assert.deepStrictEqual(result.completedSteps, ["step1"]);
-    assert.strictEqual(result.failedStep, "step2");
-  });
-
-  it("returns most recent incomplete run", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-ckpt-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const runsBase = path.join(tmpDir, ".workflows", "runs", "test", "runs");
-
-    // Older run (completed)
-    const oldDir = path.join(runsBase, "test-20260314-100000-aaaa");
-    fs.mkdirSync(oldDir, { recursive: true });
-    writeState(oldDir, { input: {}, steps: {}, status: "completed" });
-
-    // Newer run (failed)
-    const newDir = path.join(runsBase, "test-20260314-120000-bbbb");
-    fs.mkdirSync(newDir, { recursive: true });
-    writeState(newDir, { input: {}, steps: {}, status: "failed" });
-
-    const result = findIncompleteRun(tmpDir, "test");
-    assert.ok(result);
-    assert.strictEqual(result.runId, "test-20260314-120000-bbbb");
-  });
-});
-
-describe("validateResumeCompatibility", () => {
-  it("returns null when compatible", () => {
-    const state: ExecutionState = {
-      input: {},
-      steps: {
-        step1: {
-          step: "step1", agent: "a", status: "completed",
-          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-          durationMs: 0,
-        },
-      },
-      status: "failed",
-      specVersion: "1",
-    };
-    const spec = makeSpec({ version: "1", steps: { step1: { agent: "a" }, step2: { agent: "b" } } });
-    assert.strictEqual(validateResumeCompatibility(state, spec), null);
-  });
-
-  it("rejects version mismatch", () => {
-    const state: ExecutionState = {
-      input: {},
-      steps: {},
-      status: "failed",
-      specVersion: "1",
-    };
-    const spec = makeSpec({ version: "2", steps: { step1: { agent: "a" } } });
-    const msg = validateResumeCompatibility(state, spec);
-    assert.ok(msg?.includes("version"));
-  });
-
-  it("rejects when completed step no longer exists in spec", () => {
-    const state: ExecutionState = {
-      input: {},
-      steps: {
-        removed_step: {
-          step: "removed_step", agent: "a", status: "completed",
-          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-          durationMs: 0,
-        },
-      },
-      status: "failed",
-    };
-    const spec = makeSpec({ steps: { different_step: { agent: "a" } } });
-    const msg = validateResumeCompatibility(state, spec);
-    assert.ok(msg?.includes("removed_step"));
-  });
-});
-
-describe("computeResumePoint", () => {
-  it("returns first layer with pending steps", () => {
-    const plan = [
-      { steps: ["a"] },
-      { steps: ["b", "c"] },
-      { steps: ["d"] },
-    ];
-    const completed = new Set(["a"]);
-    const result = computeResumePoint(plan, completed);
-    assert.ok(result);
-    assert.strictEqual(result.resumeLayerIndex, 1);
-    assert.deepStrictEqual(result.pendingStepsInLayer, ["b", "c"]);
-  });
-
-  it("returns only pending steps in a partially completed layer", () => {
-    const plan = [
-      { steps: ["a"] },
-      { steps: ["b", "c", "d"] },
-      { steps: ["e"] },
-    ];
-    const completed = new Set(["a", "b", "d"]);
-    const result = computeResumePoint(plan, completed);
-    assert.ok(result);
-    assert.strictEqual(result.resumeLayerIndex, 1);
-    assert.deepStrictEqual(result.pendingStepsInLayer, ["c"]);
-  });
-
-  it("returns null when all steps are completed", () => {
-    const plan = [
-      { steps: ["a"] },
-      { steps: ["b"] },
-    ];
-    const completed = new Set(["a", "b"]);
-    const result = computeResumePoint(plan, completed);
-    assert.strictEqual(result, null);
-  });
-
-  it("handles first layer being the resume point", () => {
-    const plan = [
-      { steps: ["a", "b"] },
-      { steps: ["c"] },
-    ];
-    const completed = new Set<string>();
-    const result = computeResumePoint(plan, completed);
-    assert.ok(result);
-    assert.strictEqual(result.resumeLayerIndex, 0);
-    assert.deepStrictEqual(result.pendingStepsInLayer, ["a", "b"]);
-  });
-});
-
-describe("formatIncompleteRun", () => {
-  it("formats an interrupted run", () => {
-    const run = {
-      runId: "test-20260314-120000-abcd",
-      runDir: "/tmp/runs/test-20260314-120000-abcd",
-      state: { input: {}, steps: {}, status: "running" as const },
-      completedSteps: ["explore", "analyze"],
-      updatedAt: "2026-03-14T12:00:00.000Z",
-    };
-    const spec = makeSpec({ steps: { explore: { agent: "a" }, analyze: { agent: "b" }, synthesize: { agent: "c" } } });
-    const msg = formatIncompleteRun(run, spec);
-    assert.ok(msg.includes("interrupted"));
-    assert.ok(msg.includes("2/3"));
-  });
-
-  it("formats a failed run with step name", () => {
-    const run = {
-      runId: "test-20260314-120000-abcd",
-      runDir: "/tmp/runs/test-20260314-120000-abcd",
-      state: { input: {}, steps: {}, status: "failed" as const },
-      completedSteps: ["explore"],
-      failedStep: "analyze",
-      updatedAt: "2026-03-14T12:00:00.000Z",
-    };
-    const spec = makeSpec({ steps: { explore: { agent: "a" }, analyze: { agent: "b" }, synthesize: { agent: "c" } } });
-    const msg = formatIncompleteRun(run, spec);
-    assert.ok(msg.includes("failed"));
-    assert.ok(msg.includes("analyze"));
-    assert.ok(msg.includes("1/3"));
-  });
-});