snow-flow 8.42.12 → 9.0.1

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

@@ -1,1269 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Reporting & Analytics MCP Server
- * Handles reports, dashboards, and analytics operations
- * NO HARDCODED VALUES - All reporting configurations discovered dynamically
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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 mcp_logger_js_1 = require("./shared/mcp-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({
-            name: 'servicenow-reporting-analytics',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowReportingAnalyticsMCP');
-        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_create_report',
-                    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: {
-                            name: { type: 'string', description: 'Report name' },
-                            table: { type: 'string', description: 'Source table' },
-                            description: { type: 'string', description: 'Report description' },
-                            conditions: { type: 'string', description: 'Report conditions/filters' },
-                            fields: { type: 'array', description: 'Fields to include in report' },
-                            groupBy: { type: 'array', description: 'Group by fields' },
-                            aggregations: { type: 'array', description: 'Aggregation functions' },
-                            sortBy: { type: 'string', description: 'Sort field' },
-                            sortOrder: { type: 'string', description: 'Sort order (asc/desc)' },
-                            schedule: { type: 'string', description: 'Report schedule' },
-                            format: { type: 'string', description: 'Output format (PDF, Excel, CSV)' }
-                        },
-                        required: ['name', 'table', 'fields']
-                    }
-                },
-                {
-                    name: 'snow_create_dashboard',
-                    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: {
-                            name: { type: 'string', description: 'Dashboard name' },
-                            description: { type: 'string', description: 'Dashboard description' },
-                            layout: { type: 'string', description: 'Dashboard layout (grid, tabs, accordion)' },
-                            widgets: { type: 'array', description: 'Dashboard widgets configuration' },
-                            permissions: { type: 'array', description: 'User/role permissions' },
-                            refreshInterval: { type: 'number', description: 'Auto-refresh interval in minutes' },
-                            public: { type: 'boolean', description: 'Public dashboard' }
-                        },
-                        required: ['name', 'widgets']
-                    }
-                },
-                {
-                    name: 'snow_create_kpi',
-                    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: {
-                            name: { type: 'string', description: 'KPI name' },
-                            description: { type: 'string', description: 'KPI description' },
-                            table: { type: 'string', description: 'Source table' },
-                            metric: { type: 'string', description: 'Metric to measure' },
-                            aggregation: { type: 'string', description: 'Aggregation function (count, sum, avg, max, min)' },
-                            conditions: { type: 'string', description: 'KPI conditions/filters' },
-                            target: { type: 'number', description: 'Target value' },
-                            threshold: { type: 'object', description: 'Threshold configuration' },
-                            unit: { type: 'string', description: 'Unit of measurement' },
-                            frequency: { type: 'string', description: 'Update frequency' }
-                        },
-                        required: ['name', 'table', 'metric', 'aggregation']
-                    }
-                },
-                {
-                    name: 'snow_create_data_visualization',
-                    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: {
-                            name: { type: 'string', description: 'Visualization name' },
-                            type: { type: 'string', description: 'Chart type (bar, line, pie, scatter, etc.)' },
-                            dataSource: { type: 'string', description: 'Data source (table or report)' },
-                            xAxis: { type: 'string', description: 'X-axis field' },
-                            yAxis: { type: 'string', description: 'Y-axis field' },
-                            series: { type: 'array', description: 'Data series configuration' },
-                            filters: { type: 'array', description: 'Chart filters' },
-                            colors: { type: 'array', description: 'Color palette' },
-                            interactive: { type: 'boolean', description: 'Interactive chart' }
-                        },
-                        required: ['name', 'type', 'dataSource']
-                    }
-                },
-                {
-                    name: 'snow_create_performance_analytics',
-                    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: {
-                            name: { type: 'string', description: 'Analytics name' },
-                            category: { type: 'string', description: 'Analytics category' },
-                            dataSource: { type: 'string', description: 'Data source table' },
-                            metrics: { type: 'array', description: 'Performance metrics to track' },
-                            dimensions: { type: 'array', description: 'Analysis dimensions' },
-                            timeframe: { type: 'string', description: 'Time period for _analysis' },
-                            benchmarks: { type: 'array', description: 'Performance benchmarks' },
-                            alerts: { type: 'array', description: 'Alert configurations' }
-                        },
-                        required: ['name', 'dataSource', 'metrics']
-                    }
-                },
-                {
-                    name: 'snow_create_scheduled_report',
-                    description: 'Creates scheduled reports with automated email delivery in multiple formats.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            reportName: { type: 'string', description: 'Source report name' },
-                            schedule: { type: 'string', description: 'Schedule frequency' },
-                            recipients: { type: 'array', description: 'Email recipients' },
-                            format: { type: 'string', description: 'Report format (PDF, Excel, CSV)' },
-                            conditions: { type: 'string', description: 'Additional conditions' },
-                            subject: { type: 'string', description: 'Email subject' },
-                            message: { type: 'string', description: 'Email message' }
-                        },
-                        required: ['reportName', 'schedule', 'recipients']
-                    }
-                },
-                {
-                    name: 'snow_discover_reporting_tables',
-                    description: 'Discovers tables available for reporting with filtering by category and data availability.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            category: { type: 'string', description: 'Table category filter' },
-                            hasData: { type: 'boolean', description: 'Only tables with data' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_discover_report_fields',
-                    description: 'Retrieves reportable fields from tables with type filtering and metadata.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            table: { type: 'string', description: 'Table name to analyze' },
-                            fieldType: { type: 'string', description: 'Filter by field type' }
-                        },
-                        required: ['table']
-                    }
-                },
-                {
-                    name: 'snow_analyze_data_quality',
-                    description: 'Analyzes data quality including completeness, consistency, and accuracy metrics.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            table: { type: 'string', description: 'Table to analyze' },
-                            fields: { type: 'array', description: 'Specific fields to analyze' },
-                            checkCompleteness: { type: 'boolean', description: 'Check data completeness' },
-                            checkConsistency: { type: 'boolean', description: 'Check data consistency' },
-                            checkAccuracy: { type: 'boolean', description: 'Check data accuracy' }
-                        },
-                        required: ['table']
-                    }
-                },
-                {
-                    name: 'snow_generate_insights',
-                    description: 'Generates analytical insights including trends, patterns, anomalies, and actionable recommendations.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            table: { type: 'string', description: 'Table to analyze' },
-                            analysisType: { type: 'string', description: 'Analysis type (trends, patterns, anomalies)' },
-                            timeframe: { type: 'string', description: 'Time period for _analysis' },
-                            generateRecommendations: { type: 'boolean', description: 'Generate recommendations' }
-                        },
-                        required: ['table']
-                    }
-                },
-                {
-                    name: 'snow_export_report_data',
-                    description: 'Exports report data to CSV, Excel, JSON, or XML formats with configurable row limits.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            reportName: { type: 'string', description: 'Report name to export' },
-                            format: { type: 'string', description: 'Export format (CSV, Excel, JSON, XML)' },
-                            includeHeaders: { type: 'boolean', description: 'Include column headers' },
-                            maxRows: { type: 'number', description: 'Maximum rows to export' }
-                        },
-                        required: ['reportName', 'format']
-                    }
-                }
-            ]
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            try {
-                const { name, arguments: args } = request.params;
-                // Start operation with token tracking
-                this.logger.operationStart(name, args);
-                const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-                if (!authResult.success) {
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, authResult.error || 'Authentication required');
-                }
-                let result;
-                switch (name) {
-                    case 'snow_create_report':
-                        result = await this.createReport(args);
-                        break;
-                    case 'snow_create_dashboard':
-                        result = await this.createDashboard(args);
-                        break;
-                    case 'snow_create_kpi':
-                        result = await this.createKPI(args);
-                        break;
-                    case 'snow_create_data_visualization':
-                        result = await this.createDataVisualization(args);
-                        break;
-                    case 'snow_create_performance_analytics':
-                        result = await this.createPerformanceAnalytics(args);
-                        break;
-                    case 'snow_create_scheduled_report':
-                        result = await this.createScheduledReport(args);
-                        break;
-                    case 'snow_discover_reporting_tables':
-                        result = await this.discoverReportingTables(args);
-                        break;
-                    case 'snow_discover_report_fields':
-                        result = await this.discoverReportFields(args);
-                        break;
-                    case 'snow_analyze_data_quality':
-                        result = await this.analyzeDataQuality(args);
-                        break;
-                    case 'snow_generate_insights':
-                        result = await this.generateInsights(args);
-                        break;
-                    case 'snow_export_report_data':
-                        result = await this.exportReportData(args);
-                        break;
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-                // Complete operation with token tracking
-                result = this.logger.addTokenUsageToResponse(result);
-                result = this.logger.addTokenUsageToResponse(result);
-                this.logger.operationComplete(name, result);
-                return result;
-            }
-            catch (error) {
-                this.logger.error(`Error in ${request.params.name}:`, error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Create Report with dynamic discovery
-     */
-    async createReport(args) {
-        try {
-            this.logger.info('Creating Report...');
-            // Validate table and discover fields
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            const availableFields = await this.getTableFields(args.table);
-            const aggregationFunctions = await this.getAggregationFunctions();
-            // Build field list string for ServiceNow
-            const fieldList = args.fields?.join(',') || availableFields.slice(0, 10).join(',') || 'sys_id,sys_created_on,sys_updated_on';
-            // Build proper aggregation configuration
-            const aggregateConfig = args.aggregations?.length > 0 ? {
-                aggregate: true,
-                aggregation_source: args.aggregations[0]?.field || '',
-                aggregate_type: args.aggregations[0]?.type || 'COUNT'
-            } : {
-                aggregate: false
-            };
-            const reportData = {
-                title: args.name,
-                table: tableInfo.name,
-                description: args.description || '',
-                filter: args.conditions || '',
-                field_list: fieldList,
-                group_by: args.groupBy?.join(',') || '',
-                order_by: args.sortBy || 'sys_created_on',
-                order_direction: args.sortOrder === 'desc' ? 'DESC' : 'ASC',
-                type: args.aggregations?.length > 0 ? 'bar' : 'list',
-                chart_type: args.aggregations?.length > 0 ? 'bar' : 'none',
-                is_scheduled: args.schedule ? true : false,
-                schedule_type: args.schedule || 'daily',
-                export_format: args.format?.toLowerCase() || 'pdf',
-                is_published: true,
-                roles: '',
-                active: true,
-                ...aggregateConfig
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            this.logger.trackAPICall('CREATE', 'sys_report', 1);
-            const response = await this.client.createRecord('sys_report', reportData);
-            if (!response.success) {
-                throw new Error(`Failed to create Report: ${response.error}`);
-            }
-            // Create a shareable link for the report
-            const reportUrl = `${process.env.SNOW_INSTANCE}/sys_report_template.do?jvar_report_id=${response.data.sys_id}`;
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Report created successfully!\n\n📊 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n📝 Fields: ${fieldList}\n${args.groupBy?.length ? `📊 Group By: ${args.groupBy.join(', ')}\n` : ''}${args.aggregations?.length ? `🔢 Aggregations: ${args.aggregations.map((a) => `${a.type}(${a.field})`).join(', ')}\n` : ''}${args.conditions ? `🔍 Filter: ${args.conditions}\n` : ''}📄 Format: ${args.format || 'PDF'}\n🔗 View Report: ${reportUrl}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Report is now available and data is accessible!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Report:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Report: ${error}`);
-        }
-    }
-    /**
-     * Create Dashboard with dynamic widget discovery
-     */
-    async createDashboard(args) {
-        try {
-            this.logger.info('Creating Dashboard...');
-            // Get available widget types and layouts
-            const widgetTypes = await this.getWidgetTypes();
-            const layouts = await this.getDashboardLayouts();
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try Performance Analytics dashboard first (pa_dashboards)
-            this.logger.trackAPICall('CREATE', 'pa_dashboards', 1);
-            let response = await this.client.createRecord('pa_dashboards', {
-                name: args.name,
-                title: args.name,
-                description: args.description || '',
-                tabs: JSON.stringify(args.widgets?.map((widget, index) => ({
-                    name: widget.name || `Tab ${index + 1}`,
-                    label: widget.label || widget.name || `Tab ${index + 1}`,
-                    visible_tabs: widget.visible !== false,
-                    order: index * 100
-                })) || []),
-                groups: JSON.stringify(args.permissions || []),
-                refresh_interval: args.refreshInterval || 15,
-                active: true,
-                is_scheduled: args.refreshInterval ? true : false,
-                visible_to: args.public ? 'everyone' : 'owner',
-                roles: args.permissions?.join(',') || ''
-            });
-            // Fallback to Service Portal page if PA dashboard fails
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('pa_dashboards failed, trying sys_portal_page...');
-                // Create Service Portal page with dashboard layout
-                response = await this.client.createRecord('sys_portal_page', {
-                    title: args.name,
-                    id: args.name.toLowerCase().replace(/[^a-z0-9]/g, '_'),
-                    short_description: args.description || '',
-                    portal: 'sp', // Default Service Portal
-                    layout: args.layout || 'standard',
-                    draft: false,
-                    public: args.public || false,
-                    roles: args.permissions?.join(',') || '',
-                    css: `/* Dashboard CSS */\n.dashboard-container { padding: 20px; }\n.widget-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }`,
-                    internal: false
-                });
-                // If portal page created, add widgets to it
-                if (response.success && args.widgets?.length > 0) {
-                    for (const widget of args.widgets) {
-                        await this.addWidgetToPortalPage(response.data.sys_id, widget);
-                    }
-                }
-            }
-            // Final fallback to create a dashboard report collection
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('sys_portal_page failed, creating dashboard as report collection...');
-                // Create a master report that acts as a dashboard
-                response = await this.client.createRecord('sys_report', {
-                    title: args.name,
-                    description: args.description || 'Dashboard collection',
-                    table: 'sys_report', // Self-referential for dashboard
-                    type: 'list',
-                    is_scheduled: false,
-                    is_published: args.public || false,
-                    roles: args.permissions?.join(',') || '',
-                    filter: `titleLIKE${args.name.replace(' ', '_')}_widget`,
-                    field_list: 'title,table,type',
-                    order_by: 'title',
-                    aggregate: false,
-                    chart_type: 'none',
-                    active: true
-                });
-                // Create individual widget reports
-                if (response.success && args.widgets?.length > 0) {
-                    for (const widget of args.widgets) {
-                        await this.createWidgetReport(args.name, widget);
-                    }
-                }
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Dashboard: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Dashboard created successfully!\n\n📊 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n🎨 Layout: ${args.layout || 'grid'}\n📱 Widgets: ${args.widgets?.length || 0} widgets configured\n🔄 Refresh: ${args.refreshInterval || 15} minutes\n${args.public ? '🌐 Public: Yes\n' : '🔒 Private dashboard\n'}👥 Permissions: ${args.permissions?.length || 0} configured\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Dashboard is now visible in your ServiceNow instance!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Dashboard:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Dashboard: ${error}`);
-        }
-    }
-    /**
-     * Create KPI with dynamic metric discovery
-     */
-    async createKPI(args) {
-        try {
-            this.logger.info('Creating KPI...');
-            // Validate table and discover metrics
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            const availableMetrics = await this.getAvailableMetrics(args.table);
-            const kpiData = {
-                name: args.name,
-                description: args.description || '',
-                table: tableInfo.name,
-                metric: args.metric,
-                aggregation: args.aggregation,
-                conditions: args.conditions || '',
-                target: args.target || 0,
-                threshold: JSON.stringify(args.threshold || {}),
-                unit: args.unit || '',
-                frequency: args.frequency || 'daily'
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try pa_indicators (Performance Analytics) for KPIs
-            this.logger.trackAPICall('CREATE', 'pa_indicators', 1);
-            let response = await this.client.createRecord('pa_indicators', {
-                name: args.name,
-                label: args.name,
-                description: args.description || '',
-                facts_table: tableInfo.name,
-                aggregate: args.aggregation,
-                field: args.metric,
-                conditions: args.conditions || '',
-                unit: args.unit || '',
-                direction: args.target ? 'minimize' : 'maximize',
-                frequency: args.frequency || 'daily',
-                active: true
-            });
-            // Fallback to metric_definition if pa_indicators fails
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('pa_indicators failed, trying metric_definition table...');
-                response = await this.client.createRecord('metric_definition', {
-                    name: args.name,
-                    description: args.description || '',
-                    table: tableInfo.name,
-                    field: args.metric,
-                    method: args.aggregation,
-                    condition: args.conditions || '',
-                    active: true
-                });
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create KPI: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ KPI created successfully!\n\n📈 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📋 Table: ${tableInfo.label} (${tableInfo.name})\n📊 Metric: ${args.metric} (${args.aggregation})\n🎯 Target: ${args.target || 'Not set'}${args.unit ? ` ${args.unit}` : ''}\n📅 Frequency: ${args.frequency || 'daily'}\n${args.conditions ? `🔍 Conditions: ${args.conditions}\n` : ''}\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic metric discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create KPI:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create KPI: ${error}`);
-        }
-    }
-    /**
-     * Create Data Visualization with dynamic chart discovery
-     */
-    async createDataVisualization(args) {
-        try {
-            this.logger.info('Creating Data Visualization...');
-            // Get available chart types and validate data source
-            const chartTypes = await this.getChartTypes();
-            const dataSourceInfo = await this.getDataSourceInfo(args.dataSource);
-            const visualizationData = {
-                name: args.name,
-                type: args.type,
-                data_source: args.dataSource,
-                x_axis: args.xAxis || '',
-                y_axis: args.yAxis || '',
-                series: JSON.stringify(args.series || []),
-                filters: JSON.stringify(args.filters || []),
-                colors: JSON.stringify(args.colors || []),
-                interactive: args.interactive !== false
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try sys_report_chart for visualizations
-            let response = await this.client.createRecord('sys_report_chart', {
-                name: args.name,
-                title: args.name,
-                type: args.type,
-                table: args.dataSource,
-                x_axis_field: args.xAxis || '',
-                y_axis_field: args.yAxis || '',
-                chart_type: args.type,
-                series_config: JSON.stringify(args.series || []),
-                filter: args.filters ? JSON.stringify(args.filters) : '',
-                color_palette: JSON.stringify(args.colors || []),
-                is_real_time: args.interactive !== false,
-                active: true
-            });
-            // Fallback to sys_report if chart table fails
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('sys_report_chart failed, trying sys_report table...');
-                response = await this.client.createRecord('sys_report', {
-                    title: args.name,
-                    description: `Chart: ${args.type}`,
-                    table: args.dataSource,
-                    type: 'chart',
-                    chart_type: args.type,
-                    field: args.yAxis || args.xAxis || '',
-                    filter: args.filters ? JSON.stringify(args.filters) : '',
-                    is_scheduled: false,
-                    active: true
-                });
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Data Visualization: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Data Visualization created successfully!\n\n📊 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📈 Type: ${args.type}\n📊 Data Source: ${args.dataSource}\n${args.xAxis ? `📏 X-Axis: ${args.xAxis}\n` : ''}${args.yAxis ? `📐 Y-Axis: ${args.yAxis}\n` : ''}🎨 Series: ${args.series?.length || 0} configured\n🔍 Filters: ${args.filters?.length || 0} applied\n${args.interactive !== false ? '🖱️ Interactive: Yes\n' : '📊 Static chart\n'}\n✨ Created with dynamic chart type discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Data Visualization:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Data Visualization: ${error}`);
-        }
-    }
-    /**
-     * Create Performance Analytics with dynamic metric discovery
-     */
-    async createPerformanceAnalytics(args) {
-        try {
-            this.logger.info('Creating Performance Analytics...');
-            // Validate data source and discover metrics
-            const dataSourceInfo = await this.getDataSourceInfo(args.dataSource);
-            const availableMetrics = await this.getPerformanceMetrics(args.dataSource);
-            const analyticsData = {
-                name: args.name,
-                category: args.category || 'general',
-                data_source: args.dataSource,
-                metrics: JSON.stringify(args.metrics || []),
-                dimensions: JSON.stringify(args.dimensions || []),
-                timeframe: args.timeframe || '30d',
-                benchmarks: JSON.stringify(args.benchmarks || []),
-                alerts: JSON.stringify(args.alerts || [])
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Try pa_cubes for performance analytics
-            let response = await this.client.createRecord('pa_cubes', {
-                name: args.name,
-                label: args.name,
-                description: args.category || 'Performance Analytics',
-                facts_table: args.dataSource,
-                aggregate: 'COUNT',
-                field: '*',
-                conditions: '',
-                active: true
-            });
-            // Fallback to pa_indicators if pa_cubes fails
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('pa_cubes failed, trying pa_indicators...');
-                response = await this.client.createRecord('pa_indicators', {
-                    name: args.name,
-                    label: args.name,
-                    description: args.category || 'Performance Analytics',
-                    facts_table: args.dataSource,
-                    aggregate: 'COUNT',
-                    field: '*',
-                    unit: 'integer',
-                    direction: 'maximize',
-                    frequency: args.timeframe || 'daily',
-                    active: true
-                });
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Performance Analytics: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Performance Analytics created successfully!\n\n📊 **${args.name}**\n🆔 sys_id: ${response.data.sys_id}\n📂 Category: ${args.category || 'general'}\n📊 Data Source: ${args.dataSource}\n📈 Metrics: ${args.metrics?.length || 0} configured\n📐 Dimensions: ${args.dimensions?.length || 0} configured\n📅 Timeframe: ${args.timeframe || '30d'}\n🎯 Benchmarks: ${args.benchmarks?.length || 0} configured\n🚨 Alerts: ${args.alerts?.length || 0} configured\n\n✨ Created with dynamic performance metric discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Performance Analytics:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Performance Analytics: ${error}`);
-        }
-    }
-    /**
-     * Create Scheduled Report with dynamic delivery discovery
-     */
-    async createScheduledReport(args) {
-        try {
-            this.logger.info('Creating Scheduled Report...');
-            // Find the source report
-            const sourceReport = await this.findReport(args.reportName);
-            if (!sourceReport) {
-                throw new Error(`Report not found: ${args.reportName}`);
-            }
-            const scheduledReportData = {
-                name: `Scheduled: ${args.reportName}`,
-                report: sourceReport.sys_id,
-                schedule: args.schedule,
-                recipients: JSON.stringify(args.recipients || []),
-                format: args.format || 'PDF',
-                conditions: args.conditions || '',
-                subject: args.subject || `Scheduled Report: ${args.reportName}`,
-                message: args.message || 'Please find the attached scheduled report.'
-            };
-            const updateSetResult = await this.client.ensureUpdateSet();
-            // Use sysauto_report for scheduled reports
-            let response = await this.client.createRecord('sysauto_report', {
-                name: `Scheduled: ${args.reportName}`,
-                report: sourceReport.sys_id,
-                run_as: 'user',
-                run_time: args.schedule,
-                email_to: args.recipients?.join(',') || '',
-                format: args.format?.toLowerCase() || 'pdf',
-                condition: args.conditions || '',
-                subject: args.subject || `Scheduled Report: ${args.reportName}`,
-                body: args.message || 'Please find the attached report.',
-                active: true
-            });
-            // Fallback to scheduled_report if sysauto_report fails
-            if (!response.success && response.error?.includes('400')) {
-                this.logger.warn('sysauto_report failed, trying scheduled_report...');
-                response = await this.client.createRecord('scheduled_report', {
-                    name: `Scheduled: ${args.reportName}`,
-                    report: sourceReport.sys_id,
-                    schedule_type: 'daily',
-                    email_list: args.recipients?.join(';') || '',
-                    export_format: args.format?.toLowerCase() || 'pdf',
-                    active: true
-                });
-            }
-            if (!response.success) {
-                throw new Error(`Failed to create Scheduled Report: ${response.error}`);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Scheduled Report created successfully!\n\n📧 **Scheduled: ${args.reportName}**\n🆔 sys_id: ${response.data.sys_id}\n📊 Source Report: ${sourceReport.name}\n📅 Schedule: ${args.schedule}\n📄 Format: ${args.format || 'PDF'}\n📧 Recipients: ${args.recipients?.length || 0} configured\n📝 Subject: ${args.subject || `Scheduled Report: ${args.reportName}`}\n\n✨ Created with dynamic report discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to create Scheduled Report:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create Scheduled Report: ${error}`);
-        }
-    }
-    /**
-     * Discover reporting tables
-     */
-    async discoverReportingTables(args) {
-        try {
-            this.logger.info('Discovering reporting tables...');
-            let query = '';
-            if (args?.category) {
-                query = `sys_class_name=${args.category}`;
-            }
-            this.logger.trackAPICall('SEARCH', 'sys_db_object', 100);
-            const tables = await this.client.searchRecords('sys_db_object', query, 100);
-            if (!tables.success) {
-                throw new Error('Failed to discover reporting tables');
-            }
-            // Categorize tables by type
-            const categories = [
-                { name: 'ITSM', tables: [] },
-                { name: 'ITOM', tables: [] },
-                { name: 'HR', tables: [] },
-                { name: 'Security', tables: [] },
-                { name: 'Custom', tables: [] },
-                { name: 'System', tables: [] }
-            ];
-            tables.data.result.forEach((table) => {
-                const category = this.categorizeTable(table.name);
-                const categoryObj = categories.find(c => c.name === category);
-                if (categoryObj) {
-                    categoryObj.tables.push(table);
-                }
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📊 Discovered Reporting Tables:\n\n${categories.filter(cat => cat.tables.length > 0).map(category => `**${category.name} Tables:**\n${category.tables.slice(0, 10).map((table) => `- ${table.label || table.name} (${table.name})\n  ${table.super_class ? `Extends: ${table.super_class}` : 'Base table'}`).join('\n')}${category.tables.length > 10 ? `\n  ... and ${category.tables.length - 10} more` : ''}`).join('\n\n')}\n\n✨ Total tables: ${tables.data.result.length}\n🔍 All tables discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover reporting tables:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover reporting tables: ${error}`);
-        }
-    }
-    /**
-     * Discover report fields
-     */
-    async discoverReportFields(args) {
-        try {
-            this.logger.info(`Discovering report fields for table: ${args.table}`);
-            // Get table info
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            // Get fields
-            let query = `nameSTARTSWITH${args.table}^element!=NULL`;
-            if (args.fieldType) {
-                query += `^internal_type=${args.fieldType}`;
-            }
-            this.logger.trackAPICall('SEARCH', 'sys_dictionary', 100);
-            const fields = await this.client.searchRecords('sys_dictionary', query, 100);
-            if (!fields.success) {
-                throw new Error('Failed to discover report fields');
-            }
-            // Categorize fields by type
-            const fieldTypes = fields.data.result.reduce((acc, field) => {
-                const type = field.internal_type || 'unknown';
-                if (!acc[type])
-                    acc[type] = [];
-                acc[type].push(field);
-                return acc;
-            }, {});
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📊 Report Fields for **${tableInfo.label}** (${tableInfo.name}):\n\n${Object.entries(fieldTypes).map(([type, typeFields]) => `**${type.toUpperCase()} Fields:**\n${typeFields.slice(0, 10).map((field) => `- ${field.column_label || field.element} (${field.element})\n  ${field.comments || 'No description'}`).join('\n')}${typeFields.length > 10 ? `\n  ... and ${typeFields.length - 10} more` : ''}`).join('\n\n')}\n\n✨ Total fields: ${fields.data.result.length}\n🔍 All fields discovered dynamically!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover report fields:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover report fields: ${error}`);
-        }
-    }
-    /**
-     * Analyze data quality
-     */
-    async analyzeDataQuality(args) {
-        try {
-            this.logger.info(`Analyzing data quality for table: ${args.table}`);
-            // Get table info
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            // Get REAL data for analysis (increased from sample to comprehensive dataset)
-            this.logger.trackAPICall('SEARCH', args.table, 1000);
-            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,
-                totalRecords: sampleData.data.result.length,
-                completeness: this.analyzeCompleteness(sampleData.data.result, args.fields),
-                consistency: this.analyzeConsistency(sampleData.data.result, args.fields),
-                accuracy: this.analyzeAccuracy(sampleData.data.result, args.fields),
-                issues: []
-            };
-            // Generate quality score
-            const qualityScore = (_analysis.completeness.score + _analysis.consistency.score + _analysis.accuracy.score) / 3;
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📊 Data Quality Analysis for **${tableInfo.label}** (${tableInfo.name}):\n\n📈 **Overall Quality Score: ${qualityScore.toFixed(1)}%**\n\n📋 **Sample Size:** ${_analysis.totalRecords} records\n\n🔍 **Quality Metrics:**\n${args.checkCompleteness !== false ? `- **Completeness**: ${_analysis.completeness.score.toFixed(1)}% (${_analysis.completeness.complete}/${_analysis.completeness.total} fields complete)\n` : ''}${args.checkConsistency !== false ? `- **Consistency**: ${_analysis.consistency.score.toFixed(1)}% (${_analysis.consistency.consistent}/${_analysis.consistency.total} fields consistent)\n` : ''}${args.checkAccuracy !== false ? `- **Accuracy**: ${_analysis.accuracy.score.toFixed(1)}% (${_analysis.accuracy.accurate}/${_analysis.accuracy.total} fields accurate)\n` : ''}\n${_analysis.issues.length > 0 ? `\n🚨 **Issues Found:**\n${_analysis.issues.map(issue => `- ${issue.type}: ${issue.description}`).join('\n')}\n` : ''}\n✨ Analysis completed with dynamic field discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to analyze data quality:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to analyze data quality: ${error}`);
-        }
-    }
-    /**
-     * Generate insights
-     */
-    async generateInsights(args) {
-        try {
-            this.logger.info(`Generating insights for table: ${args.table}`);
-            // Get table info and data
-            const tableInfo = await this.getTableInfo(args.table);
-            if (!tableInfo) {
-                throw new Error(`Table not found: ${args.table}`);
-            }
-            const data = await this.client.searchRecords(args.table, '', 200);
-            if (!data.success) {
-                throw new Error('Failed to retrieve data for _analysis');
-            }
-            // Generate insights based on _analysis type
-            const insights = {
-                table: args.table,
-                analysisType: args.analysisType || 'patterns',
-                timeframe: args.timeframe || '30d',
-                insights: [],
-                recommendations: []
-            };
-            // Analyze patterns
-            if (args.analysisType === 'patterns' || !args.analysisType) {
-                insights.insights.push(...this.analyzePatterns(data.data.result));
-            }
-            // Analyze trends
-            if (args.analysisType === 'trends' || !args.analysisType) {
-                insights.insights.push(...this.analyzeTrends(data.data.result));
-            }
-            // Detect anomalies
-            if (args.analysisType === 'anomalies' || !args.analysisType) {
-                insights.insights.push(...this.detectAnomalies(data.data.result));
-            }
-            // Generate recommendations
-            if (args.generateRecommendations) {
-                insights.recommendations = this.generateRecommendations(insights.insights);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Data Insights for **${tableInfo.label}** (${tableInfo.name}):\n\n📊 **Analysis Type:** ${insights.analysisType}\n📅 **Timeframe:** ${insights.timeframe}\n📈 **Sample Size:** ${data.data.result.length} records\n\n💡 **Key Insights:**\n${insights.insights.map(insight => `- **${insight.type}**: ${insight.description}`).join('\n')}\n\n${insights.recommendations.length > 0 ? `🎯 **Recommendations:**\n${insights.recommendations.map(rec => `- ${rec}`).join('\n')}\n\n` : ''}\n✨ Insights generated with dynamic data _analysis!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to generate insights:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to generate insights: ${error}`);
-        }
-    }
-    /**
-     * Export report data
-     */
-    async exportReportData(args) {
-        try {
-            this.logger.info(`Exporting report data: ${args.reportName}`);
-            // Find the report
-            const report = await this.findReport(args.reportName);
-            if (!report) {
-                throw new Error(`Report not found: ${args.reportName}`);
-            }
-            // Get report data
-            const reportData = await this.getReportData(report, args.maxRows);
-            // Format export
-            const exportInfo = {
-                reportName: args.reportName,
-                format: args.format,
-                records: reportData.length,
-                size: this.calculateExportSize(reportData, args.format),
-                timestamp: new Date().toISOString()
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: `📤 Report Data Export Completed!\n\n📊 **Report:** ${args.reportName}\n📄 **Format:** ${args.format}\n📈 **Records:** ${exportInfo.records}\n📦 **Size:** ${exportInfo.size}\n📅 **Exported:** ${new Date().toLocaleString()}\n${args.includeHeaders ? '📋 Headers included\n' : ''}${args.maxRows ? `🔢 Limited to ${args.maxRows} rows\n` : ''}\n✨ Export completed with dynamic report discovery!`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to export report data:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to export report data: ${error}`);
-        }
-    }
-    // Helper methods
-    async getTableInfo(tableName) {
-        try {
-            const tableResponse = await this.client.searchRecords('sys_db_object', `name=${tableName}`, 1);
-            if (tableResponse.success && tableResponse.data?.result?.length > 0) {
-                const table = tableResponse.data.result[0];
-                return { name: table.name, label: table.label };
-            }
-            return null;
-        }
-        catch (error) {
-            this.logger.error(`Failed to get table info for ${tableName}:`, error);
-            return null;
-        }
-    }
-    async getTableFields(tableName) {
-        try {
-            const fieldsResponse = await this.client.searchRecords('sys_dictionary', `nameSTARTSWITH${tableName}^element!=NULL`, 100);
-            if (fieldsResponse.success) {
-                return fieldsResponse.data.result.map((field) => field.element);
-            }
-            return [];
-        }
-        catch (error) {
-            this.logger.error(`Failed to get fields for ${tableName}:`, error);
-            return [];
-        }
-    }
-    async getAggregationFunctions() {
-        return ['COUNT', 'SUM', 'AVG', 'MAX', 'MIN', 'DISTINCT'];
-    }
-    async getWidgetTypes() {
-        return ['chart', 'table', 'list', 'gauge', 'scorecard', 'map', 'calendar'];
-    }
-    async getDashboardLayouts() {
-        return ['grid', 'tabs', 'accordion', 'stacked', 'fluid'];
-    }
-    async getAvailableMetrics(tableName) {
-        const fields = await this.getTableFields(tableName);
-        return fields.filter(field => ['number', 'integer', 'decimal', 'float'].includes(field));
-    }
-    async getChartTypes() {
-        return ['bar', 'line', 'pie', 'donut', 'area', 'scatter', 'bubble', 'radar', 'funnel'];
-    }
-    async getDataSourceInfo(dataSource) {
-        // Could be a table or a report
-        const tableInfo = await this.getTableInfo(dataSource);
-        if (tableInfo)
-            return tableInfo;
-        const reportInfo = await this.findReport(dataSource);
-        return reportInfo;
-    }
-    async getPerformanceMetrics(dataSource) {
-        return ['response_time', 'throughput', 'error_rate', 'availability', 'utilization'];
-    }
-    async findReport(reportName) {
-        try {
-            const reportResponse = await this.client.searchRecords('sys_report', `name=${reportName}`, 1);
-            if (reportResponse.success && reportResponse.data?.result?.length > 0) {
-                return reportResponse.data.result[0];
-            }
-            return null;
-        }
-        catch (error) {
-            this.logger.error(`Failed to find report ${reportName}:`, error);
-            return null;
-        }
-    }
-    categorizeTable(tableName) {
-        if (tableName.includes('incident') || tableName.includes('problem') || tableName.includes('change') || tableName.includes('task')) {
-            return 'ITSM';
-        }
-        else if (tableName.includes('cmdb') || tableName.includes('alm') || tableName.includes('discovery')) {
-            return 'ITOM';
-        }
-        else if (tableName.includes('hr_') || tableName.includes('employee')) {
-            return 'HR';
-        }
-        else if (tableName.includes('security') || tableName.includes('vulnerability') || tableName.includes('risk')) {
-            return 'Security';
-        }
-        else if (tableName.startsWith('u_') || tableName.startsWith('x_')) {
-            return 'Custom';
-        }
-        else {
-            return 'System';
-        }
-    }
-    analyzeCompleteness(data, fields) {
-        const fieldsToCheck = fields || Object.keys(data[0] || {});
-        const total = fieldsToCheck.length;
-        let complete = 0;
-        fieldsToCheck.forEach(field => {
-            const filledCount = data.filter(record => record[field] && record[field] !== '').length;
-            if (filledCount / data.length > 0.8)
-                complete++;
-        });
-        return { score: (complete / total) * 100, complete, total };
-    }
-    analyzeConsistency(data, fields) {
-        const fieldsToCheck = fields || Object.keys(data[0] || {});
-        const total = fieldsToCheck.length;
-        let consistent = 0;
-        fieldsToCheck.forEach(field => {
-            const values = data.map(record => record[field]).filter(v => v);
-            const uniqueValues = new Set(values);
-            // Simple consistency check - not too many unique values for categorical fields
-            if (uniqueValues.size < values.length * 0.5)
-                consistent++;
-        });
-        return { score: (consistent / total) * 100, consistent, total };
-    }
-    analyzeAccuracy(data, fields) {
-        // REAL accuracy check based on actual data patterns - NO ASSUMPTIONS!
-        const fieldsToCheck = fields || Object.keys(data[0] || {});
-        const total = fieldsToCheck.length;
-        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 = [];
-        // Simple pattern analysis
-        if (data.length > 0) {
-            const fields = Object.keys(data[0]);
-            const categoricalFields = fields.filter(field => {
-                const values = data.map(record => record[field]).filter(v => v);
-                const uniqueValues = new Set(values);
-                return uniqueValues.size < values.length * 0.2;
-            });
-            if (categoricalFields.length > 0) {
-                patterns.push({
-                    type: 'Distribution Pattern',
-                    description: `Found ${categoricalFields.length} categorical fields with consistent value distributions`
-                });
-            }
-        }
-        return patterns;
-    }
-    analyzeTrends(data) {
-        const trends = [];
-        // Simple trend analysis
-        if (data.length > 10) {
-            trends.push({
-                type: 'Volume Trend',
-                description: `Dataset contains ${data.length} records indicating active data collection`
-            });
-        }
-        return trends;
-    }
-    detectAnomalies(data) {
-        const anomalies = [];
-        // Simple anomaly detection
-        if (data.length > 0) {
-            const fields = Object.keys(data[0]);
-            const numericFields = fields.filter(field => {
-                const values = data.map(record => record[field]).filter(v => v && !isNaN(v));
-                return values.length > 0;
-            });
-            if (numericFields.length > 0) {
-                anomalies.push({
-                    type: 'Data Anomaly',
-                    description: `Found ${numericFields.length} numeric fields suitable for anomaly detection`
-                });
-            }
-        }
-        return anomalies;
-    }
-    generateRecommendations(insights) {
-        const recommendations = [];
-        if (insights.length > 0) {
-            recommendations.push('Consider creating automated dashboards for key metrics');
-            recommendations.push('Implement data quality monitoring for critical fields');
-            recommendations.push('Set up alerts for anomalous data patterns');
-        }
-        return recommendations;
-    }
-    async getReportData(report, maxRows) {
-        // Simulate getting report data
-        const limit = maxRows || 100000; // Remove artificial 1k limit
-        const data = await this.client.searchRecords(report.table, report.conditions || '', limit);
-        return data.success ? data.data.result : [];
-    }
-    calculateExportSize(data, format) {
-        const recordSize = JSON.stringify(data[0] || {}).length;
-        const totalSize = recordSize * data.length;
-        if (totalSize < 1024)
-            return `${totalSize} bytes`;
-        if (totalSize < 1024 * 1024)
-            return `${(totalSize / 1024).toFixed(1)} KB`;
-        return `${(totalSize / (1024 * 1024)).toFixed(1)} MB`;
-    }
-    /**
-     * Add widget to Service Portal page
-     */
-    async addWidgetToPortalPage(pageId, widget) {
-        try {
-            await this.client.createRecord('sp_widget_instance', {
-                sp_page: pageId,
-                sp_widget: widget.widgetId || widget.id,
-                title: widget.name || widget.title,
-                order: widget.order || 0,
-                bootstrap_alt: widget.size || 'col-md-6',
-                class_name: widget.className || '',
-                active: true
-            });
-        }
-        catch (error) {
-            this.logger.error(`Failed to add widget to portal page: ${error}`);
-        }
-    }
-    /**
-     * Create widget report for dashboard
-     */
-    async createWidgetReport(dashboardName, widget) {
-        try {
-            await this.client.createRecord('sys_report', {
-                title: `${dashboardName}_widget_${widget.name}`.replace(/[^a-zA-Z0-9_]/g, '_'),
-                table: widget.table || 'incident',
-                type: widget.type || 'list',
-                filter: widget.filter || '',
-                field_list: widget.fields?.join(',') || 'number,short_description,state',
-                is_published: true,
-                roles: '',
-                active: true
-            });
-        }
-        catch (error) {
-            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);
-        this.logger.info('ServiceNow Reporting & Analytics MCP Server running on stdio');
-    }
-}
-const server = new ServiceNowReportingAnalyticsMCP();
-server.run().catch(console.error);
-//# sourceMappingURL=servicenow-reporting-analytics-mcp.js.map