npm - @ryanfw/prompt-orchestration-pipeline - Versions diffs - 0.12.0 → 0.13.1 - Mend

@ryanfw/prompt-orchestration-pipeline 0.12.0 → 0.13.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/package.json +10 -1
package/src/cli/analyze-task.js +51 -0
package/src/cli/index.js +8 -0
package/src/components/AddPipelineSidebar.jsx +144 -0
package/src/components/AnalysisProgressTray.jsx +87 -0
package/src/components/JobTable.jsx +4 -3
package/src/components/Layout.jsx +142 -139
package/src/components/MarkdownRenderer.jsx +149 -0
package/src/components/PipelineDAGGrid.jsx +404 -0
package/src/components/PipelineTypeTaskSidebar.jsx +96 -0
package/src/components/SchemaPreviewPanel.jsx +97 -0
package/src/components/StageTimeline.jsx +36 -0
package/src/components/TaskAnalysisDisplay.jsx +227 -0
package/src/components/TaskCreationSidebar.jsx +447 -0
package/src/components/TaskDetailSidebar.jsx +119 -117
package/src/components/TaskFilePane.jsx +94 -39
package/src/components/ui/button.jsx +59 -27
package/src/components/ui/sidebar.jsx +118 -0
package/src/config/models.js +99 -67
package/src/core/config.js +4 -1
package/src/llm/index.js +129 -9
package/src/pages/PipelineDetail.jsx +6 -6
package/src/pages/PipelineList.jsx +214 -0
package/src/pages/PipelineTypeDetail.jsx +234 -0
package/src/providers/deepseek.js +76 -16
package/src/providers/openai.js +61 -34
package/src/task-analysis/enrichers/analysis-writer.js +62 -0
package/src/task-analysis/enrichers/schema-deducer.js +145 -0
package/src/task-analysis/enrichers/schema-writer.js +74 -0
package/src/task-analysis/extractors/artifacts.js +137 -0
package/src/task-analysis/extractors/llm-calls.js +176 -0
package/src/task-analysis/extractors/stages.js +51 -0
package/src/task-analysis/index.js +103 -0
package/src/task-analysis/parser.js +28 -0
package/src/task-analysis/utils/ast.js +43 -0
package/src/ui/client/hooks/useAnalysisProgress.js +145 -0
package/src/ui/client/index.css +64 -0
package/src/ui/client/main.jsx +4 -0
package/src/ui/client/sse-fetch.js +120 -0
package/src/ui/dist/assets/index-cjHV9mYW.js +82578 -0
package/src/ui/dist/assets/index-cjHV9mYW.js.map +1 -0
package/src/ui/dist/assets/style-CoM9SoQF.css +180 -0
package/src/ui/dist/index.html +2 -2
package/src/ui/endpoints/create-pipeline-endpoint.js +194 -0
package/src/ui/endpoints/pipeline-analysis-endpoint.js +246 -0
package/src/ui/endpoints/pipeline-type-detail-endpoint.js +181 -0
package/src/ui/endpoints/pipelines-endpoint.js +133 -0
package/src/ui/endpoints/schema-file-endpoint.js +105 -0
package/src/ui/endpoints/task-analysis-endpoint.js +104 -0
package/src/ui/endpoints/task-creation-endpoint.js +114 -0
package/src/ui/endpoints/task-save-endpoint.js +101 -0
package/src/ui/express-app.js +45 -0
package/src/ui/lib/analysis-lock.js +67 -0
package/src/ui/lib/sse.js +30 -0
package/src/ui/server.js +4 -0
package/src/ui/utils/slug.js +31 -0
package/src/ui/watcher.js +28 -2
package/src/ui/dist/assets/index-B320avRx.js +0 -26613
package/src/ui/dist/assets/index-B320avRx.js.map +0 -1
package/src/ui/dist/assets/style-BYCoLBnK.css +0 -62

package/src/ui/dist/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
     />
     <title>Prompt Pipeline Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <script type="module" crossorigin src="/assets/index-B320avRx.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/style-BYCoLBnK.css">
