@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

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();
-  });
-});

package/src/task-analysis/enrichers/analysis-writer.ts

@@ -1,75 +0,0 @@
-// ── src/task-analysis/enrichers/analysis-writer.ts ──
-// Persists TaskAnalysis to disk as JSON.
-
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import type { TaskAnalysis } from "../types.ts";
-
-function validate(analysisData: TaskAnalysis): void {
-  const { taskFilePath, stages, models, artifacts } = analysisData;
-
-  if (taskFilePath === null || taskFilePath === undefined || taskFilePath === "") {
-    throw new Error(
-      `Invalid taskFilePath: expected a non-null, non-empty string, got ${taskFilePath === "" ? "empty string" : String(taskFilePath)}`,
-    );
-  }
-
-  if (!Array.isArray(stages)) {
-    throw new Error(
-      `Invalid stages: expected an array, got ${typeof stages}`,
-    );
-  }
-
-  if (!Array.isArray(models)) {
-    throw new Error(
-      `Invalid models: expected an array, got ${typeof models}`,
-    );
-  }
-
-  if (
-    typeof artifacts !== "object" ||
-    artifacts === null ||
-    !Array.isArray(artifacts.reads) ||
-    !Array.isArray(artifacts.writes)
-  ) {
-    throw new Error(
-      `Invalid artifacts: expected an object with reads and writes arrays`,
-    );
-  }
-
-  if (
-    "unresolvedReads" in artifacts &&
-    !Array.isArray(artifacts.unresolvedReads)
-  ) {
-    throw new Error(
-      `Invalid artifacts.unresolvedReads: expected an array, got ${typeof artifacts.unresolvedReads}`,
-    );
-  }
-
-  if (
-    "unresolvedWrites" in artifacts &&
-    !Array.isArray(artifacts.unresolvedWrites)
-  ) {
-    throw new Error(
-      `Invalid artifacts.unresolvedWrites: expected an array, got ${typeof artifacts.unresolvedWrites}`,
-    );
-  }
-}
-
-export async function writeAnalysisFile(
-  pipelinePath: string,
-  taskName: string,
-  analysisData: TaskAnalysis,
-): Promise<void> {
-  validate(analysisData);
-
-  const analysisDir = path.join(pipelinePath, "analysis");
-  await mkdir(analysisDir, { recursive: true });
-
-  const data = { ...analysisData, analyzedAt: new Date().toISOString() };
-
-  await Bun.write(
-    path.join(analysisDir, `${taskName}.analysis.json`),
-    JSON.stringify(data, null, 2),
-  );
-}

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

