@ryanfw/prompt-orchestration-pipeline 0.16.0 → 0.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server.js",
@@ -45,6 +45,7 @@
     "@radix-ui/react-tooltip": "^1.2.8",
     "@radix-ui/themes": "^3.2.1",
     "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
     "better-sqlite3": "^11.7.0",
     "chokidar": "^3.5.3",
     "commander": "^14.0.2",

package/src/api/validators/json.js

@@ -1,6 +1,8 @@
 import Ajv from "ajv";
+import addFormats from "ajv-formats";
 
-const ajv = new Ajv({ allErrors: true, strict: false });
+const ajv = new Ajv({ allErrors: true, strict: false, strictFormats: false });
+addFormats(ajv);
 
 export const validateWithSchema = (schema, data) => {
   let parsedData = data;

package/src/core/validation.js

@@ -1,7 +1,9 @@
 import Ajv from "ajv";
+import addFormats from "ajv-formats";
 import { getConfig } from "./config.js";
 
-const ajv = new Ajv({ allErrors: true });
+const ajv = new Ajv({ allErrors: true, strictFormats: false });
+addFormats(ajv);
 
 // JSON schema for seed file structure - uses config for validation rules
 function getSeedSchema() {

package/src/providers/base.js

@@ -35,7 +35,7 @@ export async function sleep(ms) {
 
 /**
  * Strip markdown code fences from text unconditionally.
- * Handles ```json, ```JSON, and plain ``` with or without newlines.
+ * Handles any language identifier (```json, ```javascript, etc.) or plain ```.
  * @param {string} text - The text to strip fences from
  * @returns {string} The cleaned text, or original if not a string
  */
@@ -43,8 +43,8 @@ export function stripMarkdownFences(text) {
   if (typeof text !== "string") return text;
   const trimmed = text.trim();
   if (trimmed.startsWith("```")) {
-    // Remove opening fence (```json, ```JSON, or just ```)
-    let cleaned = trimmed.replace(/^```(?:json|JSON)?\s*\n?/, "");
+    // Remove opening fence with any language identifier
+    let cleaned = trimmed.replace(/^```[a-zA-Z]*\s*\n?/, "");
     // Remove closing fence
     cleaned = cleaned.replace(/\n?```\s*$/, "");
     return cleaned.trim();

package/src/task-analysis/enrichers/schema-deducer.js

@@ -1,7 +1,9 @@
 import { chat } from "../../llm/index.js";
 import Ajv from "ajv";
+import addFormats from "ajv-formats";
 
-const ajv = new Ajv();
+const ajv = new Ajv({ strictFormats: false });
+addFormats(ajv);
 
 /**
  * Deduce JSON schema for an artifact using LLM with structured output.
@@ -52,6 +54,10 @@ export async function deduceArtifactSchema(taskCode, artifact) {
   }
 
   // Validate the generated example against the generated schema
+  // Remove any existing schema with the same $id to avoid "schema already exists" error
+  if (schema.$id && ajv.getSchema(schema.$id)) {
+    ajv.removeSchema(schema.$id);
+  }
   const validate = ajv.compile(schema);
   if (!validate(example)) {
     throw new Error(

package/src/ui/endpoints/task-creation-endpoint.js

@@ -1,6 +1,11 @@
 import fs from "node:fs";
 import { streamSSE } from "../lib/sse.js";
 import { createHighLevelLLM } from "../../llm/index.js";
+import { parseMentions } from "../lib/mention-parser.js";
+import {
+  loadSchemaContext,
+  buildSchemaPromptSection,
+} from "../lib/schema-loader.js";
 
 export async function handleTaskPlan(req, res) {
   console.log("[task-creation-endpoint] Request received");
@@ -36,10 +41,31 @@ export async function handleTaskPlan(req, res) {
     guidelines.length
   );
 
+  // Parse @mentions and load schema contexts for enrichment
+  const mentionedFiles = parseMentions(messages);
+  const schemaContexts = [];
+  // Load schema contexts sequentially to avoid unbounded concurrent file I/O
+  for (const fileName of mentionedFiles) {
+    // eslint-disable-next-line no-await-in-loop
+    const context = await loadSchemaContext(pipelineSlug, fileName);
+    if (context) {
+      schemaContexts.push(context);
+    }
+  }
+  const schemaEnrichment = buildSchemaPromptSection(schemaContexts);
+
+  if (schemaEnrichment) {
+    console.log(
+      "[task-creation-endpoint] Schema enrichment added for:",
+      mentionedFiles
+    );
+  }
+
   // Build LLM messages array
   const systemPrompt = `You are a pipeline task assistant. Help users create task definitions following these guidelines:
 
 ${guidelines}
+${schemaEnrichment ? `\n${schemaEnrichment}\n` : ""}
 
 Provide complete, working code. Use markdown code blocks.
 

package/src/ui/endpoints/task-save-endpoint.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { getConfig } from "../../core/config.js";
 import { sendJson } from "../utils/http-utils.js";
+import { reviewAndCorrectTask } from "../lib/task-reviewer.js";
 
 /**
  * Handle task creation requests
@@ -52,7 +53,24 @@ export async function handleTaskSave(req, res) {
     if (!taskFilePath.startsWith(tasksDir)) {
       return sendJson(res, 400, { error: "Invalid filename" });
     }
-    await fs.writeFile(taskFilePath, code, "utf8");
+
+    // Self-correct code before saving
+    let finalCode = code;
+    try {
+      const guidelinesPath = path.join(
+        rootDir,
+        "docs/pipeline-task-guidelines.md"
+      );
+      const guidelines = await fs.readFile(guidelinesPath, "utf8");
+      finalCode = await reviewAndCorrectTask(code, guidelines);
+    } catch (reviewError) {
+      console.warn(
+        "Task review failed, using original code:",
+        reviewError.message
+      );
+    }
+
+    await fs.writeFile(taskFilePath, finalCode, "utf8");
 
     // Update index.js to export new task
     const indexPath = taskRegistryPath;

package/src/ui/lib/mention-parser.js

@@ -0,0 +1,24 @@
+/**
+ * Parse @[display](id) mentions from chat messages.
+ * Used to extract referenced artifact files for schema enrichment.
+ */
+
+const MENTION_REGEX = /@\[([^\]]+)\]\(([^)]+)\)/g;
+
+/**
+ * Extract unique filenames from @mentions in messages.
+ * @param {Array<{ role: string, content: string }>} messages
+ * @returns {string[]} Array of unique filenames
+ */
+export function parseMentions(messages) {
+  const filenames = new Set();
+
+  for (const msg of messages) {
+    if (!msg.content) continue;
+    for (const match of msg.content.matchAll(MENTION_REGEX)) {
+      filenames.add(match[2]);
+    }
+  }
+
+  return [...filenames];
+}

package/src/ui/lib/schema-loader.js

@@ -0,0 +1,69 @@
+/**
+ * Schema loader utility for task creation prompt enrichment.
+ * Loads JSON Schema, sample data, and metadata for referenced artifact files.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { getPipelineConfig } from "../../core/config.js";
+
+/**
+ * Load schema context for a referenced artifact file.
+ * @param {string} pipelineSlug - Pipeline identifier
+ * @param {string} fileName - Artifact filename (e.g., "analysis-output.json")
+ * @returns {Promise<{ fileName: string, schema: object, sample: object, meta?: object } | null>}
+ */
+export async function loadSchemaContext(pipelineSlug, fileName) {
+  try {
+    const pipelineConfig = getPipelineConfig(pipelineSlug);
+    const pipelineDir = path.dirname(pipelineConfig.pipelineJsonPath);
+    const baseName = path.parse(fileName).name;
+    const schemasDir = path.join(pipelineDir, "schemas");
+
+    const schemaPath = path.join(schemasDir, `${baseName}.schema.json`);
+    const samplePath = path.join(schemasDir, `${baseName}.sample.json`);
+    const metaPath = path.join(schemasDir, `${baseName}.meta.json`);
+
+    // Schema is required - return null if missing
+    const schemaContent = await fs.readFile(schemaPath, "utf8");
+    const schema = JSON.parse(schemaContent);
+
+    // Sample is required - return null if missing
+    const sampleContent = await fs.readFile(samplePath, "utf8");
+    const sample = JSON.parse(sampleContent);
+
+    // Meta is optional
+    let meta;
+    try {
+      const metaContent = await fs.readFile(metaPath, "utf8");
+      meta = JSON.parse(metaContent);
+    } catch {
+      // Meta file missing or invalid - that's fine
+    }
+
+    return { fileName, schema, sample, meta };
+  } catch {
+    // Any error (pipeline not found, file missing, JSON parse error) -> return null
+    return null;
+  }
+}
+
+/**
+ * Build markdown prompt section from schema contexts.
+ * @param {Array<{ fileName: string, schema: object, sample: object, meta?: object }>} contexts
+ * @returns {string} Markdown formatted section for system prompt
+ */
+export function buildSchemaPromptSection(contexts) {
+  if (!contexts || contexts.length === 0) {
+    return "";
+  }
+
+  const sections = contexts.map((ctx) => {
+    let section = `### @${ctx.fileName}\n\n`;
+    section += `**JSON Schema:**\n\n\`\`\`json\n${JSON.stringify(ctx.schema, null, 2)}\n\`\`\`\n\n`;
+    section += `**Sample Data:**\n\n\`\`\`json\n${JSON.stringify(ctx.sample, null, 2)}\n\`\`\``;
+    return section;
+  });
+
+  return `## Referenced Files\n\n${sections.join("\n\n")}`;
+}

package/src/ui/lib/task-reviewer.js

@@ -0,0 +1,51 @@
+import { createHighLevelLLM } from "../../llm/index.js";
+import { stripMarkdownFences } from "../../providers/base.js";
+
+/**
+ * Review and correct task code using LLM
+ * @param {string} code - The task code to review
+ * @param {string} guidelines - Pipeline task guidelines
+ * @returns {Promise<string>} - Returns the original code if the LLM responds with
+ * NO_CHANGES_NEEDED; otherwise returns the LLM's corrected code output (after
+ * markdown fence stripping), which may be empty or invalid if the LLM response
+ * or formatting is unexpected.
+ */
+export async function reviewAndCorrectTask(code, guidelines) {
+  const llm = createHighLevelLLM();
+
+  const prompt = `Review this pipeline task code for:
+1. JavaScript syntax errors
+2. Logic flaws or bugs
+3. Violations of the pipeline task guidelines below
+4. Missing error handling for io/llm operations
+
+If the code is correct, respond with exactly: NO_CHANGES_NEEDED
+
+If corrections are needed, respond with only the corrected code (no explanation).
+
+## Guidelines
+
+${guidelines}
+
+## Code to Review
+
+\`\`\`javascript
+${code}
+\`\`\``;
+
+  const messages = [{ role: "user", content: prompt }];
+
+  const response = await llm.chat({ messages, responseFormat: "text" });
+  const content = response.content || "";
+  const trimmedContent = content.trim();
+
+  // If the LLM returned no usable content, keep the original code
+  if (!trimmedContent) {
+    return code;
+  }
+
+  if (trimmedContent.includes("NO_CHANGES_NEEDED")) {
+    return code;
+  }
+  return stripMarkdownFences(content);
+}