+    <script type="module" crossorigin src="/assets/index-cjHV9mYW.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/style-CoM9SoQF.css">
   </head>
   <body>
     <div id="root"></div>

package/src/ui/endpoints/create-pipeline-endpoint.js ADDED Viewed

@@ -0,0 +1,194 @@
+/**
+ * Create pipeline endpoint (logic-only)
+ *
+ * Exports:
+ *  - handleCreatePipeline(req, res) -> HTTP request handler
+ *
+ * This function creates a new pipeline type by:
+ *  - Validating name and description
+ *  - Generating a slug from the provided name
+ *  - Ensuring slug uniqueness in the registry
+ *  - Creating directory structure and starter files
+ *  - Updating the pipeline registry atomically
+ */
+import { getConfig } from "../../core/config.js";
+import { generateSlug, ensureUniqueSlug } from "../utils/slug.js";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * Create starter files for a new pipeline
+ */
+async function createStarterFiles(pipelineDir, slug, name, description) {
+  // Create tasks directory
+  const tasksDir = path.join(pipelineDir, "tasks");
+  await fs.mkdir(tasksDir, { recursive: true });
+  // Create pipeline.json with correct schema
+  const pipelineJsonPath = path.join(pipelineDir, "pipeline.json");
+  const pipelineJsonContent = JSON.stringify(
+    {
+      name: slug,
+      version: "1.0.0",
+      description: description,
+      tasks: [],
+    },
+    null,
+    2
+  );
+  await fs.writeFile(pipelineJsonPath, pipelineJsonContent, "utf8");
+  // Create tasks/index.js
+  const tasksIndexPath = path.join(tasksDir, "index.js");
+  const tasksIndexContent = `// Task registry for ${slug}\nmodule.exports = { tasks: {} };\n`;
+  await fs.writeFile(tasksIndexPath, tasksIndexContent, "utf8");
+}
+/**
+ * Handle pipeline creation request
+ *
+ * Behavior:
+ *  - Validate name and description are present
+ *  - Generate slug from name (kebab-case, max 47 chars)
+ *  - Ensure slug uniqueness in registry
+ *  - Create directory structure and starter files
+ *  - Update registry.json atomically using temp file
+ *  - Return slug on success
+ */
+export async function handleCreatePipeline(req, res) {
+  console.log("[CreatePipelineEndpoint] POST /api/pipelines called");
+  try {
+    const { name, description } = req.body;
+    // Validate required fields
+    if (!name || typeof name !== "string" || name.trim() === "") {
+      res.status(400).json({ error: "Name and description are required" });
+      return;
+    }
+    if (
+      !description ||
+      typeof description !== "string" ||
+      description.trim() === ""
+    ) {
+      res.status(400).json({ error: "Name and description are required" });
+      return;
+    }
+    const config = getConfig();
+    const rootDir = config.paths?.root;
+    if (!rootDir) {
+      res.status(500).json({ error: "Failed to create pipeline" });
+      return;
+    }
+    const pipelineConfigDir = path.join(rootDir, "pipeline-config");
+    const registryPath = path.join(pipelineConfigDir, "registry.json");
+    // Read existing registry
+    let registryData;
+    try {
+      const contents = await fs.readFile(registryPath, "utf8");
+      registryData = JSON.parse(contents);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        // Create registry file with empty pipelines object
+        await fs.mkdir(pipelineConfigDir, { recursive: true });
+        registryData = { pipelines: {} };
+      } else if (error instanceof SyntaxError) {
+        console.error(
+          "[CreatePipelineEndpoint] Invalid JSON in registry:",
+          error
+        );
+        res.status(500).json({ error: "Failed to create pipeline" });
+        return;
+      } else {
+        throw error;
+      }
+    }
+    // Validate registry structure
+    if (
+      !registryData ||
+      typeof registryData !== "object" ||
+      !registryData.pipelines ||
+      typeof registryData.pipelines !== "object"
+    ) {
+      console.error("[CreatePipelineEndpoint] Invalid registry structure");
+      res.status(500).json({ error: "Failed to create pipeline" });
+      return;
+    }
+    // Generate unique slug
+    const baseSlug = generateSlug(name.trim());
+    if (!baseSlug) {
+      res
+        .status(400)
+        .json({ error: "Invalid pipeline name; unable to generate slug" });
+      return;
+    }
+    const existingSlugs = new Set(Object.keys(registryData.pipelines));
+    const slug = ensureUniqueSlug(baseSlug, existingSlugs);
+    // Generate paths
+    const pipelineDir = path.join(pipelineConfigDir, slug);
+    const pipelinePath = path.join("pipeline-config", slug, "pipeline.json");
+    const taskRegistryPath = path.join(
+      "pipeline-config",
+      slug,
+      "tasks/index.js"
+    );
+    // Create starter files
+    try {
+      await createStarterFiles(
+        pipelineDir,
+        slug,
+        name.trim(),
+        description.trim()
+      );
+    } catch (error) {
+      console.error("[CreatePipelineEndpoint] Failed to create files:", error);
+      res.status(500).json({ error: "Failed to create pipeline" });
+      return;
+    }
+    // Update registry atomically using temp file
+    try {
+      registryData.pipelines[slug] = {
+        name: name.trim(),
+        description: description.trim(),
+        pipelinePath,
+        taskRegistryPath,
+      };
+      const tempPath = `${registryPath}.${Date.now()}.tmp`;
+      await fs.writeFile(
+        tempPath,
+        JSON.stringify(registryData, null, 2),
+        "utf8"
+      );
+      await fs.rename(tempPath, registryPath);
+    } catch (error) {
+      console.error(
+        "[CreatePipelineEndpoint] Failed to update registry:",
+        error
+      );
+      res.status(500).json({ error: "Failed to create pipeline" });
+      return;
+    }
+    console.log(
+      "[CreatePipelineEndpoint] Pipeline created successfully:",
+      slug
+    );
+    res.status(200).json({ slug });
+  } catch (err) {
+    console.error("[CreatePipelineEndpoint] Unexpected error:", err);
+    res.status(500).json({ error: "Failed to create pipeline" });
+  }
+}

