@ryanfw/prompt-orchestration-pipeline 0.0.1 → 0.3.0

package/src/pages/PromptPipelineDashboard.jsx

@@ -0,0 +1,223 @@
+// PromptPipelineDashboard.jsx
+import React, { useEffect, useMemo, useState } from "react";
+import { useNavigate } from "react-router-dom";
+
+import { Box, Flex, Text, Heading, Tabs, Card } from "@radix-ui/themes";
+
+import { Progress } from "../components/ui/progress";
+import { useJobListWithUpdates } from "../ui/client/hooks/useJobListWithUpdates";
+import { adaptJobSummary } from "../ui/client/adapters/job-adapter";
+import { jobCumulativeDurationMs } from "../utils/duration";
+import { useTicker } from "../ui/client/hooks/useTicker";
+
+// Referenced components — leave these alone
+import JobTable from "../components/JobTable";
+import UploadSeed from "../components/UploadSeed";
+import Layout from "../components/Layout.jsx";
+
+export default function PromptPipelineDashboard({ isConnected }) {
+  const navigate = useNavigate();
+  const hookResult = useJobListWithUpdates();
+
+  if (
+    process.env.NODE_ENV === "test" &&
+    (hookResult === undefined ||
+      hookResult === null ||
+      typeof hookResult !== "object" ||
+      Array.isArray(hookResult))
+  ) {
+    // eslint-disable-next-line no-console
+    console.error(
+      "[PromptPipelineDashboard] useJobListWithUpdates returned unexpected value",
+      {
+        hookResultType: typeof hookResult,
+        hookResultKeys:
+          hookResult && typeof hookResult === "object"
+            ? Object.keys(hookResult)
+            : null,
+        isMockFunction: Boolean(useJobListWithUpdates?.mock),
+        stack: new Error().stack,
+      }
+    );
+  }
+
+  const { data: apiJobs, loading, error, connectionStatus } = hookResult;
+
+  const jobs = useMemo(() => {
+    const src = Array.isArray(apiJobs) ? apiJobs : [];
+
+    // Do not fall back to in-memory demo data. On error, return an empty list so
+    // UI shows a neutral empty/error state rather than demo jobs.
+    if (error) {
+      return [];
+    }
+
+    return src.map(adaptJobSummary);
+  }, [apiJobs, error]);
+  const [activeTab, setActiveTab] = useState("current");
+  const [seedUploadSuccess, setSeedUploadSuccess] = useState(null);
+  const [seedUploadTimer, setSeedUploadTimer] = useState(null);
+
+  // Shared ticker for live duration updates
+  const now = useTicker(10000);
+
+  const errorCount = useMemo(
+    () => jobs.filter((j) => j.status === "failed").length,
+    [jobs]
+  );
+  const currentCount = useMemo(
+    () => jobs.filter((j) => j.status === "running").length,
+    [jobs]
+  );
+  const completedCount = useMemo(
+    () => jobs.filter((j) => j.status === "complete").length,
+    [jobs]
+  );
+
+  const filteredJobs = useMemo(() => {
+    switch (activeTab) {
+      case "current":
+        return jobs.filter((j) => j.status === "running");
+      case "errors":
+        return jobs.filter((j) => j.status === "failed");
+      case "complete":
+        return jobs.filter((j) => j.status === "complete");
+      default:
+        return [];
+    }
+  }, [jobs, activeTab]);
+
+  const overallElapsed = (job) => jobCumulativeDurationMs(job, now);
+
+  // Aggregate progress for currently running jobs (for a subtle top progress bar)
+  const runningJobs = useMemo(
+    () => jobs.filter((j) => j.status === "running"),
+    [jobs]
+  );
+  const aggregateProgress = useMemo(() => {
+    if (runningJobs.length === 0) return 0;
+    const sum = runningJobs.reduce((acc, j) => acc + (j.progress || 0), 0);
+    return Math.round(sum / runningJobs.length);
+  }, [runningJobs]);
+
+  const openJob = (job) => {
+    // Only navigate if job has a proper ID
+    if (job.id) {
+      navigate(`/pipeline/${job.id}`);
+    } else {
+      // Show console warning for jobs without valid ID
+      console.warn(`Cannot open job "${job.name}" - no valid job ID available`);
+      // TODO: Show user-facing toast or notification for better UX
+    }
+  };
+
+  // Handle seed upload success
+  const handleSeedUploadSuccess = ({ jobName }) => {
+    // Clear any existing timer
+    if (seedUploadTimer) {
+      clearTimeout(seedUploadTimer);
+    }
+
+    // Set success message
+    setSeedUploadSuccess(jobName);
+
+    // Auto-clear after exactly 5000 ms
+    const timer = setTimeout(() => {
+      setSeedUploadSuccess(null);
+      setSeedUploadTimer(null);
+    }, 5000);
+
+    setSeedUploadTimer(timer);
+  };
+
+  // Cleanup timer on unmount
+  useEffect(() => {
+    return () => {
+      if (seedUploadTimer) {
+        clearTimeout(seedUploadTimer);
+      }
+    };
+  }, [seedUploadTimer]);
+
+  // 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>
+  );
+
+  return (
+    <Layout title="Prompt Pipeline" actions={headerActions}>
+      {/* Upload Seed File Section */}
+      <Card className="mb-6">
+        <Flex direction="column" gap="3">
+          <Heading size="4" weight="medium" className="text-gray-12">
+            Upload Seed File
+          </Heading>
+
+          {/* Success Message */}
+          {seedUploadSuccess && (
+            <Box className="rounded-md bg-green-50 p-3 border border-green-200">
+              <Text size="2" className="text-green-800">
+                Job <strong>{seedUploadSuccess}</strong> created successfully
+              </Text>
+            </Box>
+          )}
+
+          <UploadSeed onUploadSuccess={handleSeedUploadSuccess} />
+        </Flex>
+      </Card>
+
+      {error && (
+        <Box className="mb-4 rounded-md bg-yellow-50 p-3 border border-yellow-200">
+          <Text size="2" className="text-yellow-800">
+            Unable to load jobs from the server
+          </Text>
+        </Box>
+      )}
+      <Tabs.Root value={activeTab} onValueChange={setActiveTab}>
+        <Tabs.List aria-label="Job filters">
+          <Tabs.Trigger value="current">Current ({currentCount})</Tabs.Trigger>
+          <Tabs.Trigger value="errors">Errors ({errorCount})</Tabs.Trigger>
+          <Tabs.Trigger value="complete">
+            Completed ({completedCount})
+          </Tabs.Trigger>
+        </Tabs.List>
+
+        <Tabs.Content value="current">
+          <JobTable
+            jobs={filteredJobs}
+            pipeline={null}
+            onOpenJob={openJob}
+            overallElapsed={overallElapsed}
+            now={now}
+          />
+        </Tabs.Content>
+        <Tabs.Content value="errors">
+          <JobTable
+            jobs={filteredJobs}
+            pipeline={null}
+            onOpenJob={openJob}
+            overallElapsed={overallElapsed}
+            now={now}
+          />
+        </Tabs.Content>
+        <Tabs.Content value="complete">
+          <JobTable
+            jobs={filteredJobs}
+            pipeline={null}
+            onOpenJob={openJob}
+            overallElapsed={overallElapsed}
+            now={now}
+          />
+        </Tabs.Content>
+      </Tabs.Root>
+    </Layout>
+  );
+}

