snow-flow 3.6.14 → 3.6.16

package/dist/mcp/servicenow-knowledge-catalog-mcp.js

@@ -720,7 +720,7 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
     }
     /**
      * Create Catalog Variable
-     * Uses item_option_new table
+     * Uses sc_cat_item_option table (CORRECTED TABLE NAME)
      */
     async createCatalogVariable(args) {
         try {
@@ -752,7 +752,8 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
                 tooltip: args.tooltip || ''
             };
             this.logger.info('🎯 Creating variable with payload:', variableData);
-            const response = await this.client.createRecord('item_option_new', variableData);
+            // ✅ CORRECT TABLE NAME: Use sc_cat_item_option instead of item_option_new
+            const response = await this.client.createRecord('sc_cat_item_option', variableData);
             if (!response.success) {
                 this.logger.error('❌ Variable creation failed:', {
                     error: response.error,
@@ -765,7 +766,7 @@ ${args.recurring_price && args.recurring_price !== '0' ? `🔄 Recurring: $${arg
             this.logger.info(`✅ Variable created with sys_id: ${createdSysId}`);
             // 🔍 VERIFICATION: Check if variable was actually created
             this.logger.info('🔍 Verifying variable creation...');
-            const verification = await this.client.searchRecords('item_option_new', `sys_id=${createdSysId}`, 1);
+            const verification = await this.client.searchRecords('sc_cat_item_option', `sys_id=${createdSysId}`, 1);
             if (!verification.success || verification.data.result.length === 0) {
                 this.logger.error('❌ VERIFICATION FAILED: Variable not found after creation!');
                 throw new Error(`Variable creation verification failed - not found in database`);
@@ -806,19 +807,127 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
     async createCatalogUIPolicy(args) {
         try {
             this.logger.info('Creating comprehensive catalog UI policy...');
-            // Helper function to resolve variable names to sys_ids
+            // First, let's fetch ALL variables for this catalog item for debugging
+            this.logger.info(`📋 Fetching all variables for catalog item ${args.cat_item} for debugging...`);
+            try {
+                const allVarsResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${args.cat_item}`, 100);
+                if (allVarsResponse.success && allVarsResponse.data.result.length > 0) {
+                    this.logger.info(`📊 Found ${allVarsResponse.data.result.length} variables for this catalog item:`);
+                    allVarsResponse.data.result.forEach((v) => {
+                        this.logger.info(`  - Variable: name='${v.name}', sys_id='${v.sys_id}', question='${v.question_text}'`);
+                    });
+                }
+                else {
+                    this.logger.warn(`⚠️ No variables found for catalog item ${args.cat_item} - this might be a problem!`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`❌ Failed to fetch variables for debugging:`, error);
+            }
+            // Helper function to resolve variable names to sys_ids with MULTIPLE FALLBACKS
             const resolveVariableId = async (variableName, catalogItem) => {
                 // If already a sys_id, return as-is
                 if (variableName && variableName.match(/^[a-f0-9]{32}$/)) {
+                    this.logger.info(`✅ Using sys_id directly: ${variableName}`);
                     return variableName;
                 }
-                // Search for variable by name in this catalog item
-                const varResponse = await this.client.searchRecords('item_option_new', `cat_item=${catalogItem}^name=${variableName}`, 1);
-                if (varResponse.success && varResponse.data.result.length > 0) {
-                    return varResponse.data.result[0].sys_id;
+                this.logger.info(`🔍 Resolving variable name '${variableName}' to sys_id for catalog item ${catalogItem}...`);
+                // Try multiple search strategies for maximum compatibility
+                const searchStrategies = [
+                    // Strategy 1: Search by name field
+                    {
+                        query: `cat_item=${catalogItem}^name=${variableName}`,
+                        description: 'by name field'
+                    },
+                    // Strategy 2: Search by name with LIKE operator
+                    {
+                        query: `cat_item=${catalogItem}^nameLIKE${variableName}`,
+                        description: 'by name with LIKE'
+                    },
+                    // Strategy 3: Search by question_text
+                    {
+                        query: `cat_item=${catalogItem}^question_text=${variableName}`,
+                        description: 'by question_text field'
+                    },
+                    // Strategy 4: Search all variables for this item and match manually
+                    {
+                        query: `cat_item=${catalogItem}`,
+                        description: 'all variables for manual matching'
+                    }
+                ];
+                for (const strategy of searchStrategies) {
+                    this.logger.info(`🔍 Trying strategy: ${strategy.description}`);
+                    try {
+                        const varResponse = await this.client.searchRecords('sc_cat_item_option', strategy.query, 50 // Get more results for manual matching
+                        );
+                        if (varResponse.success && varResponse.data.result.length > 0) {
+                            // For the "all variables" strategy, try to match manually
+                            if (strategy.description === 'all variables for manual matching') {
+                                const match = varResponse.data.result.find((v) => v.name === variableName ||
+                                    v.question_text === variableName ||
+                                    v.name?.toLowerCase() === variableName.toLowerCase());
+                                if (match) {
+                                    this.logger.info(`✅ Found variable through manual matching: ${match.sys_id}`);
+                                    return match.sys_id;
+                                }
+                            }
+                            else {
+                                // Direct match found
+                                const sysId = varResponse.data.result[0].sys_id;
+                                this.logger.info(`✅ Resolved '${variableName}' to sys_id: ${sysId} (${strategy.description})`);
+                                return sysId;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.logger.warn(`⚠️ Strategy failed: ${strategy.description}`, error);
+                    }
+                }
+                // If all strategies fail, try alternate table names (just in case)
+                const alternateTables = ['item_option_new', 'io_set_item_option'];
+                for (const table of alternateTables) {
+                    this.logger.info(`🔍 Trying alternate table: ${table}`);
+                    try {
+                        const varResponse = await this.client.searchRecords(table, `cat_item=${catalogItem}^name=${variableName}`, 1);
+                        if (varResponse.success && varResponse.data.result.length > 0) {
+                            const sysId = varResponse.data.result[0].sys_id;
+                            this.logger.info(`✅ Found in alternate table ${table}: ${sysId}`);
+                            return sysId;
+                        }
+                    }
+                    catch (error) {
+                        this.logger.warn(`⚠️ Alternate table ${table} failed:`, error);
+                    }
                 }
-                this.logger.warn(`Variable '${variableName}' not found for catalog item ${catalogItem}`);
-                return variableName; // Return original if not found
+                this.logger.error(`❌ CRITICAL: Variable '${variableName}' not found in any table for catalog item ${catalogItem}`);
+                this.logger.error(`❌ This will cause the action to fail! Please use the sys_id directly instead of the name.`);
+                // Return the name but log a warning that this will fail
+                return variableName;
+            };
+            // Helper function to map operations to correct ServiceNow format
+            const mapOperatorToServiceNow = (operator) => {
+                const opMap = {
+                    'is': '=',
+                    'equals': '=',
+                    'is_not': '!=',
+                    'is not': '!=',
+                    'not equals': '!=',
+                    'contains': 'LIKE',
+                    'does_not_contain': 'NOT LIKE',
+                    'does not contain': 'NOT LIKE',
+                    'greater_than': '>',
+                    'greater than': '>',
+                    'less_than': '<',
+                    'less than': '<',
+                    'is_empty': 'ISEMPTY',
+                    'is empty': 'ISEMPTY',
+                    'is_not_empty': 'ISNOTEMPTY', // ✅ CRITICAL FIX: was missing!
+                    'is not empty': 'ISNOTEMPTY'
+                };
+                const normalizedOp = operator.toLowerCase().trim();
+                const mapped = opMap[normalizedOp] || operator;
+                this.logger.info(`🎯 Mapped operator '${operator}' -> '${mapped}'`);
+                return mapped;
             };
             // Build condition string from conditions array
             let conditionString = '';
@@ -834,47 +943,26 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                 for (const condition of args.conditions) {
                     // Resolve variable name to sys_id
                     const variableId = await resolveVariableId(condition.catalog_variable, args.cat_item);
-                    // Build condition string in ServiceNow format
-                    // Format: variable_name=value^ORvariable_name2=value2
-                    const operator = condition.operation || '=';
-                    const connector = condition.and_or === 'OR' ? '^OR' : '^';
-                    // Map common operations to ServiceNow syntax
-                    let operatorSymbol = '=';
-                    switch (operator.toLowerCase()) {
-                        case 'is':
-                        case 'equals':
-                            operatorSymbol = '=';
-                            break;
-                        case 'is not':
-                        case 'not equals':
-                            operatorSymbol = '!=';
-                            break;
-                        case 'contains':
-                            operatorSymbol = 'CONTAINS';
-                            break;
-                        case 'greater than':
-                            operatorSymbol = '>';
-                            break;
-                        case 'less than':
-                            operatorSymbol = '<';
-                            break;
-                        case 'is empty':
-                            operatorSymbol = 'ISEMPTY';
-                            break;
-                        default:
-                            operatorSymbol = operator;
-                    }
-                    // Build the condition part
+                    // Get the correct ServiceNow operator
+                    const originalOperator = condition.operation || 'is';
+                    const serviceNowOperator = mapOperatorToServiceNow(originalOperator);
+                    // Safely get condition value (avoid undefined concatenation)
+                    const conditionValue = condition.value || '';
+                    // Build the condition part based on operator type
                     let conditionPart = '';
-                    if (operatorSymbol === 'ISEMPTY') {
-                        conditionPart = `${variableId}ISEMPTY`;
+                    if (serviceNowOperator === 'ISEMPTY' || serviceNowOperator === 'ISNOTEMPTY') {
+                        // For empty/not empty checks, no value needed
+                        conditionPart = `${variableId}${serviceNowOperator}`;
                     }
-                    else if (operatorSymbol === 'CONTAINS') {
-                        conditionPart = `${variableId}LIKE${condition.value}`;
+                    else if (serviceNowOperator === 'LIKE' || serviceNowOperator === 'NOT LIKE') {
+                        // For LIKE operations, ensure value is wrapped properly
+                        conditionPart = `${variableId}${serviceNowOperator}${conditionValue}`;
                     }
                     else {
-                        conditionPart = `${variableId}${operatorSymbol}${condition.value}`;
+                        // Standard operations (=, !=, >, <, etc.)
+                        conditionPart = `${variableId}${serviceNowOperator}${conditionValue}`;
                     }
+                    this.logger.info(`🏗️ Built condition part: ${conditionPart} (from ${originalOperator}: '${conditionValue}')`);
                     conditionParts.push(conditionPart);
                 }
                 // Join all conditions with ^ separator (ServiceNow query format)
@@ -917,16 +1005,26 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     // Resolve variable name to sys_id
                     this.logger.info(`🔍 Resolving variable: ${action.catalog_variable} for catalog item: ${args.cat_item}`);
                     const variableId = await resolveVariableId(action.catalog_variable, args.cat_item);
-                    this.logger.info(`✅ Resolved to variable ID: ${variableId}`);
-                    // Actions structuur in ServiceNow:
-                    // - catalog_ui_policy_action.catalog_variable -> item_option_new (variable)
-                    // - item_option_new.cat_item -> sc_cat_item (catalog item)
-                    // - catalog_ui_policy.catalog_item -> sc_cat_item (catalog item)
-                    // Mogelijk is er toch een ui_policy veld, maar het lijkt niet verplicht
-                    // MINIMAAL: Probeer eerst alleen de essentiële velden
+                    // Check if resolution actually worked (should be a sys_id now)
+                    const isValidSysId = variableId && variableId.match(/^[a-f0-9]{32}$/);
+                    if (!isValidSysId) {
+                        this.logger.error(`❌ CRITICAL: Failed to resolve variable '${action.catalog_variable}' to sys_id!`);
+                        this.logger.error(`❌ Got: ${variableId} (this is not a valid sys_id)`);
+                        // Continue anyway but it will likely fail
+                    }
+                    else {
+                        this.logger.info(`✅ Resolved to variable sys_id: ${variableId}`);
+                    }
+                    // ✅ CRITICAL FIX: Add "IO:" prefix as required by ServiceNow
+                    // BUT ONLY if we have a valid sys_id!
+                    const catalogVariableWithPrefix = isValidSysId ? `IO:${variableId}` : variableId;
+                    this.logger.info(`🎯 Using catalog_variable value: ${catalogVariableWithPrefix}`);
+                    // Actions structure in ServiceNow:
+                    // - catalog_ui_policy_action.catalog_variable -> "IO:" + variable_sys_id (required format)
+                    // - catalog_ui_policy_action.ui_policy -> catalog_ui_policy.sys_id
                     const actionData = {
-                        // Hoofdkoppeling: naar de variable (dit MOET kloppen)
-                        catalog_variable: variableId
+                        // ✅ Main connection: to the variable with required IO: prefix (if valid sys_id)
+                        catalog_variable: catalogVariableWithPrefix
                     };
                     // NIET: catalog_ui_policy - deze veld bestaat NIET (volgens error log)
                     // Probeer alleen ui_policy en policy als alternatief
@@ -1255,7 +1353,7 @@ ${item.recurring_price && item.recurring_price !== '0' ? `🔄 Recurring: $${ite
 🔄 Active: ${item.active ? 'Yes' : 'No'}`;
             // Get variables if requested
             if (args.include_variables) {
-                const varResponse = await this.client.searchRecords('item_option_new', `cat_item=${args.sys_id}`, 50);
+                const varResponse = await this.client.searchRecords('sc_cat_item_option', `cat_item=${args.sys_id}`, 50);
                 if (varResponse.success && varResponse.data.result.length) {
                     const variables = varResponse.data.result.map((v) => `  - ${v.question_text} (${v.type})${v.mandatory ? ' *Required' : ''}`).join('\n');
                     details += `\n\n📋 **Variables:**\n${variables}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.14",
-  "description": "COMPREHENSIVE CATALOG FIXES - v3.6.14 fixes ALL catalog tools based on user feedback. snow_create_catalog_variable: added missing essential fields (active, display_type, security). snow_get_catalog_item_details: 3-method fallback system. snow_create_catalog_ui_policy: verification after creation. All tools now have extensive debugging and verification.",
+  "version": "3.6.16",
+  "description": "ENHANCED VARIABLE RESOLUTION - v3.6.16 adds comprehensive multi-strategy variable resolution with 4 different search methods, automatic debugging that shows all available variables, better error handling when resolution fails, and support for alternate table names. Now properly handles cases where variable names can't be resolved to sys_ids and provides clear warnings.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {