@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

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

@@ -1,45 +0,0 @@
-import traverse from "@babel/traverse";
-import type { File as BabelFile } from "@babel/types";
-import type { Stage } from "../types.ts";
-
-export function extractStages(ast: BabelFile): Stage[] {
-  const stages: Stage[] = [];
-
-  traverse(ast, {
-    ExportNamedDeclaration(path) {
-      const { declaration } = path.node;
-      if (declaration == null) return;
-
-      if (declaration.type === "FunctionDeclaration") {
-        const name = declaration.id?.name;
-        if (name == null) return;
-        stages.push({
-          name,
-          order: path.node.loc?.start.line ?? 0,
-          isAsync: declaration.async ?? false,
-        });
-        return;
-      }
-
-      if (declaration.type === "VariableDeclaration") {
-        const declarator = declaration.declarations[0];
-        if (declarator == null) return;
-        if (declarator.id.type !== "Identifier") return;
-        const init = declarator.init;
-        if (
-          init == null ||
-          (init.type !== "ArrowFunctionExpression" &&
-            init.type !== "FunctionExpression")
-        )
-          return;
-        stages.push({
-          name: declarator.id.name,
-          order: path.node.loc?.start.line ?? 0,
-          isAsync: init.async ?? false,
-        });
-      }
-    },
-  });
-
-  return stages.sort((a, b) => a.order - b.order);
-}

package/src/task-analysis/parser.ts

@@ -1,20 +0,0 @@
-import { parse } from "@babel/parser";
-import type { File as BabelFile } from "@babel/types";
-
-export function parseTaskSource(code: string): BabelFile {
-  try {
-    return parse(code, { sourceType: "module", plugins: ["jsx"] });
-  } catch (err) {
-    const loc =
-      err != null &&
-      typeof err === "object" &&
-      "loc" in err &&
-      err.loc != null &&
-      typeof err.loc === "object" &&
-      "line" in err.loc &&
-      "column" in err.loc
-        ? `line ${err.loc.line}, column ${err.loc.column}`
-        : "unknown location";
-    throw new Error(`Syntax error at ${loc}`, { cause: err });
-  }
-}

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

@@ -1,45 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type {
-  TryStatement,
-  ExportNamedDeclaration,
-  FunctionDeclaration,
-  VariableDeclaration,
-} from "@babel/types";
-
-export function isInsideTryCatch(path: NodePath): boolean {
-  let current: NodePath | null = path.parentPath;
-  while (current !== null) {
-    if (current.isTryStatement()) {
-      const tryNode = current.node as TryStatement;
-      const blockPath = current.get("block") as NodePath;
-      if (blockPath.node === tryNode.block) {
-        return true;
-      }
-    }
-    current = current.parentPath;
-  }
-  return false;
-}
-
-export function getStageName(path: NodePath): string | null {
-  let current: NodePath | null = path.parentPath;
-  while (current !== null) {
-    if (current.isExportNamedDeclaration()) {
-      const node = current.node as ExportNamedDeclaration;
-      const decl = node.declaration;
-      if (decl === null || decl === undefined) return null;
-      if (decl.type === "FunctionDeclaration") {
-        return (decl as FunctionDeclaration).id?.name ?? null;
-      }
-      if (decl.type === "VariableDeclaration") {
-        const declarator = (decl as VariableDeclaration).declarations[0];
-        if (declarator?.id.type === "Identifier") {
-          return declarator.id.name;
-        }
-      }
-      return null;
-    }
-    current = current.parentPath;
-  }
-  return null;
-}