snow-flow 3.5.7 → 3.5.8

package/dist/utils/servicenow-client-with-tracking.d.ts

@@ -10,6 +10,10 @@ export declare class ServiceNowClientWithTracking extends ServiceNowClient {
      * Override makeRequest to add tracking
      */
     makeRequest(config: any): Promise<any>;
+    /**
+     * Override searchRecordsWithFields to add tracking
+     */
+    searchRecordsWithFields(table: string, query: string, fields: string[], limit?: number): Promise<any>;
     /**
      * Override searchRecords to add tracking
      */

package/dist/utils/servicenow-client-with-tracking.js

@@ -36,6 +36,27 @@ class ServiceNowClientWithTracking extends servicenow_client_js_1.ServiceNowClie
             throw error;
         }
     }
+    /**
+     * Override searchRecordsWithFields to add tracking
+     */
+    async searchRecordsWithFields(table, query, fields, limit = 10) {
+        this.mcpLogger.progress(`Searching ${table} with specific fields: ${fields.join(', ')}`);
+        try {
+            const result = await super.searchRecordsWithFields(table, query, fields, limit);
+            // Estimate tokens based on fields requested
+            const fieldCount = fields.length;
+            const estimatedTokens = Math.min(fieldCount * 100, 1000); // Rough estimate
+            this.mcpLogger.trackTokens(estimatedTokens, 0);
+            if (result?.data?.result?.length > 0) {
+                this.mcpLogger.info(`Found ${result.data.result.length} records with ${fieldCount} fields`);
+            }
+            return result;
+        }
+        catch (error) {
+            this.mcpLogger.error('Search with fields failed', error);
+            throw error;
+        }
+    }
     /**
      * Override searchRecords to add tracking
      */

package/dist/utils/servicenow-client.d.ts

@@ -156,6 +156,10 @@ export declare class ServiceNowClient {
      * Get multiple records from a table
      */
     getRecords(table: string, params?: any): Promise<ServiceNowAPIResponse<any[]>>;
+    /**
+     * Search records with specific fields
+     */
+    searchRecordsWithFields(table: string, query: string, fields: string[], limit?: number): Promise<ServiceNowAPIResponse<any>>;
     /**
      * Search records in a table using encoded query
      */

package/dist/utils/servicenow-client.js

@@ -1039,6 +1039,33 @@ class ServiceNowClient {
             };
         }
     }
