@fieldwangai/agentflow 0.1.134 → 0.1.136

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,93 @@ 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 normalizeWorkflowExtensions(value = {}) {
+  const raw = plainObject(value);
+  const out = {};
+  for (const [namespace, extension] of Object.entries(raw)) {
+    const key = cleanString(namespace, 120).toLowerCase();
+    if (!key || !/^[a-z][a-z0-9._-]{0,119}$/.test(key)) continue;
+    if (!extension || typeof extension !== "object" || Array.isArray(extension)) continue;
+    out[key] = mergeWorkflowGlobalState({}, extension);
+  }
+  return out;
+}
+
+export function materializeWorkflowExtensions(snapshot = {}, runtimeEvents = []) {
+  let extensions = normalizeWorkflowExtensions(
+    snapshot.extensions || snapshot.workflowExtensions || snapshot.workflow_extensions || {},
+  );
+  const events = [...(Array.isArray(runtimeEvents) ? runtimeEvents : [])]
+    .sort((left, right) => eventTime(left) - eventTime(right));
+  for (const event of events) {
+    const patch = event?.extensionsPatch || event?.extensions_patch;
+    if (!patch || typeof patch !== "object" || Array.isArray(patch)) continue;
+    extensions = mergeWorkflowGlobalState(extensions, normalizeWorkflowExtensions(patch));
+  }
+  return extensions;
+}
+
+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) };
@@ -176,6 +267,24 @@ export function normalizeWorkflowReport(payload = {}) {
   const workflow = normalizeWorkflowReference(payload);
   if (workflow.error) return workflow;
   const rawWorkflow = plainObject(payload.workflow);
+  const source = cleanString(payload.source || "agentflow-cli", 120).toLowerCase() || "agentflow-cli";
+  if (!/^[a-z][a-z0-9._-]{0,119}$/.test(source)) {
+    return { error: "Invalid workflow report source" };
+  }
+
+  const rawObservation = plainObject(payload.observation);
+  const hasObservation = Object.keys(rawObservation).length > 0;
+  const observationState = plainObject(rawObservation.state || rawObservation.facts || rawObservation.value);
+  if (hasObservation && !Object.keys(observationState).length) {
+    return { error: "observation requires state" };
+  }
+  const observation = hasObservation ? {
+    schema: cleanString(rawObservation.schema || rawObservation.model || "workflow-observation/v1", 160),
+    state: mergeWorkflowGlobalState({}, observationState),
+    observedAt: cleanString(rawObservation.observedAt || rawObservation.observed_at, 80),
+    clientId: cleanString(rawObservation.clientId || rawObservation.client_id, 160),
+    scope: cleanString(rawObservation.scope || "client", 80).toLowerCase() || "client",
+  } : null;
 
   const rawAction = plainObject(payload.action);
   const hasAction = Object.keys(rawAction).length > 0;
@@ -204,7 +313,33 @@ export function normalizeWorkflowReport(payload = {}) {
   const rawArtifacts = Array.isArray(payload.artifacts) ? payload.artifacts : [];
   const artifacts = rawArtifacts
     .filter((item) => item && typeof item === "object" && !Array.isArray(item))
-    .map((item, index) => normalizeWorkflowArtifact(item, index, action ? "action" : "global"));
+    .map((item, index) => ({
+      ...normalizeWorkflowArtifact(item, index, action ? "action" : "global"),
+      producer: source,
+    }));
+
+  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 rawExtensions = plainObject(payload.extensions);
+  const hasExtensions = Object.keys(rawExtensions).length > 0;
+  const extensions = hasExtensions ? normalizeWorkflowExtensions(rawExtensions) : null;
+  if (hasExtensions && !Object.keys(extensions).length) {
+    return { error: "extensions requires at least one valid namespace object" };
+  }
 
   const rawGlobalState = plainObject(payload.globalState || payload.global_state);
   const hasGlobalState = Object.keys(rawGlobalState).length > 0;
@@ -215,8 +350,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 && !hasExtensions && !hasObservation) {
+    return { error: "Workflow report requires observation, action, artifacts, globalState, projections, or extensions" };
   }
 
   const idempotencyKey = cleanString(
@@ -229,7 +364,7 @@ export function normalizeWorkflowReport(payload = {}) {
   const event = {
     schemaVersion,
     type: "workflow-report",
-    source: cleanString(payload.source || "agentflow-cli", 120) || "agentflow-cli",
+    source,
     workflow,
     workflowKey: workflow.key,
     aggregateByStage: Boolean(action),
@@ -257,6 +392,8 @@ export function normalizeWorkflowReport(payload = {}) {
       scope: "global",
     }),
     artifacts,
+    ...(hasProjections ? { projections } : {}),
+    ...(hasExtensions ? { extensionsPatch: extensions } : {}),
     ...(hasGlobalState ? {
       globalStatePatch,
       globalStateRemove,
@@ -268,6 +405,10 @@ export function normalizeWorkflowReport(payload = {}) {
     workflow,
     action,
     artifacts,
+    projections,
+    extensions,
+    observation,
+    hasRuntimeUpdate: Boolean(action || artifacts.length || hasGlobalState || hasProjections || hasExtensions),
     globalState: hasGlobalState ? {
       mode: "merge",
       patch: globalStatePatch,
@@ -408,20 +549,22 @@ export function mergeWorkflowArtifactLists(left = [], right = [], defaultScope =
   };
   const artifactAliases = (artifact) => {
     const aliases = [];
+    const producer = cleanString(artifact?.producer || artifact?.reportSource || artifact?.report_source, 120).toLowerCase();
+    const ownedAlias = (alias) => producer ? `producer:${producer}:${alias}` : alias;
     const explicitKey = cleanString(
       artifact?.key || artifact?.artifactKey || artifact?.artifact_key,
       500,
     );
-    if (explicitKey) aliases.push(`key:${explicitKey}`);
+    if (explicitKey) aliases.push(ownedAlias(`key:${explicitKey}`));
     const url = normalizedUrl(
       artifact?.canonicalUrl
       || artifact?.canonical_url
       || artifact?.href
       || artifact?.url,
     );
-    if (url) aliases.push(`url:${url}`);
+    if (url) aliases.push(ownedAlias(`url:${url}`));
     const artifactPath = cleanString(artifact?.path, 4000);
-    if (artifactPath) aliases.push(`path:${artifactPath}`);
+    if (artifactPath) aliases.push(ownedAlias(`path:${artifactPath}`));
     return aliases;
   };
   const add = (artifact) => {
@@ -448,7 +591,7 @@ export function mergeWorkflowArtifactLists(left = [], right = [], defaultScope =
   return out;
 }
 
-export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = []) {
+export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = [], projections = {}, extensions = {}) {
   const events = (Array.isArray(runtimeEvents) ? runtimeEvents : []).map((event) => ({
     id: event?.id || "",
     action: event?.action || event?.actionId || "",
@@ -457,10 +600,12 @@ export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtim
     artifacts: event?.artifacts || [],
     globalStatePatch: event?.globalStatePatch || {},
     globalStateRemove: event?.globalStateRemove || [],
+    projections: event?.projections || {},
+    extensionsPatch: event?.extensionsPatch || {},
   }));
   const hash = crypto
     .createHash("sha256")
-    .update(JSON.stringify(stableValue({ globalState, artifacts, events })))
+    .update(JSON.stringify(stableValue({ globalState, artifacts, projections, extensions, events })))
     .digest("hex")
     .slice(0, 24);
   return `runtime:${hash}`;