package/src/providers/deepseek.js

@@ -7,10 +7,10 @@ import {
 
 export async function deepseekChat({
   messages,
-  model = "deepseek-reasoner",
+  model = "deepseek-chat",
   temperature = 0.7,
   maxTokens,
-  responseFormat,
+  responseFormat = "json",
   topP,
   frequencyPenalty,
   presencePenalty,
@@ -71,21 +71,9 @@ export async function deepseekChat({
       const data = await response.json();
       const content = data.choices[0].message.content;
 
-      // Try to parse JSON if expected
-      let parsed = null;
-      if (responseFormat?.type === "json_object" || responseFormat === "json") {
-        parsed = tryParseJSON(content);
-        if (!parsed && attempt < maxRetries) {
-          lastError = new Error("Failed to parse JSON response");
-          continue;
-        }
-      }
-
       return {
-        content: parsed || content,
-        text: content,
+        content: tryParseJSON(content),
         usage: data.usage,
-        raw: data,
       };
     } catch (error) {
       lastError = error;

package/src/ui/client/adapters/job-adapter.js

@@ -0,0 +1,258 @@
+import { derivePipelineMetadata } from "../../../utils/pipelines.js";
+
+const ALLOWED_STATES = new Set(["pending", "running", "done", "failed"]);
+
+/**
+ * Normalize a raw task state into canonical enum.
+ * Returns { state, warning? } where warning is a string if normalization occurred.
+ */
+function normalizeTaskState(raw) {
+  if (!raw || typeof raw !== "string")
+    return { state: "pending", warning: "missing_state" };
+  const s = raw.toLowerCase();
+  if (ALLOWED_STATES.has(s)) return { state: s };
+  return { state: "pending", warning: `unknown_state:${raw}` };
+}
+
+/**
+ * Convert tasks input into an object of normalized task objects keyed by task name.
+ * Accepts:
+ * - object keyed by taskName -> taskObj (preferred canonical shape)
+ * - array of task objects (with optional name) - converted to object
+ */
+function normalizeTasks(rawTasks) {
+  if (!rawTasks) return { tasks: {}, warnings: [] };
+  const warnings = [];
+
+  if (typeof rawTasks === "object" && !Array.isArray(rawTasks)) {
+    // Object shape - canonical format
+    const tasks = {};
+    Object.entries(rawTasks).forEach(([name, t]) => {
+      const ns = normalizeTaskState(t && t.state);
+      if (ns.warning) warnings.push(`${name}:${ns.warning}`);
+      const taskObj = {
+        name,
+        state: ns.state,
+        startedAt: t && t.startedAt ? String(t.startedAt) : null,
+        endedAt: t && t.endedAt ? String(t.endedAt) : null,
+        attempts:
+          typeof (t && t.attempts) === "number" ? t.attempts : undefined,
+        executionTimeMs:
+          typeof (t && t.executionTimeMs) === "number"
+            ? t.executionTimeMs
+            : undefined,
+        // Preserve stage metadata for DAG visualization
+        ...(typeof t?.currentStage === "string" && t.currentStage.length > 0
+          ? { currentStage: t.currentStage }
+          : {}),
+        ...(typeof t?.failedStage === "string" && t.failedStage.length > 0
+          ? { failedStage: t.failedStage }
+          : {}),
+        // Prefer new files.* schema, fallback to legacy artifacts
+        files:
+          t && t.files
+            ? {
+                artifacts: Array.isArray(t.files.artifacts)
+                  ? t.files.artifacts.slice()
+                  : [],
+                logs: Array.isArray(t.files.logs) ? t.files.logs.slice() : [],
+                tmp: Array.isArray(t.files.tmp) ? t.files.tmp.slice() : [],
+              }
+            : {
+                artifacts: [],
+                logs: [],
+                tmp: [],
+              },
+        artifacts: Array.isArray(t && t.artifacts)
+          ? t.artifacts.slice()
+          : undefined,
+      };
+      tasks[name] = taskObj;
+    });
+    return { tasks, warnings };
+  }
+
+  if (Array.isArray(rawTasks)) {
+    // Array shape - convert to object for backward compatibility
+    const tasks = {};
+    rawTasks.forEach((t, idx) => {
+      const name = t && t.name ? String(t.name) : `task-${idx}`;
+      const ns = normalizeTaskState(t && t.state);
+      if (ns.warning) warnings.push(`${name}:${ns.warning}`);
+      tasks[name] = {
+        name,
+        state: ns.state,
+        startedAt: t && t.startedAt ? String(t.startedAt) : null,
+        endedAt: t && t.endedAt ? String(t.endedAt) : null,
+        attempts:
+          typeof (t && t.attempts) === "number" ? t.attempts : undefined,
+        executionTimeMs:
+          typeof (t && t.executionTimeMs) === "number"
+            ? t.executionTimeMs
+            : undefined,
+        // Preserve stage metadata for DAG visualization
+        ...(typeof t?.currentStage === "string" && t.currentStage.length > 0
+          ? { currentStage: t.currentStage }
+          : {}),
+        ...(typeof t?.failedStage === "string" && t.failedStage.length > 0
+          ? { failedStage: t.failedStage }
+          : {}),
+        artifacts: Array.isArray(t && t.artifacts)
+          ? t.artifacts.slice()
+          : undefined,
+      };
+    });
+    return { tasks, warnings };
+  }
+
+  return { tasks: {}, warnings: ["invalid_tasks_shape"] };
+}
+
+/**
+ * Derive status from tasks when status is missing/invalid.
+ * Rules:
+ * - failed if any task state === 'failed'
+ * - running if >=1 running and none failed
+ * - complete if all done
+ * - pending otherwise
+ */
+function deriveStatusFromTasks(tasks) {
+  const taskList = Object.values(tasks);
+  if (!Array.isArray(taskList) || taskList.length === 0) return "pending";
+  if (taskList.some((t) => t.state === "failed")) return "failed";
+  if (taskList.some((t) => t.state === "running")) return "running";
+  if (taskList.every((t) => t.state === "done")) return "complete";
+  return "pending";
+}
+
+/**
+ * Clamp number to 0..100 and ensure integer.
+ */
+function clampProgress(n) {
+  if (typeof n !== "number" || Number.isNaN(n)) return 0;
+  return Math.min(100, Math.max(0, Math.round(n)));
+}
+
+/**
+ * Compute summary stats from normalized tasks.
+ */
+function computeJobSummaryStats(tasks) {
+  const taskList = Object.values(tasks);
+  const taskCount = taskList.length;
+  const doneCount = taskList.reduce(
+    (acc, t) => acc + (t.state === "done" ? 1 : 0),
+    0
+  );
+  const status = deriveStatusFromTasks(tasks);
+  const progress =
+    taskCount > 0 ? Math.round((doneCount / taskCount) * 100) : 0;
+  return { status, progress, doneCount, taskCount };
+}
+
+/**
+ * adaptJobSummary(apiJob)
+ * - apiJob: object roughly matching docs 0.5 /api/jobs entry.
+ * Returns normalized summary object for UI consumption.
+ */
+export function adaptJobSummary(apiJob) {
+  // Demo-only: read canonical fields strictly
+  const id = apiJob.jobId;
+  const name = apiJob.title || "";
+  const rawTasks = apiJob.tasksStatus;
+  const location = apiJob.location;
+
+  // Job-level stage metadata
+  const current = apiJob.current;
+  const currentStage = apiJob.currentStage;
+
+  const { tasks, warnings } = normalizeTasks(rawTasks);
+
+  // Use API status and progress as source of truth, fall back to task-based computation only when missing
+  const apiStatus = apiJob.status;
+  const apiProgress = apiJob.progress;
+  const derivedStats = computeJobSummaryStats(tasks);
+
+  const job = {
+    id,
+    jobId: id,
+    name,
+    status: apiStatus || derivedStats.status,
+    progress: apiProgress ?? derivedStats.progress,
+    taskCount: derivedStats.taskCount,
+    doneCount: derivedStats.doneCount,
+    location,
+    tasks,
+  };
+
+  // Preserve job-level stage metadata
+  if (current != null) job.current = current;
+  if (currentStage != null) job.currentStage = currentStage;
+
+  // Optional/metadata fields (preserve if present)
+  if ("createdAt" in apiJob) job.createdAt = apiJob.createdAt;
+  if ("updatedAt" in apiJob) job.updatedAt = apiJob.updatedAt;
+
+  // Pipeline metadata
+  const { pipeline, pipelineLabel } = derivePipelineMetadata(apiJob);
+  if (pipeline != null) job.pipeline = pipeline;
+  if (pipelineLabel != null) job.pipelineLabel = pipelineLabel;
+
+  // Include warnings for debugging
+  if (warnings.length > 0) job.__warnings = warnings;
+
+  return job;
+}
+
+/**
+ * adaptJobDetail(apiDetail)
+ * - apiDetail: object roughly matching docs 0.5 /api/jobs/:jobId detail schema.
+ * Returns a normalized detailed job object for UI consumption.
+ */
+export function adaptJobDetail(apiDetail) {
+  // Demo-only: read canonical fields strictly
+  const id = apiDetail.jobId;
+  const name = apiDetail.title || "";
+  const rawTasks = apiDetail.tasksStatus;
+  const location = apiDetail.location;
+
+  // Job-level stage metadata
+  const current = apiDetail.current;
+  const currentStage = apiDetail.currentStage;
+
+  const { tasks, warnings } = normalizeTasks(rawTasks);
+
+  // Use API status and progress as source of truth, fall back to task-based computation only when missing
+  const apiStatus = apiDetail.status;
+  const apiProgress = apiDetail.progress;
+  const derivedStats = computeJobSummaryStats(tasks);
+
+  const detail = {
+    id,
+    jobId: id,
+    name,
+    status: apiStatus || derivedStats.status,
+    progress: apiProgress ?? derivedStats.progress,
+    taskCount: derivedStats.taskCount,
+    doneCount: derivedStats.doneCount,
+    location,
+    tasks,
+  };
+
+  // Preserve job-level stage metadata
+  if (current != null) detail.current = current;
+  if (currentStage != null) detail.currentStage = currentStage;
+
+  // Optional/metadata fields (preserve if present)
+  if ("createdAt" in apiDetail) detail.createdAt = apiDetail.createdAt;
+  if ("updatedAt" in apiDetail) detail.updatedAt = apiDetail.updatedAt;
+
+  // Pipeline metadata
+  const { pipeline, pipelineLabel } = derivePipelineMetadata(apiDetail);
+  if (pipeline != null) detail.pipeline = pipeline;
+  if (pipelineLabel != null) detail.pipelineLabel = pipelineLabel;
+
+  // Include warnings for debugging
+  if (warnings.length > 0) detail.__warnings = warnings;
+
+  return detail;
+}

package/src/ui/client/bootstrap.js

@@ -0,0 +1,120 @@
+/**
+ * Client bootstrap helper
+ *
+ * Usage:
+ *   await bootstrap({
+ *     stateUrl = '/api/state',
+ *     sseUrl = '/api/events',
+ *     applySnapshot: async (snapshot) => { ... },
+ *     onSseEvent: (type, data) => { ... }
+ *   })
+ *
+ * Semantics:
+ *  - Fetches stateUrl and awaits applySnapshot(snapshot)
+ *  - Only after applySnapshot resolves, creates EventSource(sseUrl)
+ *  - Attaches listeners for common event types and forwards them to onSseEvent
+ *  - Returns the created EventSource instance (or null on failure)
+ */
+export async function bootstrap({
+  stateUrl = "/api/state",
+  sseUrl = "/api/events",
+  applySnapshot = async () => {},
+  onSseEvent = () => {},
+} = {}) {
+  const controller = new AbortController();
+  try {
+    const res = await fetch(stateUrl, { signal: controller.signal });
+    if (res && res.ok) {
+      const json = await res.json();
+      // Allow applySnapshot to be async and await it
+      await applySnapshot(json);
+    } else {
+      // Try to parse body when available, but still call applySnapshot with whatever we get
+      let body = null;
+      if (res) {
+        try {
+          body = await res.json();
+        } catch (jsonErr) {
+          const contentType = res.headers.get("content-type");
+          console.error(
+            `[bootstrap] Failed to parse JSON from ${stateUrl}: status=${res.status}, content-type=${contentType}, error=${jsonErr}`
+          );
+          body = null;
+        }
+      }
+      await applySnapshot(body);
+    }
+  } catch (err) {
+    // Best-effort: still call applySnapshot with null so callers can handle startup failure
+    try {
+      await applySnapshot(null);
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  // Create EventSource after snapshot applied
+  let es = null;
+  try {
+    es = new EventSource(sseUrl);
+
+    // Forward 'state' events (server may send full state on connect in current implementation)
+    es.addEventListener("state", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("state", data);
+      } catch (err) {
+        // ignore parse errors
+      }
+    });
+
+    // Forward job-specific events
+    es.addEventListener("job:updated", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("job:updated", data);
+      } catch (err) {
+        // ignore parse errors
+      }
+    });
+
+    es.addEventListener("job:created", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("job:created", data);
+      } catch (err) {}
+    });
+
+    es.addEventListener("job:removed", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("job:removed", data);
+      } catch (err) {}
+    });
+
+    es.addEventListener("heartbeat", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("heartbeat", data);
+      } catch (err) {}
+    });
+
+    // Generic message handler as fallback
+    es.addEventListener("message", (evt) => {
+      try {
+        const data = JSON.parse(evt.data);
+        onSseEvent("message", data);
+      } catch (err) {}
+    });
+  } catch (err) {
+    // If EventSource creation fails, return null
+    try {
+      if (es && typeof es.close === "function") es.close();
+    } catch {}
+    return null;
+  }
+
+  return es;
+}
+
+export default bootstrap;