snow-flow 2.0.2 → 2.0.4

package/src/mcp/servicenow-reporting-analytics-mcp.ts

@@ -1,1123 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow Reporting & Analytics MCP Server
- * Handles reports, dashboards, and analytics operations
- * NO HARDCODED VALUES - All reporting configurations discovered dynamically
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListToolsRequestSchema,
-  McpError,
-} from '@modelcontextprotocol/sdk/types.js';
-import { ServiceNowClient } from '../utils/servicenow-client.js';
-import { mcpAuth } from '../utils/mcp-auth-middleware.js';
-import { mcpConfig } from '../utils/mcp-config-manager.js';
-import { Logger } from '../utils/logger.js';
-
-interface ReportDefinition {
-  name: string;
-  table: string;
-  conditions: string;
-  fields: string[];
-  aggregations: string[];
-  groupBy: string[];
-}
-
-interface DashboardWidget {
-  name: string;
-  type: string;
-  dataSource: string;
-  configuration: any;
-  layout: any;
-}
-
-class ServiceNowReportingAnalyticsMCP {
-  private server: Server;
-  private client: ServiceNowClient;
-  private logger: Logger;
-  private config: ReturnType<typeof mcpConfig.getConfig>;
-
-  constructor() {
-    this.server = new Server(
-      {
-        name: 'servicenow-reporting-analytics',
-        version: '1.0.0',
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      }
-    );
-
-    this.client = new ServiceNowClient();
-    this.logger = new Logger('ServiceNowReportingAnalyticsMCP');
-    this.config = mcpConfig.getConfig();
-
-    this.setupHandlers();
-  }
-
-  private setupHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        {
-          name: 'snow_create_report',
-          description: 'Create Report with dynamic table and field discovery - NO hardcoded values',
-          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: 'Create Dashboard with dynamic widget discovery',
-          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: 'Create KPI with dynamic metric discovery',
-          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: 'Create Data Visualization with dynamic chart discovery',
-          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: 'Create Performance Analytics with dynamic metric discovery',
-          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: 'Create Scheduled Report with dynamic delivery discovery',
-          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: 'Discover all tables available for reporting',
-          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: 'Discover available fields for reporting on a table',
-          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: 'Analyze data quality for reporting',
-          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: 'Generate data insights and 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: 'Export report data in various formats',
-          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(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params;
-
-        const authResult = await mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-          throw new McpError(ErrorCode.InternalError, authResult.error || 'Authentication required');
-        }
-
-        switch (name) {
-          case 'snow_create_report':
-            return await this.createReport(args);
-          case 'snow_create_dashboard':
-            return await this.createDashboard(args);
-          case 'snow_create_kpi':
-            return await this.createKPI(args);
-          case 'snow_create_data_visualization':
-            return await this.createDataVisualization(args);
-          case 'snow_create_performance_analytics':
-            return await this.createPerformanceAnalytics(args);
-          case 'snow_create_scheduled_report':
-            return await this.createScheduledReport(args);
-          case 'snow_discover_reporting_tables':
-            return await this.discoverReportingTables(args);
-          case 'snow_discover_report_fields':
-            return await this.discoverReportFields(args);
-          case 'snow_analyze_data_quality':
-            return await this.analyzeDataQuality(args);
-          case 'snow_generate_insights':
-            return await this.generateInsights(args);
-          case 'snow_export_report_data':
-            return await this.exportReportData(args);
-          default:
-            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        this.logger.error(`Error in ${request.params.name}:`, error);
-        throw error;
-      }
-    });
-  }
-
-  /**
-   * Create Report with dynamic discovery
-   */
-  private async createReport(args: any) {
-    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();
-      
-      const reportData = {
-        name: args.name,
-        table: tableInfo.name,
-        description: args.description || '',
-        conditions: args.conditions || '',
-        fields: JSON.stringify(args.fields || []),
-        group_by: JSON.stringify(args.groupBy || []),
-        aggregations: JSON.stringify(args.aggregations || []),
-        sort_by: args.sortBy || '',
-        sort_order: args.sortOrder || 'asc',
-        schedule: args.schedule || '',
-        format: args.format || 'HTML'
-      };
-
-      const updateSetResult = await this.client.ensureUpdateSet();
-      const response = await this.client.createRecord('sys_report', reportData);
-      
-      if (!response.success) {
-        throw new Error(`Failed to create Report: ${response.error}`);
-      }
-
-      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: ${args.fields?.join(', ') || 'Default fields'}\n${args.groupBy?.length ? `📊 Group By: ${args.groupBy.join(', ')}\n` : ''}${args.aggregations?.length ? `🔢 Aggregations: ${args.aggregations.join(', ')}\n` : ''}${args.conditions ? `🔍 Conditions: ${args.conditions}\n` : ''}📄 Format: ${args.format || 'HTML'}\n\n📝 Description: ${args.description || 'No description provided'}\n\n✨ Created with dynamic table and field discovery!`
-        }]
-      };
-    } catch (error) {
-      this.logger.error('Failed to create Report:', error);
-      throw new McpError(ErrorCode.InternalError, `Failed to create Report: ${error}`);
-    }
-  }
-
-  /**
-   * Create Dashboard with dynamic widget discovery
-   */
-  private async createDashboard(args: any) {
-    try {
-      this.logger.info('Creating Dashboard...');
-      
-      // Get available widget types and layouts
-      const widgetTypes = await this.getWidgetTypes();
-      const layouts = await this.getDashboardLayouts();
-      
-      const dashboardData = {
-        name: args.name,
-        description: args.description || '',
-        layout: args.layout || 'grid',
-        widgets: JSON.stringify(args.widgets || []),
-        permissions: JSON.stringify(args.permissions || []),
-        refresh_interval: args.refreshInterval || 15,
-        public: args.public || false
-      };
-
-      const updateSetResult = await this.client.ensureUpdateSet();
-      const response = await this.client.createRecord('sys_dashboard', dashboardData);
-      
-      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✨ Created with dynamic widget discovery!`
-        }]
-      };
-    } catch (error) {
-      this.logger.error('Failed to create Dashboard:', error);
-      throw new McpError(ErrorCode.InternalError, `Failed to create Dashboard: ${error}`);
-    }
-  }
-
-  /**
-   * Create KPI with dynamic metric discovery
-   */
-  private async createKPI(args: any) {
-    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
-      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 McpError(ErrorCode.InternalError, `Failed to create KPI: ${error}`);
-    }
-  }
-
-  /**
-   * Create Data Visualization with dynamic chart discovery
-   */
-  private async createDataVisualization(args: any) {
-    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 McpError(ErrorCode.InternalError, `Failed to create Data Visualization: ${error}`);
-    }
-  }
-
-  /**
-   * Create Performance Analytics with dynamic metric discovery
-   */
-  private async createPerformanceAnalytics(args: any) {
-    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 McpError(ErrorCode.InternalError, `Failed to create Performance Analytics: ${error}`);
-    }
-  }
-
-  /**
-   * Create Scheduled Report with dynamic delivery discovery
-   */
-  private async createScheduledReport(args: any) {
-    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 McpError(ErrorCode.InternalError, `Failed to create Scheduled Report: ${error}`);
-    }
-  }
-
-  /**
-   * Discover reporting tables
-   */
-  private async discoverReportingTables(args: any) {
-    try {
-      this.logger.info('Discovering reporting tables...');
-      
-      let query = '';
-      if (args?.category) {
-        query = `sys_class_name=${args.category}`;
-      }
-
-      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: [] as any[] },
-        { name: 'ITOM', tables: [] as any[] },
-        { name: 'HR', tables: [] as any[] },
-        { name: 'Security', tables: [] as any[] },
-        { name: 'Custom', tables: [] as any[] },
-        { name: 'System', tables: [] as any[] }
-      ];
-
-      tables.data.result.forEach((table: any) => {
-        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: any) => 
-              `- ${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 McpError(ErrorCode.InternalError, `Failed to discover reporting tables: ${error}`);
-    }
-  }
-
-  /**
-   * Discover report fields
-   */
-  private async discoverReportFields(args: any) {
-    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}`;
-      }
-
-      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: any, field: any) => {
-        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 as any[]).slice(0, 10).map((field: any) => 
-              `- ${field.column_label || field.element} (${field.element})\n  ${field.comments || 'No description'}`
-            ).join('\n')}${(typeFields as any[]).length > 10 ? `\n  ... and ${(typeFields as any[]).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 McpError(ErrorCode.InternalError, `Failed to discover report fields: ${error}`);
-    }
-  }
-
-  /**
-   * Analyze data quality
-   */
-  private async analyzeDataQuality(args: any) {
-    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 sample data for analysis
-      const sampleData = await this.client.searchRecords(args.table, '', 100);
-      if (!sampleData.success) {
-        throw new Error('Failed to retrieve sample data');
-      }
-
-      // 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: [] as any[]
-      };
-
-      // 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 McpError(ErrorCode.InternalError, `Failed to analyze data quality: ${error}`);
-    }
-  }
-
-  /**
-   * Generate insights
-   */
-  private async generateInsights(args: any) {
-    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: [] as any[],
-        recommendations: [] as any[]
-      };
-
-      // 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 McpError(ErrorCode.InternalError, `Failed to generate insights: ${error}`);
-    }
-  }
-
-  /**
-   * Export report data
-   */
-  private async exportReportData(args: any) {
-    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 McpError(ErrorCode.InternalError, `Failed to export report data: ${error}`);
-    }
-  }
-
-  // Helper methods
-  private async getTableInfo(tableName: string): Promise<{name: string, label: string} | null> {
-    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;
-    }
-  }
-
-  private async getTableFields(tableName: string): Promise<string[]> {
-    try {
-      const fieldsResponse = await this.client.searchRecords('sys_dictionary', `nameSTARTSWITH${tableName}^element!=NULL`, 100);
-      if (fieldsResponse.success) {
-        return fieldsResponse.data.result.map((field: any) => field.element);
-      }
-      return [];
-    } catch (error) {
-      this.logger.error(`Failed to get fields for ${tableName}:`, error);
-      return [];
-    }
-  }
-
-  private async getAggregationFunctions(): Promise<string[]> {
-    return ['COUNT', 'SUM', 'AVG', 'MAX', 'MIN', 'DISTINCT'];
-  }
-
-  private async getWidgetTypes(): Promise<string[]> {
-    return ['chart', 'table', 'list', 'gauge', 'scorecard', 'map', 'calendar'];
-  }
-
-  private async getDashboardLayouts(): Promise<string[]> {
-    return ['grid', 'tabs', 'accordion', 'stacked', 'fluid'];
-  }
-
-  private async getAvailableMetrics(tableName: string): Promise<string[]> {
-    const fields = await this.getTableFields(tableName);
-    return fields.filter(field => ['number', 'integer', 'decimal', 'float'].includes(field));
-  }
-
-  private async getChartTypes(): Promise<string[]> {
-    return ['bar', 'line', 'pie', 'donut', 'area', 'scatter', 'bubble', 'radar', 'funnel'];
-  }
-
-  private async getDataSourceInfo(dataSource: string): Promise<any> {
-    // 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;
-  }
-
-  private async getPerformanceMetrics(dataSource: string): Promise<string[]> {
-    return ['response_time', 'throughput', 'error_rate', 'availability', 'utilization'];
-  }
-
-  private async findReport(reportName: string): Promise<any> {
-    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;
-    }
-  }
-
-  private categorizeTable(tableName: string): string {
-    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';
-    }
-  }
-
-  private analyzeCompleteness(data: any[], fields?: string[]): any {
-    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 };
-  }
-
-  private analyzeConsistency(data: any[], fields?: string[]): any {
-    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 };
-  }
-
-  private analyzeAccuracy(data: any[], fields?: string[]): any {
-    // Simple accuracy check - assume most data is accurate
-    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 };
-  }
-
-  private analyzePatterns(data: any[]): any[] {
-    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;
-  }
-
-  private analyzeTrends(data: any[]): any[] {
-    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;
-  }
-
-  private detectAnomalies(data: any[]): any[] {
-    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;
-  }
-
-  private generateRecommendations(insights: any[]): string[] {
-    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;
-  }
-
-  private async getReportData(report: any, maxRows?: number): Promise<any[]> {
-    // Simulate getting report data
-    const limit = maxRows || 1000;
-    const data = await this.client.searchRecords(report.table, report.conditions || '', limit);
-    return data.success ? data.data.result : [];
-  }
-
-  private calculateExportSize(data: any[], format: string): string {
-    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`;
-  }
-
-  async run() {
-    const transport = new 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);