snow-flow-test 10.0.1-test.178 → 10.0.1-test.180

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-test.178",
+  "version": "10.0.1-test.180",
   "name": "snow-flow-test",
   "description": "Snow-Flow Test - ServiceNow Multi-Agent Development Framework",
   "license": "Elastic-2.0",

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

@@ -141,7 +141,7 @@ async function buildActionInputsForInsert(
       }
       var match = actionParams.find(function (p: any) {
         var el = str(p.element);
-        return el.endsWith('_' + key) || el === key || str(p.label).toLowerCase() === key.toLowerCase();
+        return el.endsWith('_' + key) || el.startsWith(key + '_') || el === key || str(p.label).toLowerCase() === key.toLowerCase();
       });
       if (match) resolvedInputs[str(match.element)] = value;
       else resolvedInputs[key] = value;
@@ -1001,6 +1001,15 @@ async function addActionViaGraphQL(
   steps.insert_order = resolvedOrder;
 
   const uuid = generateUUID();
+
+  // ── Data pill transformation for record actions (Update/Create Record) ──
+  // These actions need: record → data pill, table_name → displayValue, field values → packed into values string
+  var recordActionResult = await transformActionInputsForRecordAction(
+    client, flowId, inputResult.inputs, inputResult.resolvedInputs,
+    inputResult.actionParams, uuid
+  );
+  steps.record_action = recordActionResult.steps;
+
   const actionResponseFields = 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
@@ -1019,11 +1028,16 @@ async function addActionViaGraphQL(
         uiUniqueIdentifier: uuid,
         type: 'action',
         parentUiId: parentUiId || '',
-        inputs: inputResult.inputs
+        inputs: recordActionResult.inputs
       }]
     }
   };
 
+  // Add labelCache entries for data pill references in record actions
+  if (recordActionResult.labelCacheEntries.length > 0) {
+    flowPatch.labelCache = { insert: recordActionResult.labelCacheEntries };
+  }
+
   // Add parent flow logic update signal (tells GraphQL the parent was modified)
   if (parentUiId) {
     flowPatch.flowLogics = { update: [{ uiUniqueIdentifier: parentUiId, type: 'flowlogic' }] };
@@ -1040,6 +1054,427 @@ async function addActionViaGraphQL(
   }
 }
 
