@fieldwangai/agentflow 0.1.134 → 0.1.135

package/bin/lib/ui-server.mjs

@@ -177,6 +177,7 @@ import {
 import {
   legacyOverallToGlobalState,
   materializeWorkflowGlobalState,
+  materializeWorkflowProjections,
   mergeWorkflowArtifactLists,
   mergeWorkflowArtifacts,
   mergeWorkflowGlobalState,
@@ -3464,6 +3465,23 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
     || snapshot?.title
     || "",
   ).trim();
+  const timeline = Array.isArray(snapshot?.projections?.timeline)
+    ? snapshot.projections.timeline
+        .filter((entry) => entry && typeof entry === "object" && !Array.isArray(entry))
+        .map((entry) => ({
+          key: String(entry.key || [entry.source, entry.kind, entry.id].filter(Boolean).join(":")),
+          kind: String(entry.kind || ""),
+          id: String(entry.id || ""),
+          title: String(entry.title || entry.label || entry.id || ""),
+          date: String(entry.date || ""),
+          source: String(entry.source || ""),
+          dimensions: entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+            ? entry.dimensions
+            : {},
+          order: Number.isFinite(Number(entry.order)) ? Number(entry.order) : 0,
+        }))
+        .filter((entry) => entry.kind && entry.id)
+    : [];
   const updatedAtTimestamp = Math.max(
     prdWorkflowDashboardTimestamp(record),
     prdWorkflowDashboardTimestamp(snapshot),
@@ -3481,6 +3499,7 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
     platforms,
     actionCount: actions.length,
     completedActionCount: completedActions,
+    timeline,
     latestAction: latestAction
       ? {
           title: String(latestAction.title || latestAction.label || latestAction.action || latestAction.id || "").trim(),
@@ -3500,6 +3519,72 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
   };
 }
 
+function prdWorkflowDashboardTimeline(workflows = []) {
+  const buckets = new Map();
+  const assignedWorkflowIds = new Set();
+  const rows = [...(Array.isArray(workflows) ? workflows : [])].sort((left, right) => {
+    const leftAt = Date.parse(String(left?.updatedAt || ""));
+    const rightAt = Date.parse(String(right?.updatedAt || ""));
+    if (Number.isFinite(leftAt) && Number.isFinite(rightAt)) return leftAt - rightAt;
+    if (Number.isFinite(leftAt) !== Number.isFinite(rightAt)) return Number.isFinite(leftAt) ? 1 : -1;
+    return String(left?.id || left?.tapdId || "").localeCompare(String(right?.id || right?.tapdId || ""));
+  });
+  for (const workflow of rows) {
+    const workflowId = String(workflow?.id || workflow?.tapdId || "");
+    const seen = new Set();
+    for (const entry of Array.isArray(workflow?.timeline) ? workflow.timeline : []) {
+      const key = String(entry?.key || [entry?.source, entry?.kind, entry?.id].filter(Boolean).join(":"));
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      assignedWorkflowIds.add(workflowId);
+      const current = buckets.get(key) || {
+        key,
+        kind: String(entry.kind || ""),
+        id: String(entry.id || ""),
+        title: String(entry.title || entry.id || ""),
+        date: String(entry.date || ""),
+        source: String(entry.source || ""),
+        dimensions: entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+          ? entry.dimensions
+          : {},
+        order: Number.isFinite(Number(entry.order)) ? Number(entry.order) : 0,
+        workflowCount: 0,
+        completedCount: 0,
+        blockedCount: 0,
+        workflowIds: [],
+      };
+      current.kind = String(entry.kind || current.kind);
+      current.id = String(entry.id || current.id);
+      current.title = String(entry.title || current.title);
+      current.date = String(entry.date || current.date);
+      current.source = String(entry.source || current.source);
+      current.dimensions = entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+        ? entry.dimensions
+        : current.dimensions;
+      current.order = Number.isFinite(Number(entry.order)) ? Number(entry.order) : current.order;
+      current.workflowCount += 1;
+      if (workflow?.state === "completed") current.completedCount += 1;
+      if (workflow?.state === "blocked") current.blockedCount += 1;
+      current.workflowIds.push(workflowId);
+      buckets.set(key, current);
+    }
+  }
+  const timeline = Array.from(buckets.values()).sort((left, right) => {
+    const leftAt = Date.parse(String(left.date || ""));
+    const rightAt = Date.parse(String(right.date || ""));
+    const leftValid = Number.isFinite(leftAt);
+    const rightValid = Number.isFinite(rightAt);
+    if (leftValid && rightValid && leftAt !== rightAt) return leftAt - rightAt;
+    if (leftValid !== rightValid) return leftValid ? -1 : 1;
+    if (left.order !== right.order) return left.order - right.order;
+    return left.title.localeCompare(right.title, undefined, { numeric: true, sensitivity: "base" });
+  });
+  return {
+    timeline,
+    unassignedCount: rows.filter((workflow) => !assignedWorkflowIds.has(String(workflow?.id || workflow?.tapdId || ""))).length,
+  };
+}
+
 function workspaceConversationsPath(scopedRoot) {
   return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "conversations.json");
 }
