@ryanfw/prompt-orchestration-pipeline 0.0.1 → 0.4.0

package/src/ui/transformers/list-transformer.js

@@ -0,0 +1,347 @@
+/**
+ * List transformer utilities
+ *
+ * Exports:
+ *  - aggregateAndSortJobs(currentJobs, completeJobs)
+ *  - sortJobs(jobs)
+ *  - getStatusPriority(status)
+ *  - groupJobsByStatus(jobs)
+ *  - getJobListStats(jobs)
+ *  - filterJobs(jobs, searchTerm, options)
+ *  - transformJobListForAPI(jobs)
+ *  - getAggregationStats(currentJobs, completeJobs, aggregatedJobs)
+ *
+ * Behavior guided by tests in tests/list-transformer.test.js and docs/project-data-display.md
+ */
+
+import { derivePipelineMetadata } from "../../utils/pipelines.js";
+
+export function getStatusPriority(status) {
+  // Map to numeric priority where higher = higher priority
+  switch (status) {
+    case "running":
+      return 4;
+    case "error":
+      return 3;
+    case "pending":
+      return 2;
+    case "complete":
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+function getJobId(job) {
+  return job && typeof job === "object" ? job.jobId || job.id || null : null;
+}
+
+/**
+ * Validate a job object minimally: must have jobId (or id), status, and createdAt
+ */
+function isValidJob(job) {
+  if (!job || typeof job !== "object") return false;
+  if (!getJobId(job)) return false;
+  if (!job.status) return false;
+  if (!job.createdAt) return false;
+  return true;
+}
+
+/**
+ * Sort jobs by status priority (descending), then createdAt ascending, then id ascending.
+ * Filters out invalid jobs.
+ */
+export function sortJobs(jobs) {
+  if (!Array.isArray(jobs) || jobs.length === 0) return [];
+
+  const filtered = jobs.filter(isValidJob).slice();
+
+  filtered.sort((a, b) => {
+    const pa = getStatusPriority(a.status);
+    const pb = getStatusPriority(b.status);
+
+    if (pa !== pb) return pb - pa;
+
+    const ta = Date.parse(a.createdAt) || 0;
+    const tb = Date.parse(b.createdAt) || 0;
+
+    if (ta !== tb) return ta - tb;
+
+    const idA = getJobId(a);
+    const idB = getJobId(b);
+    if (idA == null && idB == null) return 0;
+    if (idA == null) return 1;
+    if (idB == null) return -1;
+    if (idA < idB) return -1;
+    if (idA > idB) return 1;
+    return 0;
+  });
+
+  return filtered;
+}
+
+/**
+ * Merge current and complete job lists with precedence: current wins.
+ * Returns sorted result using sortJobs.
+ */
+export function aggregateAndSortJobs(currentJobs, completeJobs) {
+  try {
+    const cur = Array.isArray(currentJobs) ? currentJobs : [];
+    const comp = Array.isArray(completeJobs) ? completeJobs : [];
+
+    const map = new Map();
+
+    for (const j of comp) {
+      const jobId = getJobId(j);
+      if (!jobId) continue;
+      map.set(jobId, j);
+    }
+
+    for (const j of cur) {
+      const jobId = getJobId(j);
+      if (!jobId) continue;
+      map.set(jobId, j);
+    }
+
+    const aggregated = Array.from(map.values());
+
+    return sortJobs(aggregated);
+  } catch (err) {
+    console.error("Error aggregating jobs:", err);
+    return [];
+  }
+}
+
+/**
+ * Group jobs into buckets by status.
+ * Unknown statuses are ignored.
+ */
+export function groupJobsByStatus(jobs) {
+  const buckets = {
+    running: [],
+    error: [],
+    pending: [],
+    complete: [],
+  };
+
+  if (!Array.isArray(jobs)) return buckets;
+
+  for (const job of jobs) {
+    if (!job || typeof job !== "object") continue;
+    const status = job.status;
+    if (!status || !buckets[status]) continue;
+    buckets[status].push(job);
+  }
+
+  return buckets;
+}
+
+/**
+ * Compute job list statistics:
+ *  - total
+ *  - byStatus: counts
+ *  - byLocation: counts
+ *  - averageProgress: floor average of available progress values (0 if none)
+ */
+export function getJobListStats(jobs = []) {
+  if (!Array.isArray(jobs) || jobs.length === 0) {
+    return {
+      total: 0,
+      byStatus: {},
+      byLocation: {},
+      averageProgress: 0,
+    };
+  }
+
+  const byStatus = {};
+  const byLocation = {};
+  let progressSum = 0;
+  let progressCount = 0;
+  let total = 0;
+
+  for (const job of jobs) {
+    if (!job || typeof job !== "object") continue;
+    total += 1;
+
+    if (job.status) {
+      byStatus[job.status] = (byStatus[job.status] || 0) + 1;
+    }
+
+    if (job.location) {
+      byLocation[job.location] = (byLocation[job.location] || 0) + 1;
+    }
+
+    if (typeof job.progress === "number" && !Number.isNaN(job.progress)) {
+      progressSum += job.progress;
+      progressCount += 1;
+    }
+  }
+
+  const averageProgress =
+    progressCount === 0 ? 0 : Math.floor(progressSum / progressCount);
+
+  return {
+    total,
+    byStatus,
+    byLocation,
+    averageProgress,
+  };
+}
+
+/**
+ * Filter jobs by search term (matches id or name, case-insensitive) and options {status, location}
+ * Returns jobs in original order (filtered).
+ */
+export function filterJobs(jobs, searchTerm = "", options = {}) {
+  if (!Array.isArray(jobs) || jobs.length === 0) return [];
+  const term = (searchTerm || "").trim().toLowerCase();
+
+  return jobs.filter((job) => {
+    if (!job || typeof job !== "object") return false;
+
+    if (options && options.status && job.status !== options.status)
+      return false;
+    if (options && options.location && job.location !== options.location)
+      return false;
+
+    if (!term) return true;
+
+    const hay = `${job.title || ""} ${getJobId(job) || ""}`.toLowerCase();
+    return hay.includes(term);
+  });
+}
+
+/**
+ * Transform job list for API: pick only allowed fields and drop nulls
+ */
+export function transformJobListForAPI(jobs = [], options = {}) {
+  if (!Array.isArray(jobs) || jobs.length === 0) return [];
+
+  const { includePipelineMetadata = true } = options;
+
+  const out = [];
+  for (const job of jobs) {
+    if (!job || typeof job !== "object") continue;
+
+    const base = {
+      jobId: job.jobId,
+      title: job.title,
+      status: job.status,
+      progress:
+        typeof job.progress === "number" && Number.isFinite(job.progress)
+          ? job.progress
+          : 0,
+      createdAt: job.createdAt,
+      updatedAt: job.updatedAt,
+      location: job.location,
+    };
+
+    // Only include files if present
+    if (job.files) {
+      base.files = job.files;
+    }
+
+    // Add required fields for dashboard completeness
+    if (job.current != null) {
+      base.current = job.current;
+    }
+
+    if (job.currentStage != null) {
+      base.currentStage = job.currentStage;
+    }
+
+    if (job.tasksStatus && typeof job.tasksStatus === "object") {
+      // Include tasksStatus with all required fields for UI computation
+      const tasksStatus = {};
+      for (const [taskId, task] of Object.entries(job.tasksStatus)) {
+        if (task && typeof task === "object") {
+          tasksStatus[taskId] = {
+            state: task.state || "pending",
+          };
+
+          // Include optional fields if present
+          if (task.startedAt != null)
+            tasksStatus[taskId].startedAt = task.startedAt;
+          if (task.endedAt != null) tasksStatus[taskId].endedAt = task.endedAt;
+          if (task.executionTimeMs != null)
+            tasksStatus[taskId].executionTimeMs = task.executionTimeMs;
+          if (task.currentStage != null)
+            tasksStatus[taskId].currentStage = task.currentStage;
+          if (task.failedStage != null)
+            tasksStatus[taskId].failedStage = task.failedStage;
+        }
+      }
+      base.tasksStatus = tasksStatus;
+    }
+
+    // Only include pipeline metadata if option is enabled
+    if (includePipelineMetadata) {
+      const { pipeline, pipelineLabel, pipelineSlug } =
+        derivePipelineMetadata(job);
+
+      if (pipelineSlug != null) {
+        base.pipelineSlug = pipelineSlug;
+        base.pipeline = pipelineSlug;
+      } else if (typeof pipeline === "string") {
+        base.pipeline = pipeline;
+      }
+
+      if (pipelineLabel != null) {
+        base.pipelineLabel = pipelineLabel;
+      }
+    }
+
+    out.push(base);
+  }
+
+  return out;
+}
+
+/**
+ * Compute aggregation diagnostics
+ */
+export function getAggregationStats(
+  currentJobs = [],
+  completeJobs = [],
+  aggregatedJobs = []
+) {
+  const current = Array.isArray(currentJobs) ? currentJobs : [];
+  const complete = Array.isArray(completeJobs) ? completeJobs : [];
+  const aggregated = Array.isArray(aggregatedJobs) ? aggregatedJobs : [];
+
+  const totalInput = current.length + complete.length;
+
+  // duplicates: ids present in both
+  const compIds = new Set(complete.map((j) => getJobId(j)).filter(Boolean));
+  const curIds = new Set(current.map((j) => getJobId(j)).filter(Boolean));
+
+  let duplicates = 0;
+  for (const id of curIds) {
+    if (compIds.has(id)) duplicates += 1;
+  }
+
+  const totalOutput = aggregated.length;
+  const efficiency =
+    totalInput === 0 ? 0 : Math.round((totalOutput / totalInput) * 100);
+
+  const statusDistribution = {};
+  const locationDistribution = {};
+
+  for (const j of aggregated) {
+    if (!j || typeof j !== "object") continue;
+    if (j.status)
+      statusDistribution[j.status] = (statusDistribution[j.status] || 0) + 1;
+    if (j.location)
+      locationDistribution[j.location] =
+        (locationDistribution[j.location] || 0) + 1;
+  }
+
+  return {
+    totalInput,
+    totalOutput,
+    duplicates,
+    efficiency,
+    statusDistribution,
+    locationDistribution,
+  };
+}

package/src/ui/transformers/status-transformer.js

@@ -0,0 +1,307 @@
+import { normalizeTaskFiles } from "../../utils/task-files.js";
+import { derivePipelineMetadata } from "../../utils/pipelines.js";
+
+const VALID_TASK_STATES = new Set(["pending", "running", "done", "failed"]);
+
+/**
+ * Determine job-level status from tasks mapping.
+ */
+export function determineJobStatus(tasks = {}) {
+  if (!tasks || typeof tasks !== "object") return "pending";
+  const names = Object.keys(tasks);
+  if (names.length === 0) return "pending";
+
+  const states = names.map((n) => tasks[n]?.state);
+
+  if (states.includes("failed")) return "failed";
+  if (states.includes("running")) return "running";
+  if (states.every((s) => s === "done")) return "complete";
+  return "pending";
+}
+
+/**
+ * Compute job status object { status, progress } and emit warnings for unknown states.
+ * Tests expect console.warn to be called for unknown states with substring:
+ *   Unknown task state "..."
+ */
+export function computeJobStatus(tasksInput, existingProgress = null) {
+  // Guard invalid input
+  if (
+    !tasksInput ||
+    typeof tasksInput !== "object" ||
+    Array.isArray(tasksInput)
+  ) {
+    return { status: "pending", progress: existingProgress ?? 0 };
+  }
+
+  // Normalize task states, and detect unknown states
+  const names = Object.keys(tasksInput);
+  if (names.length === 0)
+    return { status: "pending", progress: existingProgress ?? 0 };
+
+  let unknownStatesFound = new Set();
+
+  const normalized = {};
+  for (const name of names) {
+    const t = tasksInput[name];
+    const state = t && typeof t === "object" ? t.state : undefined;
+
+    if (state == null || !VALID_TASK_STATES.has(state)) {
+      if (state != null && !VALID_TASK_STATES.has(state)) {
+        unknownStatesFound.add(state);
+      }
+      normalized[name] = { state: "pending" };
+    } else {
+      normalized[name] = { state };
+    }
+  }
+
+  // Warn for unknown states
+  for (const s of unknownStatesFound) {
+    console.warn(`Unknown task state "${s}"`);
+  }
+
+  const status = determineJobStatus(normalized);
+  // Use existing progress if provided, otherwise default to 0
+  // Progress is pre-calculated in task-statuses.json, not computed from task states
+  const progress = existingProgress !== null ? existingProgress : 0;
+
+  return { status, progress };
+}
+
+/**
+ * Transform raw task input into a canonical object keyed by task name.
+ * - Returns {} for invalid inputs
+ * - Missing or invalid state -> "pending" with console.warn for invalid values
+ */
+export function transformTasks(rawTasks) {
+  if (!rawTasks) return {};
+
+  let entries = [];
+
+  if (Array.isArray(rawTasks)) {
+    entries = rawTasks.map((raw, index) => {
+      const inferredName =
+        raw?.name || raw?.id || raw?.taskId || `task-${index + 1}`;
+      return [inferredName, raw];
+    });
+  } else if (typeof rawTasks === "object") {
+    entries = Object.entries(rawTasks);
+  } else {
+    return {};
+  }
+
+  const normalized = {};
+
+  for (const [name, raw] of entries) {
+    if (typeof name !== "string" || name.length === 0) continue;
+
+    const rawState =
+      raw && typeof raw === "object" && "state" in raw ? raw.state : undefined;
+
+    let finalState = "pending";
+    if (rawState != null && VALID_TASK_STATES.has(rawState)) {
+      finalState = rawState;
+    } else if (rawState != null && !VALID_TASK_STATES.has(rawState)) {
+      console.warn(`Invalid task state "${rawState}"`);
+      finalState = "pending";
+    }
+
+    const task = {
+      state: finalState,
+    };
+
+    if (raw && typeof raw === "object") {
+      if ("startedAt" in raw) task.startedAt = raw.startedAt;
+      if ("endedAt" in raw) task.endedAt = raw.endedAt;
+      if ("attempts" in raw) task.attempts = raw.attempts;
+      if ("executionTimeMs" in raw) task.executionTimeMs = raw.executionTimeMs;
+      if ("refinementAttempts" in raw)
+        task.refinementAttempts = raw.refinementAttempts;
+      if ("stageLogPath" in raw) task.stageLogPath = raw.stageLogPath;
+      if ("errorContext" in raw) task.errorContext = raw.errorContext;
+
+      if (typeof raw.currentStage === "string" && raw.currentStage.length > 0) {
+        task.currentStage = raw.currentStage;
+      }
+      if (typeof raw.failedStage === "string" && raw.failedStage.length > 0) {
+        task.failedStage = raw.failedStage;
+      }
+
+      task.files = normalizeTaskFiles(raw?.files);
+      if ("artifacts" in raw) task.artifacts = raw.artifacts;
+
+      if ("error" in raw) {
+        if (
+          raw.error &&
+          typeof raw.error === "object" &&
+          !Array.isArray(raw.error)
+        ) {
+          task.error = { ...raw.error };
+        } else if (raw.error != null) {
+          task.error = { message: String(raw.error) };
+        } else {
+          task.error = null;
+        }
+      }
+    } else {
+      task.files = normalizeTaskFiles();
+    }
+
+    task.name =
+      raw && typeof raw === "object" && "name" in raw ? raw.name : name;
+
+    normalized[name] = task;
+  }
+
+  return normalized;
+}
+
+/**
+ * Transform a single raw job payload into canonical job object expected by UI/tests.
+ *
+ * Output schema:
+ *  - jobId: string
+ *  - title: string
+ *  - status: canonical job status
+ *  - progress: number 0-100
+ *  - createdAt / updatedAt: ISO strings | null
+ *  - location: lifecycle bucket
+ *  - current / currentStage: stage metadata (optional)
+ *  - tasksStatus: object keyed by task name
+ *  - files: normalized job-level files
+ */
+export function transformJobStatus(raw, jobId, location) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+
+  const warnings = [];
+
+  // Check for job ID mismatch (supports both legacy and canonical)
+  const rawJobId = raw.jobId || raw.id;
+  if (rawJobId && String(rawJobId) !== String(jobId)) {
+    const msg = `Job ID mismatch: JSON has "${rawJobId}", using directory name "${jobId}"`;
+    warnings.push(msg);
+    console.warn(msg);
+  }
+
+  const title = raw.title || raw.name || "Unnamed Job";
+  const createdAt = raw.createdAt || null;
+  const updatedAt = raw.updatedAt || raw.lastUpdated || createdAt || null;
+  const resolvedLocation = location || raw.location || null;
+
+  // Support both canonical (tasksStatus) and legacy (tasks) schema
+  const tasksStatus = transformTasks(raw.tasksStatus || raw.tasks);
+  const jobStatusObj = computeJobStatus(tasksStatus, raw.progress);
+
+  const jobFiles = normalizeTaskFiles(raw.files);
+
+  // Convert tasksStatus object to tasks array for API compatibility
+  const tasks = Object.entries(tasksStatus).map(([name, task]) => ({
+    name,
+    ...task,
+  }));
+
+  const job = {
+    id: jobId, // API expects 'id' not 'jobId'
+    name: title, // API expects 'name' not 'title'
+    jobId, // Keep jobId for backward compatibility
+    title, // Keep title for backward compatibility
+    status: jobStatusObj.status,
+    progress: jobStatusObj.progress,
+    createdAt,
+    updatedAt,
+    location: resolvedLocation,
+    tasksStatus, // Keep tasksStatus for backward compatibility
+    tasks, // API expects 'tasks' array
+    files: jobFiles,
+  };
+
+  if (raw.current != null) job.current = raw.current;
+  if (raw.currentStage != null) job.currentStage = raw.currentStage;
+  if (raw.lastUpdated && !job.updatedAt) job.updatedAt = raw.lastUpdated;
+
+  const { pipeline, pipelineLabel } = derivePipelineMetadata(raw);
+
+  if (pipeline != null) {
+    job.pipeline = pipeline;
+  }
+  if (pipelineLabel != null) {
+    job.pipelineLabel = pipelineLabel;
+  }
+
+  if (raw.pipelineConfig) {
+    job.pipelineConfig = raw.pipelineConfig;
+  }
+
+  if (warnings.length > 0) {
+    job.warnings = warnings;
+  }
+
+  return job;
+}
+
+/**
+ * Transform multiple job read results (as returned by readJob and job scanner logic)
+ * - Logs "Transforming N jobs" (tests assert this substring)
+ * - Filters out failed reads (ok !== true)
+ * - Uses transformJobStatus for each successful read
+ * - Preserves order of reads as provided
+ */
+export function transformMultipleJobs(jobReadResults = []) {
+  const total = Array.isArray(jobReadResults) ? jobReadResults.length : 0;
+  console.log(`Transforming ${total} jobs`);
+
+  if (!Array.isArray(jobReadResults) || jobReadResults.length === 0) return [];
+
+  const out = [];
+  for (const r of jobReadResults) {
+    if (!r || r.ok !== true) continue;
+    // r.data is expected to be raw job JSON
+    const raw = r.data || {};
+    // jobId and location metadata may be present on read result (tests attach them)
+    const jobId = r.jobId || (raw && (raw.jobId || raw.id)) || undefined;
+    const location = r.location || raw.location || undefined;
+    // If jobId is missing, skip (defensive)
+    if (!jobId) continue;
+    const transformed = transformJobStatus(raw, jobId, location);
+    if (transformed) out.push(transformed);
+  }
+  return out;
+}
+
+/**
+ * Compute transformation statistics used by tests:
+ * - totalRead: total read attempts
+ * - successfulReads: count of readResults with ok === true
+ * - successfulTransforms: transformedJobs.length
+ * - failedTransforms: successfulReads - successfulTransforms
+ * - transformationRate: Math.round(successfulTransforms / totalRead * 100) or 0
+ * - statusDistribution: counts of statuses in transformedJobs
+ */
+export function getTransformationStats(readResults = [], transformedJobs = []) {
+  const totalRead = Array.isArray(readResults) ? readResults.length : 0;
+  const successfulReads = Array.isArray(readResults)
+    ? readResults.filter((r) => r && r.ok === true).length
+    : 0;
+  const successfulTransforms = Array.isArray(transformedJobs)
+    ? transformedJobs.length
+    : 0;
+  const failedTransforms = Math.max(0, successfulReads - successfulTransforms);
+  const transformationRate =
+    totalRead === 0 ? 0 : Math.round((successfulTransforms / totalRead) * 100);
+
+  const statusDistribution = {};
+  for (const j of transformedJobs || []) {
+    if (!j || !j.status) continue;
+    statusDistribution[j.status] = (statusDistribution[j.status] || 0) + 1;
+  }
+
+  return {
+    totalRead,
+    successfulReads,
+    successfulTransforms,
+    failedTransforms,
+    transformationRate,
+    statusDistribution,
+  };
+}