+// ── DATA PILL CONDITION HELPERS ────────────────────────────────────────
+
+/**
+ * Get trigger info from a flow for constructing data pill references.
+ * Reads the flow version payload to find the trigger name, table, and outputs.
+ *
+ * Returns the data pill base (e.g., "Created or Updated_1") and table (e.g., "incident").
+ * The data pill base is used as: {{dataPillBase.fieldName}} in condition values.
+ */
+async function getFlowTriggerInfo(
+  client: any,
+  flowId: string
+): Promise<{ dataPillBase: string; triggerName: string; table: string; tableLabel: string; tableRef: string; error?: string }> {
+  var triggerName = '';
+  var table = '';
+  var tableLabel = '';
+
+  try {
+    // Read the flow version payload which contains all flow elements
+    var resp = await client.get('/api/now/table/sys_hub_flow_version', {
+      params: {
+        sysparm_query: 'flow=' + flowId + '^ORDERBYDESCsys_created_on',
+        sysparm_fields: 'sys_id,payload',
+        sysparm_limit: 1
+      }
+    });
+    var payload = resp.data.result?.[0]?.payload;
+    if (payload) {
+      var parsed = typeof payload === 'string' ? JSON.parse(payload) : payload;
+      // The payload contains triggerInstances array with trigger data
+      var triggerInstances = parsed.triggerInstances || parsed.trigger_instances || [];
+      if (!Array.isArray(triggerInstances)) {
+        // Some payloads nest elements differently
+        if (parsed.elements) {
+          triggerInstances = (Array.isArray(parsed.elements) ? parsed.elements : []).filter(
+            (e: any) => e.type === 'trigger' || e.elementType === 'trigger'
+          );
+        }
+      }
+      if (triggerInstances.length > 0) {
+        var trigger = triggerInstances[0];
+        triggerName = trigger.name || trigger.triggerName || '';
+        // Look for table in trigger inputs
+        if (trigger.inputs && Array.isArray(trigger.inputs)) {
+          for (var ti = 0; ti < trigger.inputs.length; ti++) {
+            if (trigger.inputs[ti].name === 'table') {
+              table = trigger.inputs[ti].value?.value || trigger.inputs[ti].value || '';
+              break;
+            }
+          }
+        }
+      }
+    }
+  } catch (_) {}
+
+  // Look up table label for display in label cache
+  if (table) {
+    try {
+      var labelResp = await client.get('/api/now/table/sys_db_object', {
+        params: {
+          sysparm_query: 'name=' + table,
+          sysparm_fields: 'label',
+          sysparm_display_value: 'true',
+          sysparm_limit: 1
+        }
+      });
+      tableLabel = str(labelResp.data.result?.[0]?.label) || '';
+    } catch (_) {}
+    if (!tableLabel) {
+      // Fallback: capitalize the table name
+      tableLabel = table.charAt(0).toUpperCase() + table.slice(1).replace(/_/g, ' ');
+    }
+  }
+
+  if (!triggerName) {
+    return { dataPillBase: '', triggerName: '', table: table, tableLabel: tableLabel, tableRef: table, error: 'Could not determine trigger name from flow version payload' };
+  }
+
+  var dataPillBase = triggerName + '_1.current';
+  return { dataPillBase, triggerName, table, tableLabel, tableRef: table };
+}
+
+/**
+ * Parse a ServiceNow encoded query into individual condition clauses.
+ * Each clause has: prefix (^ or ^OR), field, operator, value.
+ *
+ * Example: "category=inquiry^priority!=1^ORshort_descriptionLIKEtest"
+ * → [
+ *     { prefix: '', field: 'category', operator: '=', value: 'inquiry' },
+ *     { prefix: '^', field: 'priority', operator: '!=', value: '1' },
+ *     { prefix: '^OR', field: 'short_description', operator: 'LIKE', value: 'test' }
+ *   ]
+ */
+function parseEncodedQuery(query: string): { prefix: string; field: string; operator: string; value: string }[] {
+  if (!query || query === '^EQ') return [];
+
+  // Remove trailing ^EQ
+  var q = query.replace(/\^EQ$/, '');
+  if (!q) return [];
+
+  // Split on ^OR and ^ while keeping the separators
+  var clauses: { prefix: string; raw: string }[] = [];
+  var parts = q.split(/(\^OR|\^NQ|\^)/);
+  var currentPrefix = '';
+
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i];
+    if (part === '^' || part === '^OR' || part === '^NQ') {
+      currentPrefix = part;
+    } else if (part.length > 0) {
+      clauses.push({ prefix: currentPrefix, raw: part });
+      currentPrefix = '';
+    }
+  }
+
+  // Operators sorted by length descending to match longest first
+  var operators = [
+    'VALCHANGES', 'CHANGESFROM', 'CHANGESTO',
+    'ISNOTEMPTY', 'ISEMPTY', 'EMPTYSTRING', 'ANYTHING',
+    'NOT LIKE', 'NOT IN', 'NSAMEAS',
+    'STARTSWITH', 'ENDSWITH', 'BETWEEN', 'INSTANCEOF',
+    'DYNAMIC', 'SAMEAS',
+    'LIKE', 'IN',
+    '!=', '>=', '<=', '>', '<', '='
+  ];
+
+  var result: { prefix: string; field: string; operator: string; value: string }[] = [];
+  for (var j = 0; j < clauses.length; j++) {
+    var clause = clauses[j];
+    var raw = clause.raw;
+    var matched = false;
+
+    for (var k = 0; k < operators.length; k++) {
+      var op = operators[k];
+      var opIdx = raw.indexOf(op);
+      if (opIdx > 0) {
+        result.push({
+          prefix: clause.prefix,
+          field: raw.substring(0, opIdx),
+          operator: op,
+          value: raw.substring(opIdx + op.length)
+        });
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      // Unrecognized format — keep as-is
+      result.push({ prefix: clause.prefix, field: raw, operator: '', value: '' });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Transform an encoded query condition value to use data pill references.
+ * Replaces field names with {{dataPillBase.fieldName}} syntax.
+ *
+ * Example: "category=inquiry" → "{{Created or Updated_1.current.category}}=inquiry"
+ */
+function transformConditionToDataPills(conditionValue: string, dataPillBase: string): string {
+  if (!conditionValue || !dataPillBase) return conditionValue;
+
+  var clauses = parseEncodedQuery(conditionValue);
+  if (clauses.length === 0) return conditionValue;
+
+  var result = '';
+  for (var i = 0; i < clauses.length; i++) {
+    var clause = clauses[i];
+    result += clause.prefix;
+    result += '{{' + dataPillBase + '.' + clause.field + '}}';
+    result += clause.operator;
+    result += clause.value;
+  }
+
+  return result;
+}
+
+/**
+ * Build labelCache entries for data pills used in flow logic conditions.
+ * Each unique data pill reference needs a labelCache entry so the Flow Designer UI
+ * can display the data pill label correctly.
+ *
+ * The entry format matches the captured UI mutation format.
+ */
+function buildConditionLabelCache(
+  conditionValue: string,
+  dataPillBase: string,
+  triggerName: string,
+  table: string,
+  tableLabel: string,
+  logicUiId: string
+): any[] {
+  if (!conditionValue || !dataPillBase) return [];
+
+  var clauses = parseEncodedQuery(conditionValue);
+  if (clauses.length === 0) return [];
+
+  // Build a label cache entry for each unique field-level data pill
+  var seen: Record<string, boolean> = {};
+  var entries: any[] = [];
+
+  // Also register the record-level data pill (the base: TriggerName_1.current)
+  // This is needed for the condition builder to understand the context
+  if (!seen[dataPillBase]) {
+    seen[dataPillBase] = true;
+    entries.push({
+      name: dataPillBase,
+      label: 'Trigger - Record ' + triggerName + '\u27a1' + tableLabel + ' Record',
+      reference: table,
+      reference_display: tableLabel,
+      type: 'reference',
+      base_type: 'reference',
+      attributes: '',
+      usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }],
+      choices: {}
+    });
+  }
+
+  for (var i = 0; i < clauses.length; i++) {
+    var field = clauses[i].field;
+    if (!field) continue;
+    var pillName = dataPillBase + '.' + field;
+    if (seen[pillName]) continue;
+    seen[pillName] = true;
+
+    // Capitalize field name for label
+    var fieldLabel = field.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); });
+
+    entries.push({
+      name: pillName,
+      label: 'Trigger - Record ' + triggerName + '\u27a1' + tableLabel + ' Record\u27a1' + fieldLabel,
+      reference: '',
+      reference_display: '',
+      type: 'string',
+      base_type: 'string',
+      attributes: '',
+      usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }],
+      choices: {}
+    });
+  }
+
+  return entries;
+}
+
+// ── DATA PILL SUPPORT FOR RECORD ACTIONS (Update/Create Record) ──────
+
+/** Shorthands that users can pass for `record` to mean "the trigger's current record". */
+const RECORD_PILL_SHORTHANDS = ['current', 'trigger.current', 'trigger_record', 'trigger record'];
+
+/**
+ * Post-process action inputs for record-modifying actions (Update Record, Create Record).
+ *
+ * These actions have 3 key inputs:
+ * - `record`: reference to the record → needs data pill format {{TriggerName_1.current}}
+ * - `table_name`: target table → needs displayValue (e.g. "Incident")
+ * - `values`: packed field=value pairs → e.g. "priority=2^state=3"
+ *
+ * User-provided field-value pairs that don't match defined action parameters are
+ * automatically packed into the `values` string.
+ *
+ * Returns the transformed inputs and labelCache entries.
+ */
+async function transformActionInputsForRecordAction(
+  client: any,
+  flowId: string,
+  actionInputs: any[],
+  resolvedInputs: Record<string, string>,
+  actionParams: any[],
+  uuid: string
+): Promise<{ inputs: any[]; labelCacheEntries: any[]; steps: any }> {
+  var steps: any = {};
+
+  // Detect if this is a record action: must have both `record` and `table_name` parameters
+  var definedParamNames = actionParams.map(function (p: any) { return str(p.element); });
+  var hasRecord = definedParamNames.includes('record');
+  var hasTableName = definedParamNames.includes('table_name');
+  var hasValues = definedParamNames.includes('values');
+
+  if (!hasRecord || !hasTableName) {
+    steps.record_action = false;
+    return { inputs: actionInputs, labelCacheEntries: [], steps };
+  }
+  steps.record_action = true;
+
+  // Get trigger info for data pill construction
+  var triggerInfo = await getFlowTriggerInfo(client, flowId);
+  steps.trigger_info = {
+    dataPillBase: triggerInfo.dataPillBase,
+    triggerName: triggerInfo.triggerName,
+    table: triggerInfo.table,
+    tableLabel: triggerInfo.tableLabel,
+    error: triggerInfo.error
+  };
+
+  var dataPillBase = triggerInfo.dataPillBase; // e.g. "Created or Updated_1.current"
+  var labelCacheEntries: any[] = [];
+  var usedInstances: { uiUniqueIdentifier: string; inputName: string }[] = [];
+
+  // ── 1. Transform `record` input to data pill ──────────────────────
+  var recordInput = actionInputs.find(function (inp: any) { return inp.name === 'record'; });
+  if (recordInput && dataPillBase) {
+    var recordVal = recordInput.value?.value || '';
+    var isShorthand = RECORD_PILL_SHORTHANDS.includes(recordVal.toLowerCase());
+    var isAlreadyPill = recordVal.startsWith('{{');
+
+    if (isShorthand || !recordVal) {
+      // Auto-fill with trigger's current record data pill
+      recordInput.value = { schemaless: false, schemalessValue: '', value: '{{' + dataPillBase + '}}' };
+      usedInstances.push({ uiUniqueIdentifier: uuid, inputName: 'record' });
+      steps.record_transform = { original: recordVal, pill: '{{' + dataPillBase + '}}' };
+    } else if (isAlreadyPill) {
+      usedInstances.push({ uiUniqueIdentifier: uuid, inputName: 'record' });
+    }
+  }
+
+  // ── 2. Transform `table_name` input with displayValue ─────────────
+  var tableNameInput = actionInputs.find(function (inp: any) { return inp.name === 'table_name'; });
+  if (tableNameInput) {
+    var tableVal = tableNameInput.value?.value || '';
+    // Also accept `table` as user key (maps to table_name)
+    if (!tableVal && resolvedInputs['table']) {
+      tableVal = resolvedInputs['table'];
+    }
+    // If still empty, use trigger's table
+    if (!tableVal && triggerInfo.table) {
+      tableVal = triggerInfo.table;
+    }
+    if (tableVal) {
+      // Look up display name for the table
+      var tableDisplayName = triggerInfo.tableLabel || '';
+      if (tableVal !== triggerInfo.table || !tableDisplayName) {
+        // Different table than trigger — look up its label
+        try {
+          var tblResp = await client.get('/api/now/table/sys_db_object', {
+            params: { sysparm_query: 'name=' + tableVal, sysparm_fields: 'label', sysparm_display_value: 'true', sysparm_limit: 1 }
+          });
+          tableDisplayName = str(tblResp.data.result?.[0]?.label) || tableVal.charAt(0).toUpperCase() + tableVal.slice(1).replace(/_/g, ' ');
+        } catch (_) {
+          tableDisplayName = tableVal.charAt(0).toUpperCase() + tableVal.slice(1).replace(/_/g, ' ');
+        }
+      }
+      tableNameInput.value = { schemaless: false, schemalessValue: '', value: tableVal };
+      tableNameInput.displayValue = { schemaless: false, schemalessValue: '', value: tableDisplayName };
+      steps.table_name_transform = { value: tableVal, displayValue: tableDisplayName };
+    }
+  }
+
+  // ── 3. Pack non-parameter field values into `values` string ───────
+  // Any user-provided key that is NOT a defined action parameter goes into the values string
+  var valuesInput = actionInputs.find(function (inp: any) { return inp.name === 'values'; });
+  if (valuesInput) {
+    var fieldPairs: string[] = [];
+    var existingValues = valuesInput.value?.value || '';
+
+    // If user already passed a pre-built values string, use it
+    if (existingValues && existingValues.includes('=')) {
+      fieldPairs.push(existingValues);
+    }
+
+    // Find user-provided keys that are not defined action parameters
+    for (var key of Object.keys(resolvedInputs)) {
+      if (definedParamNames.includes(key)) continue;
+      // Also skip table (alias for table_name) and record
+      if (key === 'table' || key === 'record') continue;
+
+      var val = resolvedInputs[key];
+
+      // Check if value should be a data pill reference
+      if (val && dataPillBase) {
+        var valLower = val.toLowerCase();
+        if (RECORD_PILL_SHORTHANDS.includes(valLower)) {
+          // Shorthand → record-level data pill
+          val = '{{' + dataPillBase + '}}';
+          usedInstances.push({ uiUniqueIdentifier: uuid, inputName: key });
+        } else if (valLower.startsWith('trigger.current.') || valLower.startsWith('current.')) {
+          // Field-level data pill: "trigger.current.assigned_to" → {{dataPillBase.assigned_to}}
+          var fieldName = valLower.startsWith('trigger.current.') ? val.substring(16) : val.substring(8);
+          val = '{{' + dataPillBase + '.' + fieldName + '}}';
+          usedInstances.push({ uiUniqueIdentifier: uuid, inputName: key });
+        } else if (val.startsWith('{{')) {
+          // Already a data pill
+          usedInstances.push({ uiUniqueIdentifier: uuid, inputName: key });
+        }
+      }
+
+      fieldPairs.push(key + '=' + val);
+    }
+
+    if (fieldPairs.length > 0) {
+      var packedValues = fieldPairs.join('^');
+      valuesInput.value = { schemaless: false, schemalessValue: '', value: packedValues };
+      steps.values_transform = { packed: packedValues, fieldCount: fieldPairs.length };
+    }
+  }
+
+  // ── 4. Build labelCache entries for data pills ────────────────────
+  if (dataPillBase && usedInstances.length > 0) {
+    var tableRef = triggerInfo.tableRef || triggerInfo.table || '';
+    var tableLabel = triggerInfo.tableLabel || '';
+
+    // Record-level data pill entry
+    labelCacheEntries.push({
+      name: dataPillBase,
+      label: 'Trigger - Record ' + triggerInfo.triggerName + '\u27a1' + tableLabel + ' Record',
+      reference: tableRef,
+      reference_display: tableLabel,
+      type: 'reference',
+      base_type: 'reference',
+      attributes: '',
+      usedInstances: usedInstances,
+      choices: {}
+    });
+
+    steps.label_cache = { count: labelCacheEntries.length, pills: [dataPillBase], usedInstances: usedInstances.length };
+  }
+
+  return { inputs: actionInputs, labelCacheEntries, steps };
+}
+
 // ── FLOW LOGIC (If/Else, For Each, etc.) ─────────────────────────────
 
 async function addFlowLogicViaGraphQL(
@@ -1112,11 +1547,37 @@ async function addFlowLogicViaGraphQL(
   steps.resolved_inputs = inputResult.resolvedInputs;
   steps.input_query_stats = { defParamsFound: inputResult.defParamsCount, inputsBuilt: inputResult.inputs.length, error: inputResult.inputQueryError };
 
+  // ── Data pill transformation for condition inputs ───────────────────
+  // Flow Designer conditions require data pill references ({{TriggerName_1.current.field}})
+  // instead of bare field names. Transform encoded query conditions and build labelCache.
+  const uuid = generateUUID();
+  var labelCacheEntries: any[] = [];
+
+  var conditionInput = inputResult.inputs.find(function (inp: any) { return inp.name === 'condition'; });
+  var rawCondition = conditionInput?.value?.value || '';
+  if (rawCondition && rawCondition !== '^EQ') {
+    var triggerInfo = await getFlowTriggerInfo(client, flowId);
+    steps.trigger_info = { dataPillBase: triggerInfo.dataPillBase, triggerName: triggerInfo.triggerName, table: triggerInfo.table, tableLabel: triggerInfo.tableLabel, error: triggerInfo.error };
+
+    if (triggerInfo.dataPillBase) {
+      // Transform condition value: "category=inquiry" → "{{Created or Updated_1.current.category}}=inquiry"
+      var transformedCondition = transformConditionToDataPills(rawCondition, triggerInfo.dataPillBase);
+      conditionInput.value = { schemaless: false, schemalessValue: '', value: transformedCondition };
+      steps.condition_transform = { original: rawCondition, transformed: transformedCondition };
+
+      // Build labelCache entries for each data pill used in the condition
+      labelCacheEntries = buildConditionLabelCache(
+        rawCondition, triggerInfo.dataPillBase, triggerInfo.triggerName,
+        triggerInfo.tableRef, triggerInfo.tableLabel, uuid
+      );
+      steps.label_cache = { count: labelCacheEntries.length, pills: labelCacheEntries.map(function (e: any) { return e.name; }) };
+    }
+  }
+
   // Calculate insertion order
   const resolvedOrder = await calculateInsertOrder(client, flowId, parentUiId, order);
   steps.insert_order = resolvedOrder;
 
-  const uuid = generateUUID();
   const logicResponseFields = 'flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
@@ -1147,6 +1608,11 @@ async function addFlowLogicViaGraphQL(
     }
   };
 
+  // Add labelCache entries for data pill references in conditions
+  if (labelCacheEntries.length > 0) {
+    flowPatch.labelCache = { insert: labelCacheEntries };
+  }
+
   // Add parent flow logic update signal (tells GraphQL the parent was modified)
   if (parentUiId) {
     flowPatch.flowLogics.update = [{ uiUniqueIdentifier: parentUiId, type: 'flowlogic' }];