snow-flow 2.6.4 → 2.6.6

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

@@ -1,648 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * servicenow-reporting-analytics MCP Server - REFACTORED
- * Uses BaseMCPServer to eliminate code duplication
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowReportingAnalyticsMCP = void 0;
-const base_mcp_server_js_1 = require("./base-mcp-server.js");
-class ServiceNowReportingAnalyticsMCP extends base_mcp_server_js_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-reporting-analytics',
-            version: '2.0.0',
-            description: 'Handles reports, dashboards, and analytics operations'
-        });
-    }
-    setupTools() {
-        // Tools are defined in getTools() method
-    }
-    getTools() {
-        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']
-                }
-            }
-        ];
-    }
-    async executeTool(name, args) {
-        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
-    async handleSnowCreateReport(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateDashboard(args) {
-        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?.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
-            };
-        }
-    }
-    async handleSnowCreateKpi(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateDataVisualization(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreatePerformanceAnalytics(args) {
-        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
-            };
-        }
-    }
-    async handleSnowCreateScheduledReport(args) {
-        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
-            };
-        }
-    }
-    async handleSnowDiscoverReportingTables(args) {
-        const startTime = Date.now();
-        try {
-            const tables = [];
-            // 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) => ({
-                    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
-            };
-        }
-    }
-    async handleSnowDiscoverReportFields(args) {
-        const startTime = Date.now();
-        try {
-            const fields = [];
-            // 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) => ({
-                    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
-            };
-        }
-    }
-    async handleSnowAnalyzeDataQuality(args) {
-        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
-            };
-        }
-    }
-    async handleSnowGenerateInsights(args) {
-        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
-            };
-        }
-    }
-    async handleSnowExportReportData(args) {
-        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
-    async createDashboardWidget(dashboardId, widget) {
-        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);
-    }
-}
-exports.ServiceNowReportingAnalyticsMCP = ServiceNowReportingAnalyticsMCP;
-// Create and run the server
-if (require.main === module) {
-    const server = new ServiceNowReportingAnalyticsMCP();
-    server.start().catch(console.error);
-}
-//# sourceMappingURL=servicenow-reporting-analytics-mcp-refactored.js.map

package/dist/mcp/servicenow-security-compliance-mcp-refactored.d.ts

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-/**
- * servicenow-security-compliance 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 declare class ServiceNowSecurityComplianceMCP extends BaseMCPServer {
-    constructor();
-    protected setupTools(): void;
-    protected getTools(): Tool[];
-    protected executeTool(name: string, args: any): Promise<ToolResult>;
-    private handleSnowCreateSecurityPolicy;
-    private handleSnowCreateComplianceRule;
-    private handleSnowCreateAuditRule;
-    private handleSnowCreateAccessControl;
-    private handleSnowCreateDataPolicy;
-    private handleSnowCreateVulnerabilityScan;
-    private handleSnowDiscoverSecurityFrameworks;
-    private handleSnowDiscoverSecurityPolicies;
-    private handleSnowRunComplianceScan;
-    private handleSnowAuditTrailAnalysis;
-    private handleSnowSecurityRiskAssessment;
-}
-//# sourceMappingURL=servicenow-security-compliance-mcp-refactored.d.ts.map