snow-flow 1.1.74 → 1.1.76

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

@@ -1634,12 +1634,52 @@ class ServiceNowOperationsMCP {
         };
     }
     async analyzeUserBehavior(dateFilter) {
-        // This would require analyzing user activity across multiple tables
-        // For now, return a basic analysis
-        return {
-            message: 'User behavior analysis requires additional data collection and processing',
-            available_metrics: ['login_patterns', 'request_frequency', 'incident_reporting']
-        };
+        try {
+            // Query actual user activity data from ServiceNow
+            const activities = [];
+            // Get recent incidents created by users
+            const incidents = await this.client.searchRecords('incident', `sys_created_on>=${dateFilter}^caller_idISNOTEMPTY`, 100);
+            if (incidents.success && incidents.data) {
+                const incidentData = Array.isArray(incidents.data) ? incidents.data : [incidents.data];
+                const userIncidents = new Map();
+                incidentData.forEach(inc => {
+                    const userId = inc.caller_id?.value || inc.caller_id;
+                    if (userId) {
+                        userIncidents.set(userId, (userIncidents.get(userId) || 0) + 1);
+                    }
+                });
+                activities.push({
+                    metric: 'incident_reporting',
+                    total_incidents: incidentData.length,
+                    unique_users: userIncidents.size,
+                    avg_per_user: userIncidents.size > 0 ? Math.round(incidentData.length / userIncidents.size * 10) / 10 : 0
+                });
+            }
+            // Get service requests
+            const requests = await this.client.searchRecords('sc_request', `sys_created_on>=${dateFilter}^requested_forISNOTEMPTY`, 100);
+            if (requests.success && requests.data) {
+                const requestData = Array.isArray(requests.data) ? requests.data : [requests.data];
+                activities.push({
+                    metric: 'request_frequency',
+                    total_requests: requestData.length,
+                    period: dateFilter
+                });
+            }
+            return {
+                analysis_period: dateFilter,
+                generated_at: new Date().toISOString(),
+                user_activities: activities,
+                summary: `Analyzed ${activities.length} activity metrics for period: ${dateFilter}`,
+                note: 'Analysis based on actual ServiceNow data from incident and request tables'
+            };
+        }
+        catch (error) {
+            return {
+                error: 'User behavior analysis failed',
+                message: error instanceof Error ? error.message : String(error),
+                available_metrics: ['incident_reporting', 'request_frequency']
+            };
+        }
     }
     async calculateKnowledgeRelevance(articles, incident) {
         const relevanceScores = [];
@@ -1661,33 +1701,131 @@ class ServiceNowOperationsMCP {
         return relevanceScores.sort((a, b) => b.relevance_score - a.relevance_score);
     }
     async performPredictiveAnalysis(predictionType, timeframe) {
-        // This would require machine learning models and historical data analysis
-        // For now, return basic predictions based on current trends
-        const currentDate = new Date();
-        const predictions = {
-            prediction_type: predictionType,
-            timeframe: timeframe,
-            generated_at: currentDate.toISOString(),
-            confidence: 0.7,
-            predictions: []
-        };
-        switch (predictionType) {
-            case 'incident_volume':
-                predictions.predictions = await this.predictIncidentVolume(timeframe);
-                break;
-            case 'system_failure':
-                predictions.predictions = await this.predictSystemFailure(timeframe);
-                break;
-            case 'resource_exhaustion':
-                predictions.predictions = await this.predictResourceExhaustion(timeframe);
-                break;
-            case 'user_impact':
-                predictions.predictions = await this.predictUserImpact(timeframe);
-                break;
-            default:
-                predictions.predictions = [{ error: 'Unknown prediction type' }];
+        try {
+            const currentDate = new Date();
+            const analysis = {
+                prediction_type: predictionType,
+                timeframe: timeframe,
+                generated_at: currentDate.toISOString(),
+                analysis_method: 'trend_analysis',
+                data_points: []
+            };
+            switch (predictionType) {
+                case 'incident_volume':
+                    analysis.data_points = await this.analyzeIncidentTrends(timeframe);
+                    analysis.interpretation = 'Based on recent incident creation patterns';
+                    break;
+                case 'system_failure':
+                    analysis.data_points = await this.analyzeSystemHealthTrends(timeframe);
+                    analysis.interpretation = 'Based on critical incident patterns and system health indicators';
+                    break;
+                case 'resource_exhaustion':
+                    analysis.data_points = await this.analyzeResourceTrends(timeframe);
+                    analysis.interpretation = 'Based on request volumes and capacity indicators';
+                    break;
+                case 'user_impact':
+                    analysis.data_points = await this.analyzeUserImpactTrends(timeframe);
+                    analysis.interpretation = 'Based on user-reported incidents and service requests';
+                    break;
+                default:
+                    analysis.data_points = [{ error: 'Unknown prediction type', supported_types: ['incident_volume', 'system_failure', 'resource_exhaustion', 'user_impact'] }];
+                    analysis.interpretation = 'Unsupported analysis type';
+            }
+            return analysis;
+        }
+        catch (error) {
+            return {
+                prediction_type: predictionType,
+                timeframe: timeframe,
+                error: 'Analysis failed',
+                message: error instanceof Error ? error.message : String(error),
+                generated_at: new Date().toISOString()
+            };
         }
-        return predictions;
+    }
+    // New trend analysis methods
+    async analyzeIncidentTrends(timeframe) {
+        try {
+            const incidents = await this.client.searchRecords('incident', 'sys_created_onONToday@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)', 100);
+            if (incidents.success && incidents.data) {
+                const incidentData = Array.isArray(incidents.data) ? incidents.data : [incidents.data];
+                const dailyCounts = new Map();
+                incidentData.forEach(incident => {
+                    const date = new Date(incident.sys_created_on).toDateString();
+                    dailyCounts.set(date, (dailyCounts.get(date) || 0) + 1);
+                });
+                return Array.from(dailyCounts.entries()).map(([date, count]) => ({
+                    date,
+                    incident_count: count,
+                    trend: count > 5 ? 'increasing' : 'stable'
+                }));
+            }
+        }
+        catch (error) {
+            return [{ error: 'Failed to analyze incident trends', message: String(error) }];
+        }
+        return [{ message: 'No incident data available for analysis' }];
+    }
+    async analyzeSystemHealthTrends(timeframe) {
+        try {
+            const criticalIncidents = await this.client.searchRecords('incident', 'priority=1^sys_created_onONToday@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)', 50);
+            if (criticalIncidents.success && criticalIncidents.data) {
+                const criticalData = Array.isArray(criticalIncidents.data) ? criticalIncidents.data : [criticalIncidents.data];
+                return [{
+                        metric: 'critical_incidents',
+                        count: criticalData.length,
+                        health_indicator: criticalData.length > 3 ? 'at_risk' : 'stable',
+                        recent_issues: criticalData.slice(0, 3).map(inc => inc.short_description)
+                    }];
+            }
+        }
+        catch (error) {
+            return [{ error: 'Failed to analyze system health trends', message: String(error) }];
+        }
+        return [{ message: 'No system health data available' }];
+    }
+    async analyzeResourceTrends(timeframe) {
+        try {
+            const requests = await this.client.searchRecords('sc_request', 'sys_created_onONToday@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)', 100);
+            if (requests.success && requests.data) {
+                const requestData = Array.isArray(requests.data) ? requests.data : [requests.data];
+                return [{
+                        metric: 'request_volume',
+                        total_requests: requestData.length,
+                        resource_pressure: requestData.length > 20 ? 'high' : 'normal',
+                        trend: 'stable'
+                    }];
+            }
+        }
+        catch (error) {
+            return [{ error: 'Failed to analyze resource trends', message: String(error) }];
+        }
+        return [{ message: 'No resource usage data available' }];
+    }
+    async analyzeUserImpactTrends(timeframe) {
+        try {
+            const userIncidents = await this.client.searchRecords('incident', 'caller_idISNOTEMPTY^sys_created_onONToday@javascript:gs.daysAgoStart(7)@javascript:gs.daysAgoEnd(0)', 100);
+            if (userIncidents.success && userIncidents.data) {
+                const incidentData = Array.isArray(userIncidents.data) ? userIncidents.data : [userIncidents.data];
+                const impactCounts = new Map();
+                incidentData.forEach(incident => {
+                    const impact = incident.impact || 'unknown';
+                    impactCounts.set(impact, (impactCounts.get(impact) || 0) + 1);
+                });
+                return [{
+                        metric: 'user_impact_distribution',
+                        high_impact: impactCounts.get('1') || 0,
+                        medium_impact: impactCounts.get('2') || 0,
+                        low_impact: impactCounts.get('3') || 0,
+                        total_affected_users: incidentData.length,
+                        impact_trend: (impactCounts.get('1') || 0) > 5 ? 'increasing' : 'stable'
+                    }];
+            }
+        }
+        catch (error) {
+            return [{ error: 'Failed to analyze user impact trends', message: String(error) }];
+        }
+        return [{ message: 'No user impact data available' }];
     }
     async predictIncidentVolume(timeframe) {
         // Get historical incident data
@@ -2032,9 +2170,12 @@ class ServiceNowOperationsMCP {
             let categoryFilter = '';
             if (category_filter) {
                 // First try to find the category
-                const categoryResult = await this.client.searchRecords('sc_category', `name=${category_filter}^ORsys_id=${category_filter}`, 1);
+                const categoryResult = await this.client.searchRecords('sc_category', `nameLIKE${category_filter}^ORtitle=${category_filter}^ORsys_id=${category_filter}`, 10);
                 if (categoryResult.success && categoryResult.data?.result?.length > 0) {
-                    categoryFilter = `^sc_categories=${categoryResult.data.result[0].sys_id}`;
+                    // Try to find the most relevant category
+                    const exactMatch = categoryResult.data.result.find((c) => c.name.toLowerCase() === category_filter.toLowerCase());
+                    const category = exactMatch || categoryResult.data.result[0];
+                    categoryFilter = `^sc_categoriesLIKE${category.sys_id}`;
                 }
             }
             // Execute searches
@@ -2045,6 +2186,13 @@ class ServiceNowOperationsMCP {
                 if (result.success && result.data?.result) {
                     result.data.result.forEach((item) => {
                         if (!allResults.has(item.sys_id)) {
+                            // Filter out items that don't make sense for the search
+                            const itemName = (item.name || '').toLowerCase();
+                            const itemDesc = (item.short_description || '').toLowerCase();
+                            // Skip items that are clearly not what the user is looking for
+                            if (this.shouldExcludeItem(query, itemName, itemDesc)) {
+                                return;
+                            }
                             allResults.set(item.sys_id, {
                                 sys_id: item.sys_id,
                                 name: item.name,
@@ -2143,8 +2291,9 @@ class ServiceNowOperationsMCP {
     }
     generateSearchVariations(query) {
         const variations = [];
+        const lowerQuery = query.toLowerCase();
         // Handle common product variations
-        if (query.toLowerCase().includes('iphone')) {
+        if (lowerQuery.includes('iphone')) {
             // Add variations without spaces, with different numbers
             const baseModel = query.replace(/iphone\s*/i, 'iPhone ');
             variations.push(baseModel);
@@ -2158,33 +2307,112 @@ class ServiceNowOperationsMCP {
             }
         }
         // Handle laptop/computer variations
-        if (query.toLowerCase().includes('laptop') || query.toLowerCase().includes('computer')) {
+        if (lowerQuery.includes('laptop') || lowerQuery.includes('computer')) {
             variations.push('notebook', 'macbook', 'thinkpad', 'dell', 'hp');
         }
         // Handle phone variations
-        if (query.toLowerCase().includes('phone') || query.toLowerCase().includes('mobile')) {
+        if (lowerQuery.includes('phone') || lowerQuery.includes('mobile')) {
             variations.push('smartphone', 'android', 'samsung', 'pixel');
         }
-        return variations;
+        // Handle monitor/display variations
+        if (lowerQuery.includes('monitor') || lowerQuery.includes('display') ||
+            lowerQuery.includes('screen') || lowerQuery.includes('lcd')) {
+            variations.push('monitor', 'display', 'screen', 'lcd', 'led', 'desktop monitor', 'computer monitor', 'external display', 'lcd monitor', 'led monitor', 'dell monitor', 'hp monitor', 'samsung monitor', 'lg monitor');
+        }
+        // Handle desktop/workstation variations
+        if (lowerQuery.includes('desktop') || lowerQuery.includes('workstation')) {
+            variations.push('desktop computer', 'workstation', 'pc', 'desktop pc', 'dell desktop', 'hp desktop', 'lenovo desktop');
+        }
+        // Handle specific hardware terms
+        if (lowerQuery.includes('hardware') || lowerQuery.includes('equipment')) {
+            // Extract specific items from the query
+            const specificItems = [];
+            if (lowerQuery.includes('monitor') || lowerQuery.includes('display') || lowerQuery.includes('screen')) {
+                specificItems.push('monitor', 'display');
+            }
+            if (lowerQuery.includes('desktop')) {
+                specificItems.push('desktop', 'computer');
+            }
+            if (lowerQuery.includes('laptop')) {
+                specificItems.push('laptop', 'notebook');
+            }
+            // If we found specific items, use those instead of generic "hardware"
+            if (specificItems.length > 0) {
+                variations.push(...specificItems);
+            }
+        }
+        // Remove duplicates and empty strings
+        return [...new Set(variations)].filter(v => v && v.length > 0);
     }
     generateSearchSuggestions(query) {
         const suggestions = [];
-        if (query.toLowerCase().includes('iphone')) {
+        const lowerQuery = query.toLowerCase();
+        if (lowerQuery.includes('iphone')) {
             suggestions.push('iPhone', 'Apple iPhone', 'iOS device', 'Apple mobile');
         }
-        else if (query.toLowerCase().includes('laptop')) {
+        else if (lowerQuery.includes('laptop')) {
             suggestions.push('notebook', 'computer', 'workstation', 'MacBook', 'ThinkPad');
         }
-        else if (query.toLowerCase().includes('software')) {
+        else if (lowerQuery.includes('software')) {
             suggestions.push('license', 'application', 'subscription', 'SaaS');
         }
+        else if (lowerQuery.includes('monitor') || lowerQuery.includes('display') ||
+            lowerQuery.includes('screen') || lowerQuery.includes('lcd')) {
+            suggestions.push('monitor', 'display', 'external monitor', 'desktop monitor', 'Dell monitor', 'HP monitor', 'Samsung monitor');
+        }
+        else if (lowerQuery.includes('desktop')) {
+            suggestions.push('desktop computer', 'workstation', 'PC', 'desktop PC', 'Dell desktop', 'HP desktop');
+        }
+        else if (lowerQuery.includes('hardware')) {
+            // For hardware searches, suggest specific item types
+            suggestions.push('monitor', 'keyboard', 'mouse', 'laptop', 'desktop', 'printer', 'scanner', 'docking station', 'headset');
+        }
         else {
-            // Generic suggestions
-            suggestions.push(query.split(' ')[0], // First word only
-            query.substring(0, Math.floor(query.length / 2)), // First half
-            'hardware', 'software', 'equipment', 'device');
+            // Generic suggestions based on the query
+            const words = query.split(' ');
+            if (words.length > 1) {
+                // Try individual words
+                suggestions.push(...words.filter(w => w.length > 3));
+                // Try first and last word
+                suggestions.push(words[0], words[words.length - 1]);
+            }
+            // Add generic category suggestions
+            suggestions.push('hardware', 'software', 'equipment', 'device', 'accessory');
         }
-        return [...new Set(suggestions)].filter(s => s && s !== query);
+        return [...new Set(suggestions)].filter(s => s && s !== query && s.length > 0);
+    }
+    shouldExcludeItem(query, itemName, itemDesc) {
+        const lowerQuery = query.toLowerCase();
+        // If searching for hardware/monitors/displays, exclude service/process items
+        if ((lowerQuery.includes('hardware') || lowerQuery.includes('monitor') ||
+            lowerQuery.includes('display') || lowerQuery.includes('screen') ||
+            lowerQuery.includes('desktop') || lowerQuery.includes('equipment')) &&
+            (itemName.includes('decommission') || itemName.includes('service') ||
+                itemName.includes('process') || itemName.includes('request') ||
+                itemName.includes('removal') || itemName.includes('decomm') ||
+                itemDesc.includes('decommission') || itemDesc.includes('service process'))) {
+            return true;
+        }
+        // If searching for specific hardware, exclude unrelated items
+        if (lowerQuery.includes('monitor') || lowerQuery.includes('display') || lowerQuery.includes('screen')) {
+            // Exclude items that are clearly not monitors
+            if ((itemName.includes('server') || itemName.includes('controller') ||
+                itemName.includes('software') || itemName.includes('license') ||
+                itemName.includes('training') || itemName.includes('support')) &&
+                !itemName.includes('monitor') && !itemName.includes('display') &&
+                !itemName.includes('screen')) {
+                return true;
+            }
+        }
+        // If searching for desktops, exclude non-desktop items
+        if (lowerQuery.includes('desktop')) {
+            if ((itemName.includes('mobile') || itemName.includes('phone') ||
+                itemName.includes('tablet') || itemName.includes('service')) &&
+                !itemName.includes('desktop')) {
+                return true;
+            }
+        }
+        return false;
     }
     async handleTestFlowWithMock(args) {
         const { flow_id, create_test_user = true, test_user_data, mock_catalog_items = true, mock_catalog_data, test_inputs = {}, simulate_approvals = true, cleanup_after_test = true } = args;