snow-flow 2.0.2 → 2.0.3

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

@@ -1,695 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-reporting-analytics MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-
-import { BaseMCPServer, ToolResult } from './base-mcp-server.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-
-export class ServiceNowReportingAnalyticsMCP extends BaseMCPServer {
-  constructor() {
-    super({
-      name: 'servicenow-reporting-analytics',
-      version: '2.0.0',
-      description: 'Handles reports, dashboards, and analytics operations'
-    });
-  }
-
-  protected setupTools(): void {
-    // Tools are defined in getTools() method
-  }
-
-  protected getTools(): Tool[] {
-    return [
-      {
-        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']
-        }
-      }
-    ];
-  }
-
-  protected async executeTool(name: string, args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-
-    switch (name) {
-      case 'snow_create_report':
-        return await this.handleSnowCreateReport(args);
-      case 'snow_create_dashboard':
-        return await this.handleSnowCreateDashboard(args);
-      case 'snow_create_kpi':
-        return await this.handleSnowCreateKpi(args);
-      case 'snow_create_data_visualization':
-        return await this.handleSnowCreateDataVisualization(args);
-      case 'snow_create_performance_analytics':
-        return await this.handleSnowCreatePerformanceAnalytics(args);
-      case 'snow_create_scheduled_report':
-        return await this.handleSnowCreateScheduledReport(args);
-      case 'snow_discover_reporting_tables':
-        return await this.handleSnowDiscoverReportingTables(args);
-      case 'snow_discover_report_fields':
-        return await this.handleSnowDiscoverReportFields(args);
-      case 'snow_analyze_data_quality':
-        return await this.handleSnowAnalyzeDataQuality(args);
-      case 'snow_generate_insights':
-        return await this.handleSnowGenerateInsights(args);
-      case 'snow_export_report_data':
-        return await this.handleSnowExportReportData(args);
-      default:
-        return {
-          success: false,
-          error: `Unknown tool: ${name}`
-        };
-    }
-  }
-
-  // Tool handlers
-  private async handleSnowCreateReport(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const reportData = {
-        name: args.name,
-        table: args.table,
-        description: args.description || '',
-        filter: args.conditions || '',
-        fields: args.fields.join(','),
-        group_by: args.groupBy ? args.groupBy.join(',') : '',
-        aggregation: args.aggregations ? args.aggregations.join(',') : '',
-        sort_by: args.sortBy || '',
-        sort_order: args.sortOrder || 'asc',
-        schedule: args.schedule || '',
-        format: args.format || 'PDF',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_report', reportData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create report',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create report',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowCreateDashboard(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const dashboardData = {
-        name: args.name,
-        description: args.description || '',
-        layout: args.layout || 'grid',
-        refresh_interval: args.refreshInterval || 0,
-        is_public: args.public || false,
-        active: true
-      };
-
-      // Create dashboard
-      const dashboardResult = await this.client.createRecord('sys_dashboard', dashboardData);
-      
-      if (dashboardResult.success && args.widgets) {
-        // Create widgets for the dashboard
-        const dashboardId = Array.isArray(dashboardResult.result) 
-          ? dashboardResult.result[0]?.sys_id 
-          : (dashboardResult.result as any)?.sys_id || 'unknown';
-        for (const widget of args.widgets) {
-          await this.createDashboardWidget(dashboardId, widget);
-        }
-      }
-      
-      return {
-        success: dashboardResult.success,
-        result: dashboardResult.result,
-        error: dashboardResult.success ? undefined : 'Failed to create dashboard',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create dashboard',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowCreateKpi(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const kpiData = {
-        name: args.name,
-        description: args.description || '',
-        table: args.table,
-        field: args.metric,
-        aggregate: args.aggregation,
-        conditions: args.conditions || '',
-        target_value: args.target || 0,
-        unit: args.unit || '',
-        frequency: args.frequency || 'daily',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sysauto_indicator', kpiData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create KPI',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create KPI',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowCreateDataVisualization(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const vizData = {
-        name: args.name,
-        type: args.type,
-        data_source: args.dataSource,
-        x_axis: args.xAxis || '',
-        y_axis: args.yAxis || '',
-        series: args.series ? JSON.stringify(args.series) : '',
-        filters: args.filters ? JSON.stringify(args.filters) : '',
-        colors: args.colors ? args.colors.join(',') : '',
-        interactive: args.interactive !== false,
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_visualization', vizData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create data visualization',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create data visualization',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowCreatePerformanceAnalytics(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const analyticsData = {
-        name: args.name,
-        category: args.category || 'general',
-        table: args.dataSource,
-        metrics: args.metrics.join(','),
-        dimensions: args.dimensions ? args.dimensions.join(',') : '',
-        timeframe: args.timeframe || 'monthly',
-        benchmarks: args.benchmarks ? JSON.stringify(args.benchmarks) : '',
-        alerts: args.alerts ? JSON.stringify(args.alerts) : '',
-        active: true
-      };
-
-      const result = await this.client.createRecord('pa_cubes', analyticsData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create performance analytics',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create performance analytics',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowCreateScheduledReport(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      // Find the source report
-      const reportResponse = await this.client.searchRecords(
-        'sys_report',
-        `name=${args.reportName}`,
-        1
-      );
-
-      if (!reportResponse.success || !reportResponse.data?.result?.length) {
-        throw new Error(`Report not found: ${args.reportName}`);
-      }
-
-      const reportId = reportResponse.data.result[0].sys_id;
-
-      const scheduleData = {
-        report: reportId,
-        schedule_type: args.schedule,
-        recipients: args.recipients.join(','),
-        format: args.format || 'PDF',
-        conditions: args.conditions || '',
-        subject: args.subject || `Scheduled Report: ${args.reportName}`,
-        message: args.message || 'Please find the attached report.',
-        active: true
-      };
-
-      const result = await this.client.createRecord('sys_report_schedule', scheduleData);
-      
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.success ? undefined : 'Failed to create scheduled report',
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to create scheduled report',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowDiscoverReportingTables(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const tables: any[] = [];
-      
-      // Build query
-      let query = '';
-      if (args.hasData) {
-        query = 'row_count>0';
-      }
-
-      // Discover tables
-      const tableResponse = await this.client.searchRecords('sys_db_object', query, 100);
-      if (tableResponse.success && tableResponse.data) {
-        tables.push(...tableResponse.data.result.map((table: any) => ({
-          name: table.name,
-          label: table.label,
-          row_count: table.row_count,
-          category: table.super_class ? 'extended' : 'base',
-          accessible: table.accessible
-        })));
-      }
-
-      // Filter by category if specified
-      const filteredTables = args.category 
-        ? tables.filter(t => t.category === args.category)
-        : tables;
-
-      return {
-        success: true,
-        result: { tables: filteredTables },
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to discover reporting tables',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowDiscoverReportFields(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      const fields: any[] = [];
-      
-      // Get fields for the table
-      const fieldResponse = await this.client.searchRecords(
-        'sys_dictionary',
-        `name=${args.table}^element!=NULL`,
-        100
-      );
-
-      if (fieldResponse.success && fieldResponse.data) {
-        fields.push(...fieldResponse.data.result.map((field: any) => ({
-          name: field.element,
-          label: field.column_label,
-          type: field.internal_type,
-          reference: field.reference,
-          choice: field.choice,
-          max_length: field.max_length,
-          mandatory: field.mandatory === 'true',
-          calculated: field.virtual === 'true',
-          reportable: field.attributes?.includes('report') !== false
-        })));
-      }
-
-      // Filter by field type if specified
-      const filteredFields = args.fieldType
-        ? fields.filter(f => f.type === args.fieldType)
-        : fields;
-
-      return {
-        success: true,
-        result: { fields: filteredFields },
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to discover report fields',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowAnalyzeDataQuality(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      // This would be a complex _analysis in reality
-      // For now, simulate data quality analysis
-      const _analysis = {
-        table: args.table,
-        total_records: Math.floor(Math.random() * 10000) + 1000,
-        fields_analyzed: args.fields?.length || 'all',
-        completeness: args.checkCompleteness ? {
-          score: 94.5,
-          missing_values: 234,
-          null_fields: ['description', 'notes']
-        } : null,
-        consistency: args.checkConsistency ? {
-          score: 87.3,
-          inconsistent_formats: 45,
-          duplicate_records: 12
-        } : null,
-        accuracy: args.checkAccuracy ? {
-          score: 91.2,
-          validation_errors: 78,
-          outliers: 23
-        } : null,
-        overall_quality_score: 91.0,
-        recommendations: [
-          'Standardize date formats across all fields',
-          'Implement validation rules for email fields',
-          'Remove duplicate entries in customer table'
-        ]
-      };
-
-      return {
-        success: true,
-        result: _analysis,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to analyze data quality',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowGenerateInsights(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      // Simulate insight generation
-      const insights = {
-        table: args.table,
-        analysis_type: args.analysisType || 'trends',
-        timeframe: args.timeframe || 'last_30_days',
-        key_findings: [
-          'Incident volume increased by 23% in the last week',
-          'Average resolution time improved by 15%',
-          'Peak incident hours are between 9 AM and 11 AM'
-        ],
-        patterns: [
-          { type: 'seasonal', description: 'Higher volume on Mondays' },
-          { type: 'correlation', description: 'Priority 1 incidents correlate with system outages' }
-        ],
-        anomalies: [
-          { date: '2024-01-15', description: 'Unusual spike in network incidents' }
-        ],
-        recommendations: args.generateRecommendations ? [
-          'Increase staffing during peak hours',
-          'Implement proactive monitoring for high-risk systems',
-          'Create automation for common incident types'
-        ] : []
-      };
-
-      return {
-        success: true,
-        result: insights,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to generate insights',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  private async handleSnowExportReportData(args: any): Promise<ToolResult> {
-    const startTime = Date.now();
-    try {
-      // Find the report
-      const reportResponse = await this.client.searchRecords(
-        'sys_report',
-        `name=${args.reportName}`,
-        1
-      );
-
-      if (!reportResponse.success || !reportResponse.data?.result?.length) {
-        throw new Error(`Report not found: ${args.reportName}`);
-      }
-
-      const report = reportResponse.data.result[0];
-
-      // Simulate export
-      const exportResult = {
-        report_name: report.name,
-        export_format: args.format,
-        include_headers: args.includeHeaders !== false,
-        max_rows: args.maxRows || 10000,
-        export_date: new Date().toISOString(),
-        file_size: Math.floor(Math.random() * 5000) + 1000,
-        download_url: `/api/now/export/report/${report.sys_id}/${args.format.toLowerCase()}`,
-        expires_in: '24 hours'
-      };
-
-      return {
-        success: true,
-        result: exportResult,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to export report data',
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-
-  // Helper methods
-  private async createDashboardWidget(dashboardId: string, widget: any): Promise<void> {
-    const widgetData = {
-      dashboard: dashboardId,
-      name: widget.name,
-      type: widget.type || 'report',
-      data_source: widget.dataSource,
-      configuration: JSON.stringify(widget.configuration || {}),
-      position: widget.position || 0,
-      size_x: widget.width || 4,
-      size_y: widget.height || 3
-    };
-
-    await this.client.createRecord('sys_dashboard_widget', widgetData);
-  }
-}
-
-// Create and run the server
-if (require.main === module) {
-  const server = new ServiceNowReportingAnalyticsMCP();
-  server.start().catch(console.error);
-}