package/src/ui/endpoints/pipeline-analysis-endpoint.js ADDED Viewed

@@ -0,0 +1,246 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { streamSSE } from "../lib/sse.js";
+import { acquireLock, releaseLock } from "../lib/analysis-lock.js";
+import { getPipelineConfig } from "../../core/config.js";
+import { analyzeTask } from "../../task-analysis/index.js";
+import { writeAnalysisFile } from "../../task-analysis/enrichers/analysis-writer.js";
+import { deduceArtifactSchema } from "../../task-analysis/enrichers/schema-deducer.js";
+import { writeSchemaFiles } from "../../task-analysis/enrichers/schema-writer.js";
+/**
+ * Handle pipeline analysis endpoint.
+ * Analyzes all tasks in a pipeline and deduces schemas for artifacts.
+ *
+ * @param {object} req - Express request object
+ * @param {object} res - Express response object
+ */
+export async function handlePipelineAnalysis(req, res) {
+  const slug = req.params.slug;
+  const startTime = Date.now();
+  // Validate slug format
+  if (!slug || typeof slug !== "string") {
+    return res.status(400).json({
+      ok: false,
+      code: "invalid_slug",
+      message: "Missing or invalid slug parameter",
+    });
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(slug)) {
+    return res.status(400).json({
+      ok: false,
+      code: "invalid_slug",
+      message:
+        "Invalid slug format: only alphanumeric, hyphens, and underscores allowed",
+    });
+  }
+  // Try to acquire lock
+  const lockResult = acquireLock(slug);
+  if (!lockResult.acquired) {
+    return res.status(409).json({
+      ok: false,
+      code: "analysis_locked",
+      heldBy: lockResult.heldBy,
+    });
+  }
+  // Create SSE stream
+  const stream = streamSSE(res);
+  let lockReleased = false;
+  const releaseLockSafely = () => {
+    if (!lockReleased) {
+      releaseLock(slug);
+      lockReleased = true;
+    }
+  };
+  // Handle client disconnect
+  req.on("close", () => {
+    console.log(`[PipelineAnalysis] Client disconnected for ${slug}`);
+    releaseLockSafely();
+  });
+  try {
+    // Get pipeline configuration
+    let pipelineConfig;
+    try {
+      pipelineConfig = getPipelineConfig(slug);
+    } catch (error) {
+      stream.send("error", {
+        message: `Pipeline '${slug}' not found in registry`,
+      });
+      stream.end();
+      releaseLockSafely();
+      return;
+    }
+    const pipelineDir = path.dirname(pipelineConfig.pipelineJsonPath);
+    // Read pipeline.json
+    let pipelineData;
+    try {
+      const contents = await fs.readFile(
+        pipelineConfig.pipelineJsonPath,
+        "utf8"
+      );
+      pipelineData = JSON.parse(contents);
+    } catch (error) {
+      stream.send("error", {
+        message: `Failed to read pipeline.json: ${error.message}`,
+      });
+      stream.end();
+      releaseLockSafely();
+      return;
+    }
+    if (!Array.isArray(pipelineData.tasks)) {
+      stream.send("error", {
+        message: "Invalid pipeline.json: tasks array not found",
+      });
+      stream.end();
+      releaseLockSafely();
+      return;
+    }
+    const tasks = pipelineData.tasks;
+    const totalTasks = tasks.length;
+    // Pre-analyze all tasks to count total artifacts (only JSON files need schema deduction)
+    const taskAnalyses = [];
+    let totalArtifacts = 0;
+    for (const taskId of tasks) {
+      const taskFilePath = path.join(pipelineDir, "tasks", `${taskId}.js`);
+      try {
+        const taskCode = await fs.readFile(taskFilePath, "utf8");
+        const analysis = analyzeTask(taskCode, taskFilePath);
+        taskAnalyses.push({ taskId, taskCode, analysis });
+        // Only count JSON artifacts for schema deduction
+        totalArtifacts += analysis.artifacts.writes.filter((a) =>
+          a.fileName.endsWith(".json")
+        ).length;
+      } catch (error) {
+        stream.send("error", {
+          message: `Failed to analyze task '${taskId}': ${error.message}`,
+          taskId,
+        });
+        stream.end();
+        releaseLockSafely();
+        return;
+      }
+    }
+    // Send started event
+    stream.send("started", {
+      pipelineSlug: slug,
+      totalTasks,
+      totalArtifacts,
+    });
+    let completedTasks = 0;
+    let completedArtifacts = 0;
+    // Process each task
+    for (let taskIndex = 0; taskIndex < taskAnalyses.length; taskIndex++) {
+      const { taskId, taskCode, analysis } = taskAnalyses[taskIndex];
+      stream.send("task:start", {
+        taskId,
+        taskIndex,
+        totalTasks,
+      });
+      // Write analysis file
+      try {
+        await writeAnalysisFile(pipelineDir, taskId, analysis);
+      } catch (error) {
+        stream.send("error", {
+          message: `Failed to write analysis for task '${taskId}': ${error.message}`,
+          taskId,
+        });
+        stream.end();
+        releaseLockSafely();
+        return;
+      }
+      // Process each artifact write
+      const artifacts = analysis.artifacts.writes;
+      let jsonArtifactIndex = 0;
+      for (
+        let artifactIndex = 0;
+        artifactIndex < artifacts.length;
+        artifactIndex++
+      ) {
+        const artifact = artifacts[artifactIndex];
+        // Skip non-JSON artifacts (only JSON files need schema deduction)
+        if (!artifact.fileName.endsWith(".json")) {
+          continue;
+        }
+        stream.send("artifact:start", {
+          taskId,
+          artifactName: artifact.fileName,
+          artifactIndex: jsonArtifactIndex,
+          totalArtifacts,
+        });
+        try {
+          const deducedSchema = await deduceArtifactSchema(taskCode, artifact);
+          await writeSchemaFiles(pipelineDir, artifact.fileName, deducedSchema);
+        } catch (error) {
+          stream.send("error", {
+            message: `Failed to deduce schema for artifact '${artifact.fileName}': ${error.message}`,
+            taskId,
+            artifactName: artifact.fileName,
+          });
+          stream.end();
+          releaseLockSafely();
+          return;
+        }
+        stream.send("artifact:complete", {
+          taskId,
+          artifactName: artifact.fileName,
+          artifactIndex: jsonArtifactIndex,
+          totalArtifacts,
+        });
+        completedArtifacts++;
+        jsonArtifactIndex++;
+      }
+      stream.send("task:complete", {
+        taskId,
+        taskIndex,
+        totalTasks,
+      });
+      completedTasks++;
+    }
+    // Send complete event
+    const durationMs = Date.now() - startTime;
+    stream.send("complete", {
+      pipelineSlug: slug,
+      tasksAnalyzed: completedTasks,
+      artifactsProcessed: completedArtifacts,
+      durationMs,
+    });
+    stream.end();
+    releaseLockSafely();
+  } catch (error) {
+    console.error(`[PipelineAnalysis] Unexpected error:`, error);
+    stream.send("error", {
+      message: `Unexpected error: ${error.message}`,
+    });
+    stream.end();
+    releaseLockSafely();
+  }
+}

