snow-flow 3.0.26 → 3.1.0

package/dist/mcp/servicenow-operations-mcp.js

@@ -132,7 +132,7 @@ class ServiceNowOperationsMCP {
                     // 🎯 UNIVERSAL TABLE QUERY - Works for ANY ServiceNow table!
                     {
                         name: 'snow_query_table',
-                        description: 'Universal query tool for any ServiceNow table. Optimized for performance with smart defaults: 1000 records normally, 5000 for ML training contexts. Supports count-only mode for memory efficiency.',
+                        description: 'Universal query tool for any ServiceNow table. SMART ANALYTICS: OMIT limit for ALL records with minimal fields. For display use limit:50. For counting use include_content:false. See CLAUDE.md for optimal query patterns.',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -147,8 +147,8 @@ class ServiceNowOperationsMCP {
                                 },
                                 limit: {
                                     type: 'number',
-                                    description: 'Maximum number of results. Smart defaults: 1000 (normal queries), 5000 (ML training). Can be set higher for large datasets.',
-                                    default: 1000
+                                    description: 'Maximum records to return. OMIT for analytics (gets ALL records). Use 10-50 for display, 5000+ for ML training. No default - system auto-detects best approach.',
+                                    examples: [50, 1000, 5000]
                                 },
                                 include_content: {
                                     type: 'boolean',
@@ -829,29 +829,50 @@ class ServiceNowOperationsMCP {
         });
     }
     async handleUniversalQuery(args) {
-        // 🎯 SMART DEFAULT LIMITS - Context-aware for ML training
-        const determineSmartLimit = (providedLimit, table, query, includeContent) => {
+        // 🧠 INTELLIGENT LIMIT STRATEGY - Think about the use case!
+        const determineSmartLimit = (providedLimit, table, query, includeContent, fields) => {
+            // User explicitly set limit - respect it
             if (providedLimit !== undefined)
-                return providedLimit; // User explicitly set limit
-            // ML Training context detection
+                return providedLimit;
+            // 📊 ANALYTICS DETECTION - Need ALL data
+            const isAnalyticsContext = query?.toLowerCase().includes('analyz') ||
+                query?.toLowerCase().includes('trend') ||
+                query?.toLowerCase().includes('when') ||
+                query?.toLowerCase().includes('pattern') ||
+                query?.toLowerCase().includes('all') ||
+                query?.toLowerCase().includes('onboard') ||
+                (fields && fields.length <= 2); // Minimal fields = analytics
+            if (isAnalyticsContext) {
+                logger_js_1.logger.info(`📊 Analytics context detected - NO LIMIT applied for complete analysis`);
+                return undefined; // No limit - get ALL records
+            }
+            // 🤖 ML Training context
             const isMLContext = query?.toLowerCase().includes('train') ||
                 query?.toLowerCase().includes('ml') ||
-                table?.toLowerCase().includes('train') ||
-                (includeContent && table === 'incident'); // ML often needs incident content
+                table?.toLowerCase().includes('train');
             if (isMLContext) {
                 logger_js_1.logger.info(`🧠 ML context detected - using ML-optimized limit: 5000`);
-                return 5000; // ML training needs more data
+                return 5000; // ML training needs substantial data
             }
-            // Count-only queries can handle more records efficiently  
+            // 📈 Count-only queries - efficient
             if (!includeContent) {
-                return 2000; // Count queries are memory-efficient
+                logger_js_1.logger.info(`📈 Count-only query - can handle large datasets efficiently`);
+                return 10000; // Count queries are very memory-efficient
             }
-            // Normal content queries
-            return 1000; // Balanced default for content queries
+            // 🖥️ Display context - limited data needed
+            if (includeContent && fields && fields.length > 5) {
+                logger_js_1.logger.info(`🖥️ Display context detected - limiting to viewable records`);
+                return 100; // Display queries need less data
+            }
+            // Default: moderate limit
+            logger_js_1.logger.info(`⚠️ No specific context detected - using conservative limit. Consider specifying limit for your use case!`);
+            return 500; // Conservative default
         };
         const { table, query, include_content = false, fields, include_display_values = false, group_by, order_by } = args;
-        // Apply smart limit logic
-        const limit = determineSmartLimit(args.limit, table, query, include_content || !!fields);
+        // Apply intelligent limit strategy
+        const limit = determineSmartLimit(args.limit, table, query, include_content || !!fields, fields);
+        // For analytics, we want NO limit at all
+        const effectiveLimit = limit === undefined ? 999999 : limit; // ServiceNow max is usually 10000 per call
         // 🚨 ML Training Warning for low limits
         const isMLTrainingContext = query?.toLowerCase().includes('train') ||
             query?.toLowerCase().includes('ml') ||
@@ -859,7 +880,7 @@ class ServiceNowOperationsMCP {
         if (isMLTrainingContext && limit < 1000) {
             logger_js_1.logger.warn(`⚠️  ML Training detected with low limit (${limit}). Consider setting limit=5000+ for better training data!`);
         }
-        logger_js_1.logger.info(`Universal query on table '${table}' with: ${query} (limit: ${limit}, include_content: ${include_content})`);
+        logger_js_1.logger.info(`Universal query on table '${table}' with: ${query} (limit: ${limit === undefined ? 'UNLIMITED' : limit}, include_content: ${include_content})`);
         try {
             // Convert natural language to ServiceNow query if needed
             const processedQuery = this.processNaturalLanguageQuery(query, table);
@@ -871,7 +892,7 @@ class ServiceNowOperationsMCP {
                 finalQuery += `^ORDERBY${orderDirection}${orderField}`;
             }
             // Query the table
-            const records = await this.client.searchRecords(table, finalQuery, limit);
+            const records = await this.client.searchRecords(table, finalQuery, effectiveLimit);
             let result = {
                 table: table,
                 total_results: records.success ? records.data.result.length : 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "3.0.26",
+  "version": "3.1.0",
   "description": "Snow-Flow v3.0.18: DIRECT API VERIFICATION! 🚀 Replaced unreliable searchRecords with direct API calls (snow_query_table style) for widget verification. All null/403 error recovery now uses GET /api/now/table/sp_widget with precise queries. NO MORE FALSE NEGATIVES - verification works consistently every time!",
   "main": "dist/index.js",
   "type": "commonjs",