@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/core/__tests__/seed-naming.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "bun:test";
+import {
+  parseSeedFilename,
+  seedFilename,
+  SEED_FILENAME_PATTERN,
+} from "../seed-naming.ts";
+
+describe("seedFilename", () => {
+  it("appends the seed suffix to the jobId", () => {
+    expect(seedFilename("abc")).toBe("abc-seed.json");
+  });
+
+  it("preserves dashes and underscores in the jobId", () => {
+    expect(seedFilename("job-0123_abc")).toBe("job-0123_abc-seed.json");
+  });
+
+  it("round-trips with parseSeedFilename", () => {
+    const jobId = "job-0123_abc";
+    expect(parseSeedFilename(seedFilename(jobId))).toBe(jobId);
+  });
+});
+
+describe("parseSeedFilename", () => {
+  it("captures the jobId from a valid seed filename", () => {
+    expect(parseSeedFilename("abc-seed.json")).toBe("abc");
+  });
+
+  it("captures jobIds that include dashes and underscores", () => {
+    expect(parseSeedFilename("job-0123_abc-seed.json")).toBe("job-0123_abc");
+  });
+
+  it("returns null for a filename without the seed suffix", () => {
+    expect(parseSeedFilename("foo.json")).toBeNull();
+  });
+
+  it("returns null when the first character is not alphanumeric", () => {
+    expect(parseSeedFilename("-seed.json")).toBeNull();
+  });
+
+  it("returns null when the suffix is not .json", () => {
+    expect(parseSeedFilename("bar-seed.txt")).toBeNull();
+  });
+
+  it("returns null when the name contains a path separator", () => {
+    expect(parseSeedFilename("a/b-seed.json")).toBeNull();
+  });
+});
+
+describe("SEED_FILENAME_PATTERN", () => {
+  it("requires the leading character to be alphanumeric", () => {
+    expect(SEED_FILENAME_PATTERN.exec("_abc-seed.json")).toBeNull();
+  });
+
+  it("matches the spec regex literal", () => {
+    expect(SEED_FILENAME_PATTERN.source).toBe("^([A-Za-z0-9][A-Za-z0-9-_]*)-seed\\.json$");
+  });
+});

package/src/core/__tests__/single-derivation.test.ts

