@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/core/__tests__/json-file.test.ts

@@ -0,0 +1,111 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmod, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { JsonFileError, readJsonFile, writeJsonFile } from "../json-file";
+
+describe("readJsonFile", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "pop-json-file-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("returns the parsed typed value for a valid JSON file", async () => {
+    const path = join(dir, "valid.json");
+    await writeFile(path, JSON.stringify({ name: "demo", count: 3 }));
+
+    const value = await readJsonFile<{ name: string; count: number }>(path);
+
+    expect(value).toEqual({ name: "demo", count: 3 });
+  });
+
+  test("throws JsonFileError reason 'parse' carrying path and cause for malformed JSON, leaving the file unchanged", async () => {
+    const path = join(dir, "bad.json");
+    const original = "{ not valid json ";
+    await writeFile(path, original);
+
+    let thrown: unknown;
+    try {
+      await readJsonFile(path);
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(JsonFileError);
+    const error = thrown as JsonFileError;
+    expect(error.reason).toBe("parse");
+    expect(error.path).toBe(path);
+    expect(error.cause).toBeInstanceOf(SyntaxError);
+    expect(error.message).toContain(path);
+    expect(error.message).toContain("parse");
+    expect(error.message).toContain((error.cause as Error).message);
+
+    expect(await readFile(path, "utf8")).toBe(original);
+  });
+
+  test("throws JsonFileError reason 'missing' with path and ENOENT cause for a nonexistent file", async () => {
+    const path = join(dir, "absent.json");
+
+    let thrown: unknown;
+    try {
+      await readJsonFile(path);
+    } catch (err) {
+      thrown = err;
+    }
+
+    expect(thrown).toBeInstanceOf(JsonFileError);
+    const error = thrown as JsonFileError;
+    expect(error.reason).toBe("missing");
+    expect(error.path).toBe(path);
+    expect(error.message).toContain(path);
+    expect(error.message).toContain("missing");
+    expect(error.message).toContain("ENOENT");
+  });
+});
+
+describe("writeJsonFile", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "pop-json-file-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("round-trips a value and ends the file with a trailing newline", async () => {
+    const path = join(dir, "out.json");
+    const value = { name: "demo", tasks: ["a", "b"] };
+
+    await writeJsonFile(path, value);
+
+    const text = await readFile(path, "utf8");
+    expect(text.endsWith("\n")).toBe(true);
+    expect(JSON.parse(text)).toEqual(value);
+    expect(await readJsonFile<typeof value>(path)).toEqual(value);
+  });
+
+  test("leaves the original file intact when the write fails before rename", async () => {
+    const path = join(dir, "config.json");
+    const original = JSON.stringify({ keep: true }) + "\n";
+    await writeFile(path, original);
+
+    // Make the directory read-only so atomicWrite's temp-file write fails
+    // before it can rename over the original target.
+    await chmod(dir, 0o500);
+    try {
+      await expect(writeJsonFile(path, { partial: true })).rejects.toThrow();
+    } finally {
+      await chmod(dir, 0o700);
+    }
+
+    expect(await readFile(path, "utf8")).toBe(original);
+  });
+});

package/src/core/__tests__/lifecycle-policy.test.ts

@@ -1,5 +1,9 @@
 import { describe, test, expect } from "bun:test";