package/src/ui/endpoints/pipeline-type-detail-endpoint.js ADDED Viewed

@@ -0,0 +1,181 @@
+/**
+ * Pipeline type detail endpoint (logic-only)
+ *
+ * Exports:
+ *  - handlePipelineTypeDetail(slug) -> Core logic function
+ *  - handlePipelineTypeDetailRequest(req, res) -> HTTP response wrapper
+ *
+ * This function returns a read-only pipeline definition with tasks ordered
+ * as specified in pipeline.json for rendering a static DAG visualization.
+ */
+import { getPipelineConfig, getConfig } from "../../core/config.js";
+import { sendJson } from "../utils/http-utils.js";
+import * as configBridge from "../config-bridge.js";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * Return pipeline type detail suitable for the API.
+ *
+ * Behavior:
+ *  - Use getPipelineConfig(slug) to resolve pipeline.json path
+ *  - Read and parse pipeline.json from the resolved path
+ *  - Validate that parsed data contains a tasks array
+ *  - Return tasks as { id, title, status: 'definition' } in order
+ *  - Handle all error cases with explicit error responses
+ *
+ * @param {string} slug - Pipeline slug identifier
+ * @returns {Object} Response envelope { ok: true, data } or error envelope
+ */
+export async function handlePipelineTypeDetail(slug) {
+  console.log(`[PipelineTypeDetailEndpoint] GET /api/pipelines/${slug} called`);
+  // Validate slug parameter
+  if (!slug || typeof slug !== "string") {
+    return configBridge.createErrorResponse(
+      configBridge.Constants.ERROR_CODES.BAD_REQUEST,
+      "Invalid slug parameter"
+    );
+  }
+  // Enforce safe characters in slug to prevent path traversal and similar issues
+  const slugIsValid = /^[A-Za-z0-9_-]+$/.test(slug);
+  if (!slugIsValid) {
+    return configBridge.createErrorResponse(
+      configBridge.Constants.ERROR_CODES.BAD_REQUEST,
+      "Invalid slug parameter: only letters, numbers, hyphens, and underscores are allowed"
+    );
+  }
+  try {
+    // Resolve pipeline configuration using existing config system
+    let pipelineConfig;
+    try {
+      pipelineConfig = getPipelineConfig(slug);
+    } catch (error) {
+      return configBridge.createErrorResponse(
+        configBridge.Constants.ERROR_CODES.NOT_FOUND,
+        `Pipeline '${slug}' not found in registry`
+      );
+    }
+    const pipelineJsonPath = pipelineConfig.pipelineJsonPath;
+    // Check if pipeline.json exists
+    try {
+      await fs.access(pipelineJsonPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return configBridge.createErrorResponse(
+          configBridge.Constants.ERROR_CODES.NOT_FOUND,
+          `pipeline.json not found for pipeline '${slug}'`,
+          pipelineJsonPath
+        );
+      }
+      throw error;
+    }
+    // Read and parse pipeline.json
+    let pipelineData;
+    try {
+      const contents = await fs.readFile(pipelineJsonPath, "utf8");
+      pipelineData = JSON.parse(contents);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return configBridge.createErrorResponse(
+          configBridge.Constants.ERROR_CODES.INVALID_JSON,
+          "Invalid JSON in pipeline.json",
+          pipelineJsonPath
+        );
+      }
+      throw error;
+    }
+    // Validate pipeline structure
+    if (
+      !pipelineData ||
+      typeof pipelineData !== "object" ||
+      !Array.isArray(pipelineData.tasks)
+    ) {
+      return configBridge.createErrorResponse(
+        configBridge.Constants.ERROR_CODES.INVALID_JSON,
+        "Invalid pipeline.json format: expected 'tasks' array",
+        pipelineJsonPath
+      );
+    }
+    // Transform tasks to API format
+    const tasks = pipelineData.tasks.map((taskId, index) => {
+      if (typeof taskId !== "string" || !taskId.trim()) {
+        throw new Error(`Invalid task ID at index ${index}: ${taskId}`);
+      }
+      return {
+        id: taskId,
+        title: taskId.charAt(0).toUpperCase() + taskId.slice(1),
+        status: "definition",
+      };
+    });
+    // Get pipeline metadata from config for name/description
+    const config = getConfig();
+    const pipelineMetadata = config.pipelines?.[slug] || {};
+    return {
+      ok: true,
+      data: {
+        slug,
+        name: pipelineMetadata.name || slug,
+        description: pipelineMetadata.description || "",
+        tasks,
+      },
+    };
+  } catch (err) {
+    console.error("handlePipelineTypeDetail error:", err);
+    return configBridge.createErrorResponse(
+      configBridge.Constants.ERROR_CODES.FS_ERROR,
+      "Failed to read pipeline configuration"
+    );
+  }
+}
+/**
+ * HTTP wrapper function for pipeline type detail requests.
+ * Calls handlePipelineTypeDetail(slug) and sends the response using sendJson().
+ *
+ * @param {http.IncomingMessage} req - HTTP request object
+ * @param {http.ServerResponse} res - HTTP response object
+ */
+export async function handlePipelineTypeDetailRequest(req, res) {
+  console.info(
+    "[PipelineTypeDetailEndpoint] handlePipelineTypeDetailRequest called"
+  );
+  try {
+    const slug = req.params.slug;
+    const result = await handlePipelineTypeDetail(slug);
+    if (result.ok) {
+      sendJson(res, 200, result);
+    } else {
+      // Map error codes to appropriate HTTP status codes
+      const statusCode =
+        result.code === configBridge.Constants.ERROR_CODES.NOT_FOUND
+          ? 404
+          : result.code === configBridge.Constants.ERROR_CODES.BAD_REQUEST
+            ? 400
+            : result.code === configBridge.Constants.ERROR_CODES.INVALID_JSON ||
+                result.code === configBridge.Constants.ERROR_CODES.FS_ERROR
+              ? 500
+              : 500;
+      sendJson(res, statusCode, result);
+    }
+  } catch (err) {
+    console.error("handlePipelineTypeDetailRequest unexpected error:", err);
+    sendJson(res, 500, {
+      ok: false,
+      code: "internal_error",
+      message: "Internal server error",
+    });
+  }
+}