yaml-flow 2.5.0 → 2.6.1

package/dist/index.cjs

@@ -255,7 +255,7 @@ var StepMachine = class {
     }
   }
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   async run(initialData) {
     const runId = generateRunId();
@@ -2157,7 +2157,7 @@ async function batch(items, options) {
   if (total === 0) {
     return { items: [], completed: 0, failed: 0, total: 0, durationMs: 0 };
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let active = 0;
     function tryStartNext() {
       while (active < concurrency && nextIndex < total) {
@@ -2174,7 +2174,7 @@ async function batch(items, options) {
             failed++;
           }
           if (active === 0 && completed + failed === total) {
-            resolve({
+            resolve2({
               items: results,
               completed,
               failed,
@@ -2213,7 +2213,7 @@ async function batch(items, options) {
           active--;
           onProgress?.(makeProgress(active));
           if (completed + failed === total) {
-            resolve({
+            resolve2({
               items: results,
               completed,
               failed,
@@ -3214,7 +3214,7 @@ function createCliAdapter(opts) {
   const timeout = opts.timeout ?? 6e4;
   return {
     analyze: (prompt) => {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const args = opts.args(prompt);
         const child = child_process.execFile(
           opts.command,
@@ -3234,7 +3234,7 @@ stderr: ${stderr.slice(0, 500)}` : "") + `
 ${error.message}`
               ));
             } else {
-              resolve(stdout);
+              resolve2(stdout);
             }
           }
         );
@@ -3282,8 +3282,456 @@ function createHttpAdapter(opts) {
   };
 }
 
+// src/card-compute/index.ts
+function deepGet(obj, path) {
+  if (!path || !obj) return void 0;
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length; i++) {
+    if (cur == null) return void 0;
+    cur = cur[parts[i]];
+  }
+  return cur;
+}
+function deepSet(obj, path, value) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null || typeof cur[parts[i]] !== "object") cur[parts[i]] = {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+var _fns = {};
+_fns.sum = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  return opts.field ? a.reduce((s, r) => s + (Number(r[opts.field]) || 0), 0) : a.reduce((s, v) => s + (Number(v) || 0), 0);
+};
+_fns.avg = (input, _e, opts) => {
+  const s = _fns.sum(input, _e, opts);
+  const n = Array.isArray(input) ? input.length : 1;
+  return n ? s / n : 0;
+};
+_fns.min = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
+  return vals.length ? Math.min(...vals) : 0;
+};
+_fns.max = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
+  return vals.length ? Math.max(...vals) : 0;
+};
+_fns.count = (input) => Array.isArray(input) ? input.length : input != null ? 1 : 0;
+_fns.first = (input) => Array.isArray(input) ? input[0] : input;
+_fns.last = (input) => Array.isArray(input) ? input[input.length - 1] : input;
+_fns.add = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.reduce((s, v) => s + Number(v), 0);
+};
+_fns.sub = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Number(a[0]) - Number(a[1]) : 0;
+};
+_fns.mul = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.reduce((s, v) => s * Number(v), 1);
+};
+_fns.div = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[1]) !== 0 ? Number(a[0]) / Number(a[1]) : 0;
+};
+_fns.round = (input, _e, opts) => {
+  const decimals = opts.decimals != null ? opts.decimals : 0;
+  const factor = Math.pow(10, decimals);
+  return Math.round(Number(input) * factor) / factor;
+};
+_fns.abs = (input) => Math.abs(Number(input));
+_fns.mod = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Number(a[0]) % Number(a[1]) : 0;
+};
+_fns.gt = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) > Number(a[1]);
+};
+_fns.gte = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) >= Number(a[1]);
+};
+_fns.lt = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) < Number(a[1]);
+};
+_fns.lte = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) <= Number(a[1]);
+};
+_fns.eq = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && a[0] === a[1];
+};
+_fns.neq = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && a[0] !== a[1];
+};
+_fns.and = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.every(Boolean);
+};
+_fns.or = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.some(Boolean);
+};
+_fns.not = (input) => !input;
+_fns.concat = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.map((v) => v != null ? String(v) : "").join("");
+};
+_fns.upper = (input) => String(input || "").toUpperCase();
+_fns.lower = (input) => String(input || "").toLowerCase();
+_fns.template = (input, _e, opts) => {
+  let t = String(opts.format || "");
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    for (const k of Object.keys(input)) {
+      const v = input[k];
+      t = t.split("{{" + k + "}}").join(v != null ? String(v) : "");
+    }
+  }
+  return t;
+};
+_fns.join = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const sep = opts.separator != null ? String(opts.separator) : ", ";
+  return a.map((v) => v != null ? String(v) : "").join(sep);
+};
+_fns.split = (input, _e, opts) => {
+  const sep = opts.separator != null ? String(opts.separator) : ",";
+  return String(input || "").split(sep).map((s) => s.trim());
+};
+_fns.trim = (input) => String(input || "").trim();
+_fns.pluck = (input, _e, opts) => Array.isArray(input) ? input.map((r) => r[opts.field]) : [];
+_fns.filter = (input, _e, opts) => {
+  if (!Array.isArray(input)) return [];
+  if (opts.field) return input.filter((r) => !!r[opts.field]);
+  return input.filter(Boolean);
+};
+_fns.map = (input) => Array.isArray(input) ? input.slice() : [];
+_fns.sort = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input.slice() : [];
+  const f = opts.field;
+  const dir = opts.direction === "desc" ? -1 : 1;
+  if (f) return a.sort((x, y) => x[f] > y[f] ? dir : x[f] < y[f] ? -dir : 0);
+  return a.sort((x, y) => x > y ? dir : x < y ? -dir : 0);
+};
+_fns.slice = (input, _e, opts) => Array.isArray(input) ? input.slice(opts.start || 0, opts.end) : input;
+_fns.flat = (input, _e, opts) => {
+  const depth = opts.depth != null ? opts.depth : 1;
+  return Array.isArray(input) ? input.flat(depth) : [input];
+};
+_fns.unique = (input) => {
+  if (!Array.isArray(input)) return [input];
+  const seen = /* @__PURE__ */ new Set();
+  return input.filter((v) => {
+    const key = typeof v === "object" ? JSON.stringify(v) : v;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+_fns.group = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const g = {};
+  a.forEach((r) => {
+    const k = String(r[opts.field] || "");
+    if (!g[k]) g[k] = [];
+    g[k].push(r);
+  });
+  return g;
+};
+_fns.flatten_keys = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+  const result = [];
+  for (const k of Object.keys(input)) {
+    const vals = Array.isArray(input[k]) ? input[k] : [input[k]];
+    vals.forEach((v) => result.push({ key: k, value: v }));
+  }
+  return result;
+};
+_fns.entries = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+  return Object.keys(input).map((k) => ({ key: k, value: input[k] }));
+};
+_fns.from_entries = (input) => {
+  if (!Array.isArray(input)) return {};
+  const obj = {};
+  input.forEach((item) => {
+    if (item.key != null) obj[item.key] = item.value;
+  });
+  return obj;
+};
+_fns.length = (input) => {
+  if (Array.isArray(input)) return input.length;
+  if (typeof input === "string") return input.length;
+  if (input && typeof input === "object") return Object.keys(input).length;
+  return 0;
+};
+_fns.get = (input, _e, opts) => deepGet(input, opts.field || opts.path || "");
+_fns.default = (input, _e, opts) => input != null ? input : opts.value;
+_fns.coalesce = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] != null) return a[i];
+  }
+  return null;
+};
+_fns.now = () => (/* @__PURE__ */ new Date()).toISOString();
+_fns.diff_days = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Math.floor((new Date(a[0]).getTime() - new Date(a[1]).getTime()) / 864e5) : 0;
+};
+_fns.format_date = (input, _e, opts) => {
+  try {
+    const d = new Date(input);
+    if (opts.format === "iso") return d.toISOString();
+    if (opts.format === "date") return d.toLocaleDateString();
+    if (opts.format === "time") return d.toLocaleTimeString();
+    return d.toLocaleDateString();
+  } catch {
+    return String(input);
+  }
+};
+_fns.parse_date = (input) => {
+  try {
+    return new Date(input).toISOString();
+  } catch {
+    return null;
+  }
+};
+_fns.to_number = (input) => Number(input) || 0;
+_fns.to_string = (input) => input != null ? String(input) : "";
+_fns.to_bool = (input) => !!input;
+_fns.type_of = (input) => Array.isArray(input) ? "array" : typeof input;
+_fns.is_null = (input) => input == null;
+_fns.is_empty = (input) => {
+  if (input == null) return true;
+  if (Array.isArray(input)) return input.length === 0;
+  if (typeof input === "string") return input.length === 0;
+  if (typeof input === "object") return Object.keys(input).length === 0;
+  return false;
+};
+var _customFns = {};
+function evalExpr(expr, node) {
+  if (expr == null) return expr;
+  if (typeof expr !== "object" || Array.isArray(expr)) return expr;
+  const e = expr;
+  if (!e.fn) return expr;
+  let input = e.input;
+  if (typeof input === "string" && input.startsWith("state.")) {
+    input = deepGet(node, input);
+  } else if (Array.isArray(input)) {
+    input = input.map((v) => {
+      if (typeof v === "string" && v.startsWith("state.")) return deepGet(node, v);
+      if (v && typeof v === "object" && v.fn) return evalExpr(v, node);
+      return v;
+    });
+  } else if (input && typeof input === "object" && input.fn) {
+    input = evalExpr(input, node);
+  }
+  if (e.fn === "if") {
+    const cond = evalExpr(e.cond, node);
+    if (cond) {
+      return e.then && typeof e.then === "object" && e.then.fn ? evalExpr(e.then, node) : e.then;
+    } else {
+      return e.else && typeof e.else === "object" && e.else.fn ? evalExpr(e.else, node) : e.else;
+    }
+  }
+  if (e.fn === "filter" && Array.isArray(input) && e.where) {
+    return input.filter((item) => {
+      const tmp = { state: { ...node.state, $: item } };
+      return evalExpr(e.where, tmp);
+    });
+  }
+  if (e.fn === "map" && Array.isArray(input) && e.apply) {
+    return input.map((item) => {
+      const tmp = { state: { ...node.state, $: item } };
+      return evalExpr(e.apply, tmp);
+    });
+  }
+  const fn = _customFns[e.fn] || _fns[e.fn];
+  if (!fn) {
+    console.warn('CardCompute: unknown function "' + e.fn + '"');
+    return void 0;
+  }
+  return fn(input, evalExpr, e);
+}
+function run(node) {
+  if (!node || !node.compute) return node;
+  if (!node.state) node.state = {};
+  for (const key of Object.keys(node.compute)) {
+    try {
+      const val = evalExpr(node.compute[key], node);
+      deepSet(node.state, key, val);
+    } catch (err) {
+      console.error(`CardCompute.run error on "${node.id || "?"}.${key}":`, err);
+    }
+  }
+  return node;
+}
+function resolve(node, path) {
+  return deepGet(node, path);
+}
+function registerFunction(name, fn) {
+  _customFns[name] = fn;
+}
+var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
+  "metric",
+  "table",
+  "chart",
+  "form",
+  "filter",
+  "list",
+  "notes",
+  "todo",
+  "alert",
+  "narrative",
+  "badge",
+  "text",
+  "markdown",
+  "custom"
+]);
+var VALID_SOURCE_KINDS = /* @__PURE__ */ new Set(["api", "websocket", "static", "llm"]);
+var VALID_STATUSES = /* @__PURE__ */ new Set(["fresh", "stale", "loading", "error"]);
+var CARD_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "view", "state", "compute"]);
+var SOURCE_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "source", "state", "compute"]);
+function validateNode(node) {
+  const errors = [];
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { ok: false, errors: ["Node must be a non-null object"] };
+  }
+  const n = node;
+  if (typeof n.id !== "string" || !n.id) {
+    errors.push("id: required, must be a non-empty string");
+  }
+  if (n.type !== "card" && n.type !== "source") {
+    errors.push('type: must be "card" or "source"');
+    return { ok: false, errors };
+  }
+  const allowed = n.type === "card" ? CARD_ALLOWED_KEYS : SOURCE_ALLOWED_KEYS;
+  for (const key of Object.keys(n)) {
+    if (!allowed.has(key)) errors.push(`Unknown top-level key: "${key}"`);
+  }
+  if (n.state == null || typeof n.state !== "object" || Array.isArray(n.state)) {
+    errors.push("state: required, must be an object");
+  } else {
+    const state = n.state;
+    if (state.status != null && !VALID_STATUSES.has(state.status)) {
+      errors.push(`state.status: must be one of: ${[...VALID_STATUSES].join(", ")}`);
+    }
+  }
+  if (n.meta != null) {
+    if (typeof n.meta !== "object" || Array.isArray(n.meta)) {
+      errors.push("meta: must be an object");
+    } else {
+      const meta = n.meta;
+      if (meta.title != null && typeof meta.title !== "string") errors.push("meta.title: must be a string");
+      if (meta.tags != null && !Array.isArray(meta.tags)) errors.push("meta.tags: must be an array");
+    }
+  }
+  if (n.data != null) {
+    if (typeof n.data !== "object" || Array.isArray(n.data)) {
+      errors.push("data: must be an object");
+    } else {
+      const data = n.data;
+      if (data.requires != null && !Array.isArray(data.requires)) errors.push("data.requires: must be an array of strings");
+      if (data.provides != null && (typeof data.provides !== "object" || Array.isArray(data.provides))) errors.push("data.provides: must be an object");
+    }
+  }
+  if (n.compute != null) {
+    if (typeof n.compute !== "object" || Array.isArray(n.compute)) {
+      errors.push("compute: must be an object");
+    } else {
+      for (const [key, expr] of Object.entries(n.compute)) {
+        if (!expr || typeof expr !== "object" || Array.isArray(expr)) {
+          errors.push(`compute.${key}: must be a compute expression object`);
+        } else if (!expr.fn) {
+          errors.push(`compute.${key}: missing required "fn" property`);
+        } else {
+          const fn = expr.fn;
+          if (!_fns[fn] && !_customFns[fn]) {
+            errors.push(`compute.${key}: unknown function "${fn}"`);
+          }
+        }
+      }
+    }
+  }
+  if (n.type === "card") {
+    if (n.source != null) errors.push('Card nodes must not have "source" \u2014 use type "source" instead');
+    if (n.view == null || typeof n.view !== "object" || Array.isArray(n.view)) {
+      errors.push("view: required for card nodes, must be an object");
+    } else {
+      const view = n.view;
+      if (!Array.isArray(view.elements) || view.elements.length === 0) {
+        errors.push("view.elements: required, must be a non-empty array");
+      } else {
+        view.elements.forEach((elem, i) => {
+          if (!elem || typeof elem !== "object") {
+            errors.push(`view.elements[${i}]: must be an object`);
+            return;
+          }
+          if (!elem.kind || typeof elem.kind !== "string") {
+            errors.push(`view.elements[${i}].kind: required, must be a string`);
+          } else if (!VALID_ELEMENT_KINDS.has(elem.kind)) {
+            errors.push(`view.elements[${i}].kind: unknown kind "${elem.kind}". Valid: ${[...VALID_ELEMENT_KINDS].join(", ")}`);
+          }
+          if (elem.data != null && (typeof elem.data !== "object" || Array.isArray(elem.data))) {
+            errors.push(`view.elements[${i}].data: must be an object`);
+          }
+        });
+      }
+      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) {
+        errors.push("view.layout: must be an object");
+      }
+      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) {
+        errors.push("view.features: must be an object");
+      }
+    }
+  }
+  if (n.type === "source") {
+    if (n.view != null) errors.push('Source nodes must not have "view" \u2014 use type "card" instead');
+    if (n.source == null || typeof n.source !== "object" || Array.isArray(n.source)) {
+      errors.push("source: required for source nodes, must be an object");
+    } else {
+      const src = n.source;
+      if (!src.kind || !VALID_SOURCE_KINDS.has(src.kind)) {
+        errors.push(`source.kind: required, must be one of: ${[...VALID_SOURCE_KINDS].join(", ")}`);
+      }
+      if (typeof src.bindTo !== "string" || !src.bindTo) {
+        errors.push("source.bindTo: required, must be a state path string");
+      } else if (!src.bindTo.startsWith("state.")) {
+        errors.push('source.bindTo: must start with "state."');
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+var CardCompute = {
+  run,
+  eval: evalExpr,
+  resolve,
+  validate: validateNode,
+  registerFunction,
+  get functions() {
+    const all = {};
+    for (const k of Object.keys(_fns)) all[k] = _fns[k];
+    for (const k of Object.keys(_customFns)) all[k] = _customFns[k];
+    return all;
+  }
+};
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
+exports.CardCompute = CardCompute;
 exports.DEFAULTS = DEFAULTS;
 exports.EXECUTION_MODES = EXECUTION_MODES;
 exports.EXECUTION_STATUS = EXECUTION_STATUS;