snow-flow 10.0.1-dev.480 → 10.0.1-dev.482

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.480",
+  "version": "10.0.1-dev.482",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

package/src/servicenow/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.ts

@@ -896,8 +896,8 @@ async function addTriggerViaGraphQL(
     steps.insert = { success: !!triggerId, triggerId, triggerUiId };
     if (!triggerId) return { success: false, steps, error: 'GraphQL trigger INSERT returned no trigger ID' };
 
-    // Step 2: UPDATE with actual table and condition values (matching UI behavior from trigger-query-2.txt)
-    // The UI sends: table with displayField+displayValue+value, condition with just displayValue
+    // Step 2: UPDATE with actual table and condition values (matching UI behavior)
+    // The UI sends: table with displayField+displayValue+value, condition with displayField+displayValue(empty)+value, metadata with predicates
     if (table) {
       try {
         var tableDisplayName = '';
@@ -911,6 +911,30 @@ async function addTriggerViaGraphQL(
           tableDisplayName = table.charAt(0).toUpperCase() + table.slice(1).replace(/_/g, ' ');
         }
 
+        // Build condition predicates via query_parse API (same as UI)
+        var conditionValue = condition || '^EQ';
+        var predicatesJson = '[]';
+        if (conditionValue && conditionValue !== '^EQ') {
+          try {
+            var qpResp = await client.get('/api/now/ui/query_parse/' + table + '/map', {
+              params: { table: table, sysparm_query: conditionValue }
+            });
+            var qpResult = qpResp.data?.result;
+            if (qpResult) {
+              predicatesJson = typeof qpResult === 'string' ? qpResult : JSON.stringify(qpResult);
+            }
+          } catch (_) {
+            // Fallback: build minimal predicates from parsed condition
+            var parsedClauses = parseEncodedQuery(conditionValue);
+            if (parsedClauses.length > 0) {
+              var minPredicates = parsedClauses.map(function (c) {
+                return { field: c.field, operator: c.operator, value: c.value };
+              });
+              predicatesJson = JSON.stringify(minPredicates);
+            }
+          }
+        }
+
         var trigUpdateInputs: any[] = [
           {
             name: 'table',
@@ -920,7 +944,9 @@ async function addTriggerViaGraphQL(
           },
           {
             name: 'condition',
-            displayValue: { schemaless: false, schemalessValue: '', value: condition || '^EQ' }
+            displayField: '',
+            displayValue: { value: '' },
+            value: { schemaless: false, schemalessValue: '', value: conditionValue }
           }
         ];
 
@@ -929,11 +955,12 @@ async function addTriggerViaGraphQL(
           triggerInstances: {
             update: [{
               id: triggerId,
-              inputs: trigUpdateInputs
+              inputs: trigUpdateInputs,
+              metadata: '{"predicates":' + predicatesJson + '}'
             }]
           }
         }, triggerResponseFields);
-        steps.trigger_update = { success: true, table: table, tableDisplay: tableDisplayName };
+        steps.trigger_update = { success: true, table: table, tableDisplay: tableDisplayName, predicates: predicatesJson };
       } catch (updateErr: any) {
         steps.trigger_update = { success: false, error: updateErr.message };
         // Trigger was created — update failure is non-fatal
@@ -1222,9 +1249,9 @@ async function getFlowTriggerInfo(
   // This API returns XML (not JSON). We parse trigger info from the XML string.
   try {
     debug.processflow_api = 'attempting';
-    var pfResp = await client.get('/api/now/processflow/flow/' + flowId, {
-      headers: { 'Accept': 'application/xml, application/json' }
-    });
+    // Note: do NOT pass custom headers in config — some Axios interceptors freeze the config
+    // object, causing "Attempted to assign to readonly property" errors.
+    var pfResp = await client.get('/api/now/processflow/flow/' + flowId);
     var pfRaw = pfResp.data;
     debug.processflow_api = 'success';
     debug.processflow_type = typeof pfRaw;
@@ -1259,6 +1286,14 @@ async function getFlowTriggerInfo(
       var pfData = pfRaw.result || pfRaw;
       debug.processflow_keys = pfData && typeof pfData === 'object' ? Object.keys(pfData).slice(0, 20) : null;
 
+      // ProcessFlow API wraps actual flow data inside a "data" property
+      // e.g. {data: {triggerInstances: [...]}, errorMessage, errorCode, integrationsPluginActive}
+      if (pfData.data && typeof pfData.data === 'object' && !pfData.triggerInstances) {
+        pfData = pfData.data;
+        debug.processflow_unwrapped = true;
+        debug.processflow_data_keys = typeof pfData === 'object' ? Object.keys(pfData).slice(0, 20) : null;
+      }
+
       var pfTriggers = pfData?.triggerInstances || pfData?.trigger_instances || pfData?.triggers || [];
       if (!Array.isArray(pfTriggers) && pfData?.model?.triggerInstances) {
         pfTriggers = pfData.model.triggerInstances;
@@ -1300,16 +1335,28 @@ async function getFlowTriggerInfo(
         var parsed = typeof payload === 'string' ? JSON.parse(payload) : payload;
         debug.version_payload_keys = Object.keys(parsed);
         var trigInst = parsed.triggerInstances || parsed.trigger_instances || [];
+        debug.version_trigger_count = Array.isArray(trigInst) ? trigInst.length : typeof trigInst;
         if (Array.isArray(trigInst) && trigInst.length > 0) {
-          if (!triggerName) triggerName = trigInst[0].name || trigInst[0].triggerName || '';
-          if (!table && trigInst[0].inputs) {
-            for (var vi = 0; vi < trigInst[0].inputs.length; vi++) {
-              if (trigInst[0].inputs[vi].name === 'table') {
-                table = trigInst[0].inputs[vi].value?.value || '';
+          var t0 = trigInst[0];
+          debug.version_trigger_keys = Object.keys(t0);
+          debug.version_trigger_name_field = t0.name || t0.triggerName || t0.triggerDefinitionName || '';
+          if (!triggerName) triggerName = t0.name || t0.triggerName || t0.triggerDefinitionName || '';
+          // Also try getting the trigger definition name (e.g. "Created or Updated")
+          if (!triggerName && t0.triggerDefinition) {
+            triggerName = t0.triggerDefinition.name || '';
+          }
+          if (!table && t0.inputs) {
+            var t0Inputs = Array.isArray(t0.inputs) ? t0.inputs : [];
+            for (var vi = 0; vi < t0Inputs.length; vi++) {
+              if (t0Inputs[vi].name === 'table') {
+                table = t0Inputs[vi].value?.value || str(t0Inputs[vi].value) || '';
+                debug.version_table_input = t0Inputs[vi];
                 break;
               }
             }
           }
+          // Fallback: try reading table directly from trigger object
+          if (!table && t0.table) table = str(t0.table);
         }
       }
     } catch (_) {}
@@ -1494,14 +1541,20 @@ function transformConditionToDataPills(conditionValue: string, dataPillBase: str
 }
 
 /**
- * Build labelCache entries for field-level data pills used in flow logic conditions.
+ * Build labelCache INSERT entries for field-level data pills used in flow logic conditions.
  *
- * Returns { inserts, updates }:
- * - inserts: record-level pill with full metadata (processflow XML format)
- * - updates: field-level pills with minimal fields (name + usedInstances, matching UI mutation)
+ * Returns an array of labelCache INSERT entries with full metadata, matching the UI's exact
+ * mutation format (captured from Flow Designer network tab when editing a programmatic flow):
  *
- * The UI uses labelCache.update for field-level condition pills (captured from network tab).
- * The record-level pill is INSERTed to ensure it exists when triggers are created programmatically.
+ *   labelCache: { insert: [{
+ *     name: "Created or Updated_1.current.category",
+ *     label: "Trigger - Record Created or Updated➛Incident Record➛Category",
+ *     reference: "", reference_display: "Category",
+ *     type: "choice", base_type: "choice",
+ *     parent_table_name: "incident", column_name: "category",
+ *     usedInstances: [{uiUniqueIdentifier: "...", inputName: "condition"}],
+ *     choices: {}
+ *   }] }
  */
 async function buildConditionLabelCache(
   client: any,
@@ -1535,27 +1588,54 @@ async function buildConditionLabelCache(
   }
   if (uniqueFields.length === 0) return [];
 
-  // Build labelCache UPDATE entries for condition pills.
-  // Matches the UI's exact mutation format (from if-statement-update.txt):
-  //   labelCache: { update: [{ name: "Created or Updated_1.current.category", usedInstances: [...] }] }
-  //
-  // The record-level pill (e.g. "Created or Updated_1.current") is NOT included here because:
-  // - The ServiceNow backend automatically creates it when the trigger is saved (INSERT → UPDATE)
-  // - Sending a duplicate labelCache.insert for it can cause the entire labelCache block to fail
-  // - The UI's condition mutation never sends a record-level pill insert (confirmed via network capture)
-  var updates: any[] = [];
+  // Batch-query sys_dictionary for field metadata (type, label, reference)
+  var fieldMeta: Record<string, { type: string; label: string; reference: string }> = {};
+  try {
+    var dictResp = await client.get('/api/now/table/sys_dictionary', {
+      params: {
+        sysparm_query: 'name=' + table + '^elementIN' + uniqueFields.join(','),
+        sysparm_fields: 'element,column_label,internal_type,reference',
+        sysparm_display_value: 'false',
+        sysparm_limit: uniqueFields.length + 5
+      }
+    });
+    var dictResults = dictResp.data.result || [];
+    for (var d = 0; d < dictResults.length; d++) {
+      var rec = dictResults[d];
+      var elName = str(rec.element);
+      var intType = str(rec.internal_type?.value || rec.internal_type || 'string');
+      var colLabel = str(rec.column_label);
+      var refTable = str(rec.reference?.value || rec.reference || '');
+      if (elName) fieldMeta[elName] = { type: intType, label: colLabel, reference: refTable };
+    }
+  } catch (_) {
+    // Fallback: use "string" type and generated labels if dictionary lookup fails
+  }
+
+  // Build labelCache INSERT entries with full metadata for each field-level pill.
+  // This matches the UI's mutation format when editing a programmatically-created flow.
+  var inserts: any[] = [];
 
   for (var j = 0; j < uniqueFields.length; j++) {
     var f = uniqueFields[j];
     var pillName = dataPillBase + '.' + f;
+    var meta = fieldMeta[f] || { type: 'string', label: f.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); }), reference: '' };
 
-    updates.push({
+    inserts.push({
       name: pillName,
-      usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }]
+      label: 'Trigger - Record ' + triggerName + '\u279b' + tableLabel + ' Record\u279b' + meta.label,
+      reference: meta.reference,
+      reference_display: meta.label,
+      type: meta.type,
+      base_type: meta.type,
+      parent_table_name: table,
+      column_name: f,
+      usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }],
+      choices: {}
     });
   }
 
-  return updates;
+  return inserts;
 }
 
 // ── DATA PILL SUPPORT FOR RECORD ACTIONS (Update/Create Record) ──────
@@ -1886,22 +1966,41 @@ async function addFlowLogicViaGraphQL(
   var needsConditionUpdate = false;
   var conditionTriggerInfo: any = null;
 
-  // Pre-process: detect JS-style dot notation conditions and convert to shorthand pill format.
-  // Users may write conditions like:
-  //   "trigger.current.category = software"      (single =)
-  //   "trigger.current.category == 'software'"   (JS equality)
-  //   "current.priority = 1"                     (short prefix)
-  // These are converted to pill shorthand format that the existing logic can handle:
-  //   "{{trigger.current.category}}=software"
-  var DOT_NOTATION_RE = /((?:trigger\.)?current)\.(\w+)\s*(===?|!==?|>=|<=|>|<|=)\s*(?:'([^']*)'|"([^"]*)"|(\S+))/g;
-  if (DOT_NOTATION_RE.test(rawCondition)) {
+  // Pre-process: detect dot notation conditions and convert to shorthand pill format.
+  // Supports both symbol operators and word operators:
+  //   "trigger.current.category = software"          → "{{trigger.current.category}}=software"
+  //   "trigger.current.category == 'software'"       → "{{trigger.current.category}}=software"
+  //   "trigger.current.category equals software"     → "{{trigger.current.category}}=software"
+  //   "trigger.current.priority != 1"                → "{{trigger.current.priority}}!=1"
+  //   "current.active is true"                       → "{{current.active}}=true"
+  var WORD_OP_MAP: Record<string, string> = {
+    'equals': '=', 'is': '=', 'eq': '=',
+    'not_equals': '!=', 'is not': '!=', 'neq': '!=', 'not equals': '!=',
+    'greater than': '>', 'gt': '>', 'less than': '<', 'lt': '<',
+    'greater or equals': '>=', 'gte': '>=', 'less or equals': '<=', 'lte': '<=',
+    'contains': 'LIKE', 'starts with': 'STARTSWITH', 'ends with': 'ENDSWITH',
+    'not contains': 'NOT LIKE', 'is empty': 'ISEMPTY', 'is not empty': 'ISNOTEMPTY'
+  };
+  // First replace word operators with symbols so the regex can match uniformly
+  var dotOriginal = rawCondition;
+  var dotProcessed = rawCondition;
+  var WORD_OPS_SORTED = Object.keys(WORD_OP_MAP).sort(function (a, b) { return b.length - a.length; }); // longest first
+  for (var wi = 0; wi < WORD_OPS_SORTED.length; wi++) {
+    var wordOp = WORD_OPS_SORTED[wi];
+    // Only replace word operators that appear between a dot-notation field and a value
+    var wordRe = new RegExp('((?:trigger\\.)?current\\.\\w+)\\s+' + wordOp.replace(/ /g, '\\s+') + '\\s+', 'gi');
+    dotProcessed = dotProcessed.replace(wordRe, function (m: string, prefix: string) {
+      return prefix + WORD_OP_MAP[wordOp];
+    });
+  }
+  var DOT_NOTATION_RE = /((?:trigger\.)?current)\.(\w+)(===?|!==?|>=|<=|>|<|=|LIKE|STARTSWITH|ENDSWITH|NOT LIKE|ISEMPTY|ISNOTEMPTY)\s*(?:'([^']*)'|"([^"]*)"|(\S*))/g;
+  if (DOT_NOTATION_RE.test(dotProcessed)) {
     DOT_NOTATION_RE.lastIndex = 0;
-    var dotOriginal = rawCondition;
-    rawCondition = rawCondition.replace(DOT_NOTATION_RE, function (_m: string, prefix: string, field: string, op: string, qv1: string, qv2: string, uv: string) {
+    rawCondition = dotProcessed.replace(DOT_NOTATION_RE, function (_m: string, prefix: string, field: string, op: string, qv1: string, qv2: string, uv: string) {
       var snOp = op;
       if (op === '==' || op === '===') snOp = '=';
       else if (op === '!=' || op === '!==') snOp = '!=';
-      var val = qv1 !== undefined ? qv1 : (qv2 !== undefined ? qv2 : uv);
+      var val = qv1 !== undefined ? qv1 : (qv2 !== undefined ? qv2 : (uv || ''));
       return '{{' + prefix + '.' + field + '}}' + snOp + val;
     });
     // Replace JS && with ServiceNow ^ (AND separator)
@@ -1909,6 +2008,36 @@ async function addFlowLogicViaGraphQL(
     steps.dot_notation_rewrite = { original: dotOriginal, rewritten: rawCondition };
   }
 
+  // Pre-process: convert word operators in pill-format conditions
+  // e.g. "{{trigger.current.category}} equals software" → "{{trigger.current.category}}=software"
+  if (rawCondition.includes('{{')) {
+    var PILL_WORD_OPS: [RegExp, string][] = [
+      [/(\}\})\s+not\s+equals\s+/gi, '$1!='],
+      [/(\}\})\s+is\s+not\s+/gi, '$1!='],
+      [/(\}\})\s+equals\s+/gi, '$1='],
+      [/(\}\})\s+is\s+/gi, '$1='],
+      [/(\}\})\s+contains\s+/gi, '$1LIKE'],
+      [/(\}\})\s+starts\s+with\s+/gi, '$1STARTSWITH'],
+      [/(\}\})\s+ends\s+with\s+/gi, '$1ENDSWITH'],
+      [/(\}\})\s+greater\s+than\s+/gi, '$1>'],
+      [/(\}\})\s+less\s+than\s+/gi, '$1<'],
+      // Symbol operators: == / === / != / !== / >= / <= / > / < with optional spaces
+      [/(\}\})\s*===?\s*/g, '$1='],
+      [/(\}\})\s*!==?\s*/g, '$1!='],
+      [/(\}\})\s*>=\s*/g, '$1>='],
+      [/(\}\})\s*<=\s*/g, '$1<='],
+      [/(\}\})\s*>\s*/g, '$1>'],
+      [/(\}\})\s*<\s*/g, '$1<'],
+    ];
+    var pillWordOriginal = rawCondition;
+    for (var pwi = 0; pwi < PILL_WORD_OPS.length; pwi++) {
+      rawCondition = rawCondition.replace(PILL_WORD_OPS[pwi][0], PILL_WORD_OPS[pwi][1]);
+    }
+    if (rawCondition !== pillWordOriginal) {
+      steps.pill_word_op_rewrite = { original: pillWordOriginal, rewritten: rawCondition };
+    }
+  }
+
   // Shorthand patterns that need rewriting to the real data pill base
   // e.g. {{trigger.current.category}} → {{Created or Updated_1.current.category}}
   var PILL_SHORTHANDS = ['trigger.current', 'current', 'trigger_record', 'trigger.record'];