-import { decideTransition } from "../lifecycle-policy";
+import {
+  decideTransition,
+  areDependenciesSatisfied,
+  firstUnsatisfiedDependency,
+} from "../lifecycle-policy";
 
 describe("decideTransition", () => {
   test("start with pending task and ready dependencies returns ok", () => {
@@ -24,25 +28,25 @@ describe("decideTransition", () => {
     });
   });
 
-  test("restart from done state returns ok regardless of dependencies", () => {
+  test("restart with ready dependencies returns ok", () => {
     const result = decideTransition({
       op: "restart",
       taskState: "done",
-      dependenciesReady: false,
+      dependenciesReady: true,
     });
     expect(result).toEqual({ ok: true });
   });
 
-  test("restart from running state is blocked by policy", () => {
+  test("restart with unready dependencies is blocked by dependencies", () => {
     const result = decideTransition({
       op: "restart",
-      taskState: "running",
-      dependenciesReady: true,
+      taskState: "done",
+      dependenciesReady: false,
     });
     expect(result).toEqual({
       ok: false,
       code: "unsupported_lifecycle",
-      reason: "policy",
+      reason: "dependencies",
     });
   });
 
@@ -76,3 +80,73 @@ describe("decideTransition", () => {
     ).toThrow(/Invalid dependenciesReady/);
   });
 });
+
+describe("areDependenciesSatisfied", () => {
+  test("empty predecessor set is satisfied", () => {
+    expect(areDependenciesSatisfied([])).toBe(true);
+  });
+
+  test("single done predecessor is satisfied", () => {
+    expect(areDependenciesSatisfied(["done"])).toBe(true);
+  });
+
+  test("single skipped predecessor is satisfied", () => {
+    expect(areDependenciesSatisfied(["skipped"])).toBe(true);
+  });
+
+  test("done and skipped together are satisfied", () => {
+    expect(areDependenciesSatisfied(["done", "skipped"])).toBe(true);
+  });
+
+  test("pending predecessor is not satisfied", () => {
+    expect(areDependenciesSatisfied(["pending"])).toBe(false);
+  });
+
+  test("running predecessor is not satisfied", () => {
+    expect(areDependenciesSatisfied(["running"])).toBe(false);
+  });
+
+  test("failed predecessor is not satisfied", () => {
+    expect(areDependenciesSatisfied(["failed"])).toBe(false);
+  });
+
+  test("normalizes case and synonyms: DONE and succeeded satisfy", () => {
+    expect(areDependenciesSatisfied(["DONE", "succeeded"])).toBe(true);
+  });
+
+  test("normalizes synonyms: error maps to failed and does not satisfy", () => {
+    expect(areDependenciesSatisfied(["error"])).toBe(false);
+  });
+});
+
+describe("firstUnsatisfiedDependency", () => {
+  test("empty predecessor list returns null", () => {
+    expect(firstUnsatisfiedDependency([])).toBeNull();
+  });
+
+  test("all satisfied returns null", () => {
+    expect(
+      firstUnsatisfiedDependency([
+        { name: "a", state: "done" },
+        { name: "b", state: "skipped" },
+      ]),
+    ).toBeNull();
+  });
+
+  test("returns the first offending predecessor", () => {
+    expect(
+      firstUnsatisfiedDependency([
+        { name: "a", state: "done" },
+        { name: "b", state: "pending" },
+        { name: "c", state: "failed" },
+      ]),
+    ).toEqual({ name: "b", state: "pending" });
+  });
+
+  test("returns the first element when it offends", () => {
+    expect(firstUnsatisfiedDependency([{ name: "a", state: "running" }])).toEqual({
+      name: "a",
+      state: "running",
+    });
+  });
+});

package/src/core/__tests__/logger.test.ts

@@ -46,6 +46,28 @@ describe("createLogger", () => {
     const logger = createLogger("Test");
     expect(() => logger.sse("event", { data: "test" })).not.toThrow();
   });
+
+  test("sse performs no registry broadcast", () => {
+    const spy = mock(() => {});
+    console.log = spy;
+    const logger = createLogger("Test");
+    logger.sse("event", { data: "test" });
+    const calls = spy.mock.calls;
+    expect(calls.length).toBe(1);
+    expect(calls[0]!.join(" ")).toContain("[SSE:event]");
+  });
+
+  test("logger.ts and status-writer.ts no longer reference the dead SSE machinery", async () => {
+    const loggerSrc = await Bun.file(new URL("../logger.ts", import.meta.url)).text();
+    const statusWriterSrc = await Bun.file(new URL("../status-writer.ts", import.meta.url)).text();
+    for (const needle of ["getSSERegistry", "../ui/sse.ts", "logger.sse("]) {
+      expect(loggerSrc).not.toContain(needle);
+      expect(statusWriterSrc).not.toContain(needle);
+    }
+    for (const needle of ["task:updated", "state:change", "lifecycle_block"]) {
+      expect(statusWriterSrc).not.toContain(needle);
+    }
+  });
 });
 
 describe("createJobLogger", () => {

package/src/core/__tests__/orchestrator-no-deprecated-exports.test.ts

@@ -0,0 +1,41 @@
+import { describe, test, expect } from "bun:test";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// Source scan modeled on the deleted-config-symbols scan
+// (src/core/__tests__/config.test.ts "source deletion scan" block).
+// Guards AC-11: handleSeedAdd and SEED_PATTERN must be absent from src/ after step 10.
+const DELETED_TOKENS = ["handleSeedAdd", "SEED_PATTERN"] as const;
+
+const SRC_ROOT = join(import.meta.dir, "..", "..");
+
+function walkTs(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      out.push(...walkTs(full));
+      continue;
+    }
+    if (/\.tsx?$/.test(entry)) out.push(full);
+  }
+  return out;
+}
+
+describe("orchestrator dead-code scan (AC-11)", () => {
+  test("no src/ file references handleSeedAdd or SEED_PATTERN", () => {
+    const files = walkTs(SRC_ROOT).filter((f) => !f.includes("/__tests__/"));
+    const offending: Array<{ file: string; token: string }> = [];
+    for (const file of files) {
+      const content = readFileSync(file, "utf8");
+      for (const token of DELETED_TOKENS) {
+        if (content.includes(token)) offending.push({ file, token });
+      }
+    }
+    if (offending.length > 0) {
+      const lines = offending.map((o) => `  ${o.file}: ${o.token}`).join("\n");
+      throw new Error(`Deleted orchestrator symbols still referenced under src/:\n${lines}`);
+    }
+    expect(offending).toHaveLength(0);
+  });
+});