@ryanfw/prompt-orchestration-pipeline 0.11.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "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",
@@ -43,6 +43,7 @@
     "chokidar": "^3.5.3",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
+    "express": "^4.19.2",
     "fflate": "^0.8.2",
     "lucide-react": "^0.544.0",
     "openai": "^5.23.1",

package/src/components/DAGGrid.jsx

@@ -10,9 +10,10 @@ import { areGeometriesEqual } from "../utils/geometry-equality.js";
 import { TaskDetailSidebar } from "./TaskDetailSidebar.jsx";
 import { RestartJobModal } from "./ui/RestartJobModal.jsx";
 import { Button } from "./ui/button.jsx";
-import { restartJob } from "../ui/client/api.js";
+import { restartJob, startTask } from "../ui/client/api.js";
 import { createEmptyTaskFiles } from "../utils/task-files.js";
 import { TaskState } from "../config/statuses.js";
+import { deriveAllowedActions } from "../ui/client/adapters/job-adapter.js";
 import TimerText from "./TimerText.jsx";
 import { taskToTimerProps } from "../utils/time-utils.js";
 
@@ -87,6 +88,11 @@ const canShowRestart = (status) => {
   return status === TaskState.FAILED || status === TaskState.DONE;
 };
 
+// Check if Start button should be shown for a given status
+const canShowStart = (status) => {
+  return status === TaskState.PENDING;
+};
+
 // Custom comparison function for TaskCard memoization
 const areEqualTaskCardProps = (prevProps, nextProps) => {
   return (
@@ -95,11 +101,14 @@ const areEqualTaskCardProps = (prevProps, nextProps) => {
     prevProps.status === nextProps.status &&
     prevProps.isActive === nextProps.isActive &&
     prevProps.canRestart === nextProps.canRestart &&
+    prevProps.canStart === nextProps.canStart &&
     prevProps.isSubmitting === nextProps.isSubmitting &&
     prevProps.disabledReason === nextProps.disabledReason &&
+    prevProps.startDisabledReason === nextProps.startDisabledReason &&
     prevProps.onClick === nextProps.onClick &&
     prevProps.onKeyDown === nextProps.onKeyDown &&
-    prevProps.handleRestartClick === nextProps.handleRestartClick
+    prevProps.handleRestartClick === nextProps.handleRestartClick &&
+    prevProps.handleStartClick === nextProps.handleStartClick
   );
 };
 
@@ -111,11 +120,14 @@ const TaskCard = memo(function TaskCard({
   status,
   isActive,
   canRestart,
+  canStart,
   isSubmitting,
   disabledReason,
+  startDisabledReason,
   onClick,
   onKeyDown,
   handleRestartClick,
+  handleStartClick,
 }) {
   const { startMs, endMs } = taskToTimerProps(item);
   const reducedMotion = prefersReducedMotion();
@@ -196,9 +208,24 @@ const TaskCard = memo(function TaskCard({
           <div className="mt-2 text-sm text-gray-700">{item.body}</div>
         )}
 
-        {/* Restart button */}
-        {canShowRestart(status) && (
-          <div className="mt-3 pt-3 border-t border-gray-100">
+        {/* Action buttons */}
+        <div className="mt-3 pt-3 border-t border-gray-100 flex gap-2">
+          {/* Start button */}
+          {canShowStart(status) && (
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={(e) => handleStartClick(e, item.id)}
+              disabled={!canStart || isSubmitting}
+              className="text-xs cursor-pointer disabled:cursor-not-allowed"
+              title={!canStart ? startDisabledReason : `Start task ${item.id}`}
+            >
+              Start
+            </Button>
+          )}
+
+          {/* Restart button */}
+          {canShowRestart(status) && (
             <Button
               variant="outline"
               size="sm"
@@ -211,8 +238,8 @@ const TaskCard = memo(function TaskCard({
             >
               Restart
             </Button>
-          </div>
-        )}
+          )}
+        </div>
       </div>
     </div>
   );
@@ -237,6 +264,7 @@ function DAGGrid({
   jobId,
   filesByTypeForItem = () => createEmptyTaskFiles(),
   taskById = {},
+  pipelineTasks = [],
 }) {
   const overlayRef = useRef(null);
   const gridRef = useRef(null);
@@ -443,15 +471,11 @@ function DAGGrid({
     }
 
     const handleResize = () => compute();
-    const handleScroll = () => compute();
-
     window.addEventListener("resize", handleResize);
-    window.addEventListener("scroll", handleScroll, true);
 
     return () => {
       if (ro) ro.disconnect();
       window.removeEventListener("resize", handleResize);
-      window.removeEventListener("scroll", handleScroll, true);
       if (rafRef.current) {
         cancelAnimationFrame(rafRef.current);
       }
@@ -487,6 +511,62 @@ function DAGGrid({
     }
   }, [openIdx]);
 
+  // Start functionality
+  const handleStartClick = async (e, taskId) => {
+    e.stopPropagation(); // Prevent card click
+
+    if (!jobId || isSubmitting) return;
+
+    setIsSubmitting(true);
+    setAlertMessage(null);
+
+    try {
+      await startTask(jobId, taskId);
+
+      const successMessage = `Task ${taskId} started successfully.`;
+      setAlertMessage(successMessage);
+      setAlertType("success");
+    } catch (error) {
+      let message;
+      let type;
+
+      switch (error.code) {
+        case "job_running":
+          message = "Job is currently running; start is unavailable.";
+          type = "warning";
+          break;
+        case "job_not_found":
+          message = "Job not found.";
+          type = "error";
+          break;
+        case "task_not_found":
+          message = "Task not found.";
+          type = "error";
+          break;
+        case "task_not_pending":
+          message = "Task is not in pending state.";
+          type = "warning";
+          break;
+        case "dependencies_not_satisfied":
+          message = "Dependencies not satisfied for task.";
+          type = "warning";
+          break;
+        case "unsupported_lifecycle":
+          message = "Job must be in current to start a task.";
+          type = "warning";
+          break;
+        default:
+          message = error.message || "An unexpected error occurred.";
+          type = "error";
+      }
+
+      setAlertMessage(message);
+      setAlertType(type);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
   // Restart functionality
   const handleRestartClick = (e, taskId) => {
     e.stopPropagation(); // Prevent card click
@@ -494,7 +574,7 @@ function DAGGrid({
     setRestartModalOpen(true);
   };
 
-  const handleRestartConfirm = async () => {
+  const handleRestartConfirm = async (options) => {
     if (!jobId || isSubmitting) return;
 
     setIsSubmitting(true);
@@ -505,12 +585,17 @@ function DAGGrid({
       if (restartTaskId) {
         restartOptions.fromTask = restartTaskId;
       }
+      if (options?.singleTask) {
+        restartOptions.singleTask = options.singleTask;
+      }
 
       await restartJob(jobId, restartOptions);
 
-      const successMessage = restartTaskId
-        ? `Restart requested from ${restartTaskId}. The job will start from that task in the background.`
-        : "Restart requested. The job will reset to pending and start in the background.";
+      const successMessage = options?.singleTask
+        ? `Re-running task ${restartTaskId} in isolation. The job will remain in current after completion.`
+        : restartTaskId
+          ? `Restart requested from ${restartTaskId}. The job will start from that task in the background.`
+          : "Restart requested. The job will reset to pending and start in the background.";
       setAlertMessage(successMessage);
       setAlertType("success");
       setRestartModalOpen(false);
@@ -524,10 +609,6 @@ function DAGGrid({
           message = "Job is currently running; restart is unavailable.";
           type = "warning";
           break;
-        case "unsupported_lifecycle":
-          message = "Job must be in current lifecycle to restart.";
-          type = "warning";
-          break;
         case "job_not_found":
           message = "Job not found.";
           type = "error";
@@ -563,41 +644,65 @@ function DAGGrid({
     }
   }, [alertMessage]);
 
-  // Check if restart should be enabled (job lifecycle = current and not running)
-  const isRestartEnabled = React.useCallback(() => {
-    // Check if any item indicates that job is running (job-level state)
-    const isJobRunning = items.some(
-      (item) => item?.state === TaskState.RUNNING
-    );
-
-    // Check if any task has explicit running status (not derived from activeIndex)
-    const hasRunningTask = items.some(
-      (item) => item?.status === TaskState.RUNNING
-    );
+  // Use adapter to derive allowed actions based on job and task states
+  const allowedActions = React.useMemo(() => {
+    // Create a normalized job object for the adapter
+    const adaptedJob = {
+      status: items.some((item) => item?.state === TaskState.RUNNING)
+        ? "running"
+        : "pending",
+      tasks: items.reduce((acc, item) => {
+        if (item?.id) {
+          acc[item.id] = {
+            state: item?.status || TaskState.PENDING,
+          };
+        }
+        return acc;
+      }, {}),
+    };
 
-    const jobLifecycle = items[0]?.lifecycle || "current";
+    return deriveAllowedActions(adaptedJob, pipelineTasks);
+  }, [items, pipelineTasks]);
 
-    return jobLifecycle === "current" && !isJobRunning && !hasRunningTask;
-  }, [items]);
+  // Check if restart should be enabled using adapter logic
+  const isRestartEnabled = React.useCallback(() => {
+    return allowedActions.restart;
+  }, [allowedActions]);
+
+  // Check if start should be enabled for a specific task using adapter logic
+  const canStartTask = React.useCallback(
+    (task) => {
+      if (!task) return false;
+
+      // Use adapter logic - start is enabled globally, so check if this specific task can start
+      return allowedActions.start && task.status === TaskState.PENDING;
+    },
+    [allowedActions]
+  );
 
-  // Get disabled reason for tooltip
+  // Get disabled reason for tooltip using adapter logic
   const getRestartDisabledReason = React.useCallback(() => {
-    // Check if any item indicates that job is running (job-level state)
-    const isJobRunning = items.some(
-      (item) => item?.state === TaskState.RUNNING
-    );
+    if (allowedActions.restart) return "";
+    return "Job is currently running";
+  }, [allowedActions]);
 
-    // Check if any task has explicit running status (not derived from activeIndex)
-    const hasRunningTask = items.some(
-      (item) => item?.status === TaskState.RUNNING
-    );
+  // Get disabled reason for start tooltip using adapter logic
+  const getStartDisabledReason = React.useCallback(
+    (task) => {
+      if (!task) return "Task not found";
 
-    const jobLifecycle = items[0]?.lifecycle || "current";
+      if (task.status !== TaskState.PENDING) {
+        return "Task is not in pending state";
+      }
+
+      if (!allowedActions.start) {
+        return "Job lifecycle policy does not allow starting";
+      }
 
-    if (isJobRunning || hasRunningTask) return "Job is currently running";
-    if (jobLifecycle !== "current") return "Job must be in current lifecycle";
-    return "";
-  }, [items]);
+      return "";
+    },
+    [allowedActions]
+  );
 
   return (
     <div className="relative w-full" role="list">
@@ -694,7 +799,9 @@ function DAGGrid({
           const status = getStatus(idx);
           const isActive = idx === activeIndex;
           const canRestart = isRestartEnabled();
+          const canStart = canStartTask(item);
           const restartDisabledReason = getRestartDisabledReason();
+          const startDisabledReason = getStartDisabledReason(item);
 
           return (
             <TaskCard
@@ -704,8 +811,10 @@ function DAGGrid({
               status={status}
               isActive={isActive}
               canRestart={canRestart}
+              canStart={canStart}
               isSubmitting={isSubmitting}
               disabledReason={restartDisabledReason}
+              startDisabledReason={startDisabledReason}
               onClick={() => {
                 setOpenIdx(idx);
               }}
@@ -716,6 +825,7 @@ function DAGGrid({
                 }
               }}
               handleRestartClick={handleRestartClick}
+              handleStartClick={handleStartClick}
               item={item}
             />
           );

package/src/components/ui/RestartJobModal.jsx

@@ -7,7 +7,7 @@ import { Button } from "./button.jsx";
  * @param {Object} props
  * @param {boolean} props.open - Whether the modal is open
  * @param {Function} props.onClose - Function to call when modal is closed
- * @param {Function} props.onConfirm - Function to call when restart is confirmed
+ * @param {Function} props.onConfirm - Function to call when restart is confirmed (receives options object)
  * @param {string} props.jobId - The ID of the job to restart
  * @param {string} props.taskId - The ID of the task that triggered the restart (optional)
  * @param {boolean} props.isSubmitting - Whether the restart action is in progress
@@ -47,7 +47,10 @@ export function RestartJobModal({
   const handleKeyDown = (e) => {
     if (e.key === "Enter" && !isSubmitting && open) {
       e.preventDefault();
-      onConfirm();
+      // Do not confirm via Enter when a task is set; let the user click explicitly
+      if (!taskId) {
+        onConfirm({ singleTask: false });
+      }
     }
   };
 
@@ -100,9 +103,15 @@ export function RestartJobModal({
               </Text>
 
               {taskId && (
-                <Text as="p" className="text-sm text-gray-600 mb-3">
-                  <strong>Triggered from task:</strong> {taskId}
-                </Text>
+                <>
+                  <Text as="p" className="text-sm text-gray-600 mb-3">
+                    <strong>Triggered from task:</strong> {taskId}
+                  </Text>
+                  <Text as="p" className="text-sm text-blue-600 mb-3">
+                    <strong>Just this task:</strong> Only the selected task will
+                    be reset and re-run. Other tasks remain unchanged.
+                  </Text>
+                </>
               )}
 
               <Text as="p" className="text-sm text-gray-500 italic">
@@ -121,9 +130,20 @@ export function RestartJobModal({
                 Cancel
               </Button>
 
+              {taskId && (
+                <Button
+                  variant="outline"
+                  onClick={() => onConfirm({ singleTask: true })}
+                  disabled={isSubmitting}
+                  className="min-w-[120px]"
+                >
+                  {isSubmitting ? "Running..." : "Just this task"}
+                </Button>
+              )}
+
               <Button
                 variant="destructive"
-                onClick={onConfirm}
+                onClick={() => onConfirm({ singleTask: false })}
                 disabled={isSubmitting}
                 className="min-w-[80px]"
               >

package/src/components/ui/StopJobModal.jsx

@@ -0,0 +1,183 @@
+import React, { useEffect, useRef, useState } from "react";
+import { Box, Flex, Text, Heading, Select } from "@radix-ui/themes";
+import { Button } from "./button.jsx";
+
+/**
+ * StopJobModal component for confirming job stop
+ * @param {Object} props
+ * @param {boolean} props.isOpen - Whether the modal is open
+ * @param {Function} props.onClose - Function to call when modal is closed
+ * @param {Function} props.onConfirm - Function to call when stop is confirmed (receives jobId)
+ * @param {Array} props.runningJobs - Array of running jobs with {id, name, progress?}
+ * @param {string} [props.defaultJobId] - Default job ID to pre-select
+ * @param {boolean} props.isSubmitting - Whether the stop action is in progress
+ */
+export function StopJobModal({
+  isOpen,
+  onClose,
+  onConfirm,
+  runningJobs,
+  defaultJobId,
+  isSubmitting = false,
+}) {
+  const modalRef = useRef(null);
+  const [selectedJobId, setSelectedJobId] = useState(defaultJobId || "");
+
+  // Reset selected job when modal opens/closes
+  useEffect(() => {
+    if (isOpen) {
+      setSelectedJobId(
+        defaultJobId || (runningJobs.length === 1 ? runningJobs[0].id : "")
+      );
+    }
+  }, [isOpen, defaultJobId]);
+
+  // Handle Escape key to close modal
+  useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape" && isOpen) {
+        e.preventDefault();
+        onClose();
+      }
+    };
+
+    if (isOpen) {
+      document.addEventListener("keydown", handleKeyDown);
+      // Focus the modal for accessibility
+      if (modalRef.current) {
+        modalRef.current.focus();
+      }
+      return () => {
+        document.removeEventListener("keydown", handleKeyDown);
+      };
+    }
+  }, [isOpen, onClose]);
+
+  // Handle Enter key to confirm when modal is focused
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !isSubmitting && isOpen && selectedJobId) {
+      e.preventDefault();
+      onConfirm(selectedJobId);
+    }
+  };
+
+  if (!isOpen) return null;
+
+  const handleConfirm = () => {
+    if (selectedJobId) {
+      onConfirm(selectedJobId);
+    }
+  };
+
+  const selectedJob = runningJobs.find((job) => job.id === selectedJobId);
+
+  return (
+    <>
+      <div
+        className="fixed inset-0 z-50 flex items-center justify-center"
+        aria-hidden={!isOpen}
+      >
+        {/* Backdrop */}
+        <div
+          className="absolute inset-0 bg-black/50"
+          onClick={onClose}
+          aria-hidden="true"
+        />
+
+        {/* Modal */}
+        <div
+          ref={modalRef}
+          role="dialog"
+          aria-modal="true"
+          aria-labelledby="stop-modal-title"
+          aria-describedby="stop-modal-description"
+          className="relative bg-white rounded-lg shadow-2xl border border-gray-200 max-w-lg w-full mx-4 outline-none"
+          style={{ minWidth: "320px", maxWidth: "560px" }}
+          tabIndex={-1}
+          onKeyDown={handleKeyDown}
+        >
+          <div className="p-6">
+            {/* Header */}
+            <Heading
+              id="stop-modal-title"
+              as="h2"
+              size="5"
+              className="mb-4 text-gray-900"
+            >
+              Stop pipeline?
+            </Heading>
+
+            {/* Body */}
+            <Box id="stop-modal-description" className="mb-6">
+              <Text as="p" className="text-gray-700 mb-4">
+                This will stop the running pipeline and reset the current task
+                to pending. The pipeline will remain stopped until explicitly
+                started or restarted. Files and artifacts are preserved. This
+                cannot be undone.
+              </Text>
+
+              {runningJobs.length > 1 && !defaultJobId && (
+                <Box className="mb-4">
+                  <Text as="p" className="text-sm text-gray-600 mb-2">
+                    Select which job to stop:
+                  </Text>
+                  <Select.Root
+                    value={selectedJobId}
+                    onValueChange={setSelectedJobId}
+                    disabled={isSubmitting}
+                  >
+                    <Select.Trigger className="w-full" />
+                    <Select.Content>
+                      {runningJobs.map((job) => (
+                        <Select.Item key={job.id} value={job.id}>
+                          {job.name}{" "}
+                          {job.progress !== undefined &&
+                            `(${Math.round(job.progress)}%)`}
+                        </Select.Item>
+                      ))}
+                    </Select.Content>
+                  </Select.Root>
+                </Box>
+              )}
+
+              {selectedJob && (
+                <Text as="p" className="text-sm text-blue-600 mb-3">
+                  <strong>Job to stop:</strong> {selectedJob.name}
+                  {selectedJob.progress !== undefined &&
+                    ` (${Math.round(selectedJob.progress)}%)`}
+                </Text>
+              )}
+
+              <Text as="p" className="text-sm text-gray-500 italic">
+                Note: The job must be currently running to be stopped.
+              </Text>
+            </Box>
+
+            {/* Actions */}
+            <Flex gap="3" justify="end">
+              <Button
+                variant="outline"
+                onClick={onClose}
+                disabled={isSubmitting}
+                className="min-w-[80px]"
+              >
+                Cancel
+              </Button>
+
+              <Button
+                variant="destructive"
+                onClick={handleConfirm}
+                disabled={!selectedJobId || isSubmitting}
+                className="min-w-[80px]"
+              >
+                {isSubmitting ? "Stopping..." : "Stop"}
+              </Button>
+            </Flex>
+          </div>
+        </div>
+      </div>
+    </>
+  );
+}
+
+export default StopJobModal;

package/src/core/config.js

@@ -515,9 +515,13 @@ export function getConfig() {
       Object.keys(currentConfig.pipelines).length === 0
     ) {
       const repoRoot = resolveRepoRoot(currentConfig);
-      throw new Error(
-        `No pipelines are registered. Create pipeline-config/registry.json in ${repoRoot} to register pipelines.`
-      );
+      // In test environment, we might start without pipelines and add them later
+      // so we just warn instead of throwing, or handle it gracefully
+      if (process.env.NODE_ENV !== "test") {
+        throw new Error(
+          `No pipelines are registered. Create pipeline-config/registry.json in ${repoRoot} to register pipelines.`
+        );
+      }
     }
   }
   return currentConfig;

package/src/core/lifecycle-policy.js

@@ -0,0 +1,62 @@
+/**
+ * Static Lifecycle Policy - Pure decision engine for task transitions
+ *
+ * This module implements centralized lifecycle rules without configuration
+ * or runtime toggles, following the principle of explicit failure.
+ */
+
+/**
+ * Decide if a task transition is allowed based on static lifecycle rules
+ * @param {Object} params - Decision parameters
+ * @param {string} params.op - Operation: "start" | "restart"
+ * @param {string} params.taskState - Current task state
+ * @param {boolean} params.dependenciesReady - Whether all upstream dependencies are satisfied
+ * @returns {Object} Decision result - { ok: true } | { ok: false, code: "unsupported_lifecycle", reason: "dependencies"|"policy" }
+ */
+export function decideTransition({ op, taskState, dependenciesReady }) {
+  // Validate inputs early - let it crash on invalid data
+  if (typeof op !== "string" || !["start", "restart"].includes(op)) {
+    throw new Error(`Invalid operation: ${op}. Must be "start" or "restart"`);
+  }
+
+  if (typeof taskState !== "string") {
+    throw new Error(`Invalid taskState: ${taskState}. Must be a string`);
+  }
+
+  if (typeof dependenciesReady !== "boolean") {
+    throw new Error(
+      `Invalid dependenciesReady: ${dependenciesReady}. Must be boolean`
+    );
+  }
+
+  // Handle start operation
+  if (op === "start") {
+    if (!dependenciesReady) {
+      return Object.freeze({
+        ok: false,
+        code: "unsupported_lifecycle",
+        reason: "dependencies",
+      });
+    }
+    return Object.freeze({ ok: true });
+  }
+
+  // Handle restart operation
+  if (op === "restart") {
+    if (taskState === "completed") {
+      return Object.freeze({ ok: true });
+    }
+    return Object.freeze({
+      ok: false,
+      code: "unsupported_lifecycle",
+      reason: "policy",
+    });
+  }
+
+  // This should never be reached due to input validation
+  return Object.freeze({
+    ok: false,
+    code: "unsupported_lifecycle",
+    reason: "policy",
+  });
+}