@@ -1,89 +0,0 @@
-// ── src/task-analysis/enrichers/artifact-resolver.ts ──
-// LLM-powered resolution of dynamic artifact references.
-
-import { chat } from "../../llm/index.ts";
-import type { UnresolvedArtifactDescriptor, ArtifactResolution } from "../types.ts";
-
-const FALLBACK: ArtifactResolution = {
-  resolvedFileName: null,
-  confidence: 0,
-  reasoning: "Failed to analyze artifact reference",
-};
-
-function clampConfidence(value: unknown): number {
-  if (typeof value !== "number" || !isFinite(value)) return 0;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
-export async function resolveArtifactReference(
-  taskCode: string,
-  unresolvedArtifact: UnresolvedArtifactDescriptor,
-  availableArtifacts: string[],
-): Promise<ArtifactResolution> {
-  try {
-    const messages = [
-      {
-        role: "system" as const,
-        content:
-          "You are a code analysis expert. Given pipeline task source code, a dynamic artifact expression, and a list of available artifact filenames, determine which artifact filename the expression resolves to. Respond with a JSON object containing: resolvedFileName (string or null), confidence (number between 0 and 1), and reasoning (string).",
-      },
-      {
-        role: "user" as const,
-        content: `Analyze the following pipeline task source code and determine which artifact filename the dynamic expression resolves to.
-
-Task source code:
-\`\`\`
-${taskCode}
-\`\`\`
-
-Dynamic expression: ${unresolvedArtifact.expression}
-Code context: ${unresolvedArtifact.codeContext}
-Stage: ${unresolvedArtifact.stage}
-
-Available artifact filenames:
-${availableArtifacts.map((f) => `- ${f}`).join("\n")}
-
-Respond with a JSON object with these fields:
-- resolvedFileName: the matching filename from the available list, or null if you cannot determine it
-- confidence: a number between 0 and 1 indicating your confidence
-- reasoning: a string explaining your reasoning`,
-      },
-    ];
-
-    const response = await chat({
-      provider: "deepseek",
-      model: "deepseek-chat",
-      messages,
-      temperature: 0,
-      responseFormat: { type: "json_object" },
-    });
-
-    const { content } = response;
-
-    if (typeof content !== "object" || content === null) {
-      throw new Error(
-        `Unexpected gateway response: content must be a non-null object, got ${typeof content}`,
-      );
-    }
-
-    const { resolvedFileName, confidence, reasoning } = content as Record<string, unknown>;
-
-    let sanitizedFileName = typeof resolvedFileName === "string" ? resolvedFileName : null;
-    let sanitizedConfidence = clampConfidence(confidence);
-
-    if (sanitizedFileName !== null && !availableArtifacts.includes(sanitizedFileName)) {
-      sanitizedFileName = null;
-      sanitizedConfidence = 0;
-    }
-
-    return {
-      resolvedFileName: sanitizedFileName,
-      confidence: sanitizedConfidence,
-      reasoning: typeof reasoning === "string" ? reasoning : "",
-    };
-  } catch {
-    return FALLBACK;
-  }
-}

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

@@ -1,143 +0,0 @@
-import traverse from "@babel/traverse";
-import generate from "@babel/generator";
-import type { File as BabelFile } from "@babel/types";
-import type { NodePath } from "@babel/traverse";
-import type {
-  ArtifactRead,
-  ArtifactWrite,
-  UnresolvedRead,
-  UnresolvedWrite,
-} from "../types.ts";
-import { getStageName, isInsideTryCatch } from "../utils/ast.ts";
-
-export function extractCodeContext(
-  path: NodePath,
-  sourceCode: string
-): string {
-  if (!sourceCode || !path.node.loc) return "";
-  const lines = sourceCode.split("\n");
-  const line = path.node.loc.start.line - 1; // convert to 0-based
-  const start = Math.max(0, line - 2);
-  const end = Math.min(lines.length, line + 3);
-  return lines.slice(start, end).join("\n");
-}
-
-function resolveFileName(
-  argNode: import("@babel/types").Expression | import("@babel/types").SpreadElement
-): string | null {
-  if (argNode.type === "StringLiteral") {
-    return argNode.value;
-  }
-  if (argNode.type === "TemplateLiteral") {
-    if (argNode.expressions.length === 0) {
-      return argNode.quasis.map((q) => q.value.cooked ?? "").join("");
-    }
-    // Template with expressions: generate source text, strip backticks
-    const src = generate(argNode).code;
-    return src.replace(/^`|`$/g, "");
-  }
-  return null;
-}
-
-export function extractArtifactReads(
-  ast: BabelFile,
-  sourceCode?: string
-): { reads: ArtifactRead[]; unresolvedReads: UnresolvedRead[] } {
-  const reads: ArtifactRead[] = [];
-  const unresolvedReads: UnresolvedRead[] = [];
-
-  traverse(ast, {
-    CallExpression(path) {
-      const { callee } = path.node;
-      if (
-        callee.type !== "MemberExpression" ||
-        callee.object.type !== "Identifier" ||
-        callee.object.name !== "io" ||
-        callee.property.type !== "Identifier" ||
-        callee.property.name !== "readArtifact"
-      )
-        return;
-
-      const stage = getStageName(path);
-      if (stage === null) {
-        const loc = path.node.loc;
-        throw new Error(
-          `io.readArtifact call at line ${loc?.start.line ?? "unknown"}, column ${loc?.start.column ?? "unknown"} is not inside an exported function`
-        );
-      }
-
-      const arg = path.node.arguments[0];
-      if (!arg || arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") return;
-
-      const required = !isInsideTryCatch(path);
-      const fileName = resolveFileName(arg);
-
-      if (fileName !== null) {
-        reads.push({ fileName, stage, required });
-      } else {
-        const expression = generate(arg).code;
-        const codeContext = sourceCode
-          ? extractCodeContext(path, sourceCode)
-          : "";
-        const location = {
-          line: arg.loc?.start.line ?? 0,
-          column: arg.loc?.start.column ?? 0,
-        };
-        unresolvedReads.push({ expression, codeContext, stage, required, location });
-      }
-    },
-  });
-
-  return { reads, unresolvedReads };
-}
-
-export function extractArtifactWrites(
-  ast: BabelFile,
-  sourceCode?: string
-): { writes: ArtifactWrite[]; unresolvedWrites: UnresolvedWrite[] } {
-  const writes: ArtifactWrite[] = [];
-  const unresolvedWrites: UnresolvedWrite[] = [];
-
-  traverse(ast, {
-    CallExpression(path) {
-      const { callee } = path.node;
-      if (
-        callee.type !== "MemberExpression" ||
-        callee.object.type !== "Identifier" ||
-        callee.object.name !== "io" ||
-        callee.property.type !== "Identifier" ||
-        callee.property.name !== "writeArtifact"
-      )
-        return;
-
-      const stage = getStageName(path);
-      if (stage === null) {
-        const loc = path.node.loc;
-        throw new Error(
-          `io.writeArtifact call at line ${loc?.start.line ?? "unknown"}, column ${loc?.start.column ?? "unknown"} is not inside an exported function`
-        );
-      }
-
-      const arg = path.node.arguments[0];
-      if (!arg || arg.type === "SpreadElement" || arg.type === "ArgumentPlaceholder") return;
-
-      const fileName = resolveFileName(arg);
-
-      if (fileName !== null) {
-        writes.push({ fileName, stage });
-      } else {
-        const expression = generate(arg).code;
-        const codeContext = sourceCode
-          ? extractCodeContext(path, sourceCode)
-          : "";
-        const location = {
-          line: arg.loc?.start.line ?? 0,
-          column: arg.loc?.start.column ?? 0,
-        };
-        unresolvedWrites.push({ expression, codeContext, stage, location });
-      }
-    },
-  });
-
-  return { writes, unresolvedWrites };
-}

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

@@ -1,117 +0,0 @@
-import traverse from "@babel/traverse";
-import type { NodePath } from "@babel/traverse";
-import type { File as BabelFile } from "@babel/types";
-import type { ModelCall } from "../types.ts";
-import { getStageName } from "../utils/ast.ts";
-
-function isLLMDirectAccess(
-  path: NodePath
-): { provider: string; method: string } | null {
-  const { node } = path;
-  if (node.type !== "CallExpression") return null;
-  const { callee } = node;
-  if (callee.type !== "MemberExpression") return null;
-  if (callee.property.type !== "Identifier") return null;
-
-  const method = callee.property.name;
-  const obj = callee.object;
-  if (obj.type !== "MemberExpression") return null;
-  if (obj.object.type !== "Identifier") return null;
-  if (obj.object.name !== "llm") return null;
-  if (obj.property.type !== "Identifier") return null;
-
-  return { provider: obj.property.name, method };
-}
-
-function isLLMDestructuredAccess(
-  path: NodePath
-): { provider: string; method: string } | null {
-  const { node } = path;
-  if (node.type !== "CallExpression") return null;
-  const { callee } = node;
-  if (callee.type !== "MemberExpression") return null;
-  if (callee.object.type !== "Identifier") return null;
-  if (callee.property.type !== "Identifier") return null;
-
-  const identName = callee.object.name;
-  const method = callee.property.name;
-
-  const binding = path.scope.getBinding(identName);
-  if (!binding) return null;
-
-  const bindingPath = binding.path;
-
-  // Pattern 2: const { provider } = llm;
-  if (bindingPath.node.type === "VariableDeclarator") {
-    const { id, init } = bindingPath.node;
-    if (
-      init?.type === "Identifier" &&
-      init.name === "llm" &&
-      id.type === "ObjectPattern"
-    ) {
-      return { provider: identName, method };
-    }
-    return null;
-  }
-
-  // Pattern 3: ({ llm: { provider } }) => ...
-  // Babel registers the binding for the destructured identifier at the outer
-  // ObjectPattern level (the whole param pattern). We check that the outer
-  // ObjectPattern has a property keyed "llm" whose value is an ObjectPattern
-  // containing the identifier, and that the parent is a function node.
-  if (bindingPath.node.type === "ObjectPattern") {
-    const parentNode = bindingPath.parentPath?.node;
-    const isParam =
-      parentNode?.type === "FunctionDeclaration" ||
-      parentNode?.type === "FunctionExpression" ||
-      parentNode?.type === "ArrowFunctionExpression";
-    if (!isParam) return null;
-
-    const outerPattern = bindingPath.node;
-    for (const prop of outerPattern.properties) {
-      if (
-        prop.type === "ObjectProperty" &&
-        prop.key.type === "Identifier" &&
-        prop.key.name === "llm" &&
-        prop.value.type === "ObjectPattern"
-      ) {
-        const innerPattern = prop.value;
-        const hasIdent = innerPattern.properties.some(
-          (p) =>
-            p.type === "ObjectProperty" &&
-            p.key.type === "Identifier" &&
-            p.key.name === identName
-        );
-        if (hasIdent) return { provider: identName, method };
-      }
-    }
-    return null;
-  }
-
-  return null;
-}
-
-export function extractLLMCalls(ast: BabelFile): ModelCall[] {
-  const calls: ModelCall[] = [];
-
-  traverse(ast, {
-    CallExpression(path) {
-      const direct = isLLMDirectAccess(path);
-      const destructured = direct === null ? isLLMDestructuredAccess(path) : null;
-      const match = direct ?? destructured;
-      if (!match) return;
-
-      const stage = getStageName(path);
-      if (stage === null) {
-        const loc = path.node.loc;
-        throw new Error(
-          `LLM call at line ${loc?.start.line ?? "unknown"}, column ${loc?.start.column ?? "unknown"} is not inside an exported function`
-        );
-      }
-
-      calls.push({ provider: match.provider, method: match.method, stage });
-    },
-  });
-
-  return calls;
-}