@@ -11083,13 +11168,15 @@ function prdWorkflowMergeRuntimeEvents(scopedRoot, tapdId, snapshot) {
   const overall = prdWorkflowOverallFromEvents(tapdId, snapshot, runtimeEvents);
   const globalState = prdWorkflowGlobalStateFromEvents(tapdId, snapshot, runtimeEvents);
   const artifacts = mergeWorkflowArtifacts(snapshot?.artifacts, runtimeEvents);
+  const projections = materializeWorkflowProjections(snapshot, runtimeEvents);
   return {
     ...snapshot,
     workflow: globalState.workflow,
     overall,
     globalState,
     artifacts,
-    runtimeRevision: workflowRuntimeRevision(globalState, artifacts, runtimeEvents),
+    projections,
+    runtimeRevision: workflowRuntimeRevision(globalState, artifacts, runtimeEvents, projections),
     runtimeEvents,
     events,
     sources: {
@@ -12515,7 +12602,7 @@ export function startUiServer({
             ? getTeamById(requestedTeamId)
             : getTeamForUser(userCtx.userId);
           if (!team || team.status !== "active") {
-            json(res, 200, { ok: true, view: "team", team: null, workflows: [] });
+            json(res, 200, { ok: true, view: "team", team: null, workflows: [], timeline: [], unassignedCount: 0 });
             return;
           }
           records = listPrdWorkflowCollaborationsForTeam(team.id);
@@ -12529,9 +12616,17 @@ export function startUiServer({
           const latestClient = prdWorkflowLatestClientSnapshot(stateRoot, stateRoot, tapdId);
           const legacy = prdWorkflowReadCachedSnapshot(stateRoot, tapdId);
           const snapshot = project?.snapshot || latestClient || legacy?.snapshot || {};
-          return prdWorkflowDashboardSummary(record, snapshot, userCtx);
+          const materialized = prdWorkflowMergeRuntimeEvents(stateRoot, tapdId, snapshot);
+          return prdWorkflowDashboardSummary(record, materialized, userCtx);
+        });
+        const dashboardTimeline = prdWorkflowDashboardTimeline(workflows);
+        json(res, 200, {
+          ok: true,
+          view: view === "team" ? "team" : "personal",
+          team: teamSummaryWithUsers(team),
+          workflows,
+          ...dashboardTimeline,
         });
-        json(res, 200, { ok: true, view: view === "team" ? "team" : "personal", team: teamSummaryWithUsers(team), workflows });
       } catch (error) {
         json(res, 500, { error: (error && error.message) || String(error) });
       }
@@ -13636,6 +13731,13 @@ export function startUiServer({
           json(res, workflowScope.status || 400, { error: workflowScope.error });
           return;
         }
+        if (!workflowScope.collaboration) {
+          const ensured = ensurePrdWorkflowCollaboration({ tapdId, userId: userCtx.userId });
+          if (ensured.error) {
+            json(res, ensured.status || 400, { error: ensured.error });
+            return;
+          }
+        }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
         const currentSnapshot = prdWorkflowMaterializeSnapshot(

package/bin/lib/workflow-report.mjs

@@ -21,6 +21,10 @@ function cleanString(value, max = 4000) {
   return String(value ?? "").trim().slice(0, max);
 }
 
+function hasOwn(value, key) {
+  return Boolean(value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key));
+}
+
 function stableValue(value) {
   if (Array.isArray(value)) return value.map((item) => stableValue(item));
   if (value && typeof value === "object") {
@@ -105,6 +109,67 @@ function normalizeWorkflowArtifact(value, index = 0, defaultScope = "action") {
   };
 }
 
+export function normalizeWorkflowTimelineProjection(value, index = 0) {
+  const raw = plainObject(value);
+  const kind = cleanString(raw.kind || raw.type, 80).toLowerCase();
+  const id = cleanString(raw.id || raw.key, 240);
+  if (!kind || !id) return null;
+  const source = cleanString(raw.source || raw.namespace, 120).toLowerCase();
+  const date = cleanString(raw.date || raw.targetDate || raw.target_date, 80);
+  const dimensions = mergeWorkflowGlobalState({}, plainObject(raw.dimensions || raw.facets));
+  const key = cleanString(raw.key || [source, kind, id].filter(Boolean).join(":"), 500);
+  return {
+    ...mergeWorkflowGlobalState({}, raw),
+    key: key || `${kind}:${id}`,
+    kind,
+    id,
+    title: cleanString(raw.title || raw.label || id, 500) || id,
+    ...(source ? { source } : {}),
+    ...(date ? { date } : {}),
+    dimensions,
+    order: Number.isFinite(Number(raw.order)) ? Number(raw.order) : index,
+  };
+}
+
+function normalizeWorkflowProjectionState(value = {}) {
+  const raw = mergeWorkflowGlobalState({}, plainObject(value));
+  if (Array.isArray(value?.timeline)) {
+    raw.timeline = value.timeline
+      .map((item, index) => normalizeWorkflowTimelineProjection(item, index))
+      .filter(Boolean)
+      .slice(0, 100);
+  } else {
+    delete raw.timeline;
+  }
+  return raw;
+}
+
+export function materializeWorkflowProjections(snapshot = {}, runtimeEvents = []) {
+  const base =
+    snapshot.projections ||
+    snapshot.workflowProjections ||
+    snapshot.workflow_projections ||
+    snapshot.raw?.projections ||
+    {};
+  let projections = normalizeWorkflowProjectionState(base);
+  const events = [...(Array.isArray(runtimeEvents) ? runtimeEvents : [])]
+    .sort((left, right) => eventTime(left) - eventTime(right));
+  for (const event of events) {
+    const next = event?.projections || event?.workflowProjections || event?.workflow_projections;
+    if (!next || typeof next !== "object" || Array.isArray(next) || !hasOwn(next, "timeline")) continue;
+    projections = {
+      ...projections,
+      timeline: Array.isArray(next.timeline)
+        ? next.timeline
+            .map((item, index) => normalizeWorkflowTimelineProjection(item, index))
+            .filter(Boolean)
+            .slice(0, 100)
+        : projections.timeline || [],
+    };
+  }
+  return projections;
+}
+
 export function mergeWorkflowGlobalState(base, patch) {
   if (!patch || typeof patch !== "object" || Array.isArray(patch)) return plainObject(base);
   const out = { ...plainObject(base) };
@@ -206,6 +271,22 @@ export function normalizeWorkflowReport(payload = {}) {
     .filter((item) => item && typeof item === "object" && !Array.isArray(item))
     .map((item, index) => normalizeWorkflowArtifact(item, index, action ? "action" : "global"));
 
+  const rawProjections = plainObject(payload.projections || payload.workflowProjections || payload.workflow_projections);
+  const hasProjections = Object.keys(rawProjections).length > 0 || hasOwn(payload, "projections");
+  if (hasProjections && !hasOwn(rawProjections, "timeline")) {
+    return { error: "projections requires timeline" };
+  }
+  if (hasProjections && !Array.isArray(rawProjections.timeline)) {
+    return { error: "projections.timeline must be an array" };
+  }
+  const invalidTimelineIndex = hasProjections
+    ? rawProjections.timeline.findIndex((item, index) => !normalizeWorkflowTimelineProjection(item, index))
+    : -1;
+  if (invalidTimelineIndex >= 0) {
+    return { error: `projections.timeline[${invalidTimelineIndex}] requires kind and id` };
+  }
+  const projections = hasProjections ? normalizeWorkflowProjectionState(rawProjections) : null;
+
   const rawGlobalState = plainObject(payload.globalState || payload.global_state);
   const hasGlobalState = Object.keys(rawGlobalState).length > 0;
   const globalStatePatch = plainObject(rawGlobalState.patch);
@@ -215,8 +296,8 @@ export function normalizeWorkflowReport(payload = {}) {
   if (hasGlobalState && !Object.keys(globalStatePatch).length && !globalStateRemove.length) {
     return { error: "globalState requires patch or remove" };
   }
-  if (!action && !artifacts.length && !hasGlobalState) {
-    return { error: "Workflow report requires action, artifacts, or globalState" };
+  if (!action && !artifacts.length && !hasGlobalState && !hasProjections) {
+    return { error: "Workflow report requires action, artifacts, globalState, or projections" };
   }
 
   const idempotencyKey = cleanString(
@@ -257,6 +338,7 @@ export function normalizeWorkflowReport(payload = {}) {
       scope: "global",
     }),
     artifacts,
+    ...(hasProjections ? { projections } : {}),
     ...(hasGlobalState ? {
       globalStatePatch,
       globalStateRemove,
@@ -268,6 +350,7 @@ export function normalizeWorkflowReport(payload = {}) {
     workflow,
     action,
     artifacts,
+    projections,
     globalState: hasGlobalState ? {
       mode: "merge",
       patch: globalStatePatch,
@@ -448,7 +531,7 @@ export function mergeWorkflowArtifactLists(left = [], right = [], defaultScope =
   return out;
 }
 
-export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = []) {
+export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = [], projections = {}) {
   const events = (Array.isArray(runtimeEvents) ? runtimeEvents : []).map((event) => ({
     id: event?.id || "",
     action: event?.action || event?.actionId || "",
@@ -457,10 +540,11 @@ export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtim
     artifacts: event?.artifacts || [],
     globalStatePatch: event?.globalStatePatch || {},
     globalStateRemove: event?.globalStateRemove || [],
+    projections: event?.projections || {},
   }));
   const hash = crypto
     .createHash("sha256")
-    .update(JSON.stringify(stableValue({ globalState, artifacts, events })))
+    .update(JSON.stringify(stableValue({ globalState, artifacts, projections, events })))
     .digest("hex")
     .slice(0, 24);
   return `runtime:${hash}`;