snow-flow 3.3.0 → 3.3.2

package/dist/mcp/servicenow-cmdb-event-hr-csm-devops-mcp-enhanced.js

@@ -0,0 +1,1112 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow CMDB, Event Management, HR, CSM & DevOps MCP Server - ENHANCED VERSION
+ * With logging, token tracking, and progress indicators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const enhanced_base_mcp_server_js_1 = require("./shared/enhanced-base-mcp-server.js");
+const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
+class ServiceNowCMDBEventHRCSMDevOpsMCPEnhanced extends enhanced_base_mcp_server_js_1.EnhancedBaseMCPServer {
+    constructor() {
+        super('servicenow-cmdb-event-hr-csm-devops-enhanced', '2.0.0');
+        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                // CMDB & Discovery Tools
+                {
+                    name: 'snow_create_cmdb_ci',
+                    description: 'Creates configuration item in CMDB using cmdb_ci_* tables.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            ci_class: { type: 'string', description: 'CI class (e.g., cmdb_ci_server, cmdb_ci_appl)' },
+                            name: { type: 'string', description: 'CI name' },
+                            asset_tag: { type: 'string', description: 'Asset tag' },
+                            serial_number: { type: 'string', description: 'Serial number' },
+                            model_id: { type: 'string', description: 'Model sys_id' },
+                            location: { type: 'string', description: 'Location sys_id' },
+                            operational_status: { type: 'string', description: 'Status: operational, non-operational' },
+                            attributes: { type: 'object', description: 'Additional CI attributes' }
+                        },
+                        required: ['ci_class', 'name']
+                    }
+                },
+                {
+                    name: 'snow_create_ci_relationship',
+                    description: 'Creates CI relationship using cmdb_rel_ci table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            parent: { type: 'string', description: 'Parent CI sys_id' },
+                            child: { type: 'string', description: 'Child CI sys_id' },
+                            type: { type: 'string', description: 'Relationship type sys_id' },
+                            description: { type: 'string', description: 'Relationship description' }
+                        },
+                        required: ['parent', 'child', 'type']
+                    }
+                },
+                {
+                    name: 'snow_discover_ci_dependencies',
+                    description: 'Discovers CI dependencies from cmdb_rel_ci table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            ci_sys_id: { type: 'string', description: 'CI sys_id' },
+                            depth: { type: 'number', default: 2, description: 'Dependency depth' },
+                            direction: { type: 'string', description: 'upstream, downstream, both' }
+                        },
+                        required: ['ci_sys_id']
+                    }
+                },
+                {
+                    name: 'snow_run_discovery',
+                    description: 'Runs discovery schedule using discovery_status table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            schedule_sys_id: { type: 'string', description: 'Discovery schedule sys_id' },
+                            ip_range: { type: 'string', description: 'IP range to discover' },
+                            mid_server: { type: 'string', description: 'MID server sys_id' }
+                        },
+                        required: ['schedule_sys_id']
+                    }
+                },
+                {
+                    name: 'snow_get_discovery_status',
+                    description: 'Gets discovery status from discovery_status table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            schedule_sys_id: { type: 'string', description: 'Discovery schedule sys_id' },
+                            limit: { type: 'number', default: 10 }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_import_cmdb_data',
+                    description: 'Imports CMDB data using sys_import_set table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            table_name: { type: 'string', description: 'Target table' },
+                            data: { type: 'array', items: { type: 'object' }, description: 'Data to import' },
+                            transform_map: { type: 'string', description: 'Transform map sys_id' }
+                        },
+                        required: ['table_name', 'data']
+                    }
+                },
+                // Event Management Tools
+                {
+                    name: 'snow_create_event',
+                    description: 'Creates event using em_event table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string', description: 'Event source' },
+                            node: { type: 'string', description: 'Node/CI' },
+                            type: { type: 'string', description: 'Event type' },
+                            severity: { type: 'string', description: '1-critical to 5-info' },
+                            description: { type: 'string', description: 'Event description' },
+                            message_key: { type: 'string', description: 'Unique message key' },
+                            metric_name: { type: 'string', description: 'Metric name' },
+                            resource: { type: 'string', description: 'Resource identifier' }
+                        },
+                        required: ['source', 'node', 'type', 'severity']
+                    }
+                },
+                {
+                    name: 'snow_create_alert_rule',
+                    description: 'Creates alert rule using em_alert_rule table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Rule name' },
+                            condition: { type: 'string', description: 'Alert condition' },
+                            threshold: { type: 'number', description: 'Threshold value' },
+                            action: { type: 'string', description: 'Action to take' },
+                            active: { type: 'boolean', default: true }
+                        },
+                        required: ['name', 'condition']
+                    }
+                },
+                {
+                    name: 'snow_correlate_alerts',
+                    description: 'Correlates alerts using em_alert table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            alerts: { type: 'array', items: { type: 'string' }, description: 'Alert sys_ids' },
+                            correlation_rule: { type: 'string', description: 'Rule sys_id' },
+                            create_incident: { type: 'boolean', default: false }
+                        },
+                        required: ['alerts']
+                    }
+                },
+                {
+                    name: 'snow_get_event_metrics',
+                    description: 'Gets event metrics from em_event table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string', description: 'Filter by source' },
+                            node: { type: 'string', description: 'Filter by node' },
+                            time_range: { type: 'string', description: 'Time range' },
+                            group_by: { type: 'string', description: 'Group by field' }
+                        }
+                    }
+                },
+                // HR Service Delivery Tools
+                {
+                    name: 'snow_create_hr_case',
+                    description: 'Creates HR case using sn_hr_core_case table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            subject_person: { type: 'string', description: 'Employee sys_id' },
+                            short_description: { type: 'string', description: 'Case description' },
+                            category: { type: 'string', description: 'HR category' },
+                            subcategory: { type: 'string', description: 'HR subcategory' },
+                            priority: { type: 'string', description: 'Priority level' },
+                            confidential: { type: 'boolean', default: false },
+                            hr_service: { type: 'string', description: 'HR service sys_id' }
+                        },
+                        required: ['subject_person', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_manage_onboarding',
+                    description: 'Manages employee onboarding using sn_hr_core_task table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            employee_sys_id: { type: 'string', description: 'New employee sys_id' },
+                            start_date: { type: 'string', description: 'Start date' },
+                            department: { type: 'string', description: 'Department sys_id' },
+                            manager: { type: 'string', description: 'Manager sys_id' },
+                            tasks: { type: 'array', items: { type: 'object' }, description: 'Onboarding tasks' }
+                        },
+                        required: ['employee_sys_id', 'start_date']
+                    }
+                },
+                {
+                    name: 'snow_manage_offboarding',
+                    description: 'Manages employee offboarding using sn_hr_core_task table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            employee_sys_id: { type: 'string', description: 'Employee sys_id' },
+                            last_day: { type: 'string', description: 'Last working day' },
+                            reason: { type: 'string', description: 'Departure reason' },
+                            tasks: { type: 'array', items: { type: 'object' }, description: 'Offboarding tasks' }
+                        },
+                        required: ['employee_sys_id', 'last_day']
+                    }
+                },
+                {
+                    name: 'snow_get_hr_analytics',
+                    description: 'Gets HR analytics from sn_hr_core_case table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            metric: { type: 'string', description: 'case_volume, resolution_time, satisfaction' },
+                            time_range: { type: 'string', description: 'Analysis period' },
+                            department: { type: 'string', description: 'Filter by department' }
+                        },
+                        required: ['metric']
+                    }
+                },
+                // Customer Service Management Tools
+                {
+                    name: 'snow_create_csm_case',
+                    description: 'Creates customer service case using sn_customerservice_case table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            account: { type: 'string', description: 'Customer account sys_id' },
+                            contact: { type: 'string', description: 'Contact sys_id' },
+                            short_description: { type: 'string', description: 'Case description' },
+                            category: { type: 'string', description: 'Case category' },
+                            product: { type: 'string', description: 'Product sys_id' },
+                            priority: { type: 'string', description: 'Priority level' },
+                            channel: { type: 'string', description: 'Contact channel' }
+                        },
+                        required: ['account', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_manage_customer_account',
+                    description: 'Manages customer account using sn_customerservice_account table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Account name' },
+                            industry: { type: 'string', description: 'Industry type' },
+                            tier: { type: 'string', description: 'Customer tier' },
+                            annual_revenue: { type: 'number', description: 'Annual revenue' },
+                            primary_contact: { type: 'string', description: 'Primary contact sys_id' }
+                        },
+                        required: ['name']
+                    }
+                },
+                {
+                    name: 'snow_create_csm_communication',
+                    description: 'Creates customer communication using sn_customerservice_communication table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            case_sys_id: { type: 'string', description: 'Case sys_id' },
+                            type: { type: 'string', description: 'email, phone, chat' },
+                            direction: { type: 'string', description: 'inbound, outbound' },
+                            subject: { type: 'string', description: 'Communication subject' },
+                            body: { type: 'string', description: 'Message content' }
+                        },
+                        required: ['case_sys_id', 'type', 'body']
+                    }
+                },
+                {
+                    name: 'snow_get_customer_satisfaction',
+                    description: 'Gets CSAT metrics from sn_customerservice_csat table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            account: { type: 'string', description: 'Filter by account' },
+                            time_range: { type: 'string', description: 'Analysis period' },
+                            include_comments: { type: 'boolean', default: false }
+                        }
+                    }
+                },
+                // DevOps Tools
+                {
+                    name: 'snow_create_devops_pipeline',
+                    description: 'Creates DevOps pipeline using sn_devops_pipeline table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Pipeline name' },
+                            application: { type: 'string', description: 'Application sys_id' },
+                            stages: { type: 'array', items: { type: 'object' }, description: 'Pipeline stages' },
+                            repository: { type: 'string', description: 'Repository URL' },
+                            branch: { type: 'string', description: 'Branch name' }
+                        },
+                        required: ['name', 'application']
+                    }
+                },
+                {
+                    name: 'snow_track_deployment',
+                    description: 'Tracks deployment using sn_devops_deployment table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pipeline: { type: 'string', description: 'Pipeline sys_id' },
+                            environment: { type: 'string', description: 'Target environment' },
+                            version: { type: 'string', description: 'Version number' },
+                            status: { type: 'string', description: 'Deployment status' },
+                            change_request: { type: 'string', description: 'Associated change' }
+                        },
+                        required: ['pipeline', 'environment', 'version']
+                    }
+                },
+                {
+                    name: 'snow_manage_devops_change',
+                    description: 'Manages DevOps change using sn_devops_change table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pipeline: { type: 'string', description: 'Pipeline sys_id' },
+                            deployment: { type: 'string', description: 'Deployment sys_id' },
+                            auto_approve: { type: 'boolean', default: false },
+                            validation_results: { type: 'object', description: 'Validation data' }
+                        },
+                        required: ['pipeline', 'deployment']
+                    }
+                },
+                {
+                    name: 'snow_get_velocity_metrics',
+                    description: 'Gets team velocity from sn_devops_velocity table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            team: { type: 'string', description: 'Team sys_id' },
+                            sprint: { type: 'string', description: 'Sprint identifier' },
+                            time_range: { type: 'string', description: 'Analysis period' }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_create_devops_artifact',
+                    description: 'Creates build artifact using sn_devops_artifact table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            pipeline: { type: 'string', description: 'Pipeline sys_id' },
+                            build_number: { type: 'string', description: 'Build number' },
+                            artifact_type: { type: 'string', description: 'Artifact type' },
+                            repository_url: { type: 'string', description: 'Artifact location' },
+                            checksum: { type: 'string', description: 'Artifact checksum' }
+                        },
+                        required: ['pipeline', 'build_number']
+                    }
+                }
+            ]
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+                // Execute with enhanced tracking
+                return await this.executeTool(name, async () => {
+                    switch (name) {
+                        // CMDB & Discovery
+                        case 'snow_create_cmdb_ci':
+                            return await this.createCMDBCI(args);
+                        case 'snow_create_ci_relationship':
+                            return await this.createCIRelationship(args);
+                        case 'snow_discover_ci_dependencies':
+                            return await this.discoverCIDependencies(args);
+                        case 'snow_run_discovery':
+                            return await this.runDiscovery(args);
+                        case 'snow_get_discovery_status':
+                            return await this.getDiscoveryStatus(args);
+                        case 'snow_import_cmdb_data':
+                            return await this.importCMDBData(args);
+                        // Event Management
+                        case 'snow_create_event':
+                            return await this.createEvent(args);
+                        case 'snow_create_alert_rule':
+                            return await this.createAlertRule(args);
+                        case 'snow_correlate_alerts':
+                            return await this.correlateAlerts(args);
+                        case 'snow_get_event_metrics':
+                            return await this.getEventMetrics(args);
+                        // HR Service Delivery
+                        case 'snow_create_hr_case':
+                            return await this.createHRCase(args);
+                        case 'snow_manage_onboarding':
+                            return await this.manageOnboarding(args);
+                        case 'snow_manage_offboarding':
+                            return await this.manageOffboarding(args);
+                        case 'snow_get_hr_analytics':
+                            return await this.getHRAnalytics(args);
+                        // Customer Service Management
+                        case 'snow_create_csm_case':
+                            return await this.createCSMCase(args);
+                        case 'snow_manage_customer_account':
+                            return await this.manageCustomerAccount(args);
+                        case 'snow_create_csm_communication':
+                            return await this.createCSMCommunication(args);
+                        case 'snow_get_customer_satisfaction':
+                            return await this.getCustomerSatisfaction(args);
+                        // DevOps
+                        case 'snow_create_devops_pipeline':
+                            return await this.createDevOpsPipeline(args);
+                        case 'snow_track_deployment':
+                            return await this.trackDeployment(args);
+                        case 'snow_manage_devops_change':
+                            return await this.manageDevOpsChange(args);
+                        case 'snow_get_velocity_metrics':
+                            return await this.getVelocityMetrics(args);
+                        case 'snow_create_devops_artifact':
+                            return await this.createDevOpsArtifact(args);
+                        default:
+                            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                    }
+                });
+            }
+            catch (error) {
+                if (error instanceof types_js_1.McpError)
+                    throw error;
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Tool execution failed: ${error}`);
+            }
+        });
+    }
+    // CMDB & Discovery Methods
+    async createCMDBCI(args) {
+        this.logger.info('Creating CMDB CI...', {
+            ci_class: args.ci_class,
+            name: args.name
+        });
+        const ciData = {
+            name: args.name,
+            asset_tag: args.asset_tag || '',
+            serial_number: args.serial_number || '',
+            model_id: args.model_id || '',
+            location: args.location || '',
+            operational_status: args.operational_status || 'operational',
+            ...args.attributes
+        };
+        this.logger.progress(`Creating CI in ${args.ci_class}...`);
+        const response = await this.createRecord(args.ci_class, ciData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create CI: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ CI created', {
+            sys_id: result.sys_id,
+            name: args.name
+        });
+        return this.createResponse(`✅ Configuration Item created!
+🖥️ **${args.name}**
+📦 Class: ${args.ci_class}
+🏷️ Asset Tag: ${args.asset_tag || 'N/A'}
+📍 Location: ${args.location || 'N/A'}
+🆔 sys_id: ${result.sys_id}
+
+✨ CI added to CMDB!`);
+    }
+    async createCIRelationship(args) {
+        this.logger.info('Creating CI relationship...', {
+            parent: args.parent,
+            child: args.child
+        });
+        const relData = {
+            parent: args.parent,
+            child: args.child,
+            type: args.type,
+            description: args.description || ''
+        };
+        this.logger.progress('Creating relationship...');
+        const response = await this.createRecord('cmdb_rel_ci', relData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create relationship: ${response.error}`);
+        }
+        this.logger.info('✅ Relationship created');
+        return this.createResponse(`✅ CI Relationship created!
+🔗 Parent → Child
+📝 Type: ${args.type}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async discoverCIDependencies(args) {
+        this.logger.info('Discovering CI dependencies...', {
+            ci_sys_id: args.ci_sys_id,
+            depth: args.depth
+        });
+        const direction = args.direction || 'both';
+        let query = '';
+        if (direction === 'upstream' || direction === 'both') {
+            query = `child=${args.ci_sys_id}`;
+        }
+        if (direction === 'downstream' || direction === 'both') {
+            query += query ? `^ORparent=${args.ci_sys_id}` : `parent=${args.ci_sys_id}`;
+        }
+        this.logger.progress('Analyzing dependencies...');
+        const response = await this.queryTable('cmdb_rel_ci', query, 100);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to discover dependencies: ${response.error}`);
+        }
+        const relationships = response.data.result;
+        this.logger.info(`Found ${relationships.length} dependencies`);
+        const depList = relationships.map((rel) => `🔗 ${rel.parent.display_value} → ${rel.child.display_value} (${rel.type.display_value})`).join('\n');
+        return this.createResponse(`🔍 CI Dependencies:\n\n${depList}\n\n✨ Total: ${relationships.length} relationship(s)`);
+    }
+    async runDiscovery(args) {
+        this.logger.info('Running discovery...', {
+            schedule_sys_id: args.schedule_sys_id
+        });
+        const discoveryData = {
+            schedule: args.schedule_sys_id,
+            ip_range: args.ip_range || '',
+            mid_server: args.mid_server || '',
+            state: 'starting',
+            started: new Date().toISOString()
+        };
+        this.logger.progress('Initiating discovery...');
+        const response = await this.createRecord('discovery_status', discoveryData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to start discovery: ${response.error}`);
+        }
+        this.logger.info('✅ Discovery started');
+        return this.createResponse(`✅ Discovery started!
+🔍 Schedule: ${args.schedule_sys_id}
+🌐 IP Range: ${args.ip_range || 'Default'}
+🖥️ MID Server: ${args.mid_server || 'Auto-select'}
+🆔 Status ID: ${response.data.sys_id}
+
+⏳ Discovery in progress...`);
+    }
+    async getDiscoveryStatus(args) {
+        this.logger.info('Getting discovery status...');
+        let query = '';
+        if (args.schedule_sys_id) {
+            query = `schedule=${args.schedule_sys_id}`;
+        }
+        const response = await this.queryTable('discovery_status', query, args.limit || 10);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get status: ${response.error}`);
+        }
+        const statuses = response.data.result;
+        if (!statuses.length) {
+            return this.createResponse(`❌ No discovery status found`);
+        }
+        const statusList = statuses.map((status) => `🔍 ${status.schedule?.display_value || 'Discovery'}
+  📊 State: ${status.state}
+  ⏰ Started: ${status.started}
+  🎯 Discovered: ${status.devices_discovered || 0} devices`).join('\n\n');
+        return this.createResponse(`📊 Discovery Status:\n\n${statusList}\n\n✨ ${statuses.length} discovery run(s)`);
+    }
+    async importCMDBData(args) {
+        this.logger.info('Importing CMDB data...', {
+            table_name: args.table_name,
+            records: args.data.length
+        });
+        const importSetData = {
+            table_name: args.table_name,
+            import_set_table: `u_import_${args.table_name}`,
+            transform_map: args.transform_map || '',
+            state: 'loading'
+        };
+        this.logger.progress('Creating import set...');
+        const importSet = await this.createRecord('sys_import_set', importSetData);
+        if (!importSet.success) {
+            return this.createResponse(`❌ Failed to create import set: ${importSet.error}`);
+        }
+        // Import data records
+        let imported = 0;
+        for (const record of args.data) {
+            const importRecord = await this.createRecord(importSetData.import_set_table, {
+                ...record,
+                sys_import_set: importSet.data.sys_id
+            });
+            if (importRecord.success)
+                imported++;
+        }
+        this.logger.info(`✅ Imported ${imported} records`);
+        return this.createResponse(`✅ CMDB Import completed!
+📋 Table: ${args.table_name}
+📊 Records: ${imported}/${args.data.length}
+🆔 Import Set: ${importSet.data.sys_id}
+
+✨ Data imported successfully!`);
+    }
+    // Event Management Methods
+    async createEvent(args) {
+        this.logger.info('Creating event...', {
+            source: args.source,
+            severity: args.severity
+        });
+        const eventData = {
+            source: args.source,
+            node: args.node,
+            type: args.type,
+            severity: args.severity,
+            description: args.description || '',
+            message_key: args.message_key || `${args.source}_${Date.now()}`,
+            metric_name: args.metric_name || '',
+            resource: args.resource || '',
+            time_of_event: new Date().toISOString()
+        };
+        this.logger.progress('Creating event...');
+        const response = await this.createRecord('em_event', eventData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create event: ${response.error}`);
+        }
+        this.logger.info('✅ Event created');
+        return this.createResponse(`✅ Event created!
+🚨 Source: ${args.source}
+📊 Severity: ${args.severity}
+🖥️ Node: ${args.node}
+🔑 Message Key: ${eventData.message_key}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async createAlertRule(args) {
+        this.logger.info('Creating alert rule...', { name: args.name });
+        const ruleData = {
+            name: args.name,
+            condition: args.condition,
+            threshold: args.threshold || 0,
+            action: args.action || '',
+            active: args.active !== false
+        };
+        this.logger.progress('Creating rule...');
+        const response = await this.createRecord('em_alert_rule', ruleData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create rule: ${response.error}`);
+        }
+        this.logger.info('✅ Alert rule created');
+        return this.createResponse(`✅ Alert rule created!
+📋 **${args.name}**
+🔍 Condition: ${args.condition}
+⚠️ Threshold: ${args.threshold || 'N/A'}
+✅ Active: ${args.active !== false}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async correlateAlerts(args) {
+        this.logger.info('Correlating alerts...', {
+            alerts: args.alerts.length
+        });
+        const correlationData = {
+            alerts: args.alerts.join(','),
+            correlation_rule: args.correlation_rule || '',
+            correlation_id: `CORR_${Date.now()}`,
+            state: 'correlated'
+        };
+        this.logger.progress('Correlating alerts...');
+        // Update alerts with correlation ID
+        for (const alertId of args.alerts) {
+            await this.updateRecord('em_alert', alertId, {
+                correlation_id: correlationData.correlation_id
+            });
+        }
+        if (args.create_incident) {
+            // Create incident from correlated alerts
+            const incidentData = {
+                short_description: `Correlated Alert: ${correlationData.correlation_id}`,
+                description: `Correlated ${args.alerts.length} alerts`,
+                priority: '2',
+                category: 'event'
+            };
+            const incident = await this.createRecord('incident', incidentData);
+            if (incident.success) {
+                return this.createResponse(`✅ Alerts correlated & incident created!
+🔗 Correlation ID: ${correlationData.correlation_id}
+📊 Alerts: ${args.alerts.length}
+🎫 Incident: ${incident.data.number}`);
+            }
+        }
+        this.logger.info('✅ Alerts correlated');
+        return this.createResponse(`✅ Alerts correlated!
+🔗 Correlation ID: ${correlationData.correlation_id}
+📊 Correlated: ${args.alerts.length} alerts`);
+    }
+    async getEventMetrics(args) {
+        this.logger.info('Getting event metrics...');
+        let query = '';
+        if (args.source)
+            query += `source=${args.source}`;
+        if (args.node)
+            query += `^node=${args.node}`;
+        this.logger.progress('Analyzing events...');
+        const response = await this.queryTable('em_event', query, 100);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get metrics: ${response.error}`);
+        }
+        const events = response.data.result;
+        // Calculate metrics
+        const severityCounts = { '1': 0, '2': 0, '3': 0, '4': 0, '5': 0 };
+        events.forEach((event) => {
+            severityCounts[event.severity] = (severityCounts[event.severity] || 0) + 1;
+        });
+        return this.createResponse(`📊 Event Metrics:
+🚨 Critical: ${severityCounts['1']}
+⚠️ Major: ${severityCounts['2']}
+⚡ Minor: ${severityCounts['3']}
+ℹ️ Warning: ${severityCounts['4']}
+📝 Info: ${severityCounts['5']}
+
+✨ Total: ${events.length} events`);
+    }
+    // HR Service Delivery Methods
+    async createHRCase(args) {
+        this.logger.info('Creating HR case...', {
+            subject_person: args.subject_person,
+            category: args.category
+        });
+        const caseData = {
+            subject_person: args.subject_person,
+            short_description: args.short_description,
+            category: args.category || '',
+            subcategory: args.subcategory || '',
+            priority: args.priority || '3',
+            confidential: args.confidential || false,
+            hr_service: args.hr_service || '',
+            state: 'new'
+        };
+        this.logger.progress('Creating HR case...');
+        const response = await this.createRecord('sn_hr_core_case', caseData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create HR case: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ HR case created', { number: result.number });
+        return this.createResponse(`✅ HR Case created!
+📋 **${result.number}**
+👤 Employee: ${args.subject_person}
+📁 Category: ${args.category || 'General'}
+🔒 Confidential: ${args.confidential ? 'Yes' : 'No'}
+🆔 sys_id: ${result.sys_id}
+
+✨ HR case ready for processing!`);
+    }
+    async manageOnboarding(args) {
+        this.logger.info('Managing onboarding...', {
+            employee: args.employee_sys_id,
+            start_date: args.start_date
+        });
+        // Create onboarding case
+        const onboardingCase = await this.createRecord('sn_hr_core_case', {
+            subject_person: args.employee_sys_id,
+            short_description: `Onboarding - Start Date: ${args.start_date}`,
+            category: 'onboarding',
+            hr_service: 'employee_onboarding',
+            state: 'in_progress'
+        });
+        if (!onboardingCase.success) {
+            return this.createResponse(`❌ Failed to create onboarding: ${onboardingCase.error}`);
+        }
+        // Create onboarding tasks
+        const tasks = args.tasks || [
+            { name: 'Provision equipment', days_before: 3 },
+            { name: 'Create accounts', days_before: 2 },
+            { name: 'Schedule orientation', days_before: 1 }
+        ];
+        let createdTasks = 0;
+        for (const task of tasks) {
+            const taskData = {
+                parent: onboardingCase.data.sys_id,
+                short_description: task.name,
+                assigned_to: task.assigned_to || '',
+                due_date: task.due_date || args.start_date
+            };
+            const taskResult = await this.createRecord('sn_hr_core_task', taskData);
+            if (taskResult.success)
+                createdTasks++;
+        }
+        this.logger.info('✅ Onboarding created', {
+            case: onboardingCase.data.number,
+            tasks: createdTasks
+        });
+        return this.createResponse(`✅ Onboarding initiated!
+📋 Case: ${onboardingCase.data.number}
+👤 Employee: ${args.employee_sys_id}
+📅 Start Date: ${args.start_date}
+🏢 Department: ${args.department || 'TBD'}
+👨‍💼 Manager: ${args.manager || 'TBD'}
+📌 Tasks Created: ${createdTasks}
+
+✨ Onboarding process started!`);
+    }
+    async manageOffboarding(args) {
+        this.logger.info('Managing offboarding...', {
+            employee: args.employee_sys_id,
+            last_day: args.last_day
+        });
+        // Create offboarding case
+        const offboardingCase = await this.createRecord('sn_hr_core_case', {
+            subject_person: args.employee_sys_id,
+            short_description: `Offboarding - Last Day: ${args.last_day}`,
+            category: 'offboarding',
+            hr_service: 'employee_offboarding',
+            u_reason: args.reason || '',
+            state: 'in_progress'
+        });
+        if (!offboardingCase.success) {
+            return this.createResponse(`❌ Failed to create offboarding: ${offboardingCase.error}`);
+        }
+        // Create offboarding tasks
+        const tasks = args.tasks || [
+            { name: 'Collect equipment', days_after: 0 },
+            { name: 'Revoke access', days_after: 1 },
+            { name: 'Exit interview', days_before: 1 }
+        ];
+        let createdTasks = 0;
+        for (const task of tasks) {
+            const taskResult = await this.createRecord('sn_hr_core_task', {
+                parent: offboardingCase.data.sys_id,
+                short_description: task.name
+            });
+            if (taskResult.success)
+                createdTasks++;
+        }
+        this.logger.info('✅ Offboarding created');
+        return this.createResponse(`✅ Offboarding initiated!
+📋 Case: ${offboardingCase.data.number}
+👤 Employee: ${args.employee_sys_id}
+📅 Last Day: ${args.last_day}
+📝 Reason: ${args.reason || 'Not specified'}
+📌 Tasks Created: ${createdTasks}
+
+✨ Offboarding process started!`);
+    }
+    async getHRAnalytics(args) {
+        this.logger.info('Getting HR analytics...', { metric: args.metric });
+        let query = '';
+        if (args.department)
+            query = `department=${args.department}`;
+        const response = await this.queryTable('sn_hr_core_case', query, 100);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get analytics: ${response.error}`);
+        }
+        const cases = response.data.result;
+        if (args.metric === 'case_volume') {
+            const categoryCounts = {};
+            cases.forEach((c) => {
+                categoryCounts[c.category] = (categoryCounts[c.category] || 0) + 1;
+            });
+            const breakdown = Object.entries(categoryCounts)
+                .map(([cat, count]) => `  ${cat}: ${count}`)
+                .join('\n');
+            return this.createResponse(`📊 HR Case Volume:\n${breakdown}\n\n✨ Total: ${cases.length} cases`);
+        }
+        return this.createResponse(`📊 HR Analytics:
+📋 Total Cases: ${cases.length}
+📈 Metric: ${args.metric}
+📅 Period: ${args.time_range || 'All time'}`);
+    }
+    // Customer Service Management Methods
+    async createCSMCase(args) {
+        this.logger.info('Creating customer case...', {
+            account: args.account,
+            short_description: args.short_description
+        });
+        const caseData = {
+            account: args.account,
+            contact: args.contact || '',
+            short_description: args.short_description,
+            category: args.category || '',
+            product: args.product || '',
+            priority: args.priority || '3',
+            channel: args.channel || 'web',
+            state: 'new'
+        };
+        this.logger.progress('Creating customer case...');
+        const response = await this.createRecord('sn_customerservice_case', caseData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create case: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ Customer case created', { number: result.number });
+        return this.createResponse(`✅ Customer Case created!
+📋 **${result.number}**
+🏢 Account: ${args.account}
+📝 ${args.short_description}
+📱 Channel: ${args.channel || 'Web'}
+🆔 sys_id: ${result.sys_id}
+
+✨ Case ready for support team!`);
+    }
+    async manageCustomerAccount(args) {
+        this.logger.info('Managing customer account...', { name: args.name });
+        const accountData = {
+            name: args.name,
+            industry: args.industry || '',
+            tier: args.tier || 'standard',
+            annual_revenue: args.annual_revenue || 0,
+            primary_contact: args.primary_contact || ''
+        };
+        this.logger.progress('Creating/updating account...');
+        const response = await this.createRecord('sn_customerservice_account', accountData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to manage account: ${response.error}`);
+        }
+        this.logger.info('✅ Account managed');
+        return this.createResponse(`✅ Customer Account created!
+🏢 **${args.name}**
+🏭 Industry: ${args.industry || 'N/A'}
+⭐ Tier: ${args.tier || 'Standard'}
+💰 Revenue: ${args.annual_revenue || 'N/A'}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async createCSMCommunication(args) {
+        this.logger.info('Creating communication...', {
+            case_sys_id: args.case_sys_id,
+            type: args.type
+        });
+        const commData = {
+            case: args.case_sys_id,
+            type: args.type,
+            direction: args.direction || 'outbound',
+            subject: args.subject || '',
+            body: args.body,
+            created: new Date().toISOString()
+        };
+        this.logger.progress('Recording communication...');
+        const response = await this.createRecord('sn_customerservice_communication', commData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create communication: ${response.error}`);
+        }
+        this.logger.info('✅ Communication recorded');
+        return this.createResponse(`✅ Communication recorded!
+📧 Type: ${args.type}
+📤 Direction: ${args.direction || 'Outbound'}
+📝 Subject: ${args.subject || 'N/A'}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async getCustomerSatisfaction(args) {
+        this.logger.info('Getting CSAT metrics...');
+        let query = '';
+        if (args.account)
+            query = `account=${args.account}`;
+        const response = await this.queryTable('sn_customerservice_csat', query, 100);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get CSAT: ${response.error}`);
+        }
+        const surveys = response.data.result;
+        if (!surveys.length) {
+            return this.createResponse(`❌ No CSAT data found`);
+        }
+        // Calculate average CSAT
+        const scores = surveys.map((s) => parseFloat(s.score || 0));
+        const avgScore = (scores.reduce((a, b) => a + b, 0) / scores.length).toFixed(1);
+        let result = `📊 Customer Satisfaction:
+⭐ Average Score: ${avgScore}/5
+📋 Responses: ${surveys.length}
+📅 Period: ${args.time_range || 'All time'}`;
+        if (args.include_comments) {
+            const comments = surveys
+                .filter((s) => s.comments)
+                .slice(0, 3)
+                .map((s) => `  💬 "${s.comments}"`)
+                .join('\n');
+            if (comments) {
+                result += `\n\nRecent Comments:\n${comments}`;
+            }
+        }
+        return this.createResponse(result);
+    }
+    // DevOps Methods
+    async createDevOpsPipeline(args) {
+        this.logger.info('Creating DevOps pipeline...', {
+            name: args.name,
+            application: args.application
+        });
+        const pipelineData = {
+            name: args.name,
+            application: args.application,
+            stages: JSON.stringify(args.stages || []),
+            repository: args.repository || '',
+            branch: args.branch || 'main',
+            active: true
+        };
+        this.logger.progress('Creating pipeline...');
+        const response = await this.createRecord('sn_devops_pipeline', pipelineData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create pipeline: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ Pipeline created', { sys_id: result.sys_id });
+        return this.createResponse(`✅ DevOps Pipeline created!
+🚀 **${args.name}**
+📱 Application: ${args.application}
+📦 Repository: ${args.repository || 'N/A'}
+🌿 Branch: ${args.branch || 'main'}
+📊 Stages: ${args.stages?.length || 0}
+🆔 sys_id: ${result.sys_id}
+
+✨ Pipeline ready for deployments!`);
+    }
+    async trackDeployment(args) {
+        this.logger.info('Tracking deployment...', {
+            pipeline: args.pipeline,
+            environment: args.environment,
+            version: args.version
+        });
+        const deploymentData = {
+            pipeline: args.pipeline,
+            environment: args.environment,
+            version: args.version,
+            status: args.status || 'in_progress',
+            change_request: args.change_request || '',
+            deployed_on: new Date().toISOString()
+        };
+        this.logger.progress('Recording deployment...');
+        const response = await this.createRecord('sn_devops_deployment', deploymentData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to track deployment: ${response.error}`);
+        }
+        this.logger.info('✅ Deployment tracked');
+        return this.createResponse(`✅ Deployment tracked!
+🚀 Version: ${args.version}
+🌍 Environment: ${args.environment}
+📊 Status: ${args.status || 'In Progress'}
+🔄 Change: ${args.change_request || 'N/A'}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async manageDevOpsChange(args) {
+        this.logger.info('Managing DevOps change...', {
+            pipeline: args.pipeline,
+            deployment: args.deployment
+        });
+        const changeData = {
+            pipeline: args.pipeline,
+            deployment: args.deployment,
+            auto_approve: args.auto_approve || false,
+            validation_results: JSON.stringify(args.validation_results || {}),
+            state: args.auto_approve ? 'approved' : 'pending'
+        };
+        this.logger.progress('Processing change...');
+        const response = await this.createRecord('sn_devops_change', changeData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to manage change: ${response.error}`);
+        }
+        this.logger.info('✅ Change processed');
+        return this.createResponse(`✅ DevOps change processed!
+🔄 Pipeline: ${args.pipeline}
+🚀 Deployment: ${args.deployment}
+✅ Auto-approve: ${args.auto_approve ? 'Yes' : 'No'}
+📊 State: ${args.auto_approve ? 'Approved' : 'Pending'}
+🆔 sys_id: ${response.data.sys_id}`);
+    }
+    async getVelocityMetrics(args) {
+        this.logger.info('Getting velocity metrics...');
+        let query = '';
+        if (args.team)
+            query = `team=${args.team}`;
+        if (args.sprint)
+            query += `^sprint=${args.sprint}`;
+        const response = await this.queryTable('sn_devops_velocity', query, 50);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get velocity: ${response.error}`);
+        }
+        const metrics = response.data.result;
+        if (!metrics.length) {
+            return this.createResponse(`❌ No velocity data found`);
+        }
+        // Calculate velocity
+        const storyPoints = metrics.map((m) => parseFloat(m.story_points || 0));
+        const avgVelocity = (storyPoints.reduce((a, b) => a + b, 0) / storyPoints.length).toFixed(1);
+        return this.createResponse(`📊 Team Velocity:
+🚀 Average: ${avgVelocity} story points/sprint
+📈 Sprints: ${metrics.length}
+👥 Team: ${args.team || 'All teams'}
+📅 Period: ${args.time_range || 'Recent sprints'}
+
+✨ Velocity trending ${parseFloat(avgVelocity) > 20 ? 'up' : 'stable'}!`);
+    }
+    async createDevOpsArtifact(args) {
+        this.logger.info('Creating build artifact...', {
+            pipeline: args.pipeline,
+            build_number: args.build_number
+        });
+        const artifactData = {
+            pipeline: args.pipeline,
+            build_number: args.build_number,
+            artifact_type: args.artifact_type || 'build',
+            repository_url: args.repository_url || '',
+            checksum: args.checksum || '',
+            created: new Date().toISOString()
+        };
+        this.logger.progress('Recording artifact...');
+        const response = await this.createRecord('sn_devops_artifact', artifactData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create artifact: ${response.error}`);
+        }
+        this.logger.info('✅ Artifact created');
+        return this.createResponse(`✅ Build artifact recorded!
+📦 Build: #${args.build_number}
+🔧 Type: ${args.artifact_type || 'Build'}
+🔗 Repository: ${args.repository_url || 'N/A'}
+🔐 Checksum: ${args.checksum ? '✓' : 'N/A'}
+🆔 sys_id: ${response.data.sys_id}
+
+✨ Artifact ready for deployment!`);
+    }
+    async start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        // Log ready state
+        this.logger.info('🚀 ServiceNow CMDB, Event, HR, CSM & DevOps MCP Server (Enhanced) running');
+        this.logger.info('📊 Token tracking enabled');
+        this.logger.info('⏳ Progress indicators active');
+    }
+}
+// Start the enhanced server
+const server = new ServiceNowCMDBEventHRCSMDevOpsMCPEnhanced();
+server.start().catch((error) => {
+    console.error('Failed to start enhanced server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=servicenow-cmdb-event-hr-csm-devops-mcp-enhanced.js.map