snow-flow 2.7.1 → 2.7.3

package/dist/mcp/servicenow-machine-learning-mcp.js

@@ -548,7 +548,8 @@ class ServiceNowMachineLearningMCP {
                 return await this.trainWithStreaming(args);
             }
             // For smaller datasets, use the original approach but with optimizations
-            const incidents = await this.fetchIncidentData(Math.min(sample_size, batch_size * 5), {
+            // 🔴 CRITICAL FIX: Use full sample_size, not artificially limited amount
+            const incidents = await this.fetchIncidentData(sample_size, {
                 query,
                 intelligent_selection,
                 focus_categories
@@ -1091,7 +1092,9 @@ class ServiceNowMachineLearningMCP {
             finalQuery = 'ORDERBYDESCsys_created_on';
         }
         // Use searchRecords for proper authentication handling
+        // 🔴 CRITICAL FIX: Use the actual limit parameter, not default of 10
         const response = await this.client.searchRecords('incident', finalQuery, limit);
+        this.logger.info(`Attempting to fetch ${limit} incidents with query: ${finalQuery}`);
         if (!response.success || !response.data?.result) {
             throw new Error('Failed to fetch incident data. Ensure you have read access to the incident table.');
         }
@@ -1450,7 +1453,9 @@ class ServiceNowMachineLearningMCP {
             finalQuery += '^ORDERBYDESCsys_created_on';
         }
         // ServiceNow API supports offset through sysparm_offset
+        // 🔴 CRITICAL FIX: Ensure we're using the right limit for batches
         const response = await this.client.searchRecordsWithOffset('incident', finalQuery, limit, offset);
+        this.logger.info(`Fetching batch: limit=${limit}, offset=${offset}, query=${finalQuery}`);
         if (!response.success || !response.data?.result) {
             return [];
         }

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

@@ -781,8 +781,17 @@ class ServiceNowOperationsMCP {
             const incidents = await this.client.searchRecords('incident', processedQuery, limit);
             let result = {
                 total_results: incidents.success ? incidents.data.result.length : 0,
-                incidents: incidents.success ? incidents.data.result : []
+                // 🔴 PERFORMANCE FIX: Only include full incident data if specifically requested via fields
+                incidents: (fields && fields.length > 0) ? (incidents.success ? incidents.data.result : []) : []
             };
+            // Add basic summary instead of full data for performance
+            if (incidents.success && incidents.data.result.length > 0 && (!fields || fields.length === 0)) {
+                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'))]
+                };
+            }
             // Add intelligent _analysis if requested
             if (include__analysis && incidents.success && incidents.data.result.length > 0) {
                 const _analysis = await this.analyzeIncidents(incidents.data.result);
@@ -1096,6 +1105,11 @@ class ServiceNowOperationsMCP {
     processNaturalLanguageQuery(query, context) {
         // Convert natural language to ServiceNow encoded query
         const lowerQuery = query.toLowerCase();
+        // If already a ServiceNow encoded query, return as-is
+        if (query.includes('=') || query.includes('!=') || query.includes('^') || query.includes('LIKE')) {
+            logger_js_1.logger.info(`Using raw ServiceNow query: ${query}`);
+            return query;
+        }
         // Common ServiceNow query patterns
         if (lowerQuery.includes('high priority')) {
             return 'priority=1';
@@ -1109,6 +1123,9 @@ class ServiceNowOperationsMCP {
         if (lowerQuery.includes('closed') || lowerQuery.includes('resolved')) {
             return 'state=6^ORstate=7';
         }
+        if (lowerQuery.includes('all') || lowerQuery === '') {
+            return ''; // Empty query returns all records
+        }
         if (lowerQuery.includes('today')) {
             return 'sys_created_onONToday@javascript:gs.daysAgoStart(0)@javascript:gs.daysAgoEnd(0)';
         }

package/dist/test-fetch-incidents.d.ts

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

package/dist/test-fetch-incidents.js

@@ -0,0 +1,84 @@
+"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 fetchIncidentData like the ML MCP does
+async function testFetchIncidents() {
+    const logger = new logger_js_1.Logger('FetchIncidentsTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    console.log('🔥 Testing fetchIncidentData with 2000 samples...');
+    // Simulate exactly what the ML MCP fetchIncidentData method does
+    const sample_size = 2000;
+    const intelligent_selection = true;
+    const focus_categories = [];
+    const query = '';
+    let finalQuery = query;
+    // If intelligent selection is enabled and no custom query provided
+    if (intelligent_selection && !query) {
+        // Build an intelligent query that gets a balanced dataset
+        const queries = [];
+        // Get mix of recent and older incidents
+        queries.push('sys_created_onONLast 6 months');
+        // Get mix of priorities
+        queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
+        // Get mix of active and resolved
+        queries.push('(active=true^ORactive=false)');
+        // Focus on specific categories if provided
+        if (focus_categories.length > 0) {
+            const categoryQuery = focus_categories.map(cat => `category=${cat}`).join('^OR');
+            queries.push(`(${categoryQuery})`);
+        }
+        else {
+            // Get diverse categories
+            queries.push('categoryISNOTEMPTY');
+        }
+        // Combine all queries
+        finalQuery = queries.join('^');
+        logger.info(`Using intelligent query selection: ${finalQuery}`);
+    }
+    else if (query) {
+        logger.info(`Using custom query: ${query}`);
+    }
+    // Always order by sys_created_on DESC to get most recent first
+    if (finalQuery && !finalQuery.includes('ORDERBY')) {
+        finalQuery += '^ORDERBYDESCsys_created_on';
+    }
+    else if (!finalQuery) {
+        finalQuery = 'ORDERBYDESCsys_created_on';
+    }
+    logger.info(`Attempting to fetch ${sample_size} incidents with query: ${finalQuery}`);
+    try {
+        // 🔴 CRITICAL: Use the actual sample_size parameter, not default of 10
+        const response = await client.searchRecords('incident', finalQuery, sample_size);
+        if (!response.success || !response.data?.result) {
+            throw new Error('Failed to fetch incident data. Ensure you have read access to the incident table.');
+        }
+        logger.info(`✅ SUCCESS: Fetched ${response.data.result.length} incidents for ML training (requested: ${sample_size})`);
+        // Show data distribution like the ML MCP does
+        if (response.data.result.length > 0) {
+            const categoryDistribution = {};
+            const priorityDistribution = {};
+            response.data.result.forEach((inc) => {
+                const category = inc.category || 'uncategorized';
+                const priority = inc.priority || '3';
+                categoryDistribution[category] = (categoryDistribution[category] || 0) + 1;
+                priorityDistribution[priority] = (priorityDistribution[priority] || 0) + 1;
+            });
+            logger.info('Data distribution:');
+            logger.info(`Categories: ${JSON.stringify(categoryDistribution)}`);
+            logger.info(`Priorities: ${JSON.stringify(priorityDistribution)}`);
+            // Check if we have enough for training
+            if (response.data.result.length >= 100) {
+                logger.info('✅ Sufficient data for ML training (need at least 100 incidents)');
+            }
+            else {
+                logger.warn(`⚠️ Insufficient data for training (need at least 100 incidents, got ${response.data.result.length})`);
+            }
+        }
+    }
+    catch (error) {
+        logger.error('❌ fetchIncidentData failed:', error);
+    }
+}
+testFetchIncidents().catch(console.error);
+//# sourceMappingURL=test-fetch-incidents.js.map

package/dist/test-incident-access.d.ts

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

package/dist/test-incident-access.js

@@ -0,0 +1,72 @@
+"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");
+async function testIncidentAccess() {
+    const logger = new logger_js_1.Logger('IncidentAccessTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    logger.info('Testing incident table access...');
+    // Test 1: Empty query (get all)
+    try {
+        logger.info('Test 1: Fetching ALL incidents with empty query...');
+        const allIncidents = await client.searchRecords('incident', '', 10);
+        logger.info(`Result: ${allIncidents.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${allIncidents.data?.result?.length || 0}`);
+        if (allIncidents.data?.result?.length > 0) {
+            logger.info('Sample incident states:');
+            allIncidents.data.result.slice(0, 5).forEach((inc) => {
+                logger.info(`- ${inc.number}: state=${inc.state}, active=${inc.active}`);
+            });
+        }
+    }
+    catch (error) {
+        logger.error('Test 1 failed:', error);
+    }
+    // Test 2: State not equal to 7
+    try {
+        logger.info('\nTest 2: Fetching incidents where state!=7...');
+        const notClosedIncidents = await client.searchRecords('incident', 'state!=7', 10);
+        logger.info(`Result: ${notClosedIncidents.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${notClosedIncidents.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 2 failed:', error);
+    }
+    // Test 3: Active incidents
+    try {
+        logger.info('\nTest 3: Fetching active incidents...');
+        const activeIncidents = await client.searchRecords('incident', 'active=true', 10);
+        logger.info(`Result: ${activeIncidents.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${activeIncidents.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 3 failed:', error);
+    }
+    // Test 4: All states
+    try {
+        logger.info('\nTest 4: Checking incident states...');
+        const states = ['1', '2', '3', '4', '5', '6', '7', '8'];
+        for (const state of states) {
+            const stateIncidents = await client.searchRecords('incident', `state=${state}`, 1);
+            if (stateIncidents.success && stateIncidents.data?.result?.length > 0) {
+                logger.info(`State ${state}: Found incidents`);
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Test 4 failed:', error);
+    }
+    // Test 5: User permissions
+    try {
+        logger.info('\nTest 5: Testing user permissions...');
+        const userInfo = await client.get('/api/now/table/sys_user/me');
+        logger.info(`Current user: ${userInfo.data?.result?.user_name || 'Unknown'}`);
+        logger.info(`Roles: ${userInfo.data?.result?.roles || 'Unknown'}`);
+    }
+    catch (error) {
+        logger.error('Failed to get user info:', error);
+    }
+}
+// Run the test
+testIncidentAccess().catch(console.error);
+//# sourceMappingURL=test-incident-access.js.map

package/dist/test-limit-problem.d.ts

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

package/dist/test-limit-problem.js

@@ -0,0 +1,60 @@
+"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");
+async function testLimitProblem() {
+    const logger = new logger_js_1.Logger('LimitTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    logger.info('Testing incident limits...');
+    // Test different limits
+    const limits = [10, 50, 100, 500, 1000];
+    for (const limit of limits) {
+        try {
+            logger.info(`\nTesting with limit ${limit}...`);
+            const result = await client.searchRecords('incident', 'state!=7', limit);
+            logger.info(`Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+            logger.info(`Requested: ${limit}, Got: ${result.data?.result?.length || 0}`);
+        }
+        catch (error) {
+            logger.error(`Test with limit ${limit} failed:`, error);
+        }
+    }
+    // Test with empty query (should get all incidents)
+    try {
+        logger.info(`\nTesting all incidents with limit 1000...`);
+        const result = await client.searchRecords('incident', '', 1000);
+        logger.info(`Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Total incidents found: ${result.data?.result?.length || 0}`);
+        if (result.data?.result?.length > 0) {
+            const states = new Map();
+            const priorities = new Map();
+            result.data.result.forEach((inc) => {
+                const state = inc.state || 'unknown';
+                const priority = inc.priority || 'unknown';
+                states.set(state, (states.get(state) || 0) + 1);
+                priorities.set(priority, (priorities.get(priority) || 0) + 1);
+            });
+            logger.info('State distribution:', Object.fromEntries(states));
+            logger.info('Priority distribution:', Object.fromEntries(priorities));
+            // Count active incidents (state != 6 and state != 7)
+            const activeIncidents = result.data.result.filter((inc) => inc.state !== '6' && inc.state !== '7');
+            logger.info(`Active incidents (state not 6 or 7): ${activeIncidents.length}`);
+        }
+    }
+    catch (error) {
+        logger.error('All incidents test failed:', error);
+    }
+    // Test what the ML training was actually requesting
+    try {
+        logger.info(`\nTesting ML training scenario (sample_size 2000)...`);
+        const result = await client.searchRecords('incident', 'state!=7', 2000);
+        logger.info(`ML training result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`ML would get: ${result.data?.result?.length || 0} incidents out of requested 2000`);
+    }
+    catch (error) {
+        logger.error('ML training test failed:', error);
+    }
+}
+// Run the test
+testLimitProblem().catch(console.error);
+//# sourceMappingURL=test-limit-problem.js.map

package/dist/test-ml-batch-fix.d.ts

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

package/dist/test-ml-batch-fix.js

@@ -0,0 +1,104 @@
+"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 of ML training nu correct batch sizes gebruikt
+async function testMLBatchFix() {
+    const logger = new logger_js_1.Logger('MLBatchFixTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    console.log('🔍 Testing ML training batch size fix...');
+    // Simuleer ML fetchIncidentData methode met verschillende batch sizes
+    async function testFetchIncidentData(sample_size, description) {
+        logger.info(`\n--- ${description} ---`);
+        logger.info(`Requesting ${sample_size} incidents`);
+        const intelligent_selection = true;
+        const focus_categories = [];
+        const query = '';
+        let finalQuery = '';
+        if (intelligent_selection && !query) {
+            const queries = [];
+            queries.push('sys_created_onONLast 6 months');
+            queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
+            queries.push('(active=true^ORactive=false)');
+            queries.push('categoryISNOTEMPTY');
+            finalQuery = queries.join('^') + '^ORDERBYDESCsys_created_on';
+        }
+        try {
+            const start = Date.now();
+            // 🔴 KEY TEST: Use the actual sample_size parameter 
+            const response = await client.searchRecords('incident', finalQuery, sample_size);
+            const duration = Date.now() - start;
+            if (response.success) {
+                const actualCount = response.data?.result?.length || 0;
+                logger.info(`✅ SUCCESS: Got ${actualCount}/${sample_size} incidents (${duration}ms)`);
+                if (actualCount === Math.min(sample_size, 1000)) { // ServiceNow might limit to 1000
+                    logger.info(`✅ Correct batch size used`);
+                }
+                else if (actualCount === 10) {
+                    logger.error(`❌ STILL USING DEFAULT LIMIT OF 10!`);
+                }
+                else {
+                    logger.info(`ℹ️ Got ${actualCount} incidents (might be limited by data available)`);
+                }
+                return actualCount;
+            }
+            else {
+                logger.error(`❌ FAILED: Could not fetch incidents`);
+                return 0;
+            }
+        }
+        catch (error) {
+            logger.error(`❌ ERROR:`, error);
+            return 0;
+        }
+    }
+    // Test verschillende batch sizes
+    const testCases = [
+        { size: 50, desc: "Small batch (50)" },
+        { size: 100, desc: "Medium batch (100)" },
+        { size: 200, desc: "Large batch (200)" },
+        { size: 500, desc: "XL batch (500)" }
+    ];
+    console.log(`\n🧪 Testing different batch sizes:`);
+    const results = [];
+    for (const testCase of testCases) {
+        const count = await testFetchIncidentData(testCase.size, testCase.desc);
+        results.push({ requested: testCase.size, actual: count });
+    }
+    console.log(`\n📊 Batch Size Results:`);
+    results.forEach(r => {
+        const success = r.actual > 10 && r.actual >= Math.min(r.requested, 100); // At least more than default 10
+        console.log(`  ${r.requested} requested → ${r.actual} actual ${success ? '✅' : '❌'}`);
+    });
+    // Test streaming batches
+    console.log(`\n🌊 Testing streaming batch functionality:`);
+    const totalSample = 300;
+    const batchSize = 100;
+    const totalBatches = Math.ceil(totalSample / batchSize);
+    let streamingTotal = 0;
+    for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
+        const offset = batchNum * batchSize;
+        const currentBatchSize = Math.min(batchSize, totalSample - offset);
+        logger.info(`Streaming batch ${batchNum + 1}/${totalBatches}: offset=${offset}, size=${currentBatchSize}`);
+        try {
+            const response = await client.searchRecordsWithOffset('incident', 'sys_created_onONLast 6 months^categoryISNOTEMPTY^ORDERBYDESCsys_created_on', currentBatchSize, offset);
+            if (response.success) {
+                const batchActual = response.data?.result?.length || 0;
+                streamingTotal += batchActual;
+                logger.info(`  ✅ Batch got ${batchActual}/${currentBatchSize} incidents`);
+                if (batchActual < currentBatchSize) {
+                    logger.info(`  📋 End of data reached`);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            logger.error(`  ❌ Streaming batch ${batchNum + 1} failed:`, error);
+        }
+    }
+    console.log(`\n🎯 Streaming Results:`);
+    console.log(`  Total streamed: ${streamingTotal}/${totalSample}`);
+    console.log(`  Batch functionality: ${streamingTotal > 10 ? '✅ Working' : '❌ Still limited to 10'}`);
+}
+testMLBatchFix().catch(console.error);
+//# sourceMappingURL=test-ml-batch-fix.js.map

package/dist/test-ml-batch.d.ts

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

package/dist/test-ml-batch.js

@@ -0,0 +1,87 @@
+"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 ML batch functionality met realistische sizes
+async function testMLBatch() {
+    const logger = new logger_js_1.Logger('MLBatchTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    console.log('🔥 Testing ML batch functionality with realistic batch sizes...');
+    // ML training parameters (zoals ML daadwerkelijk gebruikt)
+    const sample_size = 1000; // Totaal aantal incidenten
+    const batch_size = 200; // Per batch
+    const intelligent_selection = true;
+    const focus_categories = [];
+    const query = '';
+    // Build intelligent query (zoals ML doet)
+    let finalQuery = '';
+    if (intelligent_selection && !query) {
+        const queries = [];
+        queries.push('sys_created_onONLast 6 months');
+        queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
+        queries.push('(active=true^ORactive=false)');
+        queries.push('categoryISNOTEMPTY');
+        finalQuery = queries.join('^') + '^ORDERBYDESCsys_created_on';
+    }
+    logger.info(`Testing ML batch training:`);
+    logger.info(`- Sample size: ${sample_size}`);
+    logger.info(`- Batch size: ${batch_size}`);
+    logger.info(`- Query: ${finalQuery}`);
+    // Test batch processing zoals ML training doet
+    const totalBatches = Math.ceil(sample_size / batch_size);
+    let totalProcessed = 0;
+    console.log(`\n📦 Processing ${totalBatches} batches...`);
+    for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
+        const offset = batchNum * batch_size;
+        const currentBatchSize = Math.min(batch_size, sample_size - offset);
+        logger.info(`\n--- Batch ${batchNum + 1}/${totalBatches} ---`);
+        logger.info(`Offset: ${offset}, Size: ${currentBatchSize}`);
+        try {
+            // Test searchRecordsWithOffset (zoals ML streaming doet)
+            const start = Date.now();
+            const response = await client.searchRecordsWithOffset('incident', finalQuery, currentBatchSize, offset);
+            const duration = Date.now() - start;
+            if (response.success && response.data?.result) {
+                const actualCount = response.data.result.length;
+                totalProcessed += actualCount;
+                logger.info(`✅ Success: ${actualCount}/${currentBatchSize} incidents (${duration}ms)`);
+                // Sample categories for this batch
+                const categories = new Set(response.data.result.slice(0, 5).map((inc) => inc.category || 'none'));
+                logger.info(`Categories sample: ${Array.from(categories).join(', ')}`);
+                // If we got fewer than requested, we've reached the end
+                if (actualCount < currentBatchSize) {
+                    logger.info(`📋 Reached end of data (got ${actualCount} < ${currentBatchSize})`);
+                    break;
+                }
+            }
+            else {
+                logger.error(`❌ Batch ${batchNum + 1} failed`);
+                break;
+            }
+        }
+        catch (error) {
+            logger.error(`❌ Batch ${batchNum + 1} error:`, error);
+            break;
+        }
+    }
+    console.log(`\n🎯 ML Batch Results:`);
+    console.log(`- Total processed: ${totalProcessed}/${sample_size} incidents`);
+    console.log(`- Success rate: ${((totalProcessed / sample_size) * 100).toFixed(1)}%`);
+    console.log(`- Ready for ML training: ${totalProcessed >= 100 ? '✅ Yes' : '❌ No (need 100+ incidents)'}`);
+    // Test normal single batch (non-streaming)
+    console.log(`\n🔄 Testing single batch (non-streaming mode):`);
+    try {
+        const singleBatch = await client.searchRecords('incident', finalQuery, batch_size);
+        if (singleBatch.success) {
+            logger.info(`✅ Single batch: ${singleBatch.data?.result?.length || 0}/${batch_size} incidents`);
+        }
+        else {
+            logger.error(`❌ Single batch failed`);
+        }
+    }
+    catch (error) {
+        logger.error(`❌ Single batch error:`, error);
+    }
+}
+testMLBatch().catch(console.error);
+//# sourceMappingURL=test-ml-batch.js.map

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

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

package/dist/test-ml-query.js

@@ -0,0 +1,100 @@
+"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");
+async function testMLQuery() {
+    const logger = new logger_js_1.Logger('MLQueryTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    logger.info('Testing ML training query...');
+    // Build the exact same intelligent query as ML training
+    const queries = [];
+    queries.push('sys_created_onONLast 6 months');
+    queries.push('(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)');
+    queries.push('(active=true^ORactive=false)');
+    queries.push('categoryISNOTEMPTY');
+    const finalQuery = queries.join('^');
+    logger.info(`Using ML intelligent query: ${finalQuery}`);
+    // Test 1: Without ordering
+    try {
+        logger.info('\nTest 1: Query without ordering...');
+        const result1 = await client.searchRecords('incident', finalQuery, 10);
+        logger.info(`Result: ${result1.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result1.data?.result?.length || 0}`);
+        if (result1.data?.result?.length > 0) {
+            logger.info('Sample incidents:');
+            result1.data.result.slice(0, 3).forEach((inc) => {
+                logger.info(`- ${inc.number}: created=${inc.sys_created_on}, priority=${inc.priority}, category=${inc.category || 'none'}`);
+            });
+        }
+    }
+    catch (error) {
+        logger.error('Test 1 failed:', error);
+    }
+    // Test 2: With ordering (as ML uses)
+    try {
+        logger.info('\nTest 2: Query with ordering...');
+        const orderedQuery = finalQuery + '^ORDERBYDESCsys_created_on';
+        const result2 = await client.searchRecords('incident', orderedQuery, 10);
+        logger.info(`Result: ${result2.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result2.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 2 failed:', error);
+    }
+    // Test 3: With offset (for streaming)
+    try {
+        logger.info('\nTest 3: Query with offset...');
+        const orderedQuery = finalQuery + '^ORDERBYDESCsys_created_on';
+        const result3 = await client.searchRecordsWithOffset('incident', orderedQuery, 10, 0);
+        logger.info(`Result: ${result3.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result3.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 3 failed:', error);
+    }
+    // Test 4: Simplify query to find the issue
+    try {
+        logger.info('\nTest 4: Testing each query part separately...');
+        const testQueries = [
+            'sys_created_onONLast 6 months',
+            'priority=1^ORpriority=2^ORpriority=3^ORpriority=4',
+            'active=true^ORactive=false',
+            'categoryISNOTEMPTY',
+            'category!=null',
+            'categoryISNOT EMPTY',
+            '' // empty query
+        ];
+        for (const q of testQueries) {
+            const result = await client.searchRecords('incident', q, 5);
+            logger.info(`Query "${q}" -> ${result.data?.result?.length || 0} results`);
+        }
+    }
+    catch (error) {
+        logger.error('Test 4 failed:', error);
+    }
+    // Test 5: Check if categoryISNOTEMPTY is the problem
+    try {
+        logger.info('\nTest 5: Testing without category filter...');
+        const queriesWithoutCategory = [
+            'sys_created_onONLast 6 months',
+            '(priority=1^ORpriority=2^ORpriority=3^ORpriority=4)',
+            '(active=true^ORactive=false)'
+        ];
+        const queryWithoutCategory = queriesWithoutCategory.join('^');
+        logger.info(`Query without category: ${queryWithoutCategory}`);
+        const result5 = await client.searchRecords('incident', queryWithoutCategory, 10);
+        logger.info(`Result: ${result5.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result5.data?.result?.length || 0}`);
+        if (result5.data?.result?.length > 0) {
+            logger.info('Categories in results:');
+            const categories = new Set(result5.data.result.map((inc) => inc.category || 'empty'));
+            logger.info(`Unique categories: ${Array.from(categories).join(', ')}`);
+        }
+    }
+    catch (error) {
+        logger.error('Test 5 failed:', error);
+    }
+}
+// Run the test
+testMLQuery().catch(console.error);
+//# sourceMappingURL=test-ml-query.js.map

package/dist/test-ml-training.d.ts

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

package/dist/test-ml-training.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const servicenow_machine_learning_mcp_js_1 = require("./mcp/servicenow-machine-learning-mcp.js");
+async function testMLTraining() {
+    console.log('🔥 Testing ML training with 2000+ incidents...');
+    try {
+        // Test the ML training directly
+        const result = await (0, servicenow_machine_learning_mcp_js_1.mcp__servicenow_machine_learning__ml_train_incident_classifier)({
+            sample_size: 2000,
+            query: '', // Use intelligent selection
+            intelligent_selection: true,
+            streaming_mode: false, // Test non-streaming first
+            batch_size: 200,
+            epochs: 50,
+            validation_split: 0.2,
+            max_vocabulary_size: 10000,
+            focus_categories: []
+        });
+        console.log('✅ ML Training Result:');
+        console.log(JSON.stringify(JSON.parse(result.content[0].text), null, 2));
+    }
+    catch (error) {
+        console.error('❌ ML Training failed:', error);
+        // If it fails, show more details
+        if (error instanceof Error) {
+            console.error('Error message:', error.message);
+            console.error('Stack trace:', error.stack);
+        }
+    }
+}
+testMLTraining().catch(console.error);
+//# sourceMappingURL=test-ml-training.js.map

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

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

package/dist/test-operations-query.js

@@ -0,0 +1,84 @@
+"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");
+async function testOperationsQuery() {
+    const logger = new logger_js_1.Logger('OperationsQueryTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    logger.info('Testing operations query processing...');
+    // Test processNaturalLanguageQuery logic
+    const testQuery = (query) => {
+        const lowerQuery = query.toLowerCase();
+        // If already a ServiceNow encoded query, return as-is
+        if (query.includes('=') || query.includes('!=') || query.includes('^') || query.includes('LIKE')) {
+            logger.info(`Recognized as ServiceNow query: ${query}`);
+            return query;
+        }
+        logger.info(`Treating as natural language: ${query}`);
+        return `short_descriptionLIKE${query}^ORdescriptionLIKE${query}`;
+    };
+    // Test queries
+    const queries = [
+        'state!=7',
+        'active=true',
+        'priority=1',
+        'all incidents',
+        'high priority',
+        ''
+    ];
+    logger.info('\n--- Testing Query Processing ---');
+    for (const query of queries) {
+        const processed = testQuery(query);
+        logger.info(`Input: "${query}" -> Output: "${processed}"`);
+    }
+    logger.info('\n--- Testing Actual Queries ---');
+    // Test 1: Raw ServiceNow query
+    try {
+        logger.info('\nTest 1: Testing with state!=7...');
+        const result1 = await client.searchRecords('incident', 'state!=7', 10);
+        logger.info(`Result: ${result1.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result1.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 1 failed:', error);
+    }
+    // Test 2: Empty query
+    try {
+        logger.info('\nTest 2: Testing with empty query...');
+        const result2 = await client.searchRecords('incident', '', 10);
+        logger.info(`Result: ${result2.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result2.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 2 failed:', error);
+    }
+    // Test 3: Complex query
+    try {
+        logger.info('\nTest 3: Testing with complex query...');
+        const result3 = await client.searchRecords('incident', 'active=true^state!=6^state!=7', 10);
+        logger.info(`Result: ${result3.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result3.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 3 failed:', error);
+    }
+    // Test 4: Test natural language conversion
+    try {
+        logger.info('\nTest 4: Testing natural language conversion...');
+        const nlQuery = 'high priority';
+        const processedQuery = testQuery(nlQuery);
+        logger.info(`Natural language: "${nlQuery}" -> "${processedQuery}"`);
+        // Now test the actual operations MCP logic
+        const operationsQuery = nlQuery.toLowerCase().includes('high priority') ? 'priority=1' : processedQuery;
+        logger.info(`Operations MCP would use: "${operationsQuery}"`);
+        const result4 = await client.searchRecords('incident', operationsQuery, 10);
+        logger.info(`Result: ${result4.success ? 'SUCCESS' : 'FAILED'}`);
+        logger.info(`Count: ${result4.data?.result?.length || 0}`);
+    }
+    catch (error) {
+        logger.error('Test 4 failed:', error);
+    }
+}
+// Run the test
+testOperationsQuery().catch(console.error);
+//# sourceMappingURL=test-operations-query.js.map

package/dist/test-snow-query-incidents.d.ts

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

package/dist/test-snow-query-incidents.js

@@ -0,0 +1,66 @@
+"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 exact same logic as snow_query_incidents MCP tool
+async function testSnowQueryIncidents() {
+    const logger = new logger_js_1.Logger('SnowQueryIncidentsTest');
+    const client = new servicenow_client_js_1.ServiceNowClient();
+    console.log('🔍 Testing snow_query_incidents MCP logic...');
+    // Simulate handleQueryIncidents exactly
+    const query = 'state!=7';
+    const limit = 5;
+    logger.info(`Querying incidents with: ${query}`);
+    try {
+        // Step 1: processNaturalLanguageQuery (from operations MCP)
+        const processNaturalLanguageQuery = (query, context) => {
+            const lowerQuery = query.toLowerCase();
+            // If already a ServiceNow encoded query, return as-is
+            if (query.includes('=') || query.includes('!=') || query.includes('^') || query.includes('LIKE')) {
+                logger.info(`Using raw ServiceNow query: ${query}`);
+                return query;
+            }
+            // Other processing would go here...
+            logger.info(`Treating as natural language: ${query}`);
+            return `short_descriptionLIKE${query}^ORdescriptionLIKE${query}`;
+        };
+        // Step 2: Process the query
+        const processedQuery = processNaturalLanguageQuery(query, 'incident');
+        logger.info(`Processed query: "${processedQuery}"`);
+        // Step 3: Execute the search (exact same as MCP)
+        const incidents = await client.searchRecords('incident', processedQuery, limit);
+        logger.info(`Search result: success=${incidents.success}, count=${incidents.data?.result?.length || 0}`);
+        // Step 4: Build result object (exact same as MCP)
+        let result = {
+            total_results: incidents.success ? incidents.data.result.length : 0,
+            incidents: incidents.success ? incidents.data.result : []
+        };
+        // Step 5: Format output (exact same as MCP)
+        const output = `Found ${incidents.success ? incidents.data.result.length : 0} incidents matching query: "${query}"\n\n${JSON.stringify(result, null, 2)}`;
+        console.log('\n📋 MCP Output would be:');
+        console.log(output);
+        if (!incidents.success || incidents.data.result.length === 0) {
+            logger.error('🚨 This matches the problem! MCP would return 0 incidents');
+        }
+        else {
+            logger.info('✅ This would work correctly in MCP');
+        }
+    }
+    catch (error) {
+        logger.error('❌ Error in snow_query_incidents simulation:', error);
+    }
+    // Direct test without MCP processing
+    console.log('\n🔄 Direct test without MCP processing:');
+    try {
+        const directResult = await client.searchRecords('incident', 'state!=7', limit);
+        logger.info(`Direct result: success=${directResult.success}, count=${directResult.data?.result?.length || 0}`);
+        if (directResult.success && directResult.data?.result?.length > 0) {
+            logger.info('✅ Direct call works - problem is in MCP processing');
+        }
+    }
+    catch (error) {
+        logger.error('❌ Direct call also fails:', error);
+    }
+}
+testSnowQueryIncidents().catch(console.error);
+//# sourceMappingURL=test-snow-query-incidents.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.7.1",
+  "version": "2.7.3",
   "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",