@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/task-analysis/__tests__/enrichers-artifact-resolver.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-import type { ChatResponse } from "../../providers/types.ts";
-
-mock.module("../../llm/index.ts", () => ({
-  chat: mock(),
-}));
-
-import { chat } from "../../llm/index.ts";
-import { resolveArtifactReference } from "../enrichers/artifact-resolver.ts";
-
-const mockedChat = chat as ReturnType<typeof mock>;
-
-const TASK_CODE = `
-export async function transform({ io }) {
-  const input = await io.readArtifact(getInputFile());
-  await io.writeArtifact("output.json", input);
-}
-`.trim();
-
-const UNRESOLVED = {
-  expression: "getInputFile()",
-  codeContext: "io.readArtifact(getInputFile())",
-  stage: "transform",
-};
-
-const AVAILABLE = ["data.json", "config.json", "output.json"];
-
-function makeResponse(content: Record<string, unknown>): Promise<ChatResponse> {
-  return Promise.resolve({
-    content,
-    usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
-  });
-}
-
-beforeEach(() => {
-  mockedChat.mockClear();
-});
-
-describe("resolveArtifactReference", () => {
-  it("returns result as-is when resolvedFileName is in availableArtifacts", async () => {
-    mockedChat.mockReturnValue(
-      makeResponse({ resolvedFileName: "data.json", confidence: 0.9, reasoning: "Matches input pattern" }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result.resolvedFileName).toBe("data.json");
-    expect(result.confidence).toBe(0.9);
-    expect(result.reasoning).toBe("Matches input pattern");
-  });
-
-  it("returns null resolvedFileName and 0 confidence when filename not in availableArtifacts", async () => {
-    mockedChat.mockReturnValue(
-      makeResponse({ resolvedFileName: "hallucinated.json", confidence: 0.8, reasoning: "Guessed" }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result.resolvedFileName).toBeNull();
-    expect(result.confidence).toBe(0);
-  });
-
-  it("clamps confidence to 1 when value exceeds 1", async () => {
-    mockedChat.mockReturnValue(
-      makeResponse({ resolvedFileName: "data.json", confidence: 7, reasoning: "Very confident" }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result.resolvedFileName).toBe("data.json");
-    expect(result.confidence).toBe(1);
-  });
-
-  it("forces confidence to 0 when value is NaN", async () => {
-    mockedChat.mockReturnValue(
-      makeResponse({ resolvedFileName: "data.json", confidence: NaN, reasoning: "Uncertain" }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result.resolvedFileName).toBe("data.json");
-    expect(result.confidence).toBe(0);
-  });
-
-  it("clamps confidence to 0 when value is negative", async () => {
-    mockedChat.mockReturnValue(
-      makeResponse({ resolvedFileName: "data.json", confidence: -1, reasoning: "Negative" }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result.resolvedFileName).toBe("data.json");
-    expect(result.confidence).toBe(0);
-  });
-
-  it("returns fallback when content is a raw string (non-object)", async () => {
-    mockedChat.mockReturnValue(
-      Promise.resolve({
-        content: '{"resolvedFileName":"x.json"}' as unknown as Record<string, unknown>,
-        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-      }),
-    );
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result).toEqual({
-      resolvedFileName: null,
-      confidence: 0,
-      reasoning: "Failed to analyze artifact reference",
-    });
-  });
-
-  it("returns fallback when chat throws", async () => {
-    mockedChat.mockRejectedValue(new Error("Network error"));
-
-    const result = await resolveArtifactReference(TASK_CODE, UNRESOLVED, AVAILABLE);
-
-    expect(result).toEqual({
-      resolvedFileName: null,
-      confidence: 0,
-      reasoning: "Failed to analyze artifact reference",
-    });
-  });
-});

package/src/task-analysis/__tests__/extractors-artifacts.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseTaskSource } from "../parser.js";
-import {
-  extractArtifactReads,
-  extractArtifactWrites,
-  extractCodeContext,
-} from "../extractors/artifacts.js";
-import traverse from "@babel/traverse";
-import type { NodePath } from "@babel/traverse";
-
-describe("extractArtifactReads", () => {
-  it("returns one read with correct fields for a simple string literal", () => {
-    const code = `export function s() { io.readArtifact("data.json") }`;
-    const ast = parseTaskSource(code);
-    const { reads, unresolvedReads } = extractArtifactReads(ast, code);
-
-    expect(reads).toHaveLength(1);
-    expect(unresolvedReads).toHaveLength(0);
-    expect(reads[0]).toMatchObject({
-      fileName: "data.json",
-      stage: "s",
-      required: true,
-    });
-  });
-
-  it("sets required=false when inside a try/catch", () => {
-    const code = `
-export function s() {
-  try {
-    io.readArtifact("data.json")
-  } catch(e) {}
-}
-    `.trim();
-    const ast = parseTaskSource(code);
-    const { reads } = extractArtifactReads(ast, code);
-
-    expect(reads).toHaveLength(1);
-    expect(reads[0]?.required).toBe(false);
-  });
-
-  it("resolves template literal with expression into reads (not unresolvedReads)", () => {
-    const code = `export function s() { io.readArtifact(\`file-\${name}.json\`) }`;
-    const ast = parseTaskSource(code);
-    const { reads, unresolvedReads } = extractArtifactReads(ast, code);
-
-    expect(unresolvedReads).toHaveLength(0);
-    expect(reads).toHaveLength(1);
-    expect(reads[0]?.fileName).toContain("${name}");
-  });
-
-  it("puts dynamic identifiers in unresolvedReads with expression and codeContext", () => {
-    const code = `export function s() { io.readArtifact(dynamicVar) }`;
-    const ast = parseTaskSource(code);
-    const { reads, unresolvedReads } = extractArtifactReads(ast, code);
-
-    expect(reads).toHaveLength(0);
-    expect(unresolvedReads).toHaveLength(1);
-    expect(unresolvedReads[0]?.expression).toBe("dynamicVar");
-    expect(typeof unresolvedReads[0]?.codeContext).toBe("string");
-    expect(unresolvedReads[0]?.codeContext.length).toBeGreaterThan(0);
-  });
-
-  it("throws when io.readArtifact is outside an exported function", () => {
-    const code = `function internal() { io.readArtifact("x") }`;
-    const ast = parseTaskSource(code);
-    expect(() => extractArtifactReads(ast, code)).toThrow();
-  });
-});
-
-describe("extractArtifactWrites", () => {
-  it("resolves template literal with no expressions into writes", () => {
-    const code = "export function s() { io.writeArtifact(`output.json`) }";
-    const ast = parseTaskSource(code);
-    const { writes, unresolvedWrites } = extractArtifactWrites(ast, code);
-
-    expect(unresolvedWrites).toHaveLength(0);
-    expect(writes).toHaveLength(1);
-    expect(writes[0]).toMatchObject({ fileName: "output.json", stage: "s" });
-  });
-
-  it("puts dynamic identifiers in unresolvedWrites with expression and codeContext", () => {
-    const code = `export function s() { io.writeArtifact(dynamicVar) }`;
-    const ast = parseTaskSource(code);
-    const { writes, unresolvedWrites } = extractArtifactWrites(ast, code);
-
-    expect(writes).toHaveLength(0);
-    expect(unresolvedWrites).toHaveLength(1);
-    expect(unresolvedWrites[0]?.expression).toBe("dynamicVar");
-    expect(typeof unresolvedWrites[0]?.codeContext).toBe("string");
-    expect(unresolvedWrites[0]?.codeContext.length).toBeGreaterThan(0);
-  });
-
-  it("throws when io.writeArtifact is outside an exported function", () => {
-    const code = `function internal() { io.writeArtifact("x") }`;
-    const ast = parseTaskSource(code);
-    expect(() => extractArtifactWrites(ast, code)).toThrow();
-  });
-});
-
-describe("extractCodeContext", () => {
-  it("returns surrounding lines from the source", () => {
-    const code = `line1\nline2\nline3\nline4\nline5`;
-    const ast = parseTaskSource(
-      `export function s() { io.readArtifact("x") }`
-    );
-    // Find a NodePath to use as anchor
-    let capturedPath: NodePath | null = null;
-    traverse(ast, {
-      CallExpression(p) {
-        capturedPath = p;
-      },
-    });
-    expect(capturedPath).not.toBeNull();
-    // The path's loc is line 1 in its own source, but we pass a different sourceCode
-    // so we just check it returns a non-empty string without crashing
-    const result = extractCodeContext(capturedPath!, code);
-    expect(typeof result).toBe("string");
-  });
-
-  it("returns empty string when sourceCode is empty", () => {
-    const ast = parseTaskSource(
-      `export function s() { io.readArtifact("x") }`
-    );
-    let capturedPath: NodePath | null = null;
-    traverse(ast, {
-      CallExpression(p) {
-        capturedPath = p;
-      },
-    });
-    expect(capturedPath).not.toBeNull();
-    expect(extractCodeContext(capturedPath!, "")).toBe("");
-  });
-});

package/src/task-analysis/__tests__/extractors-llm-calls.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseTaskSource } from "../parser.js";
-import { extractLLMCalls } from "../extractors/llm-calls.js";
-
-describe("extractLLMCalls", () => {
-  it("detects direct llm.provider.method() access", () => {
-    const code = `export function s() { llm.deepseek.chat({}) }`;
-    const ast = parseTaskSource(code);
-    const calls = extractLLMCalls(ast);
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]).toMatchObject({ provider: "deepseek", method: "chat", stage: "s" });
-  });
-
-  it("detects variable-destructured pattern: const { provider } = llm", () => {
-    const code = `export function s() { const { openai } = llm; openai.gpt5({}) }`;
-    const ast = parseTaskSource(code);
-    const calls = extractLLMCalls(ast);
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]).toMatchObject({ provider: "openai", method: "gpt5", stage: "s" });
-  });
-
-  it("detects parameter-destructured pattern: ({ llm: { provider } })", () => {
-    const code = `export function s({ llm: { anthropic } }) { anthropic.sonnet45({}) }`;
-    const ast = parseTaskSource(code);
-    const calls = extractLLMCalls(ast);
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]).toMatchObject({ provider: "anthropic", method: "sonnet45", stage: "s" });
-  });
-
-  it("does not produce a ModelCall for a same-named identifier in a different scope", () => {
-    const code = `const deepseek = {}; deepseek.chat({})`;
-    const ast = parseTaskSource(code);
-    const calls = extractLLMCalls(ast);
-
-    expect(calls).toHaveLength(0);
-  });
-
-  it("throws when llm.provider.method() is outside an exported function", () => {
-    const code = `function internal() { llm.openai.chat({}) }`;
-    const ast = parseTaskSource(code);
-    expect(() => extractLLMCalls(ast)).toThrow();
-  });
-});

package/src/task-analysis/__tests__/extractors-stages.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseTaskSource } from "../parser.js";
-import { extractStages } from "../extractors/stages.js";
-
-describe("extractStages", () => {
-  it("extracts async and non-async function declaration exports with correct order", () => {
-    const code = `
-export async function ingestion() {}
-export function parsing() {}
-    `.trim();
-    const ast = parseTaskSource(code);
-    const stages = extractStages(ast);
-
-    expect(stages).toHaveLength(2);
-
-    const ingestion = stages.find((s) => s.name === "ingestion");
-    const parsing = stages.find((s) => s.name === "parsing");
-
-    expect(ingestion).toBeDefined();
-    expect(ingestion?.isAsync).toBe(true);
-
-    expect(parsing).toBeDefined();
-    expect(parsing?.isAsync).toBe(false);
-
-    // ascending order: ingestion comes before parsing
-    const ingestionIdx = stages.indexOf(ingestion!);
-    const parsingIdx = stages.indexOf(parsing!);
-    expect(ingestionIdx).toBeLessThan(parsingIdx);
-  });
-
-  it("detects async arrow function export as an async stage", () => {
-    const code = `export const refine = async () => {}`;
-    const ast = parseTaskSource(code);
-    const stages = extractStages(ast);
-
-    expect(stages).toHaveLength(1);
-    expect(stages[0]?.name).toBe("refine");
-    expect(stages[0]?.isAsync).toBe(true);
-  });
-
-  it("returns empty array when there are no exports", () => {
-    const code = `function internal() {}`;
-    const ast = parseTaskSource(code);
-    expect(extractStages(ast)).toEqual([]);
-  });
-
-  it("ignores non-function exports", () => {
-    const code = `export const FOO = 42;`;
-    const ast = parseTaskSource(code);
-    expect(extractStages(ast)).toEqual([]);
-  });
-});

package/src/task-analysis/__tests__/index.test.ts

@@ -1,143 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { analyzeTask } from "../index.js";
-
-const TASK_CODE = `
-export async function ingestion({ io, llm }) {
-  const data = await io.readArtifact("raw-data.json");
-  await io.writeArtifact("ingested.json", data);
-  await llm.openai.complete({ prompt: "summarize" });
-}
-
-export function parsing({ io }) {
-  try {
-    const extra = io.readArtifact("optional.json");
-  } catch {}
-  const result = io.readArtifact("ingested.json");
-  io.writeArtifact("parsed.json", result);
-}
-
-export const transform = async ({ io, llm }) => {
-  const input = await io.readArtifact("parsed.json");
-  await llm.anthropic.chat({ prompt: "transform" });
-  await io.writeArtifact("transformed.json", input);
-};
-`.trim();
-
-describe("analyzeTask", () => {
-  it("returns null taskFilePath when not provided", () => {
-    const result = analyzeTask(TASK_CODE);
-    expect(result.taskFilePath).toBeNull();
-  });
-
-  it("returns null taskFilePath when explicitly passed null", () => {
-    const result = analyzeTask(TASK_CODE, null);
-    expect(result.taskFilePath).toBeNull();
-  });
-
-  it("returns provided taskFilePath", () => {
-    const result = analyzeTask(TASK_CODE, "/path/to/task.js");
-    expect(result.taskFilePath).toBe("/path/to/task.js");
-  });
-
-  it("extracts all stages in order", () => {
-    const result = analyzeTask(TASK_CODE);
-    expect(result.stages).toHaveLength(3);
-
-    const names = result.stages.map((s) => s.name);
-    expect(names).toEqual(["ingestion", "parsing", "transform"]);
-
-    expect(result.stages[0]?.isAsync).toBe(true);
-    expect(result.stages[1]?.isAsync).toBe(false);
-    expect(result.stages[2]?.isAsync).toBe(true);
-  });
-
-  it("extracts artifact reads", () => {
-    const result = analyzeTask(TASK_CODE);
-    const readNames = result.artifacts.reads.map((r) => r.fileName);
-    expect(readNames).toContain("raw-data.json");
-    expect(readNames).toContain("ingested.json");
-    expect(readNames).toContain("parsed.json");
-  });
-
-  it("marks reads inside try blocks as not required", () => {
-    const result = analyzeTask(TASK_CODE);
-    const optional = result.artifacts.reads.find(
-      (r) => r.fileName === "optional.json"
-    );
-    expect(optional).toBeDefined();
-    expect(optional?.required).toBe(false);
-  });
-
-  it("marks reads outside try blocks as required", () => {
-    const result = analyzeTask(TASK_CODE);
-    const required = result.artifacts.reads.filter((r) => r.required);
-    const names = required.map((r) => r.fileName);
-    expect(names).toContain("raw-data.json");
-    expect(names).toContain("ingested.json");
-    expect(names).toContain("parsed.json");
-  });
-
-  it("extracts artifact writes", () => {
-    const result = analyzeTask(TASK_CODE);
-    const writeNames = result.artifacts.writes.map((w) => w.fileName);
-    expect(writeNames).toContain("ingested.json");
-    expect(writeNames).toContain("parsed.json");
-    expect(writeNames).toContain("transformed.json");
-  });
-
-  it("assigns correct stage to reads and writes", () => {
-    const result = analyzeTask(TASK_CODE);
-    const rawRead = result.artifacts.reads.find(
-      (r) => r.fileName === "raw-data.json"
-    );
-    expect(rawRead?.stage).toBe("ingestion");
-
-    const transformedWrite = result.artifacts.writes.find(
-      (w) => w.fileName === "transformed.json"
-    );
-    expect(transformedWrite?.stage).toBe("transform");
-  });
-
-  it("extracts LLM calls with provider and method", () => {
-    const result = analyzeTask(TASK_CODE);
-    expect(result.models).toHaveLength(2);
-
-    const openaiCall = result.models.find((m) => m.provider === "openai");
-    expect(openaiCall).toBeDefined();
-    expect(openaiCall?.method).toBe("complete");
-    expect(openaiCall?.stage).toBe("ingestion");
-
-    const anthropicCall = result.models.find((m) => m.provider === "anthropic");
-    expect(anthropicCall).toBeDefined();
-    expect(anthropicCall?.method).toBe("chat");
-    expect(anthropicCall?.stage).toBe("transform");
-  });
-
-  it("has no unresolved reads or writes for static filenames", () => {
-    const result = analyzeTask(TASK_CODE);
-    expect(result.artifacts.unresolvedReads).toHaveLength(0);
-    expect(result.artifacts.unresolvedWrites).toHaveLength(0);
-  });
-
-  it("collects unresolved reads for dynamic filenames", () => {
-    const code = `
-export function stage({ io }) {
-  const name = getFileName();
-  io.readArtifact(name);
-}
-    `.trim();
-    const result = analyzeTask(code);
-    expect(result.artifacts.unresolvedReads).toHaveLength(1);
-    expect(result.artifacts.unresolvedReads[0]?.stage).toBe("stage");
-  });
-
-  it("propagates parse errors", () => {
-    expect(() => analyzeTask("export function {")).toThrow(Error);
-    try {
-      analyzeTask("export function {");
-    } catch (err) {
-      expect(err).toBeInstanceOf(Error);
-      expect((err as Error).message).toMatch(/line \d+, column \d+/);
-    }
-  });
-});

