@ryanfw/prompt-orchestration-pipeline 0.12.0 → 0.13.0

package/src/pages/PipelineTypeDetail.jsx

@@ -0,0 +1,234 @@
+import React, { useState, useEffect } from "react";
+import { useParams } from "react-router-dom";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import Layout from "../components/Layout.jsx";
+import PageSubheader from "../components/PageSubheader.jsx";
+import { Button } from "../components/ui/button.jsx";
+
+import PipelineDAGGrid from "../components/PipelineDAGGrid.jsx";
+import TaskCreationSidebar from "../components/TaskCreationSidebar.jsx";
+import { AnalysisProgressTray } from "../components/AnalysisProgressTray.jsx";
+import { useAnalysisProgress } from "../ui/client/hooks/useAnalysisProgress.js";
+
+export default function PipelineTypeDetail() {
+  const { slug } = useParams();
+  const [pipeline, setPipeline] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [sidebarOpen, setSidebarOpen] = useState(false);
+  const [trayDismissed, setTrayDismissed] = useState(false);
+
+  const { status, startAnalysis, reset, ...progressState } =
+    useAnalysisProgress();
+
+  const handleAnalyze = () => {
+    setTrayDismissed(false);
+    startAnalysis(slug);
+  };
+
+  useEffect(() => {
+    const fetchPipeline = async () => {
+      if (!slug) {
+        setError("No pipeline slug provided");
+        setLoading(false);
+        return;
+      }
+
+      try {
+        setLoading(true);
+        const response = await fetch(
+          `/api/pipelines/${encodeURIComponent(slug)}`
+        );
+
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new Error(
+            errorData.message || `Failed to load pipeline: ${response.status}`
+          );
+        }
+
+        const data = await response.json();
+        if (!data.ok) {
+          throw new Error(data.message || "Failed to load pipeline");
+        }
+
+        setPipeline(data.data);
+      } catch (err) {
+        setError(err.message || "Failed to load pipeline");
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchPipeline();
+  }, [slug]);
+
+  // Handle missing slug
+  if (!slug) {
+    return (
+      <Layout
+        pageTitle="Pipeline Details"
+        breadcrumbs={[
+          { label: "Home", href: "/" },
+          { label: "Pipelines", href: "/pipelines" },
+        ]}
+      >
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" color="red" className="mb-2">
+              No pipeline slug provided
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  // Loading state
+  if (loading) {
+    return (
+      <Layout
+        pageTitle="Pipeline Details"
+        breadcrumbs={[
+          { label: "Home", href: "/" },
+          { label: "Pipelines", href: "/pipelines" },
+        ]}
+      >
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" className="mb-2">
+              Loading pipeline details...
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  // Error state
+  if (error) {
+    return (
+      <Layout
+        pageTitle="Pipeline Details"
+        breadcrumbs={[
+          { label: "Home", href: "/" },
+          { label: "Pipelines", href: "/pipelines" },
+        ]}
+      >
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" color="red" className="mb-2">
+              Failed to load pipeline
+            </Text>
+            <Text size="2" color="gray" className="mt-2">
+              {error}
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  // No pipeline data
+  if (!pipeline) {
+    return (
+      <Layout
+        pageTitle="Pipeline Details"
+        breadcrumbs={[
+          { label: "Home", href: "/" },
+          { label: "Pipelines", href: "/pipelines" },
+        ]}
+      >
+        <Flex align="center" justify="center" className="min-h-64">
+          <Box className="text-center">
+            <Text size="5" weight="medium" className="mb-2">
+              Pipeline not found
+            </Text>
+          </Box>
+        </Flex>
+      </Layout>
+    );
+  }
+
+  const pageTitle = pipeline.name || "Pipeline Details";
+  const breadcrumbs = [
+    { label: "Home", href: "/" },
+    { label: "Pipelines", href: "/pipelines" },
+    { label: pipeline.name || slug },
+  ];
+
+  return (
+    <Layout pageTitle={pageTitle} breadcrumbs={breadcrumbs}>
+      <PageSubheader breadcrumbs={breadcrumbs} maxWidth="max-w-7xl">
+        <Flex gap="3" align="center">
+          <Text size="2" color="gray">
+            Slug: {slug}
+          </Text>
+          <Button
+            variant="solid"
+            size="md"
+            onClick={() => setSidebarOpen(true)}
+          >
+            Add Task
+          </Button>
+          <Button
+            variant="outline"
+            size="md"
+            onClick={handleAnalyze}
+            disabled={status === "connecting" || status === "running"}
+          >
+            Analyze Pipeline
+          </Button>
+        </Flex>
+      </PageSubheader>
+
+      {/* Pipeline description */}
+      {pipeline.description && (
+        <Box className="mb-6">
+          <Text size="2" color="gray" className="leading-relaxed">
+            {pipeline.description}
+          </Text>
+        </Box>
+      )}
+
+      {/* Pipeline DAG - will be implemented in step 5 */}
+      <Box className="bg-gray-50 rounded-lg p-4">
+        <Text size="3" weight="medium" className="mb-4">
+          Pipeline Tasks
+        </Text>
+
+        {pipeline.tasks && pipeline.tasks.length > 0 ? (
+          <Box>
+            <Text size="2" color="gray" className="mb-4">
+              {pipeline.tasks.length} task
+              {pipeline.tasks.length !== 1 ? "s" : ""} defined
+            </Text>
+
+            <PipelineDAGGrid items={pipeline.tasks} pipelineSlug={slug} />
+          </Box>
+        ) : (
+          <Box className="mb-4">
+            <Text size="2" color="gray">
+              No tasks defined for this pipeline
+            </Text>
+          </Box>
+        )}
+      </Box>
+
+      <TaskCreationSidebar
+        isOpen={sidebarOpen}
+        onClose={() => setSidebarOpen(false)}
+        pipelineSlug={slug}
+      />
+
+      {!trayDismissed && (
+        <AnalysisProgressTray
+          {...progressState}
+          status={status}
+          pipelineSlug={slug}
+          onDismiss={() => setTrayDismissed(true)}
+        />
+      )}
+    </Layout>
+  );
+}

package/src/providers/deepseek.js

@@ -12,20 +12,24 @@ export async function deepseekChat({
   model = "deepseek-chat",
   temperature = 0.7,
   maxTokens,
-  responseFormat,
+  responseFormat = "json_object",
   topP,
   frequencyPenalty,
   presencePenalty,
   stop,
+  stream = false,
   maxRetries = 3,
 }) {
-  // Enforce JSON mode - reject calls without proper JSON responseFormat
-  ensureJsonResponseFormat(responseFormat, "DeepSeek");
-
   if (!process.env.DEEPSEEK_API_KEY) {
     throw new Error("DeepSeek API key not configured");
   }
 
+  // Determine if JSON mode is requested
+  const isJsonMode =
+    responseFormat?.type === "json_object" ||
+    responseFormat?.type === "json_schema" ||
+    responseFormat === "json";
+
   const { systemMsg, userMsg } = extractMessages(messages);
 
   let lastError;
@@ -47,10 +51,11 @@ export async function deepseekChat({
         frequency_penalty: frequencyPenalty,
         presence_penalty: presencePenalty,
         stop,
+        stream,
       };
 
-      // Add response format - this is now required for all calls
-      if (responseFormat?.type === "json_object" || responseFormat === "json") {
+      // Add response format only for JSON mode (streaming uses text mode)
+      if (isJsonMode && !stream) {
         requestBody.response_format = { type: "json_object" };
       }
 
@@ -73,22 +78,35 @@ export async function deepseekChat({
         throw { status: response.status, ...error };
       }
 
+      // Streaming mode - return async generator for real-time chunks
+      if (stream) {
+        return createStreamGenerator(response.body);
+      }
+
       const data = await response.json();
       const content = data.choices[0].message.content;
 
-      // Parse JSON - this is now required for all calls
-      const parsed = tryParseJSON(content);
-      if (!parsed) {
-        throw new ProviderJsonParseError(
-          "DeepSeek",
-          model,
-          content.substring(0, 200),
-          "Failed to parse JSON response from DeepSeek API"
-        );
+      // Parse JSON only in JSON mode; return raw string for text mode
+      if (isJsonMode) {
+        const parsed = tryParseJSON(content);
+        if (!parsed) {
+          throw new ProviderJsonParseError(
+            "DeepSeek",
+            model,
+            content.substring(0, 200),
+            "Failed to parse JSON response from DeepSeek API"
+          );
+        }
+        return {
+          content: parsed,
+          usage: data.usage,
+          raw: data,
+        };
       }
 
+      // Text mode - return raw string
       return {
-        content: parsed,
+        content,
         usage: data.usage,
         raw: data,
       };
@@ -107,3 +125,45 @@ export async function deepseekChat({
 
   throw lastError || new Error(`Failed after ${maxRetries + 1} attempts`);
 }
+
+/**
+ * Create async generator for streaming DeepSeek responses.
+ * DeepSeek uses Server-Sent Events format with "data:" prefix.
+ */
+async function* createStreamGenerator(stream) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop(); // Keep incomplete line
+
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") continue;
+
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content;
+            // Skip only truly empty chunks; preserve whitespace-only content
+            if (content !== undefined && content !== null && content !== "") {
+              yield { content };
+            }
+          } catch (e) {
+            // Skip malformed JSON
+            console.warn("[deepseek] Failed to parse stream chunk:", e);
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/src/providers/openai.js

@@ -33,7 +33,7 @@ export async function openaiChat({
   temperature,
   maxTokens,
   max_tokens, // Explicitly destructure to prevent it from being in ...rest
-  responseFormat,
+  responseFormat = "json_object",
   seed,
   stop,
   topP,
@@ -46,9 +46,6 @@ export async function openaiChat({
   console.log("[OpenAI] Model:", model);
   console.log("[OpenAI] Response format:", responseFormat);
 
-  // Enforce JSON mode - reject calls without proper JSON responseFormat
-  ensureJsonResponseFormat(responseFormat, "OpenAI");
-
   const openai = getClient();
   if (!openai) throw new Error("OpenAI API key not configured");
 
@@ -56,6 +53,12 @@ export async function openaiChat({
   console.log("[OpenAI] System message length:", systemMsg.length);
   console.log("[OpenAI] User message length:", userMsg.length);
 
+  // Determine if JSON mode is requested
+  const isJsonMode =
+    responseFormat?.json_schema ||
+    responseFormat?.type === "json_object" ||
+    responseFormat === "json";
+
   let lastError;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0) await sleep(Math.pow(2, attempt) * 1000);
@@ -109,19 +112,27 @@ export async function openaiChat({
           total_tokens: promptTokens + completionTokens,
         };
 
-        // Parse JSON - this is now required for all calls
-        const parsed = tryParseJSON(text);
-        if (!parsed) {
-          throw new ProviderJsonParseError(
-            "OpenAI",
-            model,
-            text.substring(0, 200),
-            "Failed to parse JSON response from Responses API"
+        // Parse JSON only in JSON mode; return raw string for text mode
+        if (isJsonMode) {
+          const parsed = tryParseJSON(text);
+          if (!parsed) {
+            throw new ProviderJsonParseError(
+              "OpenAI",
+              model,
+              text.substring(0, 200),
+              "Failed to parse JSON response from Responses API"
+            );
+          }
+          console.log(
+            "[OpenAI] Returning response from Responses API (JSON mode)"
           );
+          return { content: parsed, text, usage, raw: resp };
         }
 
-        console.log("[OpenAI] Returning response from Responses API");
-        return { content: parsed, text, usage, raw: resp };
+        console.log(
+          "[OpenAI] Returning response from Responses API (text mode)"
+        );
+        return { content: text, text, usage, raw: resp };
       }
 
       // ---------- CLASSIC CHAT COMPLETIONS path (non-GPT-5) ----------
@@ -156,19 +167,27 @@ export async function openaiChat({
         classicText.length
       );
 
-      // Parse JSON - this is now required for all calls
-      const classicParsed = tryParseJSON(classicText);
-      if (!classicParsed) {
-        throw new ProviderJsonParseError(
-          "OpenAI",
-          model,
-          classicText.substring(0, 200),
-          "Failed to parse JSON response from Classic API"
-        );
+      // Parse JSON only in JSON mode; return raw string for text mode
+      if (isJsonMode) {
+        const classicParsed = tryParseJSON(classicText);
+        if (!classicParsed) {
+          throw new ProviderJsonParseError(
+            "OpenAI",
+            model,
+            classicText.substring(0, 200),
+            "Failed to parse JSON response from Classic API"
+          );
+        }
+        return {
+          content: classicParsed,
+          text: classicText,
+          usage: classicRes?.usage,
+          raw: classicRes,
+        };
       }
 
       return {
-        content: classicParsed,
+        content: classicText,
         text: classicText,
         usage: classicRes?.usage,
         raw: classicRes,
@@ -211,19 +230,27 @@ export async function openaiChat({
         const classicRes = await openai.chat.completions.create(classicReq);
         const text = classicRes?.choices?.[0]?.message?.content ?? "";
 
-        // Parse JSON - this is now required for all calls
-        const parsed = tryParseJSON(text);
-        if (!parsed) {
-          throw new ProviderJsonParseError(
-            "OpenAI",
-            model,
-            text.substring(0, 200),
-            "Failed to parse JSON response from fallback Classic API"
-          );
+        // Parse JSON only in JSON mode; return raw string for text mode
+        if (isJsonMode) {
+          const parsed = tryParseJSON(text);
+          if (!parsed) {
+            throw new ProviderJsonParseError(
+              "OpenAI",
+              model,
+              text.substring(0, 200),
+              "Failed to parse JSON response from fallback Classic API"
+            );
+          }
+          return {
+            content: parsed,
+            text,
+            usage: classicRes?.usage,
+            raw: classicRes,
+          };
         }
 
         return {
-          content: parsed,
+          content: text,
           text,
           usage: classicRes?.usage,
           raw: classicRes,

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

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Write task analysis file to the analysis/ directory.
+ *
+ * @param {string} pipelinePath - Path to pipeline directory
+ * @param {string} taskName - Task name (e.g., "research")
+ * @param {object} analysisData - Task analysis object containing { taskFilePath, stages, artifacts, models }
+ */
+export async function writeAnalysisFile(pipelinePath, taskName, analysisData) {
+  // Validate that analysisData contains all required properties
+  if (!analysisData || typeof analysisData !== "object") {
+    throw new Error(
+      `Invalid analysisData: expected an object but got ${typeof analysisData}`
+    );
+  }
+
+  if (
+    !analysisData.taskFilePath ||
+    typeof analysisData.taskFilePath !== "string"
+  ) {
+    throw new Error(
+      `Invalid analysisData.taskFilePath: expected a string but got ${typeof analysisData.taskFilePath}`
+    );
+  }
+
+  if (!Array.isArray(analysisData.stages)) {
+    throw new Error(
+      `Invalid analysisData.stages: expected an array but got ${typeof analysisData.stages}`
+    );
+  }
+
+  if (
+    !analysisData.artifacts ||
+    typeof analysisData.artifacts !== "object" ||
+    Array.isArray(analysisData.artifacts)
+  ) {
+    throw new Error(
+      `Invalid analysisData.artifacts: expected an object but got ${typeof analysisData.artifacts}`
+    );
+  }
+
+  if (!Array.isArray(analysisData.models)) {
+    throw new Error(
+      `Invalid analysisData.models: expected an array but got ${typeof analysisData.models}`
+    );
+  }
+
+  const analysisDir = path.join(pipelinePath, "analysis");
+  await fs.mkdir(analysisDir, { recursive: true });
+
+  const output = {
+    ...analysisData,
+    analyzedAt: new Date().toISOString(),
+  };
+
+  await fs.writeFile(
+    path.join(analysisDir, `${taskName}.analysis.json`),
+    JSON.stringify(output, null, 2)
+  );
+}