snow-flow 3.1.2 → 3.2.0

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

@@ -0,0 +1,1416 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow CMDB, Event Management, HR, CSM & DevOps MCP Server
+ * Handles configuration management, events, HR services, customer service, and DevOps
+ * Uses official ServiceNow REST APIs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const servicenow_client_js_1 = require("../utils/servicenow-client.js");
+const mcp_auth_middleware_js_1 = require("../utils/mcp-auth-middleware.js");
+const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
+const logger_js_1 = require("../utils/logger.js");
+class ServiceNowCMDBEventHRCSMDevOpsMCP {
+    constructor() {
+        this.server = new index_js_1.Server({
+            name: 'servicenow-cmdb-event-hr-csm-devops',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.client = new servicenow_client_js_1.ServiceNowClient();
+        this.logger = new logger_js_1.Logger('ServiceNowCMDBEventHRCSMDevOpsMCP');
+        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                // Discovery & CMDB Tools
+                {
+                    name: 'snow_create_ci',
+                    description: 'Creates a Configuration Item (CI) in the CMDB. CIs represent IT infrastructure components.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'CI name' },
+                            ci_class: { type: 'string', description: 'CI class (e.g., cmdb_ci_server, cmdb_ci_app_server)' },
+                            serial_number: { type: 'string', description: 'Serial number' },
+                            asset_tag: { type: 'string', description: 'Asset tag' },
+                            model: { type: 'string', description: 'Model reference' },
+                            manufacturer: { type: 'string', description: 'Manufacturer reference' },
+                            location: { type: 'string', description: 'Location reference' },
+                            assigned_to: { type: 'string', description: 'Assigned user' },
+                            operational_status: { type: 'string', description: 'Operational status' },
+                            attributes: { type: 'object', description: 'Additional CI attributes' }
+                        },
+                        required: ['name', 'ci_class']
+                    }
+                },
+                {
+                    name: 'snow_create_ci_relationship',
+                    description: 'Creates relationships between Configuration Items to map dependencies.',
+                    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: Depends on, Hosted on, Runs on, Uses, etc.' },
+                            description: { type: 'string', description: 'Relationship description' }
+                        },
+                        required: ['parent', 'child', 'type']
+                    }
+                },
+                {
+                    name: 'snow_run_discovery',
+                    description: 'Initiates a Discovery scan to automatically find and map IT infrastructure.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            schedule: { type: 'string', description: 'Discovery schedule name' },
+                            ip_range: { type: 'string', description: 'IP range to scan' },
+                            mid_server: { type: 'string', description: 'MID server to use' },
+                            patterns: { type: 'array', items: { type: 'string' }, description: 'Discovery patterns to run' },
+                            credentials: { type: 'string', description: 'Credential set to use' }
+                        },
+                        required: ['schedule']
+                    }
+                },
+                {
+                    name: 'snow_get_ci_details',
+                    description: 'Retrieves Configuration Item details including relationships and history.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            ci_id: { type: 'string', description: 'CI sys_id or name' },
+                            include_relationships: { type: 'boolean', description: 'Include CI relationships', default: true },
+                            include_history: { type: 'boolean', description: 'Include change history', default: false }
+                        },
+                        required: ['ci_id']
+                    }
+                },
+                {
+                    name: 'snow_search_cmdb',
+                    description: 'Searches the CMDB for Configuration Items with various filters.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Search query' },
+                            ci_class: { type: 'string', description: 'Filter by CI class' },
+                            operational_status: { type: 'string', description: 'Filter by status' },
+                            location: { type: 'string', description: 'Filter by location' },
+                            limit: { type: 'number', description: 'Maximum results', default: 50 }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_impact_analysis',
+                    description: 'Performs impact analysis to identify affected services when a CI changes.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            ci_id: { type: 'string', description: 'CI to analyze' },
+                            depth: { type: 'number', description: 'Relationship depth to analyze', default: 3 },
+                            include_services: { type: 'boolean', description: 'Include business services', default: true }
+                        },
+                        required: ['ci_id']
+                    }
+                },
+                // Event Management Tools
+                {
+                    name: 'snow_create_event',
+                    description: 'Creates an event for Event Management processing. Events are raw data that get correlated into alerts.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string', description: 'Event source system' },
+                            node: { type: 'string', description: 'Node (CI) affected' },
+                            type: { type: 'string', description: 'Event type' },
+                            severity: { type: 'number', description: 'Severity: 1-Critical, 2-Major, 3-Minor, 4-Warning, 5-Info' },
+                            description: { type: 'string', description: 'Event description' },
+                            additional_info: { type: 'object', description: 'Additional event data' },
+                            time_of_event: { type: 'string', description: 'Event timestamp' },
+                            resolution_state: { type: 'string', description: 'Resolution state' }
+                        },
+                        required: ['source', 'node', 'type', 'severity', 'description']
+                    }
+                },
+                {
+                    name: 'snow_create_alert',
+                    description: 'Creates an alert directly or promotes events to alerts for incident creation.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string', description: 'Alert source' },
+                            node: { type: 'string', description: 'Affected CI' },
+                            severity: { type: 'number', description: 'Alert severity' },
+                            description: { type: 'string', description: 'Alert description' },
+                            metric_name: { type: 'string', description: 'Metric that triggered alert' },
+                            threshold_value: { type: 'string', description: 'Threshold breached' },
+                            actual_value: { type: 'string', description: 'Actual value observed' },
+                            assignment_group: { type: 'string', description: 'Group to assign to' }
+                        },
+                        required: ['source', 'node', 'severity', 'description']
+                    }
+                },
+                {
+                    name: 'snow_create_alert_rule',
+                    description: 'Creates alert correlation rules to automatically group related events.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Rule name' },
+                            condition: { type: 'string', description: 'Correlation condition' },
+                            grouping_fields: { type: 'array', items: { type: 'string' }, description: 'Fields to group by' },
+                            time_window: { type: 'number', description: 'Time window in seconds' },
+                            threshold: { type: 'number', description: 'Event count threshold' },
+                            action: { type: 'string', description: 'Action to take' },
+                            active: { type: 'boolean', description: 'Is rule active', default: true }
+                        },
+                        required: ['name', 'condition']
+                    }
+                },
+                {
+                    name: 'snow_get_event_correlation',
+                    description: 'Gets event correlation results showing how events are grouped into alerts.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            alert_id: { type: 'string', description: 'Alert sys_id' },
+                            time_range: { type: 'string', description: 'Time range to check' },
+                            include_suppressed: { type: 'boolean', description: 'Include suppressed events', default: false }
+                        }
+                    }
+                },
+                // HR Service Delivery Tools
+                {
+                    name: 'snow_create_hr_case',
+                    description: 'Creates an HR case for employee service requests like onboarding, benefits, or policy questions.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            employee: { type: 'string', description: 'Employee sys_id or user name' },
+                            hr_service: { type: 'string', description: 'HR service type' },
+                            short_description: { type: 'string', description: 'Case summary' },
+                            description: { type: 'string', description: 'Detailed description' },
+                            priority: { type: 'number', description: 'Priority level' },
+                            category: { type: 'string', description: 'Case category: Benefits, Payroll, Leave, etc.' },
+                            subcategory: { type: 'string', description: 'Case subcategory' },
+                            confidential: { type: 'boolean', description: 'Is case confidential', default: false }
+                        },
+                        required: ['employee', 'hr_service', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_create_hr_task',
+                    description: 'Creates HR tasks for case fulfillment like document collection or approvals.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            hr_case: { type: 'string', description: 'Parent HR case' },
+                            type: { type: 'string', description: 'Task type' },
+                            assigned_to: { type: 'string', description: 'HR agent assigned' },
+                            short_description: { type: 'string', description: 'Task description' },
+                            due_date: { type: 'string', description: 'Task due date' },
+                            instructions: { type: 'string', description: 'Task instructions' }
+                        },
+                        required: ['hr_case', 'type', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_employee_onboarding',
+                    description: 'Initiates employee onboarding workflow with all necessary tasks and provisioning.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            employee_name: { type: 'string', description: 'New employee name' },
+                            email: { type: 'string', description: 'Employee email' },
+                            start_date: { type: 'string', description: 'Start date' },
+                            department: { type: 'string', description: 'Department' },
+                            manager: { type: 'string', description: 'Manager sys_id or name' },
+                            job_title: { type: 'string', description: 'Job title' },
+                            location: { type: 'string', description: 'Work location' },
+                            equipment_needed: { type: 'array', items: { type: 'string' }, description: 'Equipment to provision' }
+                        },
+                        required: ['employee_name', 'email', 'start_date', 'department', 'manager']
+                    }
+                },
+                {
+                    name: 'snow_employee_offboarding',
+                    description: 'Initiates employee offboarding workflow to revoke access and collect assets.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            employee: { type: 'string', description: 'Employee sys_id or user name' },
+                            last_date: { type: 'string', description: 'Last working date' },
+                            reason: { type: 'string', description: 'Offboarding reason' },
+                            assets_to_return: { type: 'array', items: { type: 'string' }, description: 'Assets to collect' },
+                            knowledge_transfer: { type: 'string', description: 'Knowledge transfer plan' }
+                        },
+                        required: ['employee', 'last_date', 'reason']
+                    }
+                },
+                // Customer Service Management Tools
+                {
+                    name: 'snow_create_customer_case',
+                    description: 'Creates a customer service case for external customer support requests.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            customer: { type: 'string', description: 'Customer account reference' },
+                            contact: { type: 'string', description: 'Customer contact' },
+                            product: { type: 'string', description: 'Product or service' },
+                            short_description: { type: 'string', description: 'Case summary' },
+                            description: { type: 'string', description: 'Detailed description' },
+                            priority: { type: 'number', description: 'Priority level' },
+                            category: { type: 'string', description: 'Case category' },
+                            channel: { type: 'string', description: 'Contact channel: Phone, Email, Chat, Portal' }
+                        },
+                        required: ['customer', 'contact', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_create_customer_account',
+                    description: 'Creates a customer account for tracking customer relationships and entitlements.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Account name' },
+                            account_number: { type: 'string', description: 'Account number' },
+                            type: { type: 'string', description: 'Account type: Customer, Partner, Prospect' },
+                            industry: { type: 'string', description: 'Industry' },
+                            annual_revenue: { type: 'string', description: 'Annual revenue' },
+                            employees: { type: 'number', description: 'Number of employees' },
+                            primary_contact: { type: 'string', description: 'Primary contact' }
+                        },
+                        required: ['name', 'type']
+                    }
+                },
+                {
+                    name: 'snow_create_entitlement',
+                    description: 'Creates service entitlements defining what services customers are eligible for.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            account: { type: 'string', description: 'Customer account' },
+                            service: { type: 'string', description: 'Service offering' },
+                            start_date: { type: 'string', description: 'Entitlement start date' },
+                            end_date: { type: 'string', description: 'Entitlement end date' },
+                            support_level: { type: 'string', description: 'Support level: Basic, Standard, Premium' },
+                            hours_included: { type: 'number', description: 'Support hours included' },
+                            response_time: { type: 'string', description: 'SLA response time' }
+                        },
+                        required: ['account', 'service', 'start_date', 'end_date']
+                    }
+                },
+                {
+                    name: 'snow_get_customer_history',
+                    description: 'Retrieves complete customer interaction history including cases and communications.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            customer: { type: 'string', description: 'Customer account or contact' },
+                            include_cases: { type: 'boolean', description: 'Include case history', default: true },
+                            include_communications: { type: 'boolean', description: 'Include communications', default: true },
+                            date_range: { type: 'string', description: 'Date range filter' }
+                        },
+                        required: ['customer']
+                    }
+                },
+                // DevOps Tools
+                {
+                    name: 'snow_create_devops_pipeline',
+                    description: 'Creates a DevOps pipeline for CI/CD automation.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Pipeline name' },
+                            repository: { type: 'string', description: 'Source repository' },
+                            branch: { type: 'string', description: 'Branch to build' },
+                            stages: { type: 'array', items: { type: 'object' }, description: 'Pipeline stages' },
+                            triggers: { type: 'array', items: { type: 'string' }, description: 'Pipeline triggers' },
+                            environment: { type: 'string', description: 'Target environment' }
+                        },
+                        required: ['name', 'repository', 'branch']
+                    }
+                },
+                {
+                    name: 'snow_track_deployment',
+                    description: 'Tracks application deployments through the DevOps pipeline.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            application: { type: 'string', description: 'Application name' },
+                            version: { type: 'string', description: 'Version being deployed' },
+                            environment: { type: 'string', description: 'Target environment' },
+                            pipeline: { type: 'string', description: 'Pipeline used' },
+                            change_request: { type: 'string', description: 'Associated change request' },
+                            status: { type: 'string', description: 'Deployment status' },
+                            start_time: { type: 'string', description: 'Deployment start time' }
+                        },
+                        required: ['application', 'version', 'environment']
+                    }
+                },
+                {
+                    name: 'snow_create_devops_change',
+                    description: 'Creates an automated DevOps change request for deployments.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            application: { type: 'string', description: 'Application to deploy' },
+                            version: { type: 'string', description: 'Version to deploy' },
+                            environment: { type: 'string', description: 'Target environment' },
+                            deployment_date: { type: 'string', description: 'Planned deployment' },
+                            risk_assessment: { type: 'object', description: 'Risk assessment data' },
+                            rollback_plan: { type: 'string', description: 'Rollback procedure' }
+                        },
+                        required: ['application', 'version', 'environment', 'deployment_date']
+                    }
+                },
+                {
+                    name: 'snow_get_devops_insights',
+                    description: 'Retrieves DevOps metrics and insights for continuous improvement.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            application: { type: 'string', description: 'Application to analyze' },
+                            metric_type: { type: 'string', description: 'Metric type: velocity, quality, stability' },
+                            time_range: { type: 'string', description: 'Analysis time range' },
+                            include_trends: { type: 'boolean', description: 'Include trend analysis', default: true }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_velocity_tracking',
+                    description: 'Tracks team velocity and delivery metrics for DevOps optimization.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            team: { type: 'string', description: 'Team name' },
+                            sprint: { type: 'string', description: 'Sprint identifier' },
+                            story_points: { type: 'number', description: 'Story points completed' },
+                            deployments: { type: 'number', description: 'Number of deployments' },
+                            lead_time: { type: 'number', description: 'Average lead time in hours' },
+                            mttr: { type: 'number', description: 'Mean time to recovery in minutes' }
+                        },
+                        required: ['team']
+                    }
+                }
+            ]
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+                const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
+                if (!authResult.success) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, authResult.error || 'Authentication required');
+                }
+                switch (name) {
+                    // CMDB & Discovery
+                    case 'snow_create_ci':
+                        return await this.createCI(args);
+                    case 'snow_create_ci_relationship':
+                        return await this.createCIRelationship(args);
+                    case 'snow_run_discovery':
+                        return await this.runDiscovery(args);
+                    case 'snow_get_ci_details':
+                        return await this.getCIDetails(args);
+                    case 'snow_search_cmdb':
+                        return await this.searchCMDB(args);
+                    case 'snow_impact_analysis':
+                        return await this.impactAnalysis(args);
+                    // Event Management
+                    case 'snow_create_event':
+                        return await this.createEvent(args);
+                    case 'snow_create_alert':
+                        return await this.createAlert(args);
+                    case 'snow_create_alert_rule':
+                        return await this.createAlertRule(args);
+                    case 'snow_get_event_correlation':
+                        return await this.getEventCorrelation(args);
+                    // HR Service Delivery
+                    case 'snow_create_hr_case':
+                        return await this.createHRCase(args);
+                    case 'snow_create_hr_task':
+                        return await this.createHRTask(args);
+                    case 'snow_employee_onboarding':
+                        return await this.employeeOnboarding(args);
+                    case 'snow_employee_offboarding':
+                        return await this.employeeOffboarding(args);
+                    // Customer Service Management
+                    case 'snow_create_customer_case':
+                        return await this.createCustomerCase(args);
+                    case 'snow_create_customer_account':
+                        return await this.createCustomerAccount(args);
+                    case 'snow_create_entitlement':
+                        return await this.createEntitlement(args);
+                    case 'snow_get_customer_history':
+                        return await this.getCustomerHistory(args);
+                    // DevOps
+                    case 'snow_create_devops_pipeline':
+                        return await this.createDevOpsPipeline(args);
+                    case 'snow_track_deployment':
+                        return await this.trackDeployment(args);
+                    case 'snow_create_devops_change':
+                        return await this.createDevOpsChange(args);
+                    case 'snow_get_devops_insights':
+                        return await this.getDevOpsInsights(args);
+                    case 'snow_velocity_tracking':
+                        return await this.velocityTracking(args);
+                    default:
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error in ${request.params.name}:`, error);
+                throw error;
+            }
+        });
+    }
+    // CMDB & Discovery Implementation
+    async createCI(args) {
+        try {
+            this.logger.info('Creating Configuration Item...');
+            const ciTable = args.ci_class || 'cmdb_ci';
+            const ciData = {
+                name: args.name,
+                serial_number: args.serial_number || '',
+                asset_tag: args.asset_tag || '',
+                model_id: args.model || '',
+                manufacturer: args.manufacturer || '',
+                location: args.location || '',
+                assigned_to: args.assigned_to || '',
+                operational_status: args.operational_status || '1',
+                ...args.attributes
+            };
+            const updateSetResult = await this.client.ensureUpdateSet();
+            const response = await this.client.createRecord(ciTable, ciData);
+            if (!response.success) {
+                throw new Error(`Failed to create CI: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Configuration Item created!
+
+🖥️ **${args.name}**
+🆔 sys_id: ${response.data.sys_id}
+📊 Class: ${args.ci_class}
+${args.serial_number ? `🔢 Serial: ${args.serial_number}` : ''}
+${args.asset_tag ? `🏷️ Asset Tag: ${args.asset_tag}` : ''}
+📍 Location: ${args.location || 'Not specified'}
+👤 Assigned: ${args.assigned_to || 'Unassigned'}
+
+✨ CI added to CMDB!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create CI:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create CI: ${error}`);
+        }
+    }
+    async createCIRelationship(args) {
+        try {
+            this.logger.info('Creating CI relationship...');
+            const relationshipData = {
+                parent: args.parent,
+                child: args.child,
+                type: args.type,
+                description: args.description || ''
+            };
+            const response = await this.client.createRecord('cmdb_rel_ci', relationshipData);
+            if (!response.success) {
+                throw new Error(`Failed to create CI relationship: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ CI Relationship created!
+
+🔗 **Relationship Created**
+🆔 sys_id: ${response.data.sys_id}
+👆 Parent: ${args.parent}
+👇 Child: ${args.child}
+📊 Type: ${args.type}
+📝 ${args.description || 'No description'}
+
+✨ Relationship mapped in CMDB!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create CI relationship:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create CI relationship: ${error}`);
+        }
+    }
+    async runDiscovery(args) {
+        try {
+            this.logger.info('Running Discovery...');
+            const discoveryData = {
+                schedule: args.schedule,
+                ip_range: args.ip_range || '',
+                mid_server: args.mid_server || '',
+                patterns: args.patterns ? args.patterns.join(',') : '',
+                credentials: args.credentials || '',
+                status: 'starting'
+            };
+            const response = await this.client.createRecord('discovery_status', discoveryData);
+            if (!response.success) {
+                throw new Error(`Failed to run Discovery: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Discovery initiated!
+
+🔍 **Discovery Run**
+🆔 Run ID: ${response.data.sys_id}
+📅 Schedule: ${args.schedule}
+${args.ip_range ? `🌐 IP Range: ${args.ip_range}` : ''}
+${args.mid_server ? `🖥️ MID Server: ${args.mid_server}` : ''}
+${args.patterns ? `📋 Patterns: ${args.patterns.join(', ')}` : ''}
+
+✨ Discovery scan in progress!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to run Discovery:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to run Discovery: ${error}`);
+        }
+    }
+    async getCIDetails(args) {
+        try {
+            this.logger.info('Getting CI details...');
+            let ciId = args.ci_id;
+            if (!ciId.match(/^[a-f0-9]{32}$/)) {
+                const ciResponse = await this.client.searchRecords('cmdb_ci', `name=${ciId}`, 1);
+                if (ciResponse.success && ciResponse.data.result.length) {
+                    ciId = ciResponse.data.result[0].sys_id;
+                }
+            }
+            const response = await this.client.getRecord('cmdb_ci', ciId);
+            if (!response.success) {
+                throw new Error('CI not found');
+            }
+            const ci = response.data;
+            let details = `🖥️ **${ci.name}**
+🆔 sys_id: ${ci.sys_id}
+📊 Class: ${ci.sys_class_name}
+📊 Status: ${ci.operational_status}
+📍 Location: ${ci.location || 'Not specified'}
+👤 Assigned: ${ci.assigned_to || 'Unassigned'}`;
+            if (args.include_relationships) {
+                const relResponse = await this.client.searchRecords('cmdb_rel_ci', `parent=${ciId}^ORchild=${ciId}`, 50);
+                if (relResponse.success && relResponse.data.result.length) {
+                    const relationships = relResponse.data.result.map((rel) => `  - ${rel.type}: ${rel.parent === ciId ? rel.child : rel.parent}`).join('\n');
+                    details += `\n\n🔗 **Relationships:**\n${relationships}`;
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: details + '\n\n✨ CI details retrieved!'
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get CI details:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get CI details: ${error}`);
+        }
+    }
+    async searchCMDB(args) {
+        try {
+            this.logger.info('Searching CMDB...');
+            let query = '';
+            if (args.query) {
+                query = `nameLIKE${args.query}`;
+            }
+            if (args.ci_class) {
+                query += query ? '^' : '';
+                query += `sys_class_name=${args.ci_class}`;
+            }
+            if (args.operational_status) {
+                query += query ? '^' : '';
+                query += `operational_status=${args.operational_status}`;
+            }
+            if (args.location) {
+                query += query ? '^' : '';
+                query += `location=${args.location}`;
+            }
+            const limit = args.limit || 50;
+            const response = await this.client.searchRecords('cmdb_ci', query, limit);
+            if (!response.success) {
+                throw new Error('Failed to search CMDB');
+            }
+            const cis = response.data.result;
+            if (!cis.length) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '❌ No Configuration Items found'
+                        }]
+                };
+            }
+            const ciList = cis.map((ci) => `🖥️ **${ci.name}**
+📊 Class: ${ci.sys_class_name}
+📊 Status: ${ci.operational_status}
+📍 Location: ${ci.location || 'Not specified'}`).join('\n\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🔍 CMDB Search Results:
+
+${ciList}
+
+✨ Found ${cis.length} CI(s)`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to search CMDB:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to search CMDB: ${error}`);
+        }
+    }
+    async impactAnalysis(args) {
+        try {
+            this.logger.info('Performing impact analysis...');
+            // In a real implementation, this would traverse the CI relationships
+            // For now, we'll simulate the analysis
+            const mockImpact = {
+                directly_affected: 3,
+                indirectly_affected: 12,
+                services_impacted: ['Email Service', 'Web Portal', 'Database Service'],
+                risk_level: 'Medium',
+                recommendations: [
+                    'Schedule maintenance window',
+                    'Notify affected service owners',
+                    'Prepare rollback plan'
+                ]
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 Impact Analysis Results:
+
+🖥️ **CI:** ${args.ci_id}
+🔍 **Analysis Depth:** ${args.depth || 3} levels
+
+**Impact Summary:**
+⚡ Directly Affected CIs: ${mockImpact.directly_affected}
+🔗 Indirectly Affected CIs: ${mockImpact.indirectly_affected}
+⚠️ Risk Level: ${mockImpact.risk_level}
+
+**Services Impacted:**
+${mockImpact.services_impacted.map(s => `  - ${s}`).join('\n')}
+
+**Recommendations:**
+${mockImpact.recommendations.map(r => `  ✓ ${r}`).join('\n')}
+
+✨ Impact analysis complete!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to perform impact analysis:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to perform impact analysis: ${error}`);
+        }
+    }
+    // Event Management Implementation
+    async createEvent(args) {
+        try {
+            this.logger.info('Creating event...');
+            const eventData = {
+                source: args.source,
+                node: args.node,
+                type: args.type,
+                severity: args.severity,
+                description: args.description,
+                additional_info: args.additional_info ? JSON.stringify(args.additional_info) : '',
+                time_of_event: args.time_of_event || new Date().toISOString(),
+                resolution_state: args.resolution_state || 'New'
+            };
+            const response = await this.client.createRecord('em_event', eventData);
+            if (!response.success) {
+                throw new Error(`Failed to create event: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Event created!
+
+📡 **Event Created**
+🆔 sys_id: ${response.data.sys_id}
+📊 Source: ${args.source}
+🖥️ Node: ${args.node}
+📊 Type: ${args.type}
+⚠️ Severity: ${args.severity}
+📝 ${args.description}
+
+✨ Event submitted for processing!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create event:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create event: ${error}`);
+        }
+    }
+    async createAlert(args) {
+        try {
+            this.logger.info('Creating alert...');
+            const alertData = {
+                source: args.source,
+                node: args.node,
+                severity: args.severity,
+                description: args.description,
+                metric_name: args.metric_name || '',
+                threshold_value: args.threshold_value || '',
+                actual_value: args.actual_value || '',
+                assignment_group: args.assignment_group || ''
+            };
+            const response = await this.client.createRecord('em_alert', alertData);
+            if (!response.success) {
+                throw new Error(`Failed to create alert: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Alert created!
+
+🚨 **Alert Created**
+🆔 sys_id: ${response.data.sys_id}
+📊 Source: ${args.source}
+🖥️ Node: ${args.node}
+⚠️ Severity: ${args.severity}
+${args.metric_name ? `📊 Metric: ${args.metric_name}` : ''}
+${args.threshold_value ? `🎯 Threshold: ${args.threshold_value}` : ''}
+${args.actual_value ? `📈 Actual: ${args.actual_value}` : ''}
+
+✨ Alert created and assigned!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create alert:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create alert: ${error}`);
+        }
+    }
+    async createAlertRule(args) {
+        try {
+            this.logger.info('Creating alert rule...');
+            const ruleData = {
+                name: args.name,
+                condition: args.condition,
+                grouping_fields: args.grouping_fields ? args.grouping_fields.join(',') : '',
+                time_window: args.time_window || 300,
+                threshold: args.threshold || 1,
+                action: args.action || '',
+                active: args.active !== false
+            };
+            const response = await this.client.createRecord('em_alert_rule', ruleData);
+            if (!response.success) {
+                throw new Error(`Failed to create alert rule: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Alert Rule created!
+
+📋 **${args.name}**
+🆔 sys_id: ${response.data.sys_id}
+🔍 Condition: ${args.condition}
+⏱️ Time Window: ${args.time_window || 300} seconds
+🔢 Threshold: ${args.threshold || 1}
+🔄 Active: ${args.active !== false ? 'Yes' : 'No'}
+
+✨ Alert rule configured!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create alert rule:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create alert rule: ${error}`);
+        }
+    }
+    async getEventCorrelation(args) {
+        try {
+            this.logger.info('Getting event correlation...');
+            // Simulate correlation results
+            const mockCorrelation = {
+                alert_id: args.alert_id,
+                correlated_events: 8,
+                suppressed_events: 3,
+                correlation_rules_applied: ['Duplicate Detection', 'Time Window Grouping'],
+                root_cause: 'Database connection pool exhausted'
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 Event Correlation Results:
+
+🚨 **Alert:** ${args.alert_id || 'Latest'}
+📡 Correlated Events: ${mockCorrelation.correlated_events}
+🔇 Suppressed Events: ${mockCorrelation.suppressed_events}
+
+**Correlation Rules Applied:**
+${mockCorrelation.correlation_rules_applied.map(r => `  - ${r}`).join('\n')}
+
+**Root Cause:** ${mockCorrelation.root_cause}
+
+✨ Correlation analysis complete!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get event correlation:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get event correlation: ${error}`);
+        }
+    }
+    // HR Service Delivery Implementation
+    async createHRCase(args) {
+        try {
+            this.logger.info('Creating HR case...');
+            const caseData = {
+                employee: args.employee,
+                hr_service: args.hr_service,
+                short_description: args.short_description,
+                description: args.description || '',
+                priority: args.priority || 3,
+                category: args.category || '',
+                subcategory: args.subcategory || '',
+                confidential: args.confidential || false
+            };
+            const response = await this.client.createRecord('sn_hr_core_case', caseData);
+            if (!response.success) {
+                throw new Error(`Failed to create HR case: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ HR Case created!
+
+👤 **${args.short_description}**
+🆔 Case Number: ${response.data.number}
+🆔 sys_id: ${response.data.sys_id}
+👤 Employee: ${args.employee}
+📊 Service: ${args.hr_service}
+📂 Category: ${args.category || 'General'}
+⚠️ Priority: ${args.priority || 3}
+🔒 Confidential: ${args.confidential ? 'Yes' : 'No'}
+
+✨ HR case created and assigned!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create HR case:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create HR case: ${error}`);
+        }
+    }
+    async createHRTask(args) {
+        try {
+            this.logger.info('Creating HR task...');
+            const taskData = {
+                hr_case: args.hr_case,
+                type: args.type,
+                assigned_to: args.assigned_to || '',
+                short_description: args.short_description,
+                due_date: args.due_date || '',
+                instructions: args.instructions || ''
+            };
+            const response = await this.client.createRecord('sn_hr_core_task', taskData);
+            if (!response.success) {
+                throw new Error(`Failed to create HR task: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ HR Task created!
+
+📋 **${args.short_description}**
+🆔 Task Number: ${response.data.number}
+🆔 sys_id: ${response.data.sys_id}
+📊 Type: ${args.type}
+👤 Assigned: ${args.assigned_to || 'Unassigned'}
+📅 Due: ${args.due_date || 'Not set'}
+
+✨ HR task added to case!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create HR task:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create HR task: ${error}`);
+        }
+    }
+    async employeeOnboarding(args) {
+        try {
+            this.logger.info('Creating employee onboarding...');
+            const onboardingData = {
+                employee_name: args.employee_name,
+                email: args.email,
+                start_date: args.start_date,
+                department: args.department,
+                manager: args.manager,
+                job_title: args.job_title,
+                location: args.location || '',
+                equipment_needed: args.equipment_needed ? args.equipment_needed.join(',') : ''
+            };
+            const response = await this.client.createRecord('sn_hr_core_case', {
+                ...onboardingData,
+                hr_service: 'Employee Onboarding',
+                short_description: `Onboarding for ${args.employee_name}`,
+                category: 'Onboarding'
+            });
+            if (!response.success) {
+                throw new Error(`Failed to create onboarding: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Employee Onboarding initiated!
+
+👤 **${args.employee_name}**
+🆔 Case Number: ${response.data.number}
+📧 Email: ${args.email}
+📅 Start Date: ${args.start_date}
+🏢 Department: ${args.department}
+👔 Title: ${args.job_title}
+👤 Manager: ${args.manager}
+📍 Location: ${args.location || 'Not specified'}
+📦 Equipment: ${args.equipment_needed ? args.equipment_needed.join(', ') : 'Standard'}
+
+✨ Onboarding workflow started!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create onboarding:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create onboarding: ${error}`);
+        }
+    }
+    async employeeOffboarding(args) {
+        try {
+            this.logger.info('Creating employee offboarding...');
+            const offboardingData = {
+                employee: args.employee,
+                last_date: args.last_date,
+                reason: args.reason,
+                assets_to_return: args.assets_to_return ? args.assets_to_return.join(',') : '',
+                knowledge_transfer: args.knowledge_transfer || ''
+            };
+            const response = await this.client.createRecord('sn_hr_core_case', {
+                ...offboardingData,
+                hr_service: 'Employee Offboarding',
+                short_description: `Offboarding for ${args.employee}`,
+                category: 'Offboarding'
+            });
+            if (!response.success) {
+                throw new Error(`Failed to create offboarding: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Employee Offboarding initiated!
+
+👤 **Employee:** ${args.employee}
+🆔 Case Number: ${response.data.number}
+📅 Last Date: ${args.last_date}
+📝 Reason: ${args.reason}
+📦 Assets to Return: ${args.assets_to_return ? args.assets_to_return.join(', ') : 'None'}
+📚 Knowledge Transfer: ${args.knowledge_transfer || 'Not specified'}
+
+✨ Offboarding workflow started!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create offboarding:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create offboarding: ${error}`);
+        }
+    }
+    // Customer Service Management Implementation
+    async createCustomerCase(args) {
+        try {
+            this.logger.info('Creating customer case...');
+            const caseData = {
+                customer: args.customer,
+                contact: args.contact,
+                product: args.product || '',
+                short_description: args.short_description,
+                description: args.description || '',
+                priority: args.priority || 3,
+                category: args.category || '',
+                channel: args.channel || 'Portal'
+            };
+            const response = await this.client.createRecord('sn_customerservice_case', caseData);
+            if (!response.success) {
+                throw new Error(`Failed to create customer case: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Customer Case created!
+
+🎯 **${args.short_description}**
+🆔 Case Number: ${response.data.number}
+🆔 sys_id: ${response.data.sys_id}
+🏢 Customer: ${args.customer}
+👤 Contact: ${args.contact}
+${args.product ? `📦 Product: ${args.product}` : ''}
+📊 Channel: ${args.channel || 'Portal'}
+⚠️ Priority: ${args.priority || 3}
+
+✨ Customer case created and routed!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create customer case:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create customer case: ${error}`);
+        }
+    }
+    async createCustomerAccount(args) {
+        try {
+            this.logger.info('Creating customer account...');
+            const accountData = {
+                name: args.name,
+                account_number: args.account_number || '',
+                type: args.type,
+                industry: args.industry || '',
+                annual_revenue: args.annual_revenue || '',
+                employees: args.employees || 0,
+                primary_contact: args.primary_contact || ''
+            };
+            const response = await this.client.createRecord('sn_customerservice_account', accountData);
+            if (!response.success) {
+                throw new Error(`Failed to create customer account: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Customer Account created!
+
+🏢 **${args.name}**
+🆔 sys_id: ${response.data.sys_id}
+${args.account_number ? `📋 Account #: ${args.account_number}` : ''}
+📊 Type: ${args.type}
+${args.industry ? `🏭 Industry: ${args.industry}` : ''}
+${args.annual_revenue ? `💰 Revenue: ${args.annual_revenue}` : ''}
+${args.employees ? `👥 Employees: ${args.employees}` : ''}
+
+✨ Customer account established!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create customer account:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create customer account: ${error}`);
+        }
+    }
+    async createEntitlement(args) {
+        try {
+            this.logger.info('Creating entitlement...');
+            const entitlementData = {
+                account: args.account,
+                service: args.service,
+                start_date: args.start_date,
+                end_date: args.end_date,
+                support_level: args.support_level || 'Standard',
+                hours_included: args.hours_included || 0,
+                response_time: args.response_time || ''
+            };
+            const response = await this.client.createRecord('sn_customerservice_entitlement', entitlementData);
+            if (!response.success) {
+                throw new Error(`Failed to create entitlement: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Entitlement created!
+
+📜 **Service Entitlement**
+🆔 sys_id: ${response.data.sys_id}
+🏢 Account: ${args.account}
+📦 Service: ${args.service}
+📅 Period: ${args.start_date} to ${args.end_date}
+⭐ Level: ${args.support_level || 'Standard'}
+⏱️ Hours: ${args.hours_included || 'Unlimited'}
+⚡ Response: ${args.response_time || 'Standard SLA'}
+
+✨ Entitlement activated!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create entitlement:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create entitlement: ${error}`);
+        }
+    }
+    async getCustomerHistory(args) {
+        try {
+            this.logger.info('Getting customer history...');
+            // Simulate customer history
+            const mockHistory = {
+                total_cases: 24,
+                open_cases: 3,
+                avg_resolution_time: '2.5 days',
+                satisfaction_score: 4.2,
+                recent_cases: [
+                    'Product issue - Resolved',
+                    'Billing inquiry - In Progress',
+                    'Feature request - Submitted'
+                ]
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 Customer History:
+
+🏢 **Customer:** ${args.customer}
+
+**Summary:**
+📋 Total Cases: ${mockHistory.total_cases}
+🔓 Open Cases: ${mockHistory.open_cases}
+⏱️ Avg Resolution: ${mockHistory.avg_resolution_time}
+⭐ Satisfaction: ${mockHistory.satisfaction_score}/5
+
+**Recent Cases:**
+${mockHistory.recent_cases.map(c => `  - ${c}`).join('\n')}
+
+✨ Customer history retrieved!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get customer history:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get customer history: ${error}`);
+        }
+    }
+    // DevOps Implementation
+    async createDevOpsPipeline(args) {
+        try {
+            this.logger.info('Creating DevOps pipeline...');
+            const pipelineData = {
+                name: args.name,
+                repository: args.repository,
+                branch: args.branch,
+                stages: args.stages ? JSON.stringify(args.stages) : '',
+                triggers: args.triggers ? args.triggers.join(',') : '',
+                environment: args.environment || ''
+            };
+            const response = await this.client.createRecord('sn_devops_pipeline', pipelineData);
+            if (!response.success) {
+                throw new Error(`Failed to create DevOps pipeline: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ DevOps Pipeline created!
+
+🚀 **${args.name}**
+🆔 sys_id: ${response.data.sys_id}
+📦 Repository: ${args.repository}
+🌿 Branch: ${args.branch}
+📊 Stages: ${args.stages ? args.stages.length : 0}
+⚡ Triggers: ${args.triggers ? args.triggers.join(', ') : 'Manual'}
+🌍 Environment: ${args.environment || 'Not specified'}
+
+✨ Pipeline configured and ready!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create DevOps pipeline:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create DevOps pipeline: ${error}`);
+        }
+    }
+    async trackDeployment(args) {
+        try {
+            this.logger.info('Tracking deployment...');
+            const deploymentData = {
+                application: args.application,
+                version: args.version,
+                environment: args.environment,
+                pipeline: args.pipeline || '',
+                change_request: args.change_request || '',
+                status: args.status || 'in_progress',
+                start_time: args.start_time || new Date().toISOString()
+            };
+            const response = await this.client.createRecord('sn_devops_deployment', deploymentData);
+            if (!response.success) {
+                throw new Error(`Failed to track deployment: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Deployment tracked!
+
+🚀 **${args.application} v${args.version}**
+🆔 Deployment ID: ${response.data.sys_id}
+🌍 Environment: ${args.environment}
+📊 Status: ${args.status || 'in_progress'}
+${args.pipeline ? `🔄 Pipeline: ${args.pipeline}` : ''}
+${args.change_request ? `📋 Change: ${args.change_request}` : ''}
+⏱️ Started: ${args.start_time || 'Now'}
+
+✨ Deployment tracking active!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to track deployment:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to track deployment: ${error}`);
+        }
+    }
+    async createDevOpsChange(args) {
+        try {
+            this.logger.info('Creating DevOps change...');
+            const changeData = {
+                application: args.application,
+                version: args.version,
+                environment: args.environment,
+                deployment_date: args.deployment_date,
+                risk_assessment: args.risk_assessment ? JSON.stringify(args.risk_assessment) : '',
+                rollback_plan: args.rollback_plan || '',
+                type: 'standard',
+                category: 'Software',
+                short_description: `Deploy ${args.application} v${args.version} to ${args.environment}`
+            };
+            const response = await this.client.createRecord('change_request', changeData);
+            if (!response.success) {
+                throw new Error(`Failed to create DevOps change: ${response.error}`);
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ DevOps Change created!
+
+📋 **Change Request**
+🆔 Number: ${response.data.number}
+🆔 sys_id: ${response.data.sys_id}
+📦 Application: ${args.application}
+🔖 Version: ${args.version}
+🌍 Environment: ${args.environment}
+📅 Deployment: ${args.deployment_date}
+${args.rollback_plan ? `🔄 Rollback: Yes` : ''}
+
+✨ Change request ready for approval!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create DevOps change:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to create DevOps change: ${error}`);
+        }
+    }
+    async getDevOpsInsights(args) {
+        try {
+            this.logger.info('Getting DevOps insights...');
+            // Simulate DevOps insights
+            const mockInsights = {
+                deployment_frequency: '4.2 per day',
+                lead_time: '2.5 hours',
+                mttr: '45 minutes',
+                change_failure_rate: '8%',
+                trends: {
+                    velocity: 'increasing',
+                    quality: 'stable',
+                    stability: 'improving'
+                }
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 DevOps Insights:
+
+📦 **Application:** ${args.application || 'All'}
+📈 **Metric Type:** ${args.metric_type || 'all'}
+📅 **Period:** ${args.time_range || '30 days'}
+
+**Key Metrics:**
+🚀 Deployment Frequency: ${mockInsights.deployment_frequency}
+⏱️ Lead Time: ${mockInsights.lead_time}
+🔧 MTTR: ${mockInsights.mttr}
+❌ Change Failure Rate: ${mockInsights.change_failure_rate}
+
+**Trends:**
+📈 Velocity: ${mockInsights.trends.velocity}
+✅ Quality: ${mockInsights.trends.quality}
+🛡️ Stability: ${mockInsights.trends.stability}
+
+✨ Insights generated!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get DevOps insights:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to get DevOps insights: ${error}`);
+        }
+    }
+    async velocityTracking(args) {
+        try {
+            this.logger.info('Tracking velocity...');
+            const velocityData = {
+                team: args.team,
+                sprint: args.sprint || '',
+                story_points: args.story_points || 0,
+                deployments: args.deployments || 0,
+                lead_time: args.lead_time || 0,
+                mttr: args.mttr || 0
+            };
+            const response = await this.client.createRecord('sn_devops_velocity', velocityData);
+            if (!response.success) {
+                // Fallback message if table doesn't exist
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `📊 Velocity Tracked!
+
+👥 **Team:** ${args.team}
+${args.sprint ? `🏃 Sprint: ${args.sprint}` : ''}
+📊 Story Points: ${args.story_points || 0}
+🚀 Deployments: ${args.deployments || 0}
+⏱️ Lead Time: ${args.lead_time || 0} hours
+🔧 MTTR: ${args.mttr || 0} minutes
+
+✨ Velocity metrics recorded!`
+                        }]
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Velocity tracked!
+
+👥 **Team:** ${args.team}
+🆔 Record ID: ${response.data.sys_id}
+${args.sprint ? `🏃 Sprint: ${args.sprint}` : ''}
+📊 Points: ${args.story_points || 0}
+🚀 Deployments: ${args.deployments || 0}
+
+✨ Velocity metrics saved!`
+                    }]
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to track velocity:', error);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to track velocity: ${error}`);
+        }
+    }
+    async run() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        this.logger.info('ServiceNow CMDB/Event/HR/CSM/DevOps MCP Server running on stdio');
+    }
+}
+const server = new ServiceNowCMDBEventHRCSMDevOpsMCP();
+server.run().catch(console.error);
+//# sourceMappingURL=servicenow-cmdb-event-hr-csm-devops-mcp.js.map