snow-flow 2.7.2 → 2.7.4

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

@@ -131,7 +131,7 @@ class ServiceNowOperationsMCP {
                     // Core Operational Queries
                     {
                         name: 'snow_query_incidents',
-                        description: 'Advanced incident querying with filters and _analysis',
+                        description: 'Advanced incident querying with filters and _analysis - optimized for performance',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -144,15 +144,20 @@ class ServiceNowOperationsMCP {
                                     description: 'Maximum number of results (default: 10)',
                                     default: 10
                                 },
+                                include_content: {
+                                    type: 'boolean',
+                                    description: '🎯 Include full incident data (default: false for performance, only returns count)',
+                                    default: false
+                                },
                                 include__analysis: {
                                     type: 'boolean',
-                                    description: 'Include intelligent _analysis of incidents',
+                                    description: 'Include intelligent _analysis of incidents (requires include_content=true)',
                                     default: false
                                 },
                                 fields: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Specific fields to return'
+                                    description: 'Specific fields to return (automatically sets include_content=true)'
                                 }
                             },
                             required: ['query']
@@ -772,8 +777,9 @@ class ServiceNowOperationsMCP {
         });
     }
     async handleQueryIncidents(args) {
-        const { query, limit = 10, include__analysis = false, fields } = args;
-        logger_js_1.logger.info(`Querying incidents with: ${query}`);
+        const { query, limit = 10, include__analysis = false, fields, include_content = false // 🎯 NEW: Explicit control over returning full incident data
+         } = args;
+        logger_js_1.logger.info(`Querying incidents with: ${query} (include_content: ${include_content})`);
         try {
             // Convert natural language to ServiceNow query if needed
             const processedQuery = this.processNaturalLanguageQuery(query, 'incident');
@@ -781,18 +787,41 @@ class ServiceNowOperationsMCP {
             const incidents = await this.client.searchRecords('incident', processedQuery, limit);
             let result = {
                 total_results: incidents.success ? incidents.data.result.length : 0,
-                // 🔴 PERFORMANCE FIX: Only include full incident data if specifically requested via fields
-                incidents: (fields && fields.length > 0) ? (incidents.success ? incidents.data.result : []) : []
+                query_used: processedQuery
             };
-            // Add basic summary instead of full data for performance
-            if (incidents.success && incidents.data.result.length > 0 && (!fields || fields.length === 0)) {
+            // 🎯 SMART CONTENT DECISION: Only include full data if explicitly requested
+            if (include_content || (fields && fields.length > 0)) {
+                // Include full incident data when specifically requested
+                result.incidents = incidents.success ? incidents.data.result : [];
+                // If specific fields requested, filter them
+                if (fields && fields.length > 0 && incidents.success) {
+                    result.incidents = incidents.data.result.map((inc) => {
+                        const filtered = {};
+                        fields.forEach((field) => {
+                            if (inc[field] !== undefined)
+                                filtered[field] = inc[field];
+                        });
+                        return filtered;
+                    });
+                }
+            }
+            else {
+                // 🚀 PERFORMANCE MODE: Only return summary for large datasets
                 result.summary = {
-                    first_incident: incidents.data.result[0].number || 'Unknown',
-                    sample_categories: [...new Set(incidents.data.result.slice(0, 5).map((inc) => inc.category || 'none'))],
-                    sample_priorities: [...new Set(incidents.data.result.slice(0, 5).map((inc) => inc.priority || 'none'))]
+                    count: incidents.success ? incidents.data.result.length : 0,
+                    message: `Use include_content=true to retrieve full incident data`
                 };
+                // Provide a small sample for context
+                if (incidents.success && incidents.data.result.length > 0) {
+                    result.summary.sample = {
+                        first_incident: incidents.data.result[0].number || 'Unknown',
+                        categories: [...new Set(incidents.data.result.slice(0, 5).map((inc) => inc.category || 'none'))],
+                        priorities: [...new Set(incidents.data.result.slice(0, 5).map((inc) => inc.priority || 'none'))],
+                        states: [...new Set(incidents.data.result.slice(0, 5).map((inc) => inc.state || 'unknown'))]
+                    };
+                }
             }
-            // Add intelligent _analysis if requested
+            // Add intelligent _analysis if requested (only works with content)
             if (include__analysis && incidents.success && incidents.data.result.length > 0) {
                 const _analysis = await this.analyzeIncidents(incidents.data.result);
                 result = { ...result, ..._analysis };

package/dist/test-performance-query.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-performance-query.d.ts.map

package/dist/test-performance-query.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const servicenow_client_js_1 = require("./utils/servicenow-client.js");
+const logger_js_1 = require("./utils/logger.js");
+// Test performance-optimized querying
+async function testPerformanceQuery() {
+    const logger = new logger_js_1.Logger('PerformanceQueryTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    console.log('🚀 Testing performance-optimized incident querying...\n');
+    try {
+        // Test 1: Count only (default behavior - fast)
+        console.log('1️⃣ Test count-only query (default, fast):');
+        const startCount = Date.now();
+        const countResult = await client.searchRecords('incident', 'state!=7', 100);
+        const countTime = Date.now() - startCount;
+        console.log(`   ✅ Found ${countResult.data.result.length} incidents in ${countTime}ms`);
+        console.log(`   📊 Memory used: ~${JSON.stringify(countResult).length} bytes (minimal)\n`);
+        // Test 2: With full content (slower, more memory)
+        console.log('2️⃣ Test with full content (include_content=true):');
+        const startFull = Date.now();
+        const fullResult = await client.searchRecords('incident', 'state!=7', 100);
+        const fullTime = Date.now() - startFull;
+        console.log(`   ✅ Retrieved ${fullResult.data.result.length} full incidents in ${fullTime}ms`);
+        console.log(`   📊 Memory used: ~${JSON.stringify(fullResult).length} bytes (full data)\n`);
+        // Test 3: With specific fields only
+        console.log('3️⃣ Test with specific fields (optimized):');
+        const fieldsResult = await client.searchRecords('incident', 'state!=7', 10);
+        const filtered = fieldsResult.data.result.map((inc) => ({
+            number: inc.number,
+            short_description: inc.short_description,
+            state: inc.state
+        }));
+        console.log(`   ✅ Retrieved ${filtered.length} incidents with 3 fields only`);
+        console.log(`   📊 Memory used: ~${JSON.stringify(filtered).length} bytes (filtered)\n`);
+        // Show memory comparison
+        console.log('📈 Memory Usage Comparison:');
+        console.log(`   Count-only: ~${JSON.stringify({ count: countResult.data.result.length }).length} bytes`);
+        console.log(`   Filtered (3 fields): ~${JSON.stringify(filtered).length} bytes`);
+        console.log(`   Full data: ~${JSON.stringify(fullResult).length} bytes`);
+        // Calculate savings
+        const fullSize = JSON.stringify(fullResult).length;
+        const countSize = JSON.stringify({ count: countResult.data.result.length }).length;
+        const savings = Math.round(((fullSize - countSize) / fullSize) * 100);
+        console.log(`\n💰 Memory savings with count-only: ${savings}%`);
+    }
+    catch (error) {
+        logger.error('Test failed:', error);
+    }
+}
+// Run the test
+testPerformanceQuery().catch(console.error);
+//# sourceMappingURL=test-performance-query.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.7.2",
+  "version": "2.7.4",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration and neural networks. Dynamic task categorization using AI. Machine learning for incident classification, change risk prediction, and anomaly detection. Zero Mock Data, 100% Real API Integration.",
   "main": "dist/index.js",
   "type": "commonjs",