@ryanfw/prompt-orchestration-pipeline 0.15.0 → 0.16.0

package/src/pages/PromptPipelineDashboard.jsx

@@ -105,21 +105,36 @@ export default function PromptPipelineDashboard() {
     }
   };
 
-  // Header actions for Layout
-  const headerActions = runningJobs.length > 0 && (
-    <Flex align="center" gap="2" className="text-gray-11">
-      <Text size="1" weight="medium">
-        Overall Progress
-      </Text>
-      <Progress value={aggregateProgress} className="w-20" />
-      <Text size="1" className="text-gray-9">
-        {aggregateProgress}%
-      </Text>
-    </Flex>
-  );
+  const progressBanner =
+    runningJobs.length > 0 ? (
+      <Box
+        role="status"
+        aria-live="polite"
+        className="bg-blue-50 border-b border-blue-200"
+      >
+        <Flex
+          align="center"
+          gap="4"
+          className="mx-auto w-full max-w-7xl px-4 sm:px-6 lg:px-8 py-3"
+        >
+          <Text size="2">
+            {runningJobs.length} job{runningJobs.length !== 1 ? "s" : ""}{" "}
+            running
+          </Text>
+          <Progress
+            value={aggregateProgress}
+            variant="running"
+            className="flex-1"
+          />
+          <Text size="2" weight="medium">
+            {aggregateProgress}%
+          </Text>
+        </Flex>
+      </Box>
+    ) : null;
 
   return (
-    <Layout title="Prompt Pipeline" actions={headerActions}>
+    <Layout title="Prompt Pipeline" subheader={progressBanner}>
       {error && (
         <Box className="mb-4 rounded-md bg-yellow-50 p-3 border border-yellow-200">
           <Text size="2" className="text-yellow-800">

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

@@ -41,6 +41,38 @@ export async function writeAnalysisFile(pipelinePath, taskName, analysisData) {
     );
   }
 
+  // Validate artifacts.reads and artifacts.writes are arrays
+  if (!Array.isArray(analysisData.artifacts.reads)) {
+    throw new Error(
+      `Invalid analysisData.artifacts.reads: expected an array but got ${typeof analysisData.artifacts.reads}`
+    );
+  }
+
+  if (!Array.isArray(analysisData.artifacts.writes)) {
+    throw new Error(
+      `Invalid analysisData.artifacts.writes: expected an array but got ${typeof analysisData.artifacts.writes}`
+    );
+  }
+
+  // Validate unresolvedReads and unresolvedWrites if present (must be arrays)
+  if (
+    analysisData.artifacts.unresolvedReads !== undefined &&
+    !Array.isArray(analysisData.artifacts.unresolvedReads)
+  ) {
+    throw new Error(
+      `Invalid analysisData.artifacts.unresolvedReads: expected an array but got ${typeof analysisData.artifacts.unresolvedReads}`
+    );
+  }
+
+  if (
+    analysisData.artifacts.unresolvedWrites !== undefined &&
+    !Array.isArray(analysisData.artifacts.unresolvedWrites)
+  ) {
+    throw new Error(
+      `Invalid analysisData.artifacts.unresolvedWrites: expected an array but got ${typeof analysisData.artifacts.unresolvedWrites}`
+    );
+  }
+
   if (!Array.isArray(analysisData.models)) {
     throw new Error(
       `Invalid analysisData.models: expected an array but got ${typeof analysisData.models}`

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

@@ -0,0 +1,98 @@
+import { chat } from "../../llm/index.js";
+
+const SYSTEM_PROMPT = `You are an expert code analyzer. Your task is to match a dynamic artifact reference in JavaScript code to one of the known artifact filenames.
+
+Given:
+1. The full task source code
+2. A dynamic expression used as an argument to io.readArtifact() or io.writeArtifact()
+3. The surrounding code context
+4. A list of available artifact filenames
+
+Analyze the code to determine what the dynamic expression likely evaluates to, then match it against the available artifacts.
+
+Return your response as JSON with this structure:
+{
+  "resolvedFileName": "matched-artifact.json" or null if no match,
+  "confidence": 0.0 to 1.0,
+  "reasoning": "Brief explanation of your analysis"
+}
+
+Guidelines:
+- Look at variable assignments, function return values, and naming patterns
+- Consider the stage name and surrounding context for clues
+- Return confidence 0 if no reasonable match exists
+- Only return high confidence (>=0.7) when there's strong evidence
+- If multiple artifacts could match, choose the most likely one but reduce confidence`;
+
+/**
+ * Resolve a dynamic artifact reference using LLM analysis.
+ *
+ * @param {string} taskCode - The full task source code
+ * @param {object} unresolvedArtifact - The unresolved artifact reference
+ * @param {string} unresolvedArtifact.expression - The dynamic expression code
+ * @param {string} unresolvedArtifact.codeContext - Surrounding code context
+ * @param {string} unresolvedArtifact.stage - Stage name where the call occurs
+ * @param {string[]} availableArtifacts - List of known artifact filenames
+ * @returns {Promise<{resolvedFileName: string|null, confidence: number, reasoning: string}>}
+ */
+export async function resolveArtifactReference(
+  taskCode,
+  unresolvedArtifact,
+  availableArtifacts
+) {
+  const { expression, codeContext, stage } = unresolvedArtifact;
+
+  const userPrompt = `Task source code:
+\`\`\`javascript
+${taskCode}
+\`\`\`
+
+Dynamic expression: ${expression}
+Stage: ${stage}
+Code context:
+\`\`\`javascript
+${codeContext}
+\`\`\`
+
+Available artifact filenames:
+${availableArtifacts.map((a) => `- ${a}`).join("\n")}
+
+Analyze the code and determine which artifact this expression likely refers to.`;
+
+  try {
+    const response = await chat({
+      provider: "deepseek",
+      messages: [
+        { role: "system", content: SYSTEM_PROMPT },
+        { role: "user", content: userPrompt },
+      ],
+      temperature: 0,
+      responseFormat: "json_object",
+    });
+
+    const parsed = JSON.parse(response.content);
+
+    const rawResolvedFileName =
+      typeof parsed.resolvedFileName === "string" ? parsed.resolvedFileName : null;
+    const resolvedFileName =
+      rawResolvedFileName && availableArtifacts.includes(rawResolvedFileName)
+        ? rawResolvedFileName
+        : null;
+
+    const rawConfidence =
+      typeof parsed.confidence === "number" ? parsed.confidence : 0;
+    const confidence = resolvedFileName === null ? 0 : rawConfidence;
+
+    return {
+      resolvedFileName,
+      confidence,
+      reasoning: parsed.reasoning ?? "",
+    };
+  } catch {
+    return {
+      resolvedFileName: null,
+      confidence: 0,
+      reasoning: "Failed to analyze artifact reference",
+    };
+  }
+}

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

@@ -7,15 +7,39 @@ const generate =
 import * as t from "@babel/types";
 import { isInsideTryCatch, getStageName } from "../utils/ast.js";
 
+/**
+ * Extract surrounding code context for a node.
+ *
+ * @param {import("@babel/traverse").NodePath} path - The Babel path
+ * @param {string} sourceCode - The original source code
+ * @returns {string} Up to 5 lines of surrounding context (2 lines before and 2 lines after the target line)
+ */
+export function extractCodeContext(path, sourceCode) {
+  if (!sourceCode || !path.node.loc) {
+    return "";
+  }
+
+  const lines = sourceCode.split("\n");
+  const nodeLine = path.node.loc.start.line;
+
+  // Get 2 lines before and 2 lines after (5 lines total, 1-indexed)
+  const startLine = Math.max(1, nodeLine - 2);
+  const endLine = Math.min(lines.length, nodeLine + 2);
+
+  return lines.slice(startLine - 1, endLine).join("\n");
+}
+
 /**
  * Extract io.readArtifact calls from the AST.
  *
  * @param {import("@babel/types").File} ast - The AST to analyze
- * @returns {Array<{fileName: string, stage: string, required: boolean}>} Array of artifact read references
+ * @param {string} [sourceCode] - The original source code (for extracting context)
+ * @returns {{reads: Array<{fileName: string, stage: string, required: boolean}>, unresolvedReads: Array<{expression: string, codeContext: string, stage: string, required: boolean, location: {line: number, column: number}}>}} Artifact read references
  * @throws {Error} If io.readArtifact call is found outside an exported function
  */
-export function extractArtifactReads(ast) {
+export function extractArtifactReads(ast, sourceCode) {
   const reads = [];
+  const unresolvedReads = [];
 
   traverse(ast, {
     CallExpression(path) {
@@ -27,15 +51,6 @@ export function extractArtifactReads(ast) {
         t.isIdentifier(callee.object, { name: "io" }) &&
         t.isIdentifier(callee.property, { name: "readArtifact" })
       ) {
-        // Extract fileName from first argument
-        const fileName = extractFileName(path.node.arguments[0]);
-
-        if (!fileName) {
-          throw new Error(
-            `io.readArtifact requires a string literal or template literal argument at ${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`
-          );
-        }
-
         // Get the stage name (must be in an exported function)
         const stage = getStageName(path);
 
@@ -48,23 +63,46 @@ export function extractArtifactReads(ast) {
         // Check if inside try/catch to determine if required
         const required = !isInsideTryCatch(path);
 
-        reads.push({ fileName, stage, required });
+        // Extract fileName from first argument
+        const fileName = extractFileName(path.node.arguments[0]);
+
+        if (fileName) {
+          reads.push({ fileName, stage, required });
+        } else if (path.node.arguments[0]) {
+          // Capture unresolved reference
+          const argNode = path.node.arguments[0];
+          const expression = generate(argNode, { concise: true }).code;
+          const codeContext = extractCodeContext(path, sourceCode);
+          const location = {
+            line: argNode.loc?.start?.line ?? 0,
+            column: argNode.loc?.start?.column ?? 0,
+          };
+          unresolvedReads.push({
+            expression,
+            codeContext,
+            stage,
+            required,
+            location,
+          });
+        }
       }
     },
   });
 
-  return reads;
+  return { reads, unresolvedReads };
 }
 
 /**
  * Extract io.writeArtifact calls from the AST.
  *
  * @param {import("@babel/types").File} ast - The AST to analyze
- * @returns {Array<{fileName: string, stage: string}>} Array of artifact write references
+ * @param {string} [sourceCode] - The original source code (for extracting context)
+ * @returns {{writes: Array<{fileName: string, stage: string}>, unresolvedWrites: Array<{expression: string, codeContext: string, stage: string, location: {line: number, column: number}}>}} Artifact write references
  * @throws {Error} If io.writeArtifact call is found outside an exported function
  */
-export function extractArtifactWrites(ast) {
+export function extractArtifactWrites(ast, sourceCode) {
   const writes = [];
+  const unresolvedWrites = [];
 
   traverse(ast, {
     CallExpression(path) {
@@ -76,15 +114,6 @@ export function extractArtifactWrites(ast) {
         t.isIdentifier(callee.object, { name: "io" }) &&
         t.isIdentifier(callee.property, { name: "writeArtifact" })
       ) {
-        // Extract fileName from first argument
-        const fileName = extractFileName(path.node.arguments[0]);
-
-        if (!fileName) {
-          throw new Error(
-            `io.writeArtifact requires a string literal or template literal argument at ${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`
-          );
-        }
-
         // Get the stage name (must be in an exported function)
         const stage = getStageName(path);
 
@@ -94,12 +123,27 @@ export function extractArtifactWrites(ast) {
           );
         }
 
-        writes.push({ fileName, stage });
+        // Extract fileName from first argument
+        const fileName = extractFileName(path.node.arguments[0]);
+
+        if (fileName) {
+          writes.push({ fileName, stage });
+        } else if (path.node.arguments[0]) {
+          // Capture unresolved reference
+          const argNode = path.node.arguments[0];
+          const expression = generate(argNode, { concise: true }).code;
+          const codeContext = extractCodeContext(path, sourceCode);
+          const location = {
+            line: argNode.loc?.start?.line ?? 0,
+            column: argNode.loc?.start?.column ?? 0,
+          };
+          unresolvedWrites.push({ expression, codeContext, stage, location });
+        }
       }
     },
   });
 
-  return writes;
+  return { writes, unresolvedWrites };
 }
 
 /**

package/src/task-analysis/index.js

@@ -49,8 +49,8 @@ export function analyzeTask(code, taskFilePath = null) {
 
   // Extract all metadata from the AST
   const stages = extractStages(ast);
-  const reads = extractArtifactReads(ast);
-  const writes = extractArtifactWrites(ast);
+  const { reads, unresolvedReads } = extractArtifactReads(ast, code);
+  const { writes, unresolvedWrites } = extractArtifactWrites(ast, code);
   const models = extractLLMCalls(ast);
 
   // Compose into the TaskAnalysis object
@@ -60,6 +60,8 @@ export function analyzeTask(code, taskFilePath = null) {
     artifacts: {
       reads,
       writes,
+      unresolvedReads,
+      unresolvedWrites,
     },
     models,
   };