+    /**
+     * Search records with specific fields
+     */
+    async searchRecordsWithFields(table, query, fields, limit = 10) {
+        try {
+            await this.ensureAuthenticated();
+            const url = `/api/now/table/${table}`;
+            const params = {
+                sysparm_query: query,
+                sysparm_limit: limit.toString(),
+                sysparm_fields: fields.join(',')
+            };
+            const response = await this.client.get(url, { params });
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        catch (error) {
+            console.error('API Error:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                data: null
+            };
+        }
+    }
     /**
      * Search records in a table using encoded query
      */

package/dist/utils/smart-field-fetcher.js

@@ -152,34 +152,103 @@ class SmartFieldFetcher {
      * (Wrapper for backward compatibility)
      */
     async fetchWidget(sys_id) {
-        return this.fetchArtifact('sp_widget', sys_id);
         console.log(`\n🔍 Smart fetching widget: ${sys_id}`);
         const results = {
             _fetch_strategy: 'smart_chunked',
             _context_hint: 'Widget fields fetched separately but are interconnected: template references {{data.x}} from server script, calls methods from client script, and uses CSS classes',
             _field_groups: {}
         };
-        // Fetch each field group
-        for (const group of WIDGET_FIELD_GROUPS) {
-            console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
-            try {
-                const response = await this.client.getRecord('sp_widget', sys_id);
-                if (response) {
+        // Try to fetch all fields first, then fall back to individual fields if too large
+        console.log(`📦 Attempting to fetch complete widget data...`);
+        try {
+            // Try to get all fields at once
+            const response = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
+            if (response && response.result && response.result.length > 0) {
+                const widgetData = response.result[0];
+                console.log(`✅ Successfully fetched complete widget`);
+                // Organize into field groups for better context
+                for (const group of WIDGET_FIELD_GROUPS) {
+                    const groupData = {};
+                    for (const fieldName of group.fields) {
+                        if (widgetData[fieldName] !== undefined) {
+                            groupData[fieldName] = widgetData[fieldName];
+                        }
+                    }
                     results._field_groups[group.groupName] = {
-                        data: response,
+                        data: groupData,
                         description: group.description,
                         fields: group.fields
                     };
-                    // Add to flat structure for easy access
-                    Object.assign(results, response.result[0]);
                 }
+                // Add complete widget data to flat structure
+                Object.assign(results, widgetData);
             }
-            catch (error) {
-                console.log(`⚠️ Failed to fetch ${group.groupName}: ${error.message}`);
-                // If group fails due to size, fetch fields individually
-                if (error.message?.includes('exceeds maximum allowed tokens')) {
-                    results._field_groups[group.groupName] = await this.fetchFieldsIndividually('sp_widget', sys_id, group.fields, group.description);
+            else {
+                throw new Error('Widget not found');
+            }
+        }
+        catch (error) {
+            console.log(`⚠️ Complete fetch failed: ${error.message}`);
+            console.log(`🔄 Switching to field-by-field fetching...`);
+            // Fall back to fetching fields per group or individually
+            for (const group of WIDGET_FIELD_GROUPS) {
+                console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
+                try {
+                    // Try to fetch all fields in this group at once
+                    const groupResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, group.fields, 1);
+                    if (groupResponse && groupResponse.success && groupResponse.data && groupResponse.data.result && groupResponse.data.result.length > 0) {
+                        const groupData = groupResponse.data.result[0];
+                        console.log(`  ✅ Successfully fetched ${group.groupName}`);
+                        results._field_groups[group.groupName] = {
+                            data: groupData,
+                            description: group.description,
+                            fields: group.fields
+                        };
+                        // Add to flat structure
+                        Object.assign(results, groupData);
+                    }
+                    else {
+                        throw new Error('No data returned for group');
+                    }
                 }
+                catch (groupError) {
+                    console.log(`  ⚠️ Group ${group.groupName} failed, fetching fields individually...`);
+                    // If group fails, fetch fields one by one
+                    const groupData = {};
+                    for (const fieldName of group.fields) {
+                        console.log(`    📄 Fetching field: ${fieldName}`);
+                        try {
+                            // Fetch just this single field
+                            const fieldResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, [fieldName], 1);
+                            if (fieldResponse && fieldResponse.success && fieldResponse.data && fieldResponse.data.result && fieldResponse.data.result.length > 0) {
+                                const fieldValue = fieldResponse.data.result[0][fieldName];
+                                if (fieldValue !== undefined && fieldValue !== null) {
+                                    groupData[fieldName] = fieldValue;
+                                    results[fieldName] = fieldValue; // Also add to flat structure
+                                    console.log(`      ✅ Got ${fieldName} (${typeof fieldValue === 'string' ? fieldValue.length : 0} chars)`);
+                                }
+                                else {
+                                    groupData[fieldName] = '';
+                                    console.log(`      ⚠️ ${fieldName} is empty`);
+                                }
+                            }
+                        }
+                        catch (fieldError) {
+                            console.log(`      ❌ Failed to fetch ${fieldName}: ${fieldError.message}`);
+                            groupData[fieldName] = ''; // Empty string for failed fields
+                        }
+                    }
+                    results._field_groups[group.groupName] = {
+                        data: groupData,
+                        description: group.description,
+                        fields: group.fields,
+                        _fetched_individually: true
+                    };
+                }
+            }
+            // Make sure we have at least the sys_id
+            if (!results.sys_id) {
+                results.sys_id = sys_id;
             }
         }
         // Add coherence validation hints

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "3.5.7",
+  "version": "3.5.8",
   "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 18 MCP servers including local development sync for editing ServiceNow artifacts with Claude Code native tools, widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
   "main": "dist/index.js",
   "type": "commonjs",