@ryanfw/prompt-orchestration-pipeline 0.10.0 → 0.12.0

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

@@ -3,6 +3,8 @@ import {
   normalizeTaskState,
   deriveJobStatusFromTasks,
 } from "../../../config/statuses.js";
+import { classifyJobForDisplay } from "../../../utils/jobs.js";
+import { decideTransition } from "../../../core/lifecycle-policy.js";
 
 /**
  * Normalize a raw task state into canonical enum.
@@ -75,6 +77,8 @@ function normalizeTasks(rawTasks) {
           : undefined,
         // Preserve tokenUsage if present
         ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
+        // Preserve error object if present
+        ...(t && t.error ? { error: t.error } : {}),
       };
       tasks[name] = taskObj;
     });
@@ -106,11 +110,28 @@ function normalizeTasks(rawTasks) {
         ...(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,
         // Preserve tokenUsage if present
         ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
+        // Preserve error object if present
+        ...(t && t.error ? { error: t.error } : {}),
       };
     });
     return { tasks, warnings };
@@ -152,7 +173,7 @@ export function adaptJobSummary(apiJob) {
   // Demo-only: read canonical fields strictly
   const id = apiJob.jobId;
   const name = apiJob.title || "";
-  const rawTasks = apiJob.tasks;
+  const rawTasks = apiJob.tasks || apiJob.tasksStatus; // Handle both formats for backward compatibility
   const location = apiJob.location;
 
   // Job-level stage metadata
@@ -206,6 +227,9 @@ export function adaptJobSummary(apiJob) {
     job.totalTokens = job.costsSummary.totalTokens;
   }
 
+  // Compute and attach display category for UI bucketing
+  job.displayCategory = classifyJobForDisplay(job);
+
   // Include warnings for debugging
   if (warnings.length > 0) job.__warnings = warnings;
 
@@ -221,7 +245,7 @@ export function adaptJobDetail(apiDetail) {
   // Demo-only: read canonical fields strictly
   const id = apiDetail.jobId;
   const name = apiDetail.title || "";
-  const rawTasks = apiDetail.tasks;
+  const rawTasks = apiDetail.tasks || apiDetail.tasksStatus; // Handle both formats for backward compatibility
   const location = apiDetail.location;
 
   // Job-level stage metadata
@@ -265,8 +289,63 @@ export function adaptJobDetail(apiDetail) {
     detail.costs = apiDetail.costs;
   }
 
+  // Compute and attach display category for UI bucketing
+  detail.displayCategory = classifyJobForDisplay(detail);
+
   // Include warnings for debugging
   if (warnings.length > 0) detail.__warnings = warnings;
 
   return detail;
 }
+
+/**
+ * deriveAllowedActions(adaptedJob, pipelineTasks)
+ * - adaptedJob: normalized job object from adaptJobSummary/adaptJobDetail
+ * - pipelineTasks: array of task names in execution order from pipeline.json
+ * Returns { start, restart } boolean flags for UI controls.
+ */
+export function deriveAllowedActions(adaptedJob, pipelineTasks) {
+  // Check if any task is running
+  const hasRunningTask = Object.values(adaptedJob.tasks || {}).some(
+    (task) => task.state === "running"
+  );
+
+  // Default to disabled if job state is running or any task is running
+  if (adaptedJob.status === "running" || hasRunningTask) {
+    return { start: false, restart: false };
+  }
+
+  // Default to enabled for restart if not running
+  const restart = true;
+
+  // Start requires checking if ANY task can be started (not ALL tasks)
+  // Edge case: if no pipeline tasks, default to enabled
+  if (pipelineTasks.length === 0) {
+    return { start: true, restart };
+  }
+
+  const start = pipelineTasks.some((taskName) => {
+    const task = adaptedJob.tasks[taskName];
+    if (!task) return false; // Task not found, skip
+
+    const taskState = task.state || "pending";
+
+    // Check if all upstream tasks are done for dependency evaluation
+    const taskIndex = pipelineTasks.indexOf(taskName);
+    const upstreamTasks = pipelineTasks.slice(0, taskIndex);
+    const dependenciesReady = upstreamTasks.every((upstreamTaskName) => {
+      const upstreamTask = adaptedJob.tasks[upstreamTaskName];
+      return upstreamTask && upstreamTask.state === "done";
+    });
+
+    const startDecision = decideTransition({
+      op: "start",
+      taskState,
+      dependenciesReady,
+    });
+
+    return startDecision.ok;
+  });
+
+  return { start, restart };
+}

package/src/ui/client/api.js

@@ -3,12 +3,14 @@
  */
 
 /**
- * Restart a job with clean-slate mode
+ * Restart a job with clean-slate mode or from a specific task
  *
  * @param {string} jobId - The ID of the job to restart
  * @param {Object} opts - Options object
- * @param {Object} opts.options - Additional options for the restart
- * @param {boolean} opts.options.clearTokenUsage - Whether to clear token usage (default: true)
+ * @param {string} [opts.fromTask] - Task ID to restart from (inclusive)
+ * @param {boolean} [opts.singleTask] - Whether to run only the target task and then stop
+ * @param {Object} [opts.options] - Additional options for the restart
+ * @param {boolean} [opts.options.clearTokenUsage=true] - Whether to clear token usage
  * @returns {Promise<Object>} Parsed JSON response from the server
  * @throws {Object} Structured error object with { code, message } for non-2xx responses
  */
@@ -19,8 +21,16 @@ export async function restartJob(jobId, opts = {}) {
   };
 
   const requestBody = opts.fromTask
-    ? { fromTask: opts.fromTask, options }
-    : { mode: "clean-slate", options };
+    ? {
+        fromTask: opts.fromTask,
+        options,
+        ...(opts.singleTask !== undefined && { singleTask: opts.singleTask }),
+      }
+    : {
+        mode: "clean-slate",
+        options,
+        ...(opts.singleTask !== undefined && { singleTask: opts.singleTask }),
+      };
 
   try {
     const response = await fetch(
@@ -67,6 +77,164 @@ export async function restartJob(jobId, opts = {}) {
   }
 }
 
+/**
+ * Rescan a job to synchronize tasks with the pipeline definition, detecting both added and removed tasks.
+ *
+ * @param {string} jobId - The ID of the job to rescan
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function rescanJob(jobId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/rescan`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message:
+          errorData.message || getErrorMessageFromStatus(response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Start a specific pending task for a job that is not actively running
+ *
+ * @param {string} jobId - The ID of the job
+ * @param {string} taskId - The ID of the task to start
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function startTask(jobId, taskId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/tasks/${encodeURIComponent(taskId)}/start`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getStartTaskErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Stop a running job's pipeline
+ *
+ * @param {string} jobId - The ID of the job to stop
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function stopJob(jobId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/stop`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getStopErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
 /**
  * Map HTTP status codes to error codes for structured error handling
  */
@@ -108,9 +276,6 @@ function getRestartErrorMessage(errorData, status) {
     if (errorData.code === "job_running") {
       return "Job is currently running; restart is unavailable.";
     }
-    if (errorData.code === "unsupported_lifecycle") {
-      return "Job must be in current to restart.";
-    }
     if (errorData.message?.includes("job_running")) {
       return "Job is currently running; restart is unavailable.";
     }
@@ -132,3 +297,63 @@ function getRestartErrorMessage(errorData, status) {
   // Fall back to provided message or default
   return errorData.message || "Failed to restart job.";
 }
+
+/**
+ * Get specific error message from error response for start task functionality
+ */
+function getStartTaskErrorMessage(errorData, status) {
+  // Handle specific 409 conflict errors
+  if (status === 409) {
+    if (errorData.code === "job_running") {
+      return "Job is currently running; start is unavailable.";
+    }
+    if (errorData.code === "dependencies_not_satisfied") {
+      return "Dependencies not satisfied for task.";
+    }
+    if (errorData.code === "unsupported_lifecycle") {
+      return "Job must be in current to start a task.";
+    }
+    return "Request conflict.";
+  }
+
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 400 errors
+  if (status === 400) {
+    return errorData.message || "Bad request";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Internal server error";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || "Failed to start task.";
+}
+
+/**
+ * Get specific error message from error response for stop functionality
+ */
+function getStopErrorMessage(errorData, status) {
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 409 errors
+  if (status === 409) {
+    return errorData.message || "Job stop is already in progress.";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Internal server error";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || `Request failed with status ${status}`;
+}

package/src/ui/client/hooks/useJobDetailWithUpdates.js

@@ -347,6 +347,7 @@ export function useJobDetailWithUpdates(jobId) {
               newEs.addEventListener("job:removed", onJobRemoved);
               newEs.addEventListener("status:changed", onStatusChanged);
               newEs.addEventListener("state:change", onStateChange);
+              newEs.addEventListener("task:updated", onTaskUpdated);
               newEs.addEventListener("error", onError);
 
               esRef.current = newEs;
@@ -373,6 +374,94 @@ export function useJobDetailWithUpdates(jobId) {
             return;
           }
 
+          // Handle task:updated events with task-level merge logic
+          if (type === "task:updated") {
+            const p = payload || {};
+            const { jobId: eventJobId, taskId, task } = p;
+
+            // Filter by jobId
+            if (eventJobId && eventJobId !== jobId) {
+              return;
+            }
+
+            // Validate required fields
+            if (!taskId || !task) {
+              return;
+            }
+
+            startTransition(() => {
+              setData((prev) => {
+                // If no previous data or tasks, return unchanged
+                if (!prev || !prev.tasks) {
+                  return prev;
+                }
+
+                const prevTask = prev.tasks[taskId];
+
+                // Compare observable fields to determine if update is needed
+                const fieldsToCompare = [
+                  "state",
+                  "currentStage",
+                  "failedStage",
+                  "startedAt",
+                  "endedAt",
+                  "attempts",
+                  "executionTimeMs",
+                  "error",
+                ];
+
+                let hasChanged = false;
+
+                // If task doesn't exist yet, always treat as changed
+                if (!prevTask) {
+                  hasChanged = true;
+                } else {
+                  // Compare observable fields to determine if update is needed
+                  for (const field of fieldsToCompare) {
+                    if (prevTask[field] !== task[field]) {
+                      hasChanged = true;
+                      break;
+                    }
+                  }
+
+                  // Also compare tokenUsage and files arrays by reference
+                  if (
+                    prevTask.tokenUsage !== task.tokenUsage ||
+                    prevTask.files !== task.files
+                  ) {
+                    hasChanged = true;
+                  }
+                }
+
+                if (!hasChanged) {
+                  return prev; // No change, preserve identity
+                }
+
+                // Create new tasks map with updated task
+                const nextTasks = { ...prev.tasks, [taskId]: task };
+
+                // Recompute job-level summary fields
+                const taskCount = Object.keys(nextTasks).length;
+                const doneCount = Object.values(nextTasks).filter(
+                  (t) => t.state === "done"
+                ).length;
+                const progress =
+                  taskCount > 0 ? (doneCount / taskCount) * 100 : 0;
+
+                // Return new job object with updated tasks and summary
+                return {
+                  ...prev,
+                  tasks: nextTasks,
+                  doneCount,
+                  taskCount,
+                  progress,
+                  lastUpdated: new Date().toISOString(),
+                };
+              });
+            });
+            return; // Skip generic handling for task:updated
+          }
+
           // Path-matching state:change → schedule debounced refetch
           if (type === "state:change") {
             const d = (payload && (payload.data || payload)) || {};
@@ -415,6 +504,7 @@ export function useJobDetailWithUpdates(jobId) {
       const onStatusChanged = (evt) =>
         handleIncomingEvent("status:changed", evt);
       const onStateChange = (evt) => handleIncomingEvent("state:change", evt);
+      const onTaskUpdated = (evt) => handleIncomingEvent("task:updated", evt);
 
       es.addEventListener("open", onOpen);
       es.addEventListener("job:updated", onJobUpdated);
@@ -422,6 +512,7 @@ export function useJobDetailWithUpdates(jobId) {
       es.addEventListener("job:removed", onJobRemoved);
       es.addEventListener("status:changed", onStatusChanged);
       es.addEventListener("state:change", onStateChange);
+      es.addEventListener("task:updated", onTaskUpdated);
       es.addEventListener("error", onError);
 
       // Set connection status from readyState when possible
@@ -439,6 +530,7 @@ export function useJobDetailWithUpdates(jobId) {
           es.removeEventListener("job:removed", onJobRemoved);
           es.removeEventListener("status:changed", onStatusChanged);
           es.removeEventListener("state:change", onStateChange);
+          es.removeEventListener("task:updated", onTaskUpdated);
           es.removeEventListener("error", onError);
           es.close();
         } catch (err) {

package/src/ui/client/hooks/useJobList.js

@@ -20,7 +20,20 @@ export function useJobList() {
         setData(null);
       } else {
         const json = await res.json();
-        setData(json);
+        if (json && typeof json === "object" && "ok" in json) {
+          if (json.ok && Array.isArray(json.data)) {
+            setData(json.data);
+          } else if (!json.ok) {
+            setError({ code: json.code, message: json.message });
+            setData(null);
+          } else {
+            // Fallback: data is not an array; treat as empty to avoid crashes
+            setData([]);
+          }
+        } else {
+          // Legacy path: response is already an array
+          setData(Array.isArray(json) ? json : []);
+        }
       }
     } catch (err) {
       if (err.name === "AbortError") {