@@ -0,0 +1,159 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+
+import { describe, expect, it } from "bun:test";
+
+const ROOT = path.resolve(import.meta.dir, "../../..");
+const SRC_DIR = path.join(ROOT, "src");
+const DOCS_PATH = path.join(ROOT, "docs/http-api.md");
+const BREAKING_CHANGE_DATE = "2026-06-19";
+
+const ALLOWLIST = new Set<string>([
+  "src/core/job-view.ts",
+  "src/config/statuses.ts",
+  "src/ui/server/endpoints/job-control-endpoints.ts",
+  "src/ui/client/adapters/job-adapter.ts",
+]);
+
+const DISPLAY_EXEMPT = new Set<string>([
+  "src/utils/ui.tsx",
+  "src/ui/components/JobCard.tsx",
+]);
+
+const TASK_IDX_PATTERN = /`task-\$\{[^}]+\}`/;
+const QUOTED_DONE = /(["'])done\1/;
+const QUOTED_COMPLETE = /(["'])complete\1/;
+const QUOTED_FAILED = /(["'])failed\1/;
+const QUOTED_ERROR = /(["'])error\1/;
+
+const LOG_CONTEXT = /\b(console|logger)\.[a-z]+\s*\(|\b[a-zA-Z_]\w*Error\s*\(/;
+
+interface Hit {
+  file: string;
+  line: number;
+  content: string;
+}
+
+async function walkSourceFiles(dir: string): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "__tests__" || entry.name === "node_modules" || entry.name === "dist") continue;
+      files.push(...(await walkSourceFiles(fullPath)));
+    } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function toRelativePath(absolutePath: string): string {
+  return path.relative(ROOT, absolutePath).split(path.sep).join("/");
+}
+
+function isJsxAttributeValue(line: string, literal: string): boolean {
+  const jsxAttrPattern = new RegExp(`=\\s*["']${literal}["']`);
+  if (!jsxAttrPattern.test(line)) return false;
+  return /[<>]/.test(line) || /<\/?[A-Za-z]/.test(line);
+}
+
+async function findTaskIndexSynthesis(): Promise<Hit[]> {
+  const files = await walkSourceFiles(SRC_DIR);
+  const hits: Hit[] = [];
+  for (const file of files) {
+    const relPath = toRelativePath(file);
+    if (ALLOWLIST.has(relPath) || DISPLAY_EXEMPT.has(relPath)) continue;
+    const source = await readFile(file, "utf-8");
+    const lines = source.split("\n");
+    lines.forEach((line, index) => {
+      if (TASK_IDX_PATTERN.test(line)) {
+        hits.push({ file: relPath, line: index + 1, content: line.trim() });
+      }
+    });
+  }
+  return hits;
+}
+
+async function findStatusMapping(literalA: RegExp, literalB: RegExp, literalAWord: string, literalBWord: string): Promise<Hit[]> {
+  const files = await walkSourceFiles(SRC_DIR);
+  const hits: Hit[] = [];
+  for (const file of files) {
+    const relPath = toRelativePath(file);
+    if (ALLOWLIST.has(relPath) || DISPLAY_EXEMPT.has(relPath)) continue;
+    const source = await readFile(file, "utf-8");
+    const lines = source.split("\n");
+    lines.forEach((line, index) => {
+      if (LOG_CONTEXT.test(line)) return;
+      if (!literalA.test(line) || !literalB.test(line)) return;
+      if (isJsxAttributeValue(line, literalAWord) || isJsxAttributeValue(line, literalBWord)) return;
+      hits.push({ file: relPath, line: index + 1, content: line.trim() });
+    });
+  }
+  return hits;
+}
+
+describe("single derivation point guard (AC-11)", () => {
+  it("no production source synthesizes `task-${index}` outside the allowlist", async () => {
+    const hits = await findTaskIndexSynthesis();
+    expect(hits, formatHits("task-${index} synthesis", hits)).toEqual([]);
+  });
+
+  it("no production source maps 'done' ↔ 'complete' job-status spellings outside the allowlist", async () => {
+    const hits = await findStatusMapping(QUOTED_DONE, QUOTED_COMPLETE, "done", "complete");
+    expect(hits, formatHits("done ↔ complete status mapping", hits)).toEqual([]);
+  });
+
+  it("no production source maps 'failed' ↔ 'error' job-status spellings outside the allowlist", async () => {
+    const hits = await findStatusMapping(QUOTED_FAILED, QUOTED_ERROR, "failed", "error");
+    expect(hits, formatHits("failed ↔ error status mapping", hits)).toEqual([]);
+  });
+});
+
+describe("display-exempt files are display-only", () => {
+  it("exempt files do not import normalizeJobView or core/job-view", async () => {
+    for (const relPath of DISPLAY_EXEMPT) {
+      const absPath = path.join(ROOT, relPath);
+      const source = await readFile(absPath, "utf-8");
+      expect(source, `${relPath} should not import normalizeJobView`).not.toContain("normalizeJobView");
+      expect(source, `${relPath} should not import core/job-view`).not.toContain("core/job-view");
+    }
+  });
+});
+
+describe("docs/http-api.md breaking-change note (C-11, AC-11 G-mode)", () => {
+  it("contains the dated breaking-change entry for 'error' → 'failed'", async () => {
+    const docs = await readFile(DOCS_PATH, "utf-8");
+    expect(docs).toContain(BREAKING_CHANGE_DATE);
+    expect(docs.toLowerCase()).toContain("breaking change");
+    const errorToFailedRow = /(["'])error\1[^\n]*?["']failed["']|(["'])error\2[^a-zA-Z]+[→=>]+[^a-zA-Z]+(.*?)(["'])failed\4/;
+    expect(docs, "expected a row or sentence pairing \"error\" with \"failed\"").toMatch(errorToFailedRow);
+  });
+
+  it("contains the dated breaking-change entry for 'done' → 'complete'", async () => {
+    const docs = await readFile(DOCS_PATH, "utf-8");
+    expect(docs).toContain(BREAKING_CHANGE_DATE);
+    const doneToCompleteRow = /(["'])done\1[^\n]*?["']complete["']|(["'])done\2[^a-zA-Z]+[→=>]+[^a-zA-Z]+(.*?)(["'])complete\4/;
+    expect(docs, "expected a row or sentence pairing \"done\" with \"complete\"").toMatch(doneToCompleteRow);
+  });
+
+  it("documents name-keyed task ids with a 'task-${index}' fallback", async () => {
+    const docs = await readFile(DOCS_PATH, "utf-8");
+    expect(docs).toContain("task-${index}");
+    expect(docs.toLowerCase()).toMatch(/name[- ]keyed/);
+  });
+
+  it("enumerates the canonical JobStatus enum", async () => {
+    const docs = await readFile(DOCS_PATH, "utf-8");
+    for (const value of ["pending", "running", "failed", "complete", "waiting"]) {
+      expect(docs, `canonical JobStatus value "${value}" should be documented`).toContain(`\`${value}\``);
+    }
+  });
+});
+
+function formatHits(label: string, hits: Hit[]): string {
+  if (hits.length === 0) return `no ${label} found outside the allowlist`;
+  return `${label} found in ${hits.length} file(s) outside the allowlist:\n` +
+    hits.map((hit) => `  - ${hit.file}:${hit.line}: ${hit.content}`).join("\n");
+}