package/src/task-analysis/__tests__/parser.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseTaskSource } from "../parser.js";
-
-describe("parseTaskSource", () => {
-  it("parses valid ESM code and returns a File node with a body", () => {
-    const result = parseTaskSource("export function foo() {}");
-    expect(result.type).toBe("File");
-    expect(result.program.body.length).toBeGreaterThan(0);
-  });
-
-  it("parses valid JSX code without error", () => {
-    const result = parseTaskSource(
-      "export function Comp() { return <div /> }",
-    );
-    expect(result.type).toBe("File");
-  });
-
-  it("throws an Error with line/column info and cause on invalid code", () => {
-    expect(() => parseTaskSource("export function {")).toThrow(Error);
-    try {
-      parseTaskSource("export function {");
-    } catch (err) {
-      expect(err).toBeInstanceOf(Error);
-      const message = (err as Error).message;
-      expect(message).toMatch(/line \d+, column \d+/);
-      expect((err as Error).cause).toBeDefined();
-    }
-  });
-});
-
-describe("Babel import interop smoke test", () => {
-  it("@babel/traverse default import is a function", async () => {
-    const { default: traverse } = await import("@babel/traverse");
-    expect(typeof traverse).toBe("function");
-  });
-
-  it("@babel/generator default import is a function", async () => {
-    const { default: generate } = await import("@babel/generator");
-    expect(typeof generate).toBe("function");
-  });
-});

