snow-flow 2.8.9 → 2.9.4

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

@@ -44,6 +44,7 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const tf = __importStar(require("@tensorflow/tfjs-node"));
 const logger_js_1 = require("../utils/logger.js");
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
+const ml_data_fetcher_js_1 = require("../utils/ml-data-fetcher.js");
 class ServiceNowMachineLearningMCP {
     constructor(credentials) {
         // Model cache
@@ -108,14 +109,18 @@ class ServiceNowMachineLearningMCP {
                 // Training tools
                 {
                     name: 'ml_train_incident_classifier',
-                    description: 'Train LSTM neural network on historical incident data with INTELLIGENT data selection. Snow-Flow automatically selects balanced training data or accepts custom queries. Works WITHOUT PA/PI plugins - only needs incident table access!',
+                    description: 'Train LSTM neural network on historical incident data with INTELLIGENT data selection. Snow-Flow automatically detects available data and uses the optimal amount (up to 5000) for best accuracy. Works WITHOUT PA/PI plugins - only needs incident table access!',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             sample_size: {
                                 type: 'number',
-                                description: 'Number of incidents to use for training',
-                                default: 1000
+                                description: 'Number of incidents to use for training. If not specified, automatically uses all available data (up to 5000). Set to limit training data.'
+                            },
+                            auto_maximize_data: {
+                                type: 'boolean',
+                                description: 'Automatically use all available incident data for best model accuracy (default: true)',
+                                default: true
                             },
                             epochs: {
                                 type: 'number',
@@ -134,7 +139,7 @@ class ServiceNowMachineLearningMCP {
                             },
                             intelligent_selection: {
                                 type: 'boolean',
-                                description: 'Let Snow-Flow intelligently select balanced training data across categories, priorities, and time periods',
+                                description: 'Let Snow-Flow intelligently select balanced training data across categories, priorities, and time periods. Combined with auto_maximize_data for optimal results.',
                                 default: true
                             },
                             focus_categories: {
@@ -505,7 +510,9 @@ class ServiceNowMachineLearningMCP {
      * Uses PI if available, otherwise uses custom TensorFlow.js
      */
     async trainIncidentClassifier(args) {
-        const { sample_size = 1000, epochs = 50, validation_split = 0.2, query = '', intelligent_selection = true, focus_categories = [], batch_size = 100, streaming_mode = true } = args;
+        const { sample_size, // No default - will be determined dynamically
+        epochs = 50, validation_split = 0.2, query = '', intelligent_selection = true, focus_categories = [], batch_size = 100, streaming_mode = true, auto_maximize_data = true // New option to automatically use all available data
+         } = args;
         // CRITICAL FIX: Ensure max_vocabulary_size is ALWAYS valid
         const max_vocabulary_size = Math.max(1000, args.max_vocabulary_size || 5000);
         try {
@@ -513,6 +520,91 @@ class ServiceNowMachineLearningMCP {
             if (!this.mlAPICheckComplete) {
                 await this.checkMLAPIAvailability();
             }
+            // First, check how much data is available
+            let actualSampleSize = sample_size || 2000; // Default to 2000 if not specified
+            if (auto_maximize_data || !sample_size) {
+                this.logger.info('🔍 Checking available incident data for optimal training...');
+                try {
+                    // Count available incidents that match our criteria
+                    const countQuery = query || (intelligent_selection ?
+                        'categoryISNOTEMPTY^descriptionISNOTEMPTY^sys_created_onONLast 6 months' :
+                        '');
+                    // Use ServiceNow aggregate API to count records efficiently
+                    let totalAvailable = 0;
+                    try {
+                        // Try using the stats API first (most efficient)
+                        const statsResponse = await this.makeServiceNowRequest('/api/now/stats/incident', {
+                            sysparm_query: countQuery,
+                            sysparm_count: true
+                        });
+                        if (statsResponse.data?.result?.stats?.count) {
+                            totalAvailable = parseInt(statsResponse.data.result.stats.count);
+                        }
+                    }
+                    catch (statsError) {
+                        // Fallback: Use aggregate API
+                        try {
+                            const aggResponse = await this.makeServiceNowRequest('/api/now/table/incident', {
+                                sysparm_query: countQuery,
+                                sysparm_count: true,
+                                sysparm_limit: 1
+                            });
+                            // ServiceNow returns count in result
+                            if (aggResponse?.result && Array.isArray(aggResponse.result)) {
+                                // Even with limit 1, we can estimate based on typical data
+                                totalAvailable = 2000; // Conservative estimate when count API fails
+                                this.logger.info('Using conservative estimate of 2000 incidents');
+                            }
+                        }
+                        catch (aggError) {
+                            // Final fallback: Estimate based on a sample
+                            const sampleResult = await this.client.searchRecords('incident', countQuery, 1000);
+                            if (sampleResult.success && sampleResult.data?.result) {
+                                totalAvailable = sampleResult.data.result.length >= 1000 ? 5000 : sampleResult.data.result.length;
+                                this.logger.info(`Estimated ${totalAvailable} incidents available (sampled)`);
+                            }
+                        }
+                    }
+                    // Use a reasonable maximum (5000) to avoid memory issues
+                    const maxRecommended = 5000;
+                    const optimalSize = Math.min(totalAvailable, maxRecommended);
+                    if (totalAvailable > 0) {
+                        this.logger.info(`📊 Found ${totalAvailable} incidents available for training`);
+                        if (sample_size && sample_size > totalAvailable) {
+                            this.logger.warn(`⚠️ Requested ${sample_size} samples but only ${totalAvailable} available`);
+                        }
+                        // Use the optimal amount of data
+                        actualSampleSize = sample_size ?
+                            Math.min(sample_size, totalAvailable) :
+                            optimalSize;
+                        this.logger.info(`✅ Using ${actualSampleSize} incidents for training (optimal for this dataset)`);
+                        // Provide recommendations based on data size
+                        if (actualSampleSize < 500) {
+                            this.logger.warn('⚠️ Less than 500 samples - model accuracy may be limited');
+                            this.logger.info('💡 Recommendation: Gather more incident data for better results');
+                        }
+                        else if (actualSampleSize < 1000) {
+                            this.logger.info('📈 Moderate dataset - expect 70-80% accuracy');
+                        }
+                        else if (actualSampleSize < 2000) {
+                            this.logger.info('📈 Good dataset - expect 80-85% accuracy');
+                        }
+                        else {
+                            this.logger.info('🎯 Excellent dataset - expect 85-95% accuracy');
+                        }
+                    }
+                    else {
+                        // Fallback to a default if count fails
+                        actualSampleSize = sample_size || 1000;
+                        this.logger.info(`Using default sample size: ${actualSampleSize}`);
+                    }
+                }
+                catch (error) {
+                    // If counting fails, use the provided or default size
+                    actualSampleSize = sample_size || 1000;
+                    this.logger.warn('Could not determine available data, using:', actualSampleSize);
+                }
+            }
             // If PI is available, try to use it first
             if (this.hasPI) {
                 try {
@@ -553,7 +645,7 @@ class ServiceNowMachineLearningMCP {
             // 🔴 CRITICAL FIX: Use full sample_size, not artificially limited amount
             let incidents = [];
             try {
-                incidents = await this.fetchIncidentData(sample_size, {
+                incidents = await this.fetchIncidentData(actualSampleSize, {
                     query,
                     intelligent_selection,
                     focus_categories
@@ -1169,40 +1261,115 @@ class ServiceNowMachineLearningMCP {
         else if (!finalQuery) {
             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.');
-        }
-        this.logger.info(`Fetched ${response.data.result.length} incidents for ML training (requested: ${limit})`);
-        // If intelligent selection, ensure we have a balanced dataset
-        if (intelligent_selection && 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;
+        // Use smart ML data fetcher for batched retrieval to avoid token limits
+        this.logger.info(`🤖 Using smart ML data fetcher for ${limit} incidents`);
+        try {
+            // Create a delegate for the operations MCP
+            const operationsMCP = {
+                handleTool: async (toolName, args) => {
+                    if (toolName === 'snow_query_table') {
+                        const { table, query: q, limit: l, fields, include_content } = args;
+                        // Use the client to fetch data
+                        const response = await this.client.searchRecords(table, q || '', l || 100);
+                        if (!response.success) {
+                            throw new Error(`Query failed: ${response.error}`);
+                        }
+                        const records = response.data?.result || [];
+                        // Filter fields if specified
+                        let filteredRecords = records;
+                        if (fields && fields.length > 0) {
+                            filteredRecords = records.map((record) => {
+                                const filtered = {};
+                                for (const field of fields) {
+                                    if (field in record) {
+                                        filtered[field] = record[field];
+                                    }
+                                }
+                                return filtered;
+                            });
+                        }
+                        // Format response
+                        if (include_content) {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: JSON.stringify(filteredRecords, null, 2)
+                                    }]
+                            };
+                        }
+                        else {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: `Found ${records.length} ${table} records matching query: "${q || 'all'}"`
+                                    }]
+                            };
+                        }
+                    }
+                    throw new Error(`Unknown tool: ${toolName}`);
+                }
+            };
+            const dataFetcher = new ml_data_fetcher_js_1.MLDataFetcher(operationsMCP);
+            const result = await dataFetcher.smartFetch({
+                table: 'incident',
+                query: finalQuery,
+                totalSamples: limit,
+                batchSize: 50, // Small batches to avoid token limits
+                discoverFields: true,
+                includeContent: true
             });
-            this.logger.info('Data distribution:');
-            this.logger.info(`Categories: ${JSON.stringify(categoryDistribution)}`);
-            this.logger.info(`Priorities: ${JSON.stringify(priorityDistribution)}`);
+            this.logger.info(`🎉 Fetched ${result.totalFetched} incidents in ${result.batchesProcessed} batches`);
+            this.logger.info(`🔍 Used fields: ${result.fields.slice(0, 10).join(', ')}${result.fields.length > 10 ? '...' : ''}`);
+            // If intelligent selection, log distribution
+            if (intelligent_selection && result.data.length > 0) {
+                const categoryDistribution = {};
+                const priorityDistribution = {};
+                result.data.forEach((inc) => {
+                    const category = inc.category || 'uncategorized';
+                    const priority = inc.priority || '3';
+                    categoryDistribution[category] = (categoryDistribution[category] || 0) + 1;
+                    priorityDistribution[priority] = (priorityDistribution[priority] || 0) + 1;
+                });
+                this.logger.info('Data distribution:');
+                this.logger.info(`Categories: ${Object.keys(categoryDistribution).length} unique`);
+                this.logger.info(`Priorities: ${JSON.stringify(priorityDistribution)}`);
+            }
+            // Map the fetched data to our IncidentData format
+            return result.data.map((inc) => ({
+                short_description: inc.short_description || '',
+                description: inc.description || '',
+                category: inc.category || 'uncategorized',
+                subcategory: inc.subcategory || '',
+                priority: parseInt(inc.priority) || 3,
+                impact: parseInt(inc.impact) || 2,
+                urgency: parseInt(inc.urgency) || 2,
+                resolved: inc.state === '6' || inc.state === '7' || inc.active === 'false',
+                resolution_time: inc.resolved_at && inc.sys_created_on ?
+                    (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
+            }));
+        }
+        catch (error) {
+            // Fallback to direct fetch with smaller limit if smart fetcher fails
+            this.logger.warn('Smart fetcher failed, using fallback with reduced limit:', error.message);
+            const fallbackLimit = Math.min(limit, 100); // Limit to 100 to avoid token issues
+            const response = await this.client.searchRecords('incident', finalQuery, fallbackLimit);
+            if (!response.success || !response.data?.result) {
+                throw new Error('Failed to fetch incident data. Ensure you have read access to the incident table.');
+            }
+            this.logger.info(`Fetched ${response.data.result.length} incidents (fallback mode, limited to ${fallbackLimit})`);
+            return response.data.result.map((inc) => ({
+                short_description: inc.short_description || '',
+                description: inc.description || '',
+                category: inc.category || 'uncategorized',
+                subcategory: inc.subcategory || '',
+                priority: parseInt(inc.priority) || 3,
+                impact: parseInt(inc.impact) || 2,
+                urgency: parseInt(inc.urgency) || 2,
+                resolved: inc.resolved === 'true',
+                resolution_time: inc.resolved_at && inc.sys_created_on ?
+                    (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
+            }));
         }
-        return response.data.result.map((inc) => ({
-            short_description: inc.short_description || '',
-            description: inc.description || '',
-            category: inc.category || 'uncategorized',
-            subcategory: inc.subcategory || '',
-            priority: parseInt(inc.priority) || 3,
-            impact: parseInt(inc.impact) || 2,
-            urgency: parseInt(inc.urgency) || 2,
-            resolved: inc.resolved === 'true',
-            resolution_time: inc.resolved_at && inc.sys_created_on ?
-                (new Date(inc.resolved_at).getTime() - new Date(inc.sys_created_on).getTime()) / 1000 : undefined
-        }));
     }
     async prepareIncidentData(incidents) {
         // Create tokenizer
@@ -1303,28 +1470,111 @@ class ServiceNowMachineLearningMCP {
         return undefined;
     }
     async fetchChangeData(limit, includeFailed) {
-        // Fetch real change data from ServiceNow - NO MOCK DATA
-        const queryParams = {
-            sysparm_limit: limit,
-            sysparm_query: includeFailed ? 'state!=cancelled' : 'state=closed^close_code=successful',
-            sysparm_fields: 'number,short_description,risk,impact,category,type,state,close_code,sys_created_on,closed_at'
-        };
-        const response = await this.makeServiceNowRequest('/api/now/table/change_request', queryParams);
-        if (!response || !response.result) {
-            throw new Error('Failed to fetch change data from ServiceNow. ' +
-                'Ensure you have permission to read change_request table.');
-        }
-        return response.result.map((change) => ({
-            number: change.number,
-            description: change.short_description || '',
-            risk: change.risk || 'moderate',
-            impact: parseInt(change.impact) || 2,
-            category: change.category || 'standard',
-            type: change.type || 'standard',
-            successful: change.close_code === 'successful',
-            duration: change.closed_at && change.sys_created_on ?
-                (new Date(change.closed_at).getTime() - new Date(change.sys_created_on).getTime()) / 1000 : 0
-        }));
+        // Use smart data fetcher for change requests to avoid token limits
+        this.logger.info(`🤖 Using smart ML data fetcher for ${limit} change requests`);
+        const query = includeFailed ? 'state!=cancelled' : 'state=closed^close_code=successful';
+        try {
+            // Create a delegate for the operations MCP
+            const operationsMCP = {
+                handleTool: async (toolName, args) => {
+                    if (toolName === 'snow_query_table') {
+                        const { table, query: q, limit: l, fields, include_content } = args;
+                        // Use the client to fetch data
+                        const response = await this.client.searchRecords(table, q || '', l || 100);
+                        if (!response.success) {
+                            throw new Error(`Query failed: ${response.error}`);
+                        }
+                        const records = response.data?.result || [];
+                        // Filter fields if specified
+                        let filteredRecords = records;
+                        if (fields && fields.length > 0) {
+                            filteredRecords = records.map((record) => {
+                                const filtered = {};
+                                for (const field of fields) {
+                                    if (field in record) {
+                                        filtered[field] = record[field];
+                                    }
+                                }
+                                return filtered;
+                            });
+                        }
+                        // Format response
+                        if (include_content) {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: JSON.stringify(filteredRecords, null, 2)
+                                    }]
+                            };
+                        }
+                        else {
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: `Found ${records.length} ${table} records matching query: "${q || 'all'}"`
+                                    }]
+                            };
+                        }
+                    }
+                    throw new Error(`Unknown tool: ${toolName}`);
+                }
+            };
+            const dataFetcher = new ml_data_fetcher_js_1.MLDataFetcher(operationsMCP);
+            const result = await dataFetcher.smartFetch({
+                table: 'change_request',
+                query,
+                totalSamples: limit,
+                batchSize: 50, // Small batches to avoid token limits
+                fields: ['number', 'short_description', 'risk', 'impact', 'category', 'type',
+                    'state', 'close_code', 'sys_created_on', 'closed_at', 'start_date', 'end_date',
+                    'assignment_group', 'approval', 'test_plan', 'backout_plan', 'rollback_tested'],
+                includeContent: true
+            });
+            this.logger.info(`🎉 Fetched ${result.totalFetched} change requests in ${result.batchesProcessed} batches`);
+            return result.data.map((change) => ({
+                short_description: change.short_description || '',
+                risk: change.risk || 'moderate',
+                category: change.category || 'standard',
+                type: change.type || 'standard',
+                planned_start: change.start_date ? new Date(change.start_date) : new Date(),
+                planned_end: change.end_date ? new Date(change.end_date) : new Date(),
+                assignment_group: change.assignment_group?.display_value || change.assignment_group || '',
+                approval_count: parseInt(change.approval) || 0,
+                test_plan: change.test_plan === 'true' || false,
+                backout_plan: change.backout_plan === 'true' || false,
+                rollback_tested: change.rollback_tested === 'true' || false,
+                implementation_success: change.close_code === 'successful'
+            }));
+        }
+        catch (error) {
+            // Fallback to direct API call with smaller limit
+            this.logger.warn('Smart fetcher failed, using fallback:', error.message);
+            const fallbackLimit = Math.min(limit, 100);
+            const queryParams = {
+                sysparm_limit: fallbackLimit,
+                sysparm_query: query,
+                sysparm_fields: 'number,short_description,risk,impact,category,type,state,close_code,sys_created_on,closed_at'
+            };
+            const response = await this.makeServiceNowRequest('/api/now/table/change_request', queryParams);
+            if (!response || !response.result) {
+                throw new Error('Failed to fetch change data from ServiceNow. ' +
+                    'Ensure you have permission to read change_request table.');
+            }
+            return response.result.map((change) => ({
+                short_description: change.short_description || '',
+                risk: change.risk || 'moderate',
+                category: change.category || 'standard',
+                type: change.type || 'standard',
+                planned_start: change.start_date ? new Date(change.start_date) : new Date(),
+                planned_end: change.end_date ? new Date(change.end_date) : new Date(),
+                assignment_group: change.assignment_group?.display_value || change.assignment_group || '',
+                approval_count: parseInt(change.approval) || 0,
+                test_plan: change.test_plan === 'true' || false,
+                backout_plan: change.backout_plan === 'true' || false,
+                rollback_tested: change.rollback_tested === 'true' || false,
+                implementation_success: change.close_code === 'successful'
+            }));
+        }
     }
     async prepareChangeData(changes) {
         // Implement change data preparation

package/dist/mcp/servicenow-operations-mcp.d.ts

@@ -11,5 +11,75 @@
  * - Knowledge base integration
  * - Predictive analytics
  */
-export {};
+declare class ServiceNowOperationsMCP {
+    private server;
+    private client;
+    constructor();
+    private setupToolHandlers;
+    private handleUniversalQuery;
+    private detectCommonFields;
+    private handleQueryIncidents;
+    private handleAnalyzeIncident;
+    private handleAutoResolveIncident;
+    private handleQueryRequests;
+    private handleQueryProblems;
+    private handleCMDBSearch;
+    private handleUserLookup;
+    private handleOperationalMetrics;
+    private handlePatternAnalysis;
+    private handleKnowledgeSearch;
+    private handlePredictiveAnalysis;
+    private processNaturalLanguageQuery;
+    private analyzeIncidents;
+    private getIncidentDetails;
+    private performIncidentAnalysis;
+    private generateRootCauseAnalysis;
+    private generateAutomatedActions;
+    private generateResolutionActions;
+    private executeResolutionActions;
+    private getRequestItems;
+    private getRelatedIncidents;
+    private getCIRelationships;
+    private getUserDetails;
+    private calculateOperationalMetrics;
+    private getDateFilter;
+    private analyzePatterns;
+    private analyzeIncidentPatterns;
+    private analyzeRequestTrends;
+    private analyzeProblemRootCauses;
+    private analyzeUserBehavior;
+    private calculateKnowledgeRelevance;
+    private performPredictiveAnalysis;
+    private analyzeIncidentTrends;
+    private analyzeSystemHealthTrends;
+    private analyzeResourceTrends;
+    private analyzeUserImpactTrends;
+    private predictIncidentVolume;
+    private predictSystemFailure;
+    private predictResourceExhaustion;
+    private predictUserImpact;
+    private handleCatalogItemManager;
+    private createCatalogVariable;
+    private mapVariableType;
+    private handleCatalogItemSearch;
+    private generateSearchVariations;
+    private generateSearchSuggestions;
+    private shouldExcludeItem;
+    private handleCleanupTestArtifacts;
+    private cleanupTestCatalogItems;
+    private cleanupTestUsers;
+    private cleanupTestRequests;
+    private getServiceNowUrl;
+    private handleCreateUserGroup;
+    private handleCreateUser;
+    private handleAssignUserToGroup;
+    private handleRemoveUserFromGroup;
+    private handleListGroupMembers;
+    private findUserBySysIdOrUsername;
+    private findGroupBySysIdOrName;
+    private findDepartment;
+    private findLocation;
+    run(): Promise<void>;
+}
+export { ServiceNowOperationsMCP };
 //# sourceMappingURL=servicenow-operations-mcp.d.ts.map

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

@@ -13,6 +13,7 @@
  * - Predictive analytics
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowOperationsMCP = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
@@ -131,7 +132,7 @@ class ServiceNowOperationsMCP {
                     // 🎯 UNIVERSAL TABLE QUERY - Works for ANY ServiceNow table!
                     {
                         name: 'snow_query_table',
-                        description: '🚀 Universal high-performance query tool for ANY ServiceNow table - optimized for memory efficiency',
+                        description: '🚀 Universal high-performance query tool for ANY ServiceNow table - optimized for memory efficiency. SMART DEFAULTS: 1000 records (5000 for ML training contexts)',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -146,8 +147,8 @@ class ServiceNowOperationsMCP {
                                 },
                                 limit: {
                                     type: 'number',
-                                    description: 'Maximum number of results (default: 10)',
-                                    default: 10
+                                    description: '🎯 Maximum number of results. SMART DEFAULTS: 1000 (normal queries), 5000 (ML training contexts). Set higher for large ML datasets (10000+)',
+                                    default: 1000
                                 },
                                 include_content: {
                                     type: 'boolean',
@@ -828,8 +829,37 @@ class ServiceNowOperationsMCP {
         });
     }
     async handleUniversalQuery(args) {
-        const { table, query, limit = 10, include_content = false, fields, include_display_values = false, group_by, order_by } = args;
-        logger_js_1.logger.info(`Universal query on table '${table}' with: ${query} (include_content: ${include_content})`);
+        // 🎯 SMART DEFAULT LIMITS - Context-aware for ML training
+        const determineSmartLimit = (providedLimit, table, query, includeContent) => {
+            if (providedLimit !== undefined)
+                return providedLimit; // User explicitly set limit
+            // ML Training context detection
+            const isMLContext = query?.toLowerCase().includes('train') ||
+                query?.toLowerCase().includes('ml') ||
+                table?.toLowerCase().includes('train') ||
+                (includeContent && table === 'incident'); // ML often needs incident content
+            if (isMLContext) {
+                logger_js_1.logger.info(`🧠 ML context detected - using ML-optimized limit: 5000`);
+                return 5000; // ML training needs more data
+            }
+            // Count-only queries can handle more records efficiently  
+            if (!includeContent) {
+                return 2000; // Count queries are memory-efficient
+            }
+            // Normal content queries
+            return 1000; // Balanced default for content queries
+        };
+        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);
+        // 🚨 ML Training Warning for low limits
+        const isMLTrainingContext = query?.toLowerCase().includes('train') ||
+            query?.toLowerCase().includes('ml') ||
+            args.limit !== undefined && args.limit < 1000;
+        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})`);
         try {
             // Convert natural language to ServiceNow query if needed
             const processedQuery = this.processNaturalLanguageQuery(query, table);
@@ -3140,10 +3170,13 @@ class ServiceNowOperationsMCP {
         logger_js_1.logger.info('ServiceNow Operations MCP Server started');
     }
 }
-// Start the server
-const server = new ServiceNowOperationsMCP();
-server.run().catch((error) => {
-    logger_js_1.logger.error('Failed to start ServiceNow Operations MCP server:', error);
-    process.exit(1);
-});
+exports.ServiceNowOperationsMCP = ServiceNowOperationsMCP;
+// Start the server only if run directly
+if (require.main === module) {
+    const server = new ServiceNowOperationsMCP();
+    server.run().catch((error) => {
+        logger_js_1.logger.error('Failed to start ServiceNow Operations MCP server:', error);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=servicenow-operations-mcp.js.map

package/dist/test-smart-limits.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Test Smart Limits for snow_query_table
+ *
+ * This script validates that the smart default limit system works correctly:
+ * - ML context: 5000 default
+ * - Count-only: 2000 default
+ * - Normal content: 1000 default
+ * - Explicit limits: Always respected
+ */
+declare function testSmartLimits(): Promise<void>;
+export { testSmartLimits };
+//# sourceMappingURL=test-smart-limits.d.ts.map