@ryanfw/prompt-orchestration-pipeline 0.0.1 → 0.4.0

package/src/ui/watcher.js

@@ -4,6 +4,18 @@
  */
 
 import chokidar from "chokidar";
+import path from "node:path";
+import { detectJobChange } from "./job-change-detector.js";
+import { sseEnhancer } from "./sse-enhancer.js";
+
+/**
+ * Normalize path separators to forward slash and trim
+ * Reuses the same logic from job-change-detector
+ */
+function normalizePath(p) {
+  if (!p || typeof p !== "string") return "";
+  return p.replace(/\\/g, "/").replace(/\/\/+/g, "/");
+}
 
 /**
  * Start watching specified paths for file changes
@@ -11,10 +23,15 @@ import chokidar from "chokidar";
  * @param {Function} onChange - Callback function to handle file changes
  * @param {Object} options - Configuration options
  * @param {number} options.debounceMs - Debounce time in milliseconds (default: 200)
+ * @param {string} options.baseDir - Base directory for path normalization (required)
  * @returns {Object} Watcher instance with close method
  */
 export function start(paths, onChange, options = {}) {
-  const debounceMs = options.debounceMs || 200;
+  if (!options.baseDir) {
+    throw new Error("options.baseDir is required");
+  }
+
+  const { baseDir, debounceMs = 200 } = options;
   let debounceTimer = null;
   let pendingChanges = [];
 
@@ -42,19 +59,56 @@ export function start(paths, onChange, options = {}) {
   };
 
   // Handle file events
-  watcher.on("add", (path) => {
-    pendingChanges.push({ path, type: "created" });
+  watcher.on("add", (rawPath) => {
+    // Compute relative path from baseDir and normalize
+    const rel = normalizePath(path.relative(baseDir, rawPath));
+    // Always use relative path for consistency with tests
+    const normalizedPath = rel;
+
+    console.debug("[Watcher] File added:", normalizedPath);
+    pendingChanges.push({ path: normalizedPath, type: "created" });
     scheduleFlush();
+
+    // Check for job-specific changes with normalized path
+    const jobChange = detectJobChange(normalizedPath);
+    if (jobChange) {
+      console.debug("[Watcher] Job change detected:", jobChange);
+      sseEnhancer.handleJobChange(jobChange);
+    }
   });
 
-  watcher.on("change", (path) => {
-    pendingChanges.push({ path, type: "modified" });
+  watcher.on("change", (rawPath) => {
+    // Compute relative path from baseDir and normalize
+    const rel = normalizePath(path.relative(baseDir, rawPath));
+    // Always use relative path for consistency with tests
+    const normalizedPath = rel;
+
+    console.debug("[Watcher] File changed:", normalizedPath);
+    pendingChanges.push({ path: normalizedPath, type: "modified" });
     scheduleFlush();
+
+    // Check for job-specific changes with normalized path
+    const jobChange = detectJobChange(normalizedPath);
+    if (jobChange) {
+      console.debug("[Watcher] Job change detected:", jobChange);
+      sseEnhancer.handleJobChange(jobChange);
+    }
   });
 
-  watcher.on("unlink", (path) => {
-    pendingChanges.push({ path, type: "deleted" });
+  watcher.on("unlink", (rawPath) => {
+    // Compute relative path from baseDir and normalize
+    const rel = normalizePath(path.relative(baseDir, rawPath));
+    // Always use relative path for consistency with tests
+    const normalizedPath = rel;
+
+    pendingChanges.push({ path: normalizedPath, type: "deleted" });
     scheduleFlush();
+
+    // Check for job-specific changes with normalized path
+    const jobChange = detectJobChange(normalizedPath);
+    if (jobChange) {
+      sseEnhancer.handleJobChange(jobChange);
+    }
   });
 
   // Return watcher with enhanced close method

package/src/utils/dag.js

@@ -0,0 +1,101 @@
+function normalizeJobTasks(tasks) {
+  if (!tasks) return {};
+
+  if (Array.isArray(tasks)) {
+    const taskMap = {};
+    for (const task of tasks) {
+      const taskId = task?.name || task?.id;
+      if (taskId) taskMap[taskId] = task;
+    }
+    return taskMap;
+  }
+
+  return tasks;
+}
+
+export function computeTaskStage(job, taskId) {
+  const tasks = normalizeJobTasks(job?.tasks);
+  const t = tasks?.[taskId];
+
+  // Priority 1: Task-level currentStage (most specific)
+  if (typeof t?.currentStage === "string" && t.currentStage.length > 0) {
+    return t.currentStage;
+  }
+
+  // Priority 2: Job-level currentStage ONLY if this task IS the current task
+  if (
+    job?.current === taskId &&
+    typeof job?.currentStage === "string" &&
+    job.currentStage.length > 0
+  ) {
+    return job.currentStage;
+  }
+
+  // Priority 3: failedStage for failed tasks
+  if (typeof t?.failedStage === "string" && t.failedStage.length > 0) {
+    return t.failedStage;
+  }
+
+  // Priority 4: Error debug info
+  if (typeof t?.error?.debug?.stage === "string") {
+    return t.error.debug.stage;
+  }
+
+  // No stage information available
+  return undefined;
+}
+
+export function computeDagItems(job, pipeline) {
+  const jobTasks = normalizeJobTasks(job?.tasks);
+  const pipelineTasks = pipeline?.tasks || [];
+
+  const pipelineItems = pipelineTasks.map((taskId) => {
+    const jobTask = jobTasks[taskId];
+    return {
+      id: taskId,
+      status: jobTask ? jobTask.state : "pending",
+      source: "pipeline",
+      stage: computeTaskStage(job, taskId),
+    };
+  });
+
+  const pipelineTaskIds = new Set(pipelineTasks);
+  const jobOnlyTaskIds = Object.keys(jobTasks).filter(
+    (taskId) => !pipelineTaskIds.has(taskId)
+  );
+
+  const jobOnlyItems = jobOnlyTaskIds.map((taskId) => {
+    const jobTask = jobTasks[taskId];
+    return {
+      id: taskId,
+      status: jobTask.state,
+      source: "job-extra",
+      stage: computeTaskStage(job, taskId),
+    };
+  });
+
+  return [...pipelineItems, ...jobOnlyItems];
+}
+
+export function computeActiveIndex(items) {
+  if (!items || items.length === 0) return 0;
+
+  // Find first running task
+  const firstRunningIndex = items.findIndex(
+    (item) => item.status === "running"
+  );
+  if (firstRunningIndex !== -1) return firstRunningIndex;
+
+  // Find first failed task
+  const firstFailedIndex = items.findIndex((item) => item.status === "failed");
+  if (firstFailedIndex !== -1) return firstFailedIndex;
+
+  // Find last completed task
+  let lastDoneIndex = -1;
+  items.forEach((item, index) => {
+    if (item.status === "done") lastDoneIndex = index;
+  });
+
+  if (lastDoneIndex !== -1) return lastDoneIndex;
+  return 0;
+}

package/src/utils/duration.js

@@ -0,0 +1,126 @@
+/**
+ * Duration policy utilities for consistent time display across components
+ */
+
+/**
+ * Normalizes task state names to canonical values
+ * @param {string} state - Raw task state
+ * @returns {string} Normalized state
+ */
+export function normalizeState(state) {
+  switch (state) {
+    case "done":
+      return "completed";
+    case "failed":
+    case "error":
+      return "error";
+    case "pending":
+    case "running":
+    case "current":
+    case "completed":
+    case "rejected":
+      return state;
+    default:
+      return state; // Pass through unknown states
+  }
+}
+
+/**
+ * Calculates display duration for a task according to policy rules
+ * @param {Object} task - Task object with state, startedAt, endedAt, executionTime, executionTimeMs
+ * @param {number} now - Current timestamp (default: Date.now())
+ * @returns {number} Duration in milliseconds
+ */
+export function taskDisplayDurationMs(task, now = Date.now()) {
+  const { state, startedAt, endedAt, executionTime, executionTimeMs } = task;
+  const normalizedState = normalizeState(state);
+
+  switch (normalizedState) {
+    case "pending":
+      return 0;
+
+    case "running":
+    case "current":
+      if (!startedAt) {
+        return 0;
+      }
+      const startTime = Date.parse(startedAt);
+      return Math.max(0, now - startTime);
+
+    case "completed":
+      // Prefer executionTimeMs or executionTime if available, even without startedAt
+      const execTime =
+        executionTimeMs != null ? executionTimeMs : executionTime;
+      if (typeof execTime === "number" && execTime >= 0) {
+        return execTime;
+      }
+
+      // If no execution time, calculate from timestamps
+      if (!startedAt) {
+        return 0;
+      }
+      const completedStartTime = Date.parse(startedAt);
+      const endTime = endedAt ? Date.parse(endedAt) : now;
+      return Math.max(0, endTime - completedStartTime);
+
+    case "rejected":
+      return 0;
+
+    default:
+      return 0;
+  }
+}
+
+/**
+ * Calculates cumulative duration across all tasks in a job
+ * @param {Object} job - Job object with tasks (array or object)
+ * @param {number} now - Current timestamp (default: Date.now())
+ * @returns {number} Total duration in milliseconds
+ */
+export function jobCumulativeDurationMs(job, now = Date.now()) {
+  const { tasks } = job;
+
+  if (!tasks) {
+    return 0;
+  }
+
+  let taskList;
+  if (Array.isArray(tasks)) {
+    taskList = tasks;
+  } else if (typeof tasks === "object") {
+    taskList = Object.values(tasks);
+  } else {
+    return 0;
+  }
+
+  return taskList.reduce((total, task) => {
+    return total + taskDisplayDurationMs(task, now);
+  }, 0);
+}
+
+// Legacy helpers (kept for compatibility but not used for policy)
+export function fmtDuration(ms) {
+  if (ms <= 0) return "0s";
+
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    const remainingSeconds = seconds % 60;
+    if (remainingSeconds > 0) {
+      return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+    } else {
+      return `${hours}h ${remainingMinutes}m`;
+    }
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+export function elapsedBetween(startTime, endTime = Date.now()) {
+  return Math.max(0, endTime - startTime);
+}

package/src/utils/id-generator.js

@@ -0,0 +1,30 @@
+/**
+ * Utility functions for generating random IDs
+ * @module utils/id-generator
+ */
+
+import { randomBytes } from "node:crypto";
+
+/**
+ * Generate a random job ID using crypto.randomBytes
+ * @param {number} [length=12] - Length of the ID in bytes
+ * @returns {string} Random alphanumeric ID
+ */
+export function generateJobId(length = 12) {
+  const bytes = randomBytes(length);
+  return bytes
+    .toString("base64")
+    .replace(/[+/=]/g, "") // Remove URL-unsafe characters
+    .substring(0, length); // Ensure consistent length
+}
+
+/**
+ * Generate a random job ID with a prefix
+ * @param {string} [prefix='job'] - Prefix for the ID
+ * @param {number} [length=8] - Length of the random part
+ * @returns {string} Random ID with prefix
+ */
+export function generateJobIdWithPrefix(prefix = "job", length = 8) {
+  const randomPart = generateJobId(length);
+  return `${prefix}_${randomPart}`;
+}

package/src/utils/jobs.js

@@ -0,0 +1,7 @@
+export const countCompleted = (job) => {
+  const list = Array.isArray(job?.tasks)
+    ? job.tasks
+    : Object.values(job?.tasks || {});
+  return list.filter((t) => t?.state === "done" || t?.state === "completed")
+    .length;
+};

package/src/utils/pipelines.js

@@ -0,0 +1,44 @@
+export function humanizePipelineSlug(slug) {
+  if (!slug || typeof slug !== "string") return "";
+  return slug
+    .replace(/[-_]+/g, " ")
+    .split(" ")
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+export function derivePipelineMetadata(source = {}) {
+  const pipelineValue = source?.pipeline;
+  const pipelineSlugFromSource =
+    source?.pipelineSlug ??
+    (typeof pipelineValue === "string" ? pipelineValue : null);
+
+  const pipelineLabel =
+    source?.pipelineLabel ??
+    (typeof pipelineSlugFromSource === "string"
+      ? humanizePipelineSlug(pipelineSlugFromSource)
+      : null);
+
+  const pipelineObject =
+    pipelineValue &&
+    typeof pipelineValue === "object" &&
+    !Array.isArray(pipelineValue)
+      ? pipelineValue
+      : null;
+
+  const pipeline =
+    pipelineObject ??
+    (typeof pipelineSlugFromSource === "string"
+      ? pipelineSlugFromSource
+      : null);
+
+  return {
+    pipeline,
+    pipelineSlug:
+      typeof pipelineSlugFromSource === "string"
+        ? pipelineSlugFromSource
+        : null,
+    pipelineLabel: pipelineLabel || null,
+  };
+}

package/src/utils/task-files.js

@@ -0,0 +1,271 @@
+/**
+ * Task files selector utilities.
+ *
+ * Single source of truth for normalizing `task.files` structure that flows
+ * from tasks_status.json into the UI. The enforced contract is:
+ *
+ *   {
+ *     artifacts: string[],
+ *     logs: string[],
+ *     tmp: string[]
+ *   }
+ *
+ * Any other keys (e.g., legacy "input"/"output") are ignored with a warning.
+ */
+
+/**
+ * @typedef {Object} TaskFiles
+ * @property {string[]} artifacts
+ * @property {string[]} logs
+ * @property {string[]} tmp
+ */
+
+const CATEGORY_KEYS = ["artifacts", "logs", "tmp"];
+const LEGACY_KEY_SET = new Set([
+  "input",
+  "inputs",
+  "output",
+  "outputs",
+  "legacyInput",
+  "legacyOutput",
+  "inputFiles",
+  "outputFiles",
+]);
+
+/**
+ * Produce a fresh TaskFiles object with empty arrays.
+ * @returns {TaskFiles}
+ */
+export function createEmptyTaskFiles() {
+  return { artifacts: [], logs: [], tmp: [] };
+}
+
+/**
+ * Normalize an unknown value into an array of strings.
+ * @param {unknown} value
+ * @returns {string[]}
+ */
+function coerceStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+
+/**
+ * Emit warnings for unsupported task.files keys while ensuring we do not block execution.
+ * @param {string[]} keys
+ */
+function reportUnsupportedKeys(keys) {
+  if (keys.length === 0) return;
+
+  const legacyKeys = keys.filter((key) => LEGACY_KEY_SET.has(key));
+  const otherKeys = keys.filter((key) => !LEGACY_KEY_SET.has(key));
+
+  if (legacyKeys.length > 0) {
+    console.warn(
+      `[task-files] Ignoring unsupported legacy keys: ${legacyKeys.join(", ")}`
+    );
+  }
+  if (otherKeys.length > 0) {
+    console.warn(
+      `[task-files] Ignoring unsupported task.files keys: ${otherKeys.join(", ")}`
+    );
+  }
+}
+
+/**
+ * Normalize an arbitrary input into a strict TaskFiles structure.
+ * @param {unknown} candidate
+ * @returns {TaskFiles}
+ */
+export function normalizeTaskFiles(candidate) {
+  const safeCandidate =
+    candidate && typeof candidate === "object" && !Array.isArray(candidate)
+      ? candidate
+      : {};
+
+  const unsupportedKeys = Object.keys(safeCandidate).filter(
+    (key) => !CATEGORY_KEYS.includes(key)
+  );
+  reportUnsupportedKeys(unsupportedKeys);
+
+  return {
+    artifacts: coerceStringArray(safeCandidate.artifacts),
+    logs: coerceStringArray(safeCandidate.logs),
+    tmp: coerceStringArray(safeCandidate.tmp),
+  };
+}
+
+/**
+ * Ensure provided task object has a normalized `files` property that matches
+ * the enforced contract. Returns the normalized structure for convenience.
+ * @param {Record<string, unknown> | null | undefined} task
+ * @returns {TaskFiles}
+ */
+export function ensureTaskFiles(task) {
+  const normalized = normalizeTaskFiles(task?.files);
+  if (task && typeof task === "object") {
+    task.files = normalized;
+  }
+  return normalized;
+}
+
+/**
+ * Determine whether a task matches a provided identifier.
+ * @param {Record<string, unknown>} task
+ * @param {string | number} taskId
+ * @returns {boolean}
+ */
+function matchesTaskIdentifier(task, taskId) {
+  if (!task || typeof task !== "object" || taskId == null) return false;
+  const target = String(taskId);
+  if (task.id != null && String(task.id) === target) return true;
+  if (task.name != null && String(task.name) === target) return true;
+  return false;
+}
+
+/**
+ * Locate a task within a provided tasks collection.
+ * @param {unknown} tasks
+ * @param {string | number} taskId
+ * @returns {Record<string, unknown> | null}
+ */
+function findTaskCandidate(tasks, taskId) {
+  if (!tasks || taskId == null) return null;
+
+  if (Array.isArray(tasks)) {
+    if (typeof taskId === "number" && tasks[taskId]) {
+      const indexedTask = tasks[taskId];
+      if (indexedTask && typeof indexedTask === "object") {
+        return indexedTask;
+      }
+    }
+
+    return tasks.find((task) => matchesTaskIdentifier(task, taskId)) ?? null;
+  }
+
+  if (typeof tasks === "object") {
+    const direct = tasks[taskId];
+    if (direct && typeof direct === "object") {
+      return direct;
+    }
+
+    for (const task of Object.values(tasks)) {
+      if (matchesTaskIdentifier(task, taskId)) {
+        return task;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Public selector that retrieves a strict TaskFiles structure for a specific task.
+ * @param {Object} job
+ * @param {string | number} taskId
+ * @returns {TaskFiles}
+ */
+export function getTaskFilesForTask(job, taskId) {
+  console.debug("[getTaskFilesForTask] Called with:", { job, taskId });
+
+  if (!job || typeof job !== "object") {
+    console.debug("[getTaskFilesForTask] No job or invalid job object");
+    return createEmptyTaskFiles();
+  }
+
+  const taskCandidate = findTaskCandidate(job.tasks, taskId);
+  if (!taskCandidate) {
+    console.debug(
+      "[getTaskFilesForTask] No task candidate found for taskId:",
+      taskId
+    );
+    return createEmptyTaskFiles();
+  }
+
+  const result = ensureTaskFiles(taskCandidate);
+  console.debug("[getTaskFilesForTask] Task files result:", { taskId, result });
+  return result;
+}
+
+/**
+ * List task files by type with fallback to empty task files
+ * @param {string} jobId - Job ID
+ * @param {string} taskId - Task ID
+ * @param {string} type - File type (artifacts/logs/tmp)
+ * @returns {Promise<string[]>} Array of file names
+ */
+export async function listTaskFiles(jobId, taskId, type) {
+  try {
+    console.debug("[listTaskFiles] Called with:", { jobId, taskId, type });
+
+    // Use fetch API directly for consistency with UI
+    const apiUrl = new URL(
+      `/api/jobs/${jobId}/tasks/${taskId}/files?type=${type}`,
+      window.location.origin
+    );
+
+    console.debug("[listTaskFiles] Fetching from:", apiUrl.toString());
+
+    const response = await fetch(apiUrl.toString());
+    const data = await response.json();
+
+    console.debug("[listTaskFiles] Response:", data);
+
+    if (data.ok && data.data && data.data.files) {
+      const fileNames = data.data.files.map((f) => f.name);
+      console.debug("[listTaskFiles] Found files:", fileNames);
+      return fileNames;
+    }
+
+    console.debug("[listTaskFiles] No valid files found in response");
+    return [];
+  } catch (error) {
+    console.error("[listTaskFiles] Error:", error);
+    return [];
+  }
+}
+
+/**
+ * Read task file content with proper error handling
+ * @param {string} jobId - Job ID
+ * @param {string} taskId - Task ID
+ * @param {string} type - File type (artifacts/logs/tmp)
+ * @param {string} filename - File name
+ * @returns {Promise<Object|null>} File object or null if error
+ */
+export async function readTaskFile(jobId, taskId, type, filename) {
+  try {
+    console.debug("[readTaskFile] Called with:", {
+      jobId,
+      taskId,
+      type,
+      filename,
+    });
+
+    // Use fetch API directly for consistency with UI
+    const apiUrl = new URL(
+      `/api/jobs/${jobId}/tasks/${taskId}/file?type=${type}&filename=${encodeURIComponent(
+        filename
+      )}`,
+      window.location.origin
+    );
+
+    console.debug("[readTaskFile] Fetching from:", apiUrl.toString());
+
+    const response = await fetch(apiUrl.toString());
+    const data = await response.json();
+
+    console.debug("[readTaskFile] Response:", data);
+
+    if (data.ok) {
+      console.debug("[readTaskFile] File read successfully");
+      return data;
+    }
+
+    console.error("[readTaskFile] File read failed:", data);
+    return null;
+  } catch (error) {
+    console.error("[readTaskFile] Error:", error);
+    return null;
+  }
+}