package/src/task-analysis/__tests__/utils-ast.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import type { NodePath } from "@babel/traverse";
-import type { CallExpression } from "@babel/types";
-import { isInsideTryCatch, getStageName } from "../utils/ast.js";
-
-function findReadArtifactPath(code: string): NodePath<CallExpression> | null {
-  const ast = parse(code, { sourceType: "module", plugins: ["jsx"] });
-  let captured: NodePath<CallExpression> | null = null;
-
-  traverse(ast, {
-    CallExpression(path) {
-      const callee = path.node.callee;
-      if (
-        callee.type === "MemberExpression" &&
-        callee.property.type === "Identifier" &&
-        callee.property.name === "readArtifact"
-      ) {
-        captured = path;
-      }
-    },
-  });
-
-  return captured;
-}
-
-describe("isInsideTryCatch", () => {
-  it("returns true when call is inside a try block", () => {
-    const code = `
-      export async function myStage() {
-        try {
-          io.readArtifact("x")
-        } catch(e) {}
-      }
-    `;
-    const path = findReadArtifactPath(code);
-    expect(path).not.toBeNull();
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(isInsideTryCatch(path!)).toBe(true);
-  });
-
-  it("returns false when call is outside a try block", () => {
-    const code = `
-      export async function myStage() {
-        io.readArtifact("x")
-      }
-    `;
-    const path = findReadArtifactPath(code);
-    expect(path).not.toBeNull();
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(isInsideTryCatch(path!)).toBe(false);
-  });
-});
-
-describe("getStageName", () => {
-  it("returns the stage name for a call inside an exported function", () => {
-    const code = `
-      export async function myStage() {
-        try {
-          io.readArtifact("x")
-        } catch(e) {}
-      }
-    `;
-    const path = findReadArtifactPath(code);
-    expect(path).not.toBeNull();
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(getStageName(path!)).toBe("myStage");
-  });
-
-  it("returns null when call is not inside an exported function", () => {
-    const code = `
-      async function notExported() {
-        io.readArtifact("x")
-      }
-    `;
-    const path = findReadArtifactPath(code);
-    expect(path).not.toBeNull();
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    expect(getStageName(path!)).toBeNull();
-  });
-});