elsabro 7.3.0 → 7.3.2

package/flow-engine/src/graph.js

@@ -64,15 +64,16 @@ function buildGraph(flowDefinition) {
 
 /**
  * Validate that all node references (next, routes, true, false, onMaxIterations,
- * onError) point to existing nodes.
+ * onError) point to existing nodes, and detect orphaned nodes.
  *
- * @param {{ nodes: Map<string, object> }} graph
+ * @param {{ nodes: Map<string, object>, entryNode: string }} graph
  * @returns {{ valid: boolean, errors: string[] }}
  */
 function validateGraph(graph) {
   const errors = [];
   const nodeIds = new Set(graph.nodes.keys());
 
+  // 1. Check for dangling references (invalid routes)
   for (const [id, node] of graph.nodes) {
     const refs = getNextNodes(node);
     for (const ref of refs) {
@@ -82,6 +83,33 @@ function validateGraph(graph) {
     }
   }
 
+  // 2. Detect orphaned nodes (nodes that are never reachable from entry)
+  const reachable = new Set();
+  const queue = [graph.entryNode];
+
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (reachable.has(currentId)) continue;
+
+    reachable.add(currentId);
+    const node = graph.nodes.get(currentId);
+    if (!node) continue; // Skip if node doesn't exist (handled by dangling ref check)
+
+    const nextNodes = getNextNodes(node);
+    for (const nextId of nextNodes) {
+      if (!reachable.has(nextId) && nodeIds.has(nextId)) {
+        queue.push(nextId);
+      }
+    }
+  }
+
+  // Find orphaned nodes
+  for (const nodeId of nodeIds) {
+    if (!reachable.has(nodeId)) {
+      errors.push(`Orphaned node "${nodeId}" is unreachable from entry point`);
+    }
+  }
+
   return { valid: errors.length === 0, errors };
 }
 

package/flow-engine/src/template.js

@@ -73,7 +73,17 @@ registerFunction('collectErrors', (context) => {
 registerFunction('hasCriticalIssues', (context, obj) => {
   if (!obj) return false;
   const json = typeof obj === 'string' ? obj : JSON.stringify(obj);
-  return json.includes('"critical"') || json.includes('"blocking"');
+
+  // Enhanced pattern detection for critical issues
+  const criticalPatterns = [
+    '"critical"',
+    '"blocking"',
+    '"P0"',
+    '"MUST_FIX"',
+    '"URGENT"'
+  ];
+
+  return criticalPatterns.some(pattern => json.includes(pattern));
 });
 
 registerFunction('generateSummary', (context) => {
@@ -144,92 +154,162 @@ function parseLiteral(str) {
 }
 
 /**
- * Resolve a single expression string (the content inside {{ }}).
- *
- * @param {string} expr – raw expression without {{ }}
- * @param {object} context – { inputs, nodes, steps, state }
- * @returns {*}
+ * Handle filter syntax: "value | filterName"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Filtered value or null if no match
  */
-function resolveExpression(expr, context) {
-  const trimmed = expr.trim();
-
-  // 1. Check for filter syntax: "value | filterName"
-  //    Only match pipes that are NOT inside || (fallback operator)
-  const filterMatch = trimmed.match(/^(.+?)\s*\|\s*(?!\|)(\w+)\s*$/);
-  if (filterMatch) {
-    const innerValue = resolveExpression(filterMatch[1], context);
-    const filterName = filterMatch[2];
-    const filter = _filters.get(filterName);
-    if (!filter) {
-      throw new TemplateError(`Unknown filter: "${filterName}"`);
-    }
-    return filter(innerValue);
+function tryResolveFilter(expr, context) {
+  // Only match pipes that are NOT inside || (fallback operator)
+  const filterMatch = expr.match(/^(.+?)\s*\|\s*(?!\|)(\w+)\s*$/);
+  if (!filterMatch) return null;
+
+  const innerValue = resolveExpression(filterMatch[1], context);
+  const filterName = filterMatch[2];
+  const filter = _filters.get(filterName);
+  if (!filter) {
+    throw new TemplateError(`Unknown filter: "${filterName}"`);
   }
+  return filter(innerValue);
+}
 
-  // 2. Check for fallback operator: "expr || default"
-  const fallbackMatch = trimmed.match(/^(.+?)\s*\|\|\s*(.+)$/);
-  if (fallbackMatch) {
-    const primary = resolveExpression(fallbackMatch[1], context);
-    if (primary != null && primary !== '') return primary;
-    // Try to resolve the default as an expression or literal
-    const fallbackLiteral = parseLiteral(fallbackMatch[2]);
-    if (fallbackLiteral.matched) return fallbackLiteral.value;
-    return resolveExpression(fallbackMatch[2], context);
-  }
+/**
+ * Handle fallback operator: "expr || default"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Primary or fallback value, or null if no match
+ */
+function tryResolveFallback(expr, context) {
+  const fallbackMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+  if (!fallbackMatch) return null;
+
+  const primary = resolveExpression(fallbackMatch[1], context);
+  if (primary != null && primary !== '') return primary;
+
+  // Try to resolve the default as a literal or expression
+  const fallbackLiteral = parseLiteral(fallbackMatch[2]);
+  if (fallbackLiteral.matched) return fallbackLiteral.value;
+  return resolveExpression(fallbackMatch[2], context);
+}
+
+/**
+ * Handle negation: "!expr"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Negated value or null if no match
+ */
+function tryResolveNegation(expr, context) {
+  if (!expr.startsWith('!')) return null;
+  const inner = resolveExpression(expr.slice(1), context);
+  return !inner;
+}
 
-  // 3. Check for negation: "!expr"
-  if (trimmed.startsWith('!')) {
-    const inner = resolveExpression(trimmed.slice(1), context);
-    return !inner;
+/**
+ * Handle boolean && expression
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Boolean result or null if no match
+ */
+function tryResolveAnd(expr, context) {
+  if (!expr.includes('&&')) return null;
+
+  const parts = expr.split('&&').map(p => p.trim());
+  return parts.every(part => {
+    const val = resolveExpression(part, context);
+    return !!val;
+  });
+}
+
+/**
+ * Handle comparison operators: ===, !==
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Comparison result or null if no match
+ */
+function tryResolveComparison(expr, context) {
+  const compMatch = expr.match(/^(.+?)\s*(===|!==)\s*(.+)$/);
+  if (!compMatch) return null;
+
+  const left = resolveExpression(compMatch[1], context);
+  const right = resolveExpression(compMatch[3], context);
+  if (compMatch[2] === '===') return left === right;
+  if (compMatch[2] === '!==') return left !== right;
+  return null;
+}
+
+/**
+ * Handle function call: "functionName(args)"
+ * @param {string} expr
+ * @param {object} context
+ * @returns {*|null} - Function result or null if no match
+ */
+function tryResolveFunctionCall(expr, context) {
+  const funcMatch = expr.match(/^(\w+)\(([^)]*)\)$/);
+  if (!funcMatch) return null;
+
+  const funcName = funcMatch[1];
+  const fn = _functions.get(funcName);
+  if (!fn) {
+    throw new TemplateError(`Unknown function: "${funcName}"`);
   }
 
-  // 4. Check for boolean && expression
-  if (trimmed.includes('&&')) {
-    const parts = trimmed.split('&&').map(p => p.trim());
-    return parts.every(part => {
-      const val = resolveExpression(part, context);
-      return !!val;
-    });
+  const argsStr = funcMatch[2].trim();
+  if (argsStr === '') {
+    return fn(context);
   }
 
-  // 5. Check for comparison operators: ===, !==
-  const compMatch = trimmed.match(/^(.+?)\s*(===|!==)\s*(.+)$/);
-  if (compMatch) {
-    const left = resolveExpression(compMatch[1], context);
-    const right = resolveExpression(compMatch[3], context);
-    if (compMatch[2] === '===') return left === right;
-    if (compMatch[2] === '!==') return left !== right;
+  // Parse argument: could be a path reference or a quoted string
+  const argLiteral = parseLiteral(argsStr);
+  if (argLiteral.matched) {
+    return fn(context, argLiteral.value);
   }
 
-  // 6. Check for function call: "functionName(args)"
-  const funcMatch = trimmed.match(/^(\w+)\(([^)]*)\)$/);
-  if (funcMatch) {
-    const funcName = funcMatch[1];
-    const fn = _functions.get(funcName);
-    if (!fn) {
-      throw new TemplateError(`Unknown function: "${funcName}"`);
-    }
-    const argsStr = funcMatch[2].trim();
-    if (argsStr === '') {
-      return fn(context);
-    }
-    // Parse argument: could be a path reference or a quoted string
-    const argLiteral = parseLiteral(argsStr);
-    if (argLiteral.matched) {
-      return fn(context, argLiteral.value);
-    }
-    // Resolve as expression (path)
-    const argValue = resolveExpression(argsStr, context);
-    return fn(context, argValue);
+  // Resolve as expression (path)
+  const argValue = resolveExpression(argsStr, context);
+  return fn(context, argValue);
+}
+
+/**
+ * Resolve a single expression string (the content inside {{ }}).
+ *
+ * Delegates to specialized handlers in order:
+ * 1. Filter syntax: "value | filterName"
+ * 2. Fallback operator: "expr || default"
+ * 3. Negation: "!expr"
+ * 4. Boolean AND: "a && b"
+ * 5. Comparison: "a === b", "a !== b"
+ * 6. Function call: "functionName(args)"
+ * 7. Literal value: true, false, number, string, [], {}
+ * 8. Path resolution: "inputs.task", "nodes.X.outputs.Y"
+ *
+ * @param {string} expr – raw expression without {{ }}
+ * @param {object} context – { inputs, nodes, steps, state }
+ * @returns {*}
+ */
+function resolveExpression(expr, context) {
+  const trimmed = expr.trim();
+
+  // Try each expression type in order (most specific to least specific)
+  const handlers = [
+    tryResolveFilter,
+    tryResolveFallback,
+    tryResolveNegation,
+    tryResolveAnd,
+    tryResolveComparison,
+    tryResolveFunctionCall
+  ];
+
+  for (const handler of handlers) {
+    const result = handler(trimmed, context);
+    if (result !== null) return result;
   }
 
-  // 7. Literal value
+  // Try literal value
   const literal = parseLiteral(trimmed);
   if (literal.matched) return literal.value;
 
-  // 8. Path resolution (the most common case)
-  const value = resolvePath(context, trimmed);
-  return value;
+  // Default: path resolution (most common case)
+  return resolvePath(context, trimmed);
 }
 
 /**