@@ -2032,25 +2161,31 @@ async function addFlowLogicViaGraphQL(
       steps.label_cache = labelCacheResult.map(function (e: any) { return e.name; });
 
       try {
-        // Match the UI's exact format for condition UPDATE (from if-statement-update.txt):
-        // - labelCache.update: field-level pills with minimal name + usedInstances
-        // - NO labelCache.insert (record-level pill is auto-created by backend during trigger save)
-        // - condition input: only name + value (NO displayValue, NO flowLogicDefinition)
+        // Match the UI's exact format for condition UPDATE (captured from clean Flow Designer network trace):
+        // - labelCache.insert: field-level pills with FULL metadata (type, parent_table_name, etc.)
+        // - Two inputs: condition_name (label) + condition (pill expression)
+        // - No flowLogicDefinition, no displayValue on condition
         var updatePatch: any = {
           flowId: flowId,
           flowLogics: {
             update: [{
               uiUniqueIdentifier: returnedUuid,
               type: 'flowlogic',
-              inputs: [{
-                name: 'condition',
-                value: { schemaless: false, schemalessValue: '', value: transformedCondition }
-              }]
+              inputs: [
+                {
+                  name: 'condition_name',
+                  value: { schemaless: false, schemalessValue: '', value: 'label' }
+                },
+                {
+                  name: 'condition',
+                  value: { schemaless: false, schemalessValue: '', value: transformedCondition }
+                }
+              ]
             }]
           }
         };
         if (labelCacheResult.length > 0) {
-          updatePatch.labelCache = { update: labelCacheResult };
+          updatePatch.labelCache = { insert: labelCacheResult };
         }
         // Log the exact GraphQL mutation for debugging
         steps.condition_update_mutation = jsToGraphQL(updatePatch);