snow-flow 3.0.10 → 3.0.14

package/dist/mcp/servicenow-reporting-analytics-mcp.js

@@ -13,6 +13,7 @@ const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const mcp_auth_middleware_js_1 = require("../utils/mcp-auth-middleware.js");
 const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
 const logger_js_1 = require("../utils/logger.js");
+const anti_mock_data_validator_js_1 = require("../utils/anti-mock-data-validator.js");
 class ServiceNowReportingAnalyticsMCP {
     constructor() {
         this.server = new index_js_1.Server({
@@ -33,7 +34,7 @@ class ServiceNowReportingAnalyticsMCP {
             tools: [
                 {
                     name: 'snow_create_report',
-                    description: 'Creates reports with filtering, grouping, and aggregation capabilities. Supports multiple output formats and scheduling.',
+                    description: '🔥 REAL DATA ONLY: Creates reports with filtering, grouping, and aggregation using LIVE ServiceNow data. NO mock/demo data used. All data pulled directly from your ServiceNow instance tables.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -54,7 +55,7 @@ class ServiceNowReportingAnalyticsMCP {
                 },
                 {
                     name: 'snow_create_dashboard',
-                    description: 'Creates interactive dashboards with configurable widgets, layouts, and refresh intervals.',
+                    description: '🔥 REAL DATA ONLY: Creates interactive dashboards using LIVE ServiceNow data. All widgets populated with actual data from your instance. NO mock/demo data used.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -71,7 +72,7 @@ class ServiceNowReportingAnalyticsMCP {
                 },
                 {
                     name: 'snow_create_kpi',
-                    description: 'Creates Key Performance Indicators with targets, thresholds, and automated tracking.',
+                    description: '🔥 REAL DATA ONLY: Creates KPIs calculated from LIVE ServiceNow data. All metrics based on actual records in your instance. NO mock/demo data used.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -91,7 +92,7 @@ class ServiceNowReportingAnalyticsMCP {
                 },
                 {
                     name: 'snow_create_data_visualization',
-                    description: 'Creates data visualizations including charts, graphs, and interactive displays.',
+                    description: '🔥 REAL DATA ONLY: Creates charts and visualizations using LIVE ServiceNow data. All graphs populated with actual data from your instance tables. NO mock/demo data used.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -110,7 +111,7 @@ class ServiceNowReportingAnalyticsMCP {
                 },
                 {
                     name: 'snow_create_performance_analytics',
-                    description: 'Creates performance analytics configurations for tracking metrics, dimensions, and benchmarks.',
+                    description: '🔥 REAL DATA ONLY: Creates performance analytics using LIVE ServiceNow data. All metrics calculated from actual records in your instance. NO mock/demo data used.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -754,11 +755,14 @@ class ServiceNowReportingAnalyticsMCP {
             if (!tableInfo) {
                 throw new Error(`Table not found: ${args.table}`);
             }
-            // Get sample data for analysis
-            const sampleData = await this.client.searchRecords(args.table, '', 100);
+            // Get REAL data for analysis (increased from sample to comprehensive dataset)
+            const sampleData = await this.client.searchRecords(args.table, '', 1000); // Get up to 1000 records for REAL analysis
             if (!sampleData.success) {
                 throw new Error('Failed to retrieve sample data');
             }
+            // 🔥 ENFORCE ZERO MOCK DATA TOLERANCE - Validate all data is real ServiceNow data
+            (0, anti_mock_data_validator_js_1.validateRealData)(sampleData.data.result, `Data Quality Analysis for ${args.table}`);
+            this.logger.info(`✅ Anti-mock validation passed: ${sampleData.data.result.length} real ServiceNow records confirmed`);
             // Analyze data quality
             const _analysis = {
                 table: args.table,
@@ -979,11 +983,62 @@ class ServiceNowReportingAnalyticsMCP {
         return { score: (consistent / total) * 100, consistent, total };
     }
     analyzeAccuracy(data, fields) {
-        // Simple accuracy check - assume most data is accurate
+        // REAL accuracy check based on actual data patterns - NO ASSUMPTIONS!
         const fieldsToCheck = fields || Object.keys(data[0] || {});
         const total = fieldsToCheck.length;
-        const accurate = Math.floor(total * 0.85); // Assume 85% accuracy
-        return { score: (accurate / total) * 100, accurate, total };
+        let accurate = 0;
+        fieldsToCheck.forEach(field => {
+            const values = data.map(record => record[field]).filter(v => v !== null && v !== undefined && v !== '');
+            if (values.length === 0) {
+                return; // Skip empty fields
+            }
+            // Real accuracy checks based on field patterns
+            let fieldAccurate = true;
+            // Check for common accuracy issues
+            if (field.includes('email')) {
+                // Email validation
+                const validEmails = values.filter(email => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(email)));
+                fieldAccurate = validEmails.length / values.length > 0.8;
+            }
+            else if (field.includes('phone') || field.includes('number')) {
+                // Phone/number validation
+                const validNumbers = values.filter(num => /^[\d\s\+\-\(\)]+$/.test(String(num)));
+                fieldAccurate = validNumbers.length / values.length > 0.8;
+            }
+            else if (field.includes('date') || field.includes('time')) {
+                // Date validation
+                const validDates = values.filter(date => !isNaN(Date.parse(String(date))));
+                fieldAccurate = validDates.length / values.length > 0.9;
+            }
+            else if (field === 'state' || field === 'status') {
+                // State/status should have consistent values
+                const uniqueValues = new Set(values.map(v => String(v).toLowerCase()));
+                fieldAccurate = uniqueValues.size <= Math.max(3, values.length * 0.1); // Max 10% unique values for state fields
+            }
+            else {
+                // General data consistency check - detect test/demo/mock data
+                const suspiciousValues = values.filter(v => {
+                    const str = String(v).toLowerCase();
+                    return str.includes('test') ||
+                        str.includes('demo') ||
+                        str.includes('sample') ||
+                        str.includes('mock') ||
+                        str.includes('fake') ||
+                        str === 'n/a' ||
+                        str === 'tbd' ||
+                        str === 'placeholder';
+                });
+                fieldAccurate = suspiciousValues.length / values.length < 0.05; // Less than 5% suspicious values
+            }
+            if (fieldAccurate)
+                accurate++;
+        });
+        return {
+            score: total > 0 ? (accurate / total) * 100 : 0,
+            accurate,
+            total,
+            details: `Real accuracy analysis of ${data.length} actual ServiceNow records - NO assumptions or mock data`
+        };
     }
     analyzePatterns(data) {
         const patterns = [];
@@ -1096,6 +1151,88 @@ class ServiceNowReportingAnalyticsMCP {
             this.logger.error(`Failed to create widget report: ${error}`);
         }
     }
+    /**
+     * Sanitize table name input
+     */
+    sanitizeTableName(tableName) {
+        if (!tableName || typeof tableName !== 'string') {
+            return '';
+        }
+        // Convert common invalid formats to valid table names
+        let cleaned = tableName.toLowerCase().trim();
+        // Map common user inputs to actual table names
+        const tableMapping = {
+            'itsm overview metrics': 'incident',
+            'itsm trend analysis': 'incident',
+            'change request pipeline': 'change_request',
+            'incident overview': 'incident',
+            'change overview': 'change_request',
+            'problem overview': 'problem',
+            'user overview': 'sys_user',
+            'task overview': 'task',
+            'service request': 'sc_request',
+            'catalog request': 'sc_req_item',
+            'knowledge': 'kb_knowledge',
+            'configuration item': 'cmdb_ci',
+            'asset': 'alm_asset'
+        };
+        // Check for direct mapping
+        if (tableMapping[cleaned]) {
+            return tableMapping[cleaned];
+        }
+        // Remove spaces and special characters, convert to underscores
+        cleaned = cleaned.replace(/[\s-]+/g, '_').replace(/[^a-z0-9_]/g, '');
+        // Validate format (should be lowercase with underscores)
+        if (!/^[a-z][a-z0-9_]*$/.test(cleaned)) {
+            return '';
+        }
+        return cleaned;
+    }
+    /**
+     * Suggest similar table names
+     */
+    async suggestSimilarTables(inputTable) {
+        try {
+            const searchTerm = inputTable.toLowerCase().replace(/[^a-zA-Z]/g, '%');
+            const response = await this.client.searchRecords('sys_db_object', `labelLIKE${searchTerm}`, 5);
+            if (response.success && response.data?.result) {
+                return response.data.result.map((table) => ({
+                    name: table.name,
+                    label: table.label || table.name
+                }));
+            }
+            return [];
+        }
+        catch (error) {
+            this.logger.error('Failed to suggest similar tables:', error);
+            return [];
+        }
+    }
+    /**
+     * Check dashboard creation permissions
+     */
+    async checkDashboardPermissions() {
+        try {
+            // Test with a simple query to pa_dashboards to check read access
+            const testQuery = await this.client.searchRecords('pa_dashboards', '', 1);
+            const requiredRoles = ['pa_admin', 'pa_power_user', 'admin'];
+            if (testQuery.success) {
+                return { canCreate: true, requiredRoles };
+            }
+            // If we get a specific 403, it's a permission issue
+            if (testQuery.error?.includes('403') || testQuery.error?.includes('Access Denied')) {
+                return { canCreate: false, requiredRoles };
+            }
+            // For other errors, assume permission issue
+            return { canCreate: false, requiredRoles };
+        }
+        catch (error) {
+            return {
+                canCreate: false,
+                requiredRoles: ['pa_admin', 'pa_power_user', 'admin']
+            };
+        }
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/dist/services/widget-deployment-service.d.ts

@@ -55,7 +55,8 @@ export declare class WidgetDeploymentService {
      */
     private updateWidget;
     /**
-     * Verify widget deployment
+     * Verify widget deployment with retry logic for eventual consistency
+     * ServiceNow has database replication lag of 1-3 seconds
      */
     private verifyDeployment;
     /**

package/dist/services/widget-deployment-service.js

@@ -9,6 +9,7 @@ exports.widgetDeployment = exports.WidgetDeploymentService = void 0;
 const servicenow_client_js_1 = require("../utils/servicenow-client.js");
 const logger_js_1 = require("../utils/logger.js");
 const unified_auth_store_js_1 = require("../utils/unified-auth-store.js");
+const servicenow_eventual_consistency_js_1 = require("../utils/servicenow-eventual-consistency.js");
 class WidgetDeploymentService {
     constructor() {
         this.client = null;
@@ -68,8 +69,13 @@ class WidgetDeploymentService {
                 const result = await this.createWidget(client, widgetData);
                 sys_id = result.sys_id;
             }
-            // Verify deployment
+            // Verify deployment with eventual consistency handling
             const verified = await this.verifyDeployment(client, sys_id);
+            // Log verification result with context
+            if (!verified) {
+                this.logger.warn(`⚠️  Verification returned false - this may be a ServiceNow timing issue`);
+                this.logger.info(`🔗 Direct verification link: https://${client.instance || 'instance'}.service-now.com/sp_widget.do?sys_id=${sys_id}`);
+            }
             // Get widget details for response
             const widgetDetails = await this.getWidgetDetails(client, sys_id);
             return {
@@ -78,8 +84,8 @@ class WidgetDeploymentService {
                 portalUrl: this.buildPortalUrl(client, sys_id),
                 apiEndpoint: this.buildApiEndpoint(client, sys_id),
                 message: isUpdate
-                    ? `Widget '${config.name}' updated successfully`
-                    : `Widget '${config.name}' created successfully`,
+                    ? `Widget '${config.name}' updated successfully${!verified ? ' (verification pending - check ServiceNow directly)' : ''}`
+                    : `Widget '${config.name}' created successfully${!verified ? ' (verification pending - check ServiceNow directly)' : ''}`,
                 verificationStatus: verified ? 'verified' : 'unverified'
             };
         }
@@ -150,22 +156,17 @@ class WidgetDeploymentService {
         await client.updateRecord('sp_widget', sys_id, widgetData);
     }
     /**
-     * Verify widget deployment
+     * Verify widget deployment with retry logic for eventual consistency
+     * ServiceNow has database replication lag of 1-3 seconds
      */
     async verifyDeployment(client, sys_id) {
-        try {
-            const response = await client.getRecord('sp_widget', sys_id);
-            if (response && response.sys_id === sys_id) {
-                this.logger.info(`✅ Widget deployment verified: ${sys_id}`);
-                return true;
-            }
-            this.logger.warn('Widget verification failed - sys_id mismatch');
-            return false;
-        }
-        catch (error) {
-            this.logger.error('Widget verification failed:', error);
-            return false;
+        const result = await servicenow_eventual_consistency_js_1.widgetConsistency.verifyRecordExists(client, 'sp_widget', sys_id, servicenow_eventual_consistency_js_1.CONSISTENCY_CONFIGS.WIDGET);
+        if (!result.success && result.isLikelyTimingIssue) {
+            this.logger.warn(`⚠️  Widget verification failed after ${result.attempts} attempts`);
+            this.logger.warn(`⚠️  This appears to be a ServiceNow timing issue, not a deployment failure`);
+            this.logger.info(`🔗 Check directly: https://${client.instance}/sp_widget.do?sys_id=${sys_id}`);
         }
+        return result.success;
     }
     /**
      * Get widget details

package/dist/utils/anti-mock-data-validator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Anti-Mock Data Validator
+ *
+ * This utility ensures NO mock, demo, sample, or fake data is ever used in any MCP tools.
+ * All data must come from real ServiceNow instances.
+ */
+interface ValidationResult {
+    isValid: boolean;
+    violations: string[];
+    suspiciousFields: string[];
+    suspiciousValues: any[];
+}
+interface DataIntegrityCheck {
+    hasRealData: boolean;
+    dataQualityScore: number;
+    mockDataDetected: boolean;
+    details: string[];
+}
+export declare class AntiMockDataValidator {
+    private logger;
+    private readonly MOCK_DATA_PATTERNS;
+    private readonly SUSPICIOUS_NUMERIC_PATTERNS;
+    constructor();
+    /**
+     * Validate that dataset contains only real ServiceNow data
+     */
+    validateDataset(data: any[], source?: string): ValidationResult;
+    /**
+     * Validate individual field value
+     */
+    private validateFieldValue;
+    /**
+     * Validate patterns across the entire dataset
+     */
+    private validateDatasetPatterns;
+    /**
+     * Count sequential sys_id patterns
+     */
+    private countSequentialIds;
+    /**
+     * Check if two sys_ids are sequential
+     */
+    private areIdsSequential;
+    /**
+     * Count records created at exactly the same time
+     */
+    private countSimultaneousCreations;
+    /**
+     * Perform comprehensive data integrity check
+     */
+    performDataIntegrityCheck(data: any[], source?: string): DataIntegrityCheck;
+    /**
+     * Enforce zero tolerance policy for mock data
+     */
+    enforceZeroTolerancePolicy(data: any[], source?: string): void;
+    /**
+     * Generate validation report
+     */
+    generateValidationReport(data: any[], source?: string): string;
+}
+export declare const antiMockValidator: AntiMockDataValidator;
+export declare const validateRealData: (data: any[], source?: string) => void;
+export declare const checkDataIntegrity: (data: any[], source?: string) => DataIntegrityCheck;
+export declare const generateDataReport: (data: any[], source?: string) => string;
+export {};
+//# sourceMappingURL=anti-mock-data-validator.d.ts.map