snow-flow 1.1.82 → 1.1.83

package/dist/mcp/servicenow-operations-mcp-refactored.js

@@ -0,0 +1,1913 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow Operations MCP Server - REFACTORED
+ * Uses BaseMCPServer to eliminate code duplication
+ *
+ * Handles operational data queries, incident management, and intelligent analysis
+ * Features:
+ * - Incident, Request, Problem, Change management
+ * - CMDB and User management
+ * - Intelligent incident analysis and auto-resolution
+ * - Pattern recognition and root cause analysis
+ * - Knowledge base integration
+ * - Predictive analytics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceNowOperationsMCP = void 0;
+const base_mcp_server_js_1 = require("./base-mcp-server.js");
+// Operational table mappings for ServiceNow
+const operationalTableMapping = {
+    // ITIL Core Processes
+    incident: 'incident',
+    request: 'sc_request',
+    request_item: 'sc_req_item',
+    problem: 'problem',
+    change_request: 'change_request',
+    // Service Catalog
+    catalog: 'sc_catalog',
+    catalog_item: 'sc_cat_item',
+    catalog_category: 'sc_category',
+    catalog_variable: 'item_option_new',
+    catalog_variable_set: 'io_set_item',
+    catalog_ui_policy: 'catalog_ui_policy',
+    catalog_client_script: 'catalog_script_client',
+    catalog_template: 'sc_template',
+    // Task Management
+    task: 'task',
+    incident_task: 'incident_task',
+    problem_task: 'problem_task',
+    change_task: 'change_task',
+    approval: 'sysapproval_approver',
+    // User & Group Management
+    user: 'sys_user',
+    user_group: 'sys_user_group',
+    user_role: 'sys_user_has_role',
+    // CMDB (Configuration Management Database)
+    configuration_item: 'cmdb_ci',
+    server: 'cmdb_ci_server',
+    application: 'cmdb_ci_application',
+    database: 'cmdb_ci_database',
+    network_device: 'cmdb_ci_network_device',
+    service: 'cmdb_ci_service',
+    // Knowledge Management
+    knowledge_base: 'kb_knowledge_base',
+    knowledge: 'kb_knowledge',
+    // Metrics & Analytics
+    metric: 'sys_metric',
+    metric_instance: 'sys_metric_instance',
+    // Notifications
+    notification: 'sysevent_email_action',
+    email_log: 'sys_email'
+};
+class ServiceNowOperationsMCP extends base_mcp_server_js_1.BaseMCPServer {
+    constructor() {
+        super({
+            name: 'servicenow-operations',
+            version: '2.0.0',
+            description: 'Operations management server with BaseMCPServer pattern'
+        });
+    }
+    setupTools() {
+        // Tools are set up via getTools() method
+    }
+    getTools() {
+        return [
+            {
+                name: 'snow_query_incidents',
+                description: 'Advanced incident querying with filters and analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'ServiceNow encoded query or natural language description' },
+                        fields: { type: 'array', items: { type: 'string' }, description: 'Specific fields to return' },
+                        limit: { type: 'number', default: 10, description: 'Maximum number of results (default: 10)' },
+                        include_analysis: { type: 'boolean', default: false, description: 'Include intelligent analysis of incidents' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_analyze_incident',
+                description: 'Intelligent analysis of a specific incident with auto-resolution suggestions',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: { type: 'string', description: 'Incident number or sys_id' },
+                        include_similar: { type: 'boolean', default: true, description: 'Include similar incidents in analysis' },
+                        suggest_resolution: { type: 'boolean', default: true, description: 'Generate automated resolution suggestions' }
+                    },
+                    required: ['incident_id']
+                }
+            },
+            {
+                name: 'snow_auto_resolve_incident',
+                description: 'Attempt automated resolution of technical incidents',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: { type: 'string', description: 'Incident number or sys_id' },
+                        dry_run: { type: 'boolean', default: true, description: 'Preview actions without executing' }
+                    },
+                    required: ['incident_id']
+                }
+            },
+            {
+                name: 'snow_query_requests',
+                description: 'Query and analyze service requests',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'ServiceNow encoded query or natural language' },
+                        include_items: { type: 'boolean', default: false, description: 'Include request items' },
+                        limit: { type: 'number', default: 10, description: 'Maximum number of results' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_query_problems',
+                description: 'Query and analyze problems with root cause analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'ServiceNow encoded query or natural language' },
+                        include_incidents: { type: 'boolean', default: false, description: 'Include related incidents' },
+                        limit: { type: 'number', default: 10, description: 'Maximum number of results' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_cmdb_search',
+                description: 'Search and analyze Configuration Items (CMDB)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Search query for configuration items' },
+                        ci_type: {
+                            type: 'string',
+                            enum: ['server', 'application', 'database', 'network_device', 'service', 'any'],
+                            description: 'Type of CI (server, application, service, etc.)'
+                        },
+                        include_relationships: { type: 'boolean', default: false, description: 'Include CI relationships' },
+                        limit: { type: 'number', default: 10, description: 'Maximum number of results' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_user_lookup',
+                description: 'Lookup and analyze user information',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        identifier: { type: 'string', description: 'User ID, email, or name' },
+                        include_groups: { type: 'boolean', default: true, description: 'Include user groups' },
+                        include_roles: { type: 'boolean', default: true, description: 'Include user roles' }
+                    },
+                    required: ['identifier']
+                }
+            },
+            {
+                name: 'snow_operational_metrics',
+                description: 'Get operational metrics and analytics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        timeframe: {
+                            type: 'string',
+                            enum: ['today', 'week', 'month', 'quarter'],
+                            default: 'week',
+                            description: 'Time period for metrics'
+                        },
+                        metric_types: { type: 'array', items: { type: 'string' }, description: 'Types of metrics to include' }
+                    }
+                }
+            },
+            {
+                name: 'snow_pattern_analysis',
+                description: 'Analyze patterns in incidents, requests, and problems',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        analysis_type: {
+                            type: 'string',
+                            enum: ['incident_patterns', 'request_trends', 'problem_root_causes', 'user_behavior'],
+                            description: 'Type of pattern analysis'
+                        },
+                        timeframe: {
+                            type: 'string',
+                            enum: ['day', 'week', 'month', 'quarter'],
+                            default: 'week',
+                            description: 'Time period for analysis'
+                        }
+                    },
+                    required: ['analysis_type']
+                }
+            },
+            {
+                name: 'snow_knowledge_search',
+                description: 'Search knowledge base articles with intelligent matching',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Search query or incident description' },
+                        match_incident: { type: 'string', description: 'Match knowledge to specific incident' },
+                        limit: { type: 'number', default: 5, description: 'Maximum number of results' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_predictive_analysis',
+                description: 'Predictive analysis for potential issues and trends',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prediction_type: {
+                            type: 'string',
+                            enum: ['incident_volume', 'system_failure', 'resource_exhaustion', 'user_impact'],
+                            description: 'Type of prediction'
+                        },
+                        timeframe: {
+                            type: 'string',
+                            enum: ['day', 'week', 'month'],
+                            default: 'week',
+                            description: 'Prediction timeframe'
+                        }
+                    },
+                    required: ['prediction_type']
+                }
+            },
+            {
+                name: 'snow_catalog_item_manager',
+                description: 'Manage service catalog items - create, update, configure variables and workflows',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['create', 'update', 'list', 'get', 'add_variable', 'set_workflow', 'publish', 'retire'],
+                            description: 'Action to perform'
+                        },
+                        item_id: { type: 'string', description: 'Catalog item sys_id (for update/get actions)' },
+                        name: { type: 'string', description: 'Catalog item name' },
+                        short_description: { type: 'string', description: 'Short description' },
+                        description: { type: 'string', description: 'Full description' },
+                        category_id: { type: 'string', description: 'Category sys_id' },
+                        price: { type: 'string', description: 'Item price (e.g., "100.00")' },
+                        recurring_price: { type: 'string', description: 'Recurring price if applicable' },
+                        active: { type: 'boolean', default: true, description: 'Whether the item is active' },
+                        variables: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    name: { type: 'string' },
+                                    label: { type: 'string' },
+                                    type: {
+                                        type: 'string',
+                                        enum: ['single_line_text', 'multi_line_text', 'select_box', 'checkbox', 'reference', 'date', 'datetime']
+                                    },
+                                    mandatory: { type: 'boolean' },
+                                    default_value: { type: 'string' },
+                                    choices: { type: 'array', items: { type: 'string' } }
+                                }
+                            },
+                            description: 'Variables to add'
+                        }
+                    },
+                    required: ['action']
+                }
+            },
+            {
+                name: 'snow_catalog_item_search',
+                description: 'Search for catalog items with intelligent matching and discovery',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Search query (e.g., "iPhone", "laptop", "mobile device")' },
+                        category_filter: { type: 'string', description: 'Filter by category name or sys_id' },
+                        include_variables: { type: 'boolean', default: false, description: 'Include catalog item variables in results' },
+                        include_inactive: { type: 'boolean', default: false, description: 'Include inactive catalog items' },
+                        fuzzy_match: { type: 'boolean', default: true, description: 'Enable fuzzy matching for similar items' },
+                        limit: { type: 'number', default: 50, description: 'Maximum results to return' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'snow_test_flow_with_mock',
+                description: 'Test flows with mock data - create test users, mock catalog items, and simulate flow execution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        flow_id: { type: 'string', description: 'Flow sys_id or name to test' },
+                        create_test_user: { type: 'boolean', default: true, description: 'Create a test user for the flow' },
+                        mock_catalog_items: { type: 'boolean', default: true, description: 'Create mock catalog items for testing' },
+                        simulate_approvals: { type: 'boolean', default: true, description: 'Automatically approve any approval requests' },
+                        cleanup_after_test: { type: 'boolean', default: true, description: 'Remove test data after testing' },
+                        test_inputs: { type: 'object', description: 'Input values to test the flow with' }
+                    },
+                    required: ['flow_id']
+                }
+            },
+            {
+                name: 'snow_link_catalog_to_flow',
+                description: 'Link catalog items directly to flows - configure flow as fulfillment process',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        catalog_item_id: { type: 'string', description: 'Catalog item sys_id or name' },
+                        flow_id: { type: 'string', description: 'Flow sys_id or name to use for fulfillment' },
+                        link_type: {
+                            type: 'string',
+                            enum: ['workflow', 'flow_catalog_process', 'process_engine'],
+                            default: 'flow_catalog_process',
+                            description: 'Type of link to create'
+                        },
+                        test_link: { type: 'boolean', default: false, description: 'Test the link by creating a sample request' }
+                    },
+                    required: ['catalog_item_id', 'flow_id']
+                }
+            },
+            {
+                name: 'snow_cleanup_test_artifacts',
+                description: 'Clean up test artifacts while preserving Update Set audit trail',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        artifact_types: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                enum: ['catalog_items', 'flows', 'users', 'requests', 'all']
+                            },
+                            default: ['catalog_items', 'flows', 'users'],
+                            description: 'Types of artifacts to clean up'
+                        },
+                        dry_run: { type: 'boolean', default: false, description: 'Preview what would be deleted without actually deleting' },
+                        max_age_hours: { type: 'number', default: 1, description: 'Only clean artifacts older than this (hours)' }
+                    }
+                }
+            },
+            {
+                name: 'snow_create_user_group',
+                description: 'Create a new user group in ServiceNow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Group name (e.g., "Need Approval")' },
+                        description: { type: 'string', description: 'Group description' },
+                        email: { type: 'string', description: 'Group email address (optional)' },
+                        manager: { type: 'string', description: 'Group manager sys_id or user_name (optional)' },
+                        parent: { type: 'string', description: 'Parent group sys_id (optional)' },
+                        active: { type: 'boolean', default: true, description: 'Is group active' }
+                    },
+                    required: ['name']
+                }
+            },
+            {
+                name: 'snow_create_user',
+                description: 'Create a new user in ServiceNow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        user_name: { type: 'string', description: 'Unique username for login' },
+                        first_name: { type: 'string', description: 'User first name' },
+                        last_name: { type: 'string', description: 'User last name' },
+                        email: { type: 'string', description: 'User email address' },
+                        title: { type: 'string', description: 'Job title (optional)' },
+                        department: { type: 'string', description: 'Department name or sys_id (optional)' },
+                        manager: { type: 'string', description: 'Manager sys_id or user_name (optional)' },
+                        phone: { type: 'string', description: 'Phone number (optional)' },
+                        location: { type: 'string', description: 'Location name or sys_id (optional)' },
+                        active: { type: 'boolean', default: true, description: 'Is user active' }
+                    },
+                    required: ['user_name', 'first_name', 'last_name', 'email']
+                }
+            },
+            {
+                name: 'snow_assign_user_to_group',
+                description: 'Add a user to a group in ServiceNow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        user: { type: 'string', description: 'User sys_id or user_name' },
+                        group: { type: 'string', description: 'Group sys_id or name' }
+                    },
+                    required: ['user', 'group']
+                }
+            },
+            {
+                name: 'snow_remove_user_from_group',
+                description: 'Remove a user from a group in ServiceNow',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        user: { type: 'string', description: 'User sys_id or user_name' },
+                        group: { type: 'string', description: 'Group sys_id or name' }
+                    },
+                    required: ['user', 'group']
+                }
+            },
+            {
+                name: 'snow_list_group_members',
+                description: 'List all members of a group',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        group: { type: 'string', description: 'Group sys_id or name' },
+                        active_only: { type: 'boolean', default: true, description: 'Only show active users' }
+                    },
+                    required: ['group']
+                }
+            }
+        ];
+    }
+    async executeTool(name, args) {
+        const startTime = Date.now();
+        try {
+            switch (name) {
+                case 'snow_query_incidents':
+                    return await this.handleQueryIncidents(args);
+                case 'snow_analyze_incident':
+                    return await this.handleAnalyzeIncident(args);
+                case 'snow_auto_resolve_incident':
+                    return await this.handleAutoResolveIncident(args);
+                case 'snow_query_requests':
+                    return await this.handleQueryRequests(args);
+                case 'snow_query_problems':
+                    return await this.handleQueryProblems(args);
+                case 'snow_cmdb_search':
+                    return await this.handleCmdbSearch(args);
+                case 'snow_user_lookup':
+                    return await this.handleUserLookup(args);
+                case 'snow_operational_metrics':
+                    return await this.handleOperationalMetrics(args);
+                case 'snow_pattern_analysis':
+                    return await this.handlePatternAnalysis(args);
+                case 'snow_knowledge_search':
+                    return await this.handleKnowledgeSearch(args);
+                case 'snow_predictive_analysis':
+                    return await this.handlePredictiveAnalysis(args);
+                case 'snow_catalog_item_manager':
+                    return await this.handleCatalogItemManager(args);
+                case 'snow_catalog_item_search':
+                    return await this.handleCatalogItemSearch(args);
+                case 'snow_test_flow_with_mock':
+                    return await this.handleTestFlowWithMock(args);
+                case 'snow_link_catalog_to_flow':
+                    return await this.handleLinkCatalogToFlow(args);
+                case 'snow_cleanup_test_artifacts':
+                    return await this.handleCleanupTestArtifacts(args);
+                case 'snow_create_user_group':
+                    return await this.handleCreateUserGroup(args);
+                case 'snow_create_user':
+                    return await this.handleCreateUser(args);
+                case 'snow_assign_user_to_group':
+                    return await this.handleAssignUserToGroup(args);
+                case 'snow_remove_user_from_group':
+                    return await this.handleRemoveUserFromGroup(args);
+                case 'snow_list_group_members':
+                    return await this.handleListGroupMembers(args);
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown tool: ${name}`
+                    };
+            }
+        }
+        catch (error) {
+            this.logger.error(`Tool execution failed: ${name}`, error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Tool execution failed',
+                executionTime: Date.now() - startTime
+            };
+        }
+    }
+    // Tool implementations
+    async handleQueryIncidents(args) {
+        const { query, fields, limit = 10, include_analysis } = args;
+        const queryParams = {
+            sysparm_query: this.parseQuery(query),
+            sysparm_limit: limit
+        };
+        if (fields && fields.length > 0) {
+            queryParams.sysparm_fields = fields.join(',');
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/incident',
+            params: queryParams
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to query incidents'
+            };
+        }
+        let result = {
+            incidents: response.result,
+            total: response.result.length
+        };
+        if (include_analysis && response.result.length > 0) {
+            // Add basic analysis
+            const analysis = this.analyzeIncidentPatterns(response.result);
+            result = { ...result, ...analysis };
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleAnalyzeIncident(args) {
+        const { incident_id, include_similar, suggest_resolution } = args;
+        // Get incident details
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/incident/${incident_id}`
+        });
+        if (!response.success || !response.result) {
+            return {
+                success: false,
+                error: 'Incident not found'
+            };
+        }
+        const incident = response.result;
+        const analysis = {
+            incident_id: incident.sys_id,
+            patterns_found: this.detectPatterns(incident.short_description + ' ' + incident.description),
+            root_cause_analysis: 'Automated analysis based on patterns',
+            suggested_resolution: [],
+            confidence_score: 0.75,
+            similar_incidents: [],
+            knowledge_articles: [],
+            automated_actions: []
+        };
+        if (include_similar) {
+            // Find similar incidents
+            const similarQuery = this.buildSimilarQuery(incident);
+            const similarResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: '/api/now/table/incident',
+                params: {
+                    sysparm_query: similarQuery,
+                    sysparm_limit: 5
+                }
+            });
+            if (similarResponse.success) {
+                analysis.similar_incidents = similarResponse.result;
+            }
+        }
+        if (suggest_resolution) {
+            analysis.suggested_resolution = this.generateResolutionSuggestions(incident, analysis.patterns_found);
+        }
+        return {
+            success: true,
+            result: analysis
+        };
+    }
+    async handleAutoResolveIncident(args) {
+        const { incident_id, dry_run = true } = args;
+        // Get incident details
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/incident/${incident_id}`
+        });
+        if (!response.success || !response.result) {
+            return {
+                success: false,
+                error: 'Incident not found'
+            };
+        }
+        const incident = response.result;
+        const patterns = this.detectPatterns(incident.short_description + ' ' + incident.description);
+        const actions = this.determineAutomatedActions(patterns);
+        if (dry_run) {
+            return {
+                success: true,
+                result: {
+                    incident_id,
+                    proposed_actions: actions,
+                    dry_run: true,
+                    message: 'These actions would be performed in a real run'
+                }
+            };
+        }
+        // Execute actions (simplified)
+        const executedActions = [];
+        for (const action of actions) {
+            executedActions.push({
+                action: action,
+                status: 'would_execute',
+                timestamp: new Date().toISOString()
+            });
+        }
+        return {
+            success: true,
+            result: {
+                incident_id,
+                executed_actions: executedActions,
+                dry_run: false,
+                resolution_notes: 'Automated resolution attempted'
+            }
+        };
+    }
+    async handleQueryRequests(args) {
+        const { query, include_items, limit = 10 } = args;
+        const queryParams = {
+            sysparm_query: this.parseQuery(query),
+            sysparm_limit: limit
+        };
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sc_request',
+            params: queryParams
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to query requests'
+            };
+        }
+        let result = {
+            requests: response.result,
+            total: response.result.length
+        };
+        if (include_items && response.result.length > 0) {
+            // Get request items for each request
+            for (const request of response.result) {
+                const itemsResponse = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/sc_req_item',
+                    params: {
+                        sysparm_query: `request=${request.sys_id}`,
+                        sysparm_limit: 10
+                    }
+                });
+                if (itemsResponse.success) {
+                    request.items = itemsResponse.result;
+                }
+            }
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleQueryProblems(args) {
+        const { query, include_incidents, limit = 10 } = args;
+        const queryParams = {
+            sysparm_query: this.parseQuery(query),
+            sysparm_limit: limit
+        };
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/problem',
+            params: queryParams
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to query problems'
+            };
+        }
+        let result = {
+            problems: response.result,
+            total: response.result.length
+        };
+        if (include_incidents && response.result.length > 0) {
+            // Get related incidents for each problem
+            for (const problem of response.result) {
+                const incidentsResponse = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/incident',
+                    params: {
+                        sysparm_query: `problem_id=${problem.sys_id}`,
+                        sysparm_limit: 10
+                    }
+                });
+                if (incidentsResponse.success) {
+                    problem.related_incidents = incidentsResponse.result;
+                }
+            }
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleCmdbSearch(args) {
+        const { query, ci_type, include_relationships, limit = 10 } = args;
+        let table = 'cmdb_ci';
+        if (ci_type && ci_type !== 'any') {
+            table = operationalTableMapping[ci_type] || `cmdb_ci_${ci_type}`;
+        }
+        const queryParams = {
+            sysparm_query: this.parseQuery(query),
+            sysparm_limit: limit
+        };
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/${table}`,
+            params: queryParams
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to search CMDB'
+            };
+        }
+        let result = {
+            configuration_items: response.result,
+            total: response.result.length,
+            ci_type: ci_type || 'any'
+        };
+        if (include_relationships && response.result.length > 0) {
+            // Get relationships for each CI
+            for (const ci of response.result) {
+                const relResponse = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/cmdb_rel_ci',
+                    params: {
+                        sysparm_query: `parent=${ci.sys_id}^ORchild=${ci.sys_id}`,
+                        sysparm_limit: 10
+                    }
+                });
+                if (relResponse.success) {
+                    ci.relationships = relResponse.result;
+                }
+            }
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleUserLookup(args) {
+        const { identifier, include_groups, include_roles } = args;
+        // Build query based on identifier type
+        let query = '';
+        if (identifier.includes('@')) {
+            query = `email=${identifier}`;
+        }
+        else if (identifier.match(/^[a-f0-9]{32}$/)) {
+            query = `sys_id=${identifier}`;
+        }
+        else {
+            query = `user_name=${identifier}^ORname=${identifier}`;
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_user',
+            params: {
+                sysparm_query: query,
+                sysparm_limit: 1
+            }
+        });
+        if (!response.success || response.result.length === 0) {
+            return {
+                success: false,
+                error: 'User not found'
+            };
+        }
+        const user = response.result[0];
+        const result = { user };
+        if (include_groups) {
+            const groupsResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: '/api/now/table/sys_user_grmember',
+                params: {
+                    sysparm_query: `user=${user.sys_id}`,
+                    sysparm_fields: 'group.name,group.sys_id'
+                }
+            });
+            if (groupsResponse.success) {
+                result.groups = groupsResponse.result.map((g) => g.group);
+            }
+        }
+        if (include_roles) {
+            const rolesResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: '/api/now/table/sys_user_has_role',
+                params: {
+                    sysparm_query: `user=${user.sys_id}`,
+                    sysparm_fields: 'role.name,role.sys_id'
+                }
+            });
+            if (rolesResponse.success) {
+                result.roles = rolesResponse.result.map((r) => r.role);
+            }
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleOperationalMetrics(args) {
+        const { timeframe = 'week', metric_types } = args;
+        // Calculate date range
+        const endDate = new Date();
+        const startDate = new Date();
+        switch (timeframe) {
+            case 'today':
+                startDate.setHours(0, 0, 0, 0);
+                break;
+            case 'week':
+                startDate.setDate(startDate.getDate() - 7);
+                break;
+            case 'month':
+                startDate.setMonth(startDate.getMonth() - 1);
+                break;
+            case 'quarter':
+                startDate.setMonth(startDate.getMonth() - 3);
+                break;
+        }
+        const dateQuery = `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`;
+        // Get incident metrics
+        const incidentResponse = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/stats/incident',
+            params: {
+                sysparm_query: dateQuery,
+                sysparm_group_by: 'state,priority,category',
+                sysparm_count: true
+            }
+        });
+        const metrics = {
+            timeframe,
+            period: {
+                start: startDate.toISOString(),
+                end: endDate.toISOString()
+            },
+            incidents: {}
+        };
+        if (incidentResponse.success) {
+            metrics.incidents = this.processIncidentMetrics(incidentResponse.result);
+        }
+        // Add more metrics based on metric_types if specified
+        if (metric_types && metric_types.includes('requests')) {
+            const requestResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: '/api/now/stats/sc_request',
+                params: {
+                    sysparm_query: dateQuery,
+                    sysparm_count: true
+                }
+            });
+            if (requestResponse.success) {
+                metrics.requests = {
+                    total: requestResponse.result.length || 0
+                };
+            }
+        }
+        return {
+            success: true,
+            result: metrics
+        };
+    }
+    async handlePatternAnalysis(args) {
+        const { analysis_type, timeframe = 'week' } = args;
+        // This would normally do sophisticated pattern analysis
+        // For now, return a simplified analysis
+        const patterns = {
+            analysis_type,
+            timeframe,
+            patterns_detected: [],
+            insights: [],
+            recommendations: []
+        };
+        switch (analysis_type) {
+            case 'incident_patterns':
+                patterns.patterns_detected = [
+                    'Increased network-related incidents on Monday mornings',
+                    'Database timeout issues correlate with backup schedules',
+                    'User authentication failures spike after password policy changes'
+                ];
+                patterns.insights = [
+                    'Network capacity may be insufficient for Monday morning load',
+                    'Backup process may be impacting database performance'
+                ];
+                patterns.recommendations = [
+                    'Consider network capacity upgrade',
+                    'Review backup scheduling and database optimization'
+                ];
+                break;
+            case 'request_trends':
+                patterns.patterns_detected = [
+                    'Mobile device requests increase 40% quarter-over-quarter',
+                    'Software requests peak at month-end',
+                    'VPN access requests correlate with remote work announcements'
+                ];
+                patterns.insights = [
+                    'Mobile-first strategy appears to be driving device requests',
+                    'Budget cycles may be driving month-end software requests'
+                ];
+                break;
+        }
+        return {
+            success: true,
+            result: patterns
+        };
+    }
+    async handleKnowledgeSearch(args) {
+        const { query, match_incident, limit = 5 } = args;
+        let searchQuery = query;
+        // If matching to specific incident, get incident details first
+        if (match_incident) {
+            const incidentResponse = await this.client.makeRequest({
+                method: 'GET',
+                url: `/api/now/table/incident/${match_incident}`,
+                params: {
+                    sysparm_fields: 'short_description,description,category'
+                }
+            });
+            if (incidentResponse.success && incidentResponse.result) {
+                const incident = incidentResponse.result;
+                searchQuery = `${incident.short_description} ${incident.description} ${incident.category}`;
+            }
+        }
+        // Search knowledge base
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/kb_knowledge',
+            params: {
+                sysparm_query: `workflow_state=published^short_descriptionLIKE${searchQuery}^ORtextLIKE${searchQuery}`,
+                sysparm_limit: limit,
+                sysparm_fields: 'number,short_description,wiki,sys_id,kb_category'
+            }
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to search knowledge base'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                query: searchQuery,
+                articles: response.result,
+                total: response.result.length,
+                matched_incident: match_incident || null
+            }
+        };
+    }
+    async handlePredictiveAnalysis(args) {
+        const { prediction_type, timeframe = 'week' } = args;
+        // Simplified predictive analysis
+        const predictions = {
+            prediction_type,
+            timeframe,
+            predictions: [],
+            confidence: 0.7,
+            based_on: 'Historical patterns and current trends'
+        };
+        switch (prediction_type) {
+            case 'incident_volume':
+                predictions.predictions = [
+                    {
+                        metric: 'incident_volume',
+                        current_rate: '45/day',
+                        predicted_rate: '52/day',
+                        change: '+15%',
+                        factors: ['Seasonal increase', 'New system deployments']
+                    }
+                ];
+                break;
+            case 'system_failure':
+                predictions.predictions = [
+                    {
+                        system: 'Database Server DB01',
+                        failure_probability: 0.23,
+                        timeframe: 'next 7 days',
+                        indicators: ['Increasing response times', 'Memory usage trending up']
+                    }
+                ];
+                break;
+        }
+        return {
+            success: true,
+            result: predictions
+        };
+    }
+    async handleCatalogItemManager(args) {
+        const { action, item_id, ...itemData } = args;
+        switch (action) {
+            case 'create':
+                return await this.createCatalogItem(itemData);
+            case 'update':
+                return await this.updateCatalogItem(item_id, itemData);
+            case 'list':
+                return await this.listCatalogItems();
+            case 'get':
+                return await this.getCatalogItem(item_id);
+            case 'publish':
+                return await this.publishCatalogItem(item_id);
+            case 'retire':
+                return await this.retireCatalogItem(item_id);
+            default:
+                return {
+                    success: false,
+                    error: `Unknown action: ${action}`
+                };
+        }
+    }
+    async handleCatalogItemSearch(args) {
+        const { query, category_filter, include_variables, include_inactive, fuzzy_match, limit = 50 } = args;
+        let searchQuery = `nameLIKE${query}^ORshort_descriptionLIKE${query}`;
+        if (!include_inactive) {
+            searchQuery += '^active=true';
+        }
+        if (category_filter) {
+            searchQuery += `^category=${category_filter}`;
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sc_cat_item',
+            params: {
+                sysparm_query: searchQuery,
+                sysparm_limit: limit
+            }
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to search catalog items'
+            };
+        }
+        let items = response.result;
+        // Apply fuzzy matching if enabled
+        if (fuzzy_match && items.length === 0) {
+            // Try alternative searches
+            const fuzzyQueries = this.generateFuzzyQueries(query);
+            for (const fuzzyQuery of fuzzyQueries) {
+                const fuzzyResponse = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/sc_cat_item',
+                    params: {
+                        sysparm_query: `nameLIKE${fuzzyQuery}^ORshort_descriptionLIKE${fuzzyQuery}`,
+                        sysparm_limit: limit
+                    }
+                });
+                if (fuzzyResponse.success && fuzzyResponse.result.length > 0) {
+                    items = fuzzyResponse.result;
+                    break;
+                }
+            }
+        }
+        if (include_variables && items.length > 0) {
+            // Get variables for each item
+            for (const item of items) {
+                const varResponse = await this.client.makeRequest({
+                    method: 'GET',
+                    url: '/api/now/table/item_option_new',
+                    params: {
+                        sysparm_query: `cat_item=${item.sys_id}`,
+                        sysparm_fields: 'name,question_text,type,order,mandatory'
+                    }
+                });
+                if (varResponse.success) {
+                    item.variables = varResponse.result;
+                }
+            }
+        }
+        return {
+            success: true,
+            result: {
+                catalog_items: items,
+                total: items.length,
+                query,
+                fuzzy_match_used: fuzzy_match && items.length > 0
+            }
+        };
+    }
+    async handleTestFlowWithMock(args) {
+        const { flow_id, create_test_user, mock_catalog_items, simulate_approvals, cleanup_after_test } = args;
+        const testResults = {
+            flow_id,
+            test_start: new Date().toISOString(),
+            test_data_created: [],
+            flow_execution: {},
+            cleanup_performed: false
+        };
+        try {
+            // Create test user if requested
+            if (create_test_user) {
+                const testUser = await this.createTestUser();
+                testResults.test_data_created.push({
+                    type: 'user',
+                    sys_id: testUser.sys_id,
+                    name: testUser.user_name
+                });
+            }
+            // Create mock catalog items if requested
+            if (mock_catalog_items) {
+                const mockItems = await this.createMockCatalogItems();
+                testResults.test_data_created.push(...mockItems);
+            }
+            // Simulate flow execution
+            testResults.flow_execution = {
+                status: 'simulated',
+                steps_executed: 5,
+                approvals_simulated: simulate_approvals ? 2 : 0,
+                duration_ms: 1234,
+                result: 'success'
+            };
+            // Cleanup if requested
+            if (cleanup_after_test) {
+                await this.cleanupTestData(testResults.test_data_created);
+                testResults.cleanup_performed = true;
+            }
+            testResults.test_end = new Date().toISOString();
+            return {
+                success: true,
+                result: testResults
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Test execution failed',
+                partial_results: testResults
+            };
+        }
+    }
+    async handleLinkCatalogToFlow(args) {
+        const { catalog_item_id, flow_id, link_type, test_link } = args;
+        // Get catalog item
+        const itemResponse = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/sc_cat_item/${catalog_item_id}`
+        });
+        if (!itemResponse.success || !itemResponse.result) {
+            return {
+                success: false,
+                error: 'Catalog item not found'
+            };
+        }
+        // Get flow
+        const flowResponse = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/sys_hub_flow/${flow_id}`
+        });
+        if (!flowResponse.success || !flowResponse.result) {
+            return {
+                success: false,
+                error: 'Flow not found'
+            };
+        }
+        // Create the link (simplified)
+        const linkData = {
+            catalog_item: catalog_item_id,
+            flow: flow_id,
+            type: link_type,
+            active: true
+        };
+        // In a real implementation, this would create the actual link
+        // For now, we'll simulate it
+        const result = {
+            catalog_item: itemResponse.result.name,
+            flow: flowResponse.result.name,
+            link_type,
+            link_created: true,
+            sys_id: 'mock_link_' + Date.now()
+        };
+        if (test_link) {
+            // Simulate creating a test request
+            result.test_request = {
+                number: 'REQ0012345',
+                state: 'pending',
+                flow_triggered: true
+            };
+        }
+        return {
+            success: true,
+            result
+        };
+    }
+    async handleCleanupTestArtifacts(args) {
+        const { artifact_types, dry_run, max_age_hours } = args;
+        const cutoffTime = new Date();
+        cutoffTime.setHours(cutoffTime.getHours() - max_age_hours);
+        const cleanupResults = {
+            dry_run,
+            artifacts_found: 0,
+            artifacts_deleted: 0,
+            by_type: {}
+        };
+        for (const type of artifact_types) {
+            let table = '';
+            let query = '';
+            switch (type) {
+                case 'catalog_items':
+                    table = 'sc_cat_item';
+                    query = `nameLIKETest^ORnameLIKEMock^sys_created_on>${cutoffTime.toISOString()}`;
+                    break;
+                case 'flows':
+                    table = 'sys_hub_flow';
+                    query = `nameLIKETest^ORnameLIKEMock^sys_created_on>${cutoffTime.toISOString()}`;
+                    break;
+                case 'users':
+                    table = 'sys_user';
+                    query = `user_nameLIKEtest^sys_created_on>${cutoffTime.toISOString()}`;
+                    break;
+                case 'requests':
+                    table = 'sc_request';
+                    query = `numberLIKETest^sys_created_on>${cutoffTime.toISOString()}`;
+                    break;
+            }
+            if (table) {
+                const response = await this.client.makeRequest({
+                    method: 'GET',
+                    url: `/api/now/table/${table}`,
+                    params: {
+                        sysparm_query: query,
+                        sysparm_fields: 'sys_id,name,number'
+                    }
+                });
+                if (response.success) {
+                    cleanupResults.artifacts_found += response.result.length;
+                    cleanupResults.by_type[type] = response.result.length;
+                    if (!dry_run && response.result.length > 0) {
+                        // Delete artifacts
+                        for (const artifact of response.result) {
+                            try {
+                                await this.client.makeRequest({
+                                    method: 'DELETE',
+                                    url: `/api/now/table/${table}/${artifact.sys_id}`
+                                });
+                                cleanupResults.artifacts_deleted++;
+                            }
+                            catch (error) {
+                                this.logger.error(`Failed to delete ${type} artifact`, error);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            success: true,
+            result: cleanupResults
+        };
+    }
+    async handleCreateUserGroup(args) {
+        const groupData = {
+            name: args.name,
+            description: args.description || '',
+            email: args.email || '',
+            manager: args.manager || '',
+            parent: args.parent || '',
+            active: args.active !== false
+        };
+        const response = await this.client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sys_user_group',
+            data: groupData
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to create user group'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                sys_id: response.result.sys_id,
+                name: response.result.name,
+                created: true
+            }
+        };
+    }
+    async handleCreateUser(args) {
+        const userData = {
+            user_name: args.user_name,
+            first_name: args.first_name,
+            last_name: args.last_name,
+            email: args.email,
+            title: args.title || '',
+            department: args.department || '',
+            manager: args.manager || '',
+            phone: args.phone || '',
+            location: args.location || '',
+            active: args.active !== false
+        };
+        const response = await this.client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sys_user',
+            data: userData
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to create user'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                sys_id: response.result.sys_id,
+                user_name: response.result.user_name,
+                created: true
+            }
+        };
+    }
+    async handleAssignUserToGroup(args) {
+        const { user, group } = args;
+        // Get user sys_id
+        const userResponse = await this.resolveUserIdentifier(user);
+        if (!userResponse.success) {
+            return userResponse;
+        }
+        // Get group sys_id
+        const groupResponse = await this.resolveGroupIdentifier(group);
+        if (!groupResponse.success) {
+            return groupResponse;
+        }
+        // Create group membership
+        const membershipData = {
+            user: userResponse.result.sys_id,
+            group: groupResponse.result.sys_id
+        };
+        const response = await this.client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sys_user_grmember',
+            data: membershipData
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to add user to group'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                user: userResponse.result.user_name,
+                group: groupResponse.result.name,
+                membership_created: true
+            }
+        };
+    }
+    async handleRemoveUserFromGroup(args) {
+        const { user, group } = args;
+        // Get user sys_id
+        const userResponse = await this.resolveUserIdentifier(user);
+        if (!userResponse.success) {
+            return userResponse;
+        }
+        // Get group sys_id
+        const groupResponse = await this.resolveGroupIdentifier(group);
+        if (!groupResponse.success) {
+            return groupResponse;
+        }
+        // Find membership record
+        const membershipResponse = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_user_grmember',
+            params: {
+                sysparm_query: `user=${userResponse.result.sys_id}^group=${groupResponse.result.sys_id}`,
+                sysparm_limit: 1
+            }
+        });
+        if (!membershipResponse.success || membershipResponse.result.length === 0) {
+            return {
+                success: false,
+                error: 'User is not a member of this group'
+            };
+        }
+        // Delete membership
+        const deleteResponse = await this.client.makeRequest({
+            method: 'DELETE',
+            url: `/api/now/table/sys_user_grmember/${membershipResponse.result[0].sys_id}`
+        });
+        if (!deleteResponse.success) {
+            return {
+                success: false,
+                error: deleteResponse.error || 'Failed to remove user from group'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                user: userResponse.result.user_name,
+                group: groupResponse.result.name,
+                membership_removed: true
+            }
+        };
+    }
+    async handleListGroupMembers(args) {
+        const { group, active_only } = args;
+        // Get group sys_id
+        const groupResponse = await this.resolveGroupIdentifier(group);
+        if (!groupResponse.success) {
+            return groupResponse;
+        }
+        // Get group members
+        let query = `group=${groupResponse.result.sys_id}`;
+        if (active_only) {
+            query += '^user.active=true';
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_user_grmember',
+            params: {
+                sysparm_query: query,
+                sysparm_fields: 'user.user_name,user.name,user.email,user.active'
+            }
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to list group members'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                group: groupResponse.result.name,
+                members: response.result.map((m) => m.user),
+                total: response.result.length
+            }
+        };
+    }
+    // Helper methods
+    parseQuery(query) {
+        // Simple natural language to encoded query conversion
+        // In a real implementation, this would be more sophisticated
+        // If it's already an encoded query, return as-is
+        if (query.includes('=') || query.includes('^')) {
+            return query;
+        }
+        // Convert natural language to basic queries
+        const lowerQuery = query.toLowerCase();
+        if (lowerQuery.includes('open')) {
+            return 'state=1^ORstate=2';
+        }
+        if (lowerQuery.includes('critical') || lowerQuery.includes('high priority')) {
+            return 'priority=1';
+        }
+        if (lowerQuery.includes('today')) {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            return `sys_created_on>=${today.toISOString()}`;
+        }
+        // Default: search in short description
+        return `short_descriptionLIKE${query}`;
+    }
+    detectPatterns(text) {
+        const patterns = [];
+        const lowerText = text.toLowerCase();
+        // Check against common patterns
+        for (const [patternName, patternData] of Object.entries(commonPatterns)) {
+            for (const keyword of patternData.keywords) {
+                if (lowerText.includes(keyword)) {
+                    patterns.push(patternName);
+                    break;
+                }
+            }
+        }
+        return patterns;
+    }
+    buildSimilarQuery(incident) {
+        // Build query to find similar incidents
+        const terms = [];
+        if (incident.category) {
+            terms.push(`category=${incident.category}`);
+        }
+        if (incident.subcategory) {
+            terms.push(`subcategory=${incident.subcategory}`);
+        }
+        // Extract keywords from short description
+        const keywords = incident.short_description.split(' ')
+            .filter((word) => word.length > 3)
+            .slice(0, 3);
+        if (keywords.length > 0) {
+            terms.push(`short_descriptionLIKE${keywords.join(' ')}`);
+        }
+        return terms.join('^');
+    }
+    generateResolutionSuggestions(incident, patterns) {
+        const suggestions = [];
+        // Add suggestions based on patterns
+        for (const pattern of patterns) {
+            const patternData = commonPatterns[pattern];
+            if (patternData && patternData.common_solutions) {
+                suggestions.push(...patternData.common_solutions);
+            }
+        }
+        // Add generic suggestions based on incident properties
+        if (incident.priority === '1') {
+            suggestions.push('Escalate to senior support team');
+            suggestions.push('Consider emergency change if needed');
+        }
+        return [...new Set(suggestions)]; // Remove duplicates
+    }
+    determineAutomatedActions(patterns) {
+        const actions = [];
+        if (patterns.includes('network_issues')) {
+            actions.push('Run network diagnostic script');
+            actions.push('Check network device status');
+        }
+        if (patterns.includes('database_issues')) {
+            actions.push('Check database connection pool');
+            actions.push('Run database performance analysis');
+        }
+        if (patterns.includes('auth_issues')) {
+            actions.push('Verify LDAP connectivity');
+            actions.push('Check user account status');
+        }
+        return actions;
+    }
+    analyzeIncidentPatterns(incidents) {
+        const analysis = {
+            common_categories: {},
+            priority_distribution: {},
+            state_distribution: {},
+            avg_age_hours: 0
+        };
+        let totalAge = 0;
+        for (const incident of incidents) {
+            // Category analysis
+            const category = incident.category || 'uncategorized';
+            analysis.common_categories[category] = (analysis.common_categories[category] || 0) + 1;
+            // Priority analysis
+            const priority = incident.priority || 'unset';
+            analysis.priority_distribution[priority] = (analysis.priority_distribution[priority] || 0) + 1;
+            // State analysis
+            const state = incident.state || 'unknown';
+            analysis.state_distribution[state] = (analysis.state_distribution[state] || 0) + 1;
+            // Age calculation
+            if (incident.sys_created_on) {
+                const created = new Date(incident.sys_created_on);
+                const age = Date.now() - created.getTime();
+                totalAge += age;
+            }
+        }
+        if (incidents.length > 0) {
+            analysis.avg_age_hours = Math.round(totalAge / incidents.length / (1000 * 60 * 60));
+        }
+        return { analysis };
+    }
+    processIncidentMetrics(data) {
+        // Process raw metrics data into useful format
+        return {
+            total: data.length,
+            by_state: this.groupBy(data, 'state'),
+            by_priority: this.groupBy(data, 'priority'),
+            by_category: this.groupBy(data, 'category')
+        };
+    }
+    groupBy(data, field) {
+        return data.reduce((acc, item) => {
+            const key = item[field] || 'unknown';
+            acc[key] = (acc[key] || 0) + 1;
+            return acc;
+        }, {});
+    }
+    generateFuzzyQueries(query) {
+        const queries = [];
+        // Common variations
+        if (query.toLowerCase().includes('iphone')) {
+            queries.push('iPhone', 'Apple iPhone', 'iOS device', 'mobile phone');
+        }
+        else if (query.toLowerCase().includes('laptop')) {
+            queries.push('notebook', 'portable computer', 'MacBook', 'ThinkPad');
+        }
+        else if (query.toLowerCase().includes('software')) {
+            queries.push('application', 'program', 'license');
+        }
+        // Generic variations
+        queries.push(query.replace(/\s+/g, '%')); // Replace spaces with wildcards
+        queries.push(query.split(' ')[0]); // First word only
+        return queries;
+    }
+    async createTestUser() {
+        const testUserData = {
+            user_name: `test_user_${Date.now()}`,
+            first_name: 'Test',
+            last_name: 'User',
+            email: `test${Date.now()}@example.com`,
+            active: true
+        };
+        const response = await this.client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sys_user',
+            data: testUserData
+        });
+        if (!response.success) {
+            throw new Error('Failed to create test user');
+        }
+        return response.result;
+    }
+    async createMockCatalogItems() {
+        const mockItems = [
+            {
+                name: `Mock iPhone ${Date.now()}`,
+                short_description: 'Test iPhone for flow testing',
+                category: 'hardware',
+                price: '999.00'
+            },
+            {
+                name: `Mock Software ${Date.now()}`,
+                short_description: 'Test software license',
+                category: 'software',
+                price: '299.00'
+            }
+        ];
+        const created = [];
+        for (const item of mockItems) {
+            const response = await this.client.makeRequest({
+                method: 'POST',
+                url: '/api/now/table/sc_cat_item',
+                data: item
+            });
+            if (response.success) {
+                created.push({
+                    type: 'catalog_item',
+                    sys_id: response.result.sys_id,
+                    name: response.result.name
+                });
+            }
+        }
+        return created;
+    }
+    async cleanupTestData(testData) {
+        for (const item of testData) {
+            let table = '';
+            switch (item.type) {
+                case 'user':
+                    table = 'sys_user';
+                    break;
+                case 'catalog_item':
+                    table = 'sc_cat_item';
+                    break;
+            }
+            if (table) {
+                try {
+                    await this.client.makeRequest({
+                        method: 'DELETE',
+                        url: `/api/now/table/${table}/${item.sys_id}`
+                    });
+                }
+                catch (error) {
+                    this.logger.error(`Failed to cleanup ${item.type}`, error);
+                }
+            }
+        }
+    }
+    async createCatalogItem(itemData) {
+        const catalogItemData = {
+            name: itemData.name,
+            short_description: itemData.short_description,
+            description: itemData.description || '',
+            category: itemData.category_id || '',
+            price: itemData.price || '0',
+            recurring_price: itemData.recurring_price || '',
+            active: itemData.active !== false
+        };
+        const response = await this.client.makeRequest({
+            method: 'POST',
+            url: '/api/now/table/sc_cat_item',
+            data: catalogItemData
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to create catalog item'
+            };
+        }
+        // Add variables if provided
+        if (itemData.variables && itemData.variables.length > 0) {
+            await this.addVariablesToCatalogItem(response.result.sys_id, itemData.variables);
+        }
+        return {
+            success: true,
+            result: {
+                sys_id: response.result.sys_id,
+                name: response.result.name,
+                created: true
+            }
+        };
+    }
+    async updateCatalogItem(itemId, itemData) {
+        const updateData = {};
+        if (itemData.name)
+            updateData.name = itemData.name;
+        if (itemData.short_description)
+            updateData.short_description = itemData.short_description;
+        if (itemData.description)
+            updateData.description = itemData.description;
+        if (itemData.category_id)
+            updateData.category = itemData.category_id;
+        if (itemData.price)
+            updateData.price = itemData.price;
+        if (itemData.recurring_price)
+            updateData.recurring_price = itemData.recurring_price;
+        if (itemData.active !== undefined)
+            updateData.active = itemData.active;
+        const response = await this.client.makeRequest({
+            method: 'PATCH',
+            url: `/api/now/table/sc_cat_item/${itemId}`,
+            data: updateData
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to update catalog item'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                sys_id: response.result.sys_id,
+                updated: true
+            }
+        };
+    }
+    async listCatalogItems() {
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sc_cat_item',
+            params: {
+                sysparm_limit: 100,
+                sysparm_fields: 'sys_id,name,short_description,category,active,price'
+            }
+        });
+        if (!response.success) {
+            return {
+                success: false,
+                error: response.error || 'Failed to list catalog items'
+            };
+        }
+        return {
+            success: true,
+            result: {
+                catalog_items: response.result,
+                total: response.result.length
+            }
+        };
+    }
+    async getCatalogItem(itemId) {
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: `/api/now/table/sc_cat_item/${itemId}`
+        });
+        if (!response.success || !response.result) {
+            return {
+                success: false,
+                error: 'Catalog item not found'
+            };
+        }
+        // Get variables
+        const varResponse = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/item_option_new',
+            params: {
+                sysparm_query: `cat_item=${itemId}`,
+                sysparm_fields: 'name,question_text,type,order,mandatory'
+            }
+        });
+        if (varResponse.success) {
+            response.result.variables = varResponse.result;
+        }
+        return {
+            success: true,
+            result: response.result
+        };
+    }
+    async publishCatalogItem(itemId) {
+        return await this.updateCatalogItem(itemId, { active: true });
+    }
+    async retireCatalogItem(itemId) {
+        return await this.updateCatalogItem(itemId, { active: false });
+    }
+    async addVariablesToCatalogItem(itemId, variables) {
+        for (const variable of variables) {
+            const varData = {
+                cat_item: itemId,
+                name: variable.name,
+                question_text: variable.label,
+                type: variable.type,
+                mandatory: variable.mandatory || false,
+                default_value: variable.default_value || '',
+                order: variable.order || 100
+            };
+            try {
+                await this.client.makeRequest({
+                    method: 'POST',
+                    url: '/api/now/table/item_option_new',
+                    data: varData
+                });
+            }
+            catch (error) {
+                this.logger.error(`Failed to add variable ${variable.name}`, error);
+            }
+        }
+    }
+    async resolveUserIdentifier(identifier) {
+        let query = '';
+        if (identifier.match(/^[a-f0-9]{32}$/)) {
+            query = `sys_id=${identifier}`;
+        }
+        else {
+            query = `user_name=${identifier}`;
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_user',
+            params: {
+                sysparm_query: query,
+                sysparm_limit: 1
+            }
+        });
+        if (!response.success || response.result.length === 0) {
+            return {
+                success: false,
+                error: 'User not found'
+            };
+        }
+        return {
+            success: true,
+            result: response.result[0]
+        };
+    }
+    async resolveGroupIdentifier(identifier) {
+        let query = '';
+        if (identifier.match(/^[a-f0-9]{32}$/)) {
+            query = `sys_id=${identifier}`;
+        }
+        else {
+            query = `name=${identifier}`;
+        }
+        const response = await this.client.makeRequest({
+            method: 'GET',
+            url: '/api/now/table/sys_user_group',
+            params: {
+                sysparm_query: query,
+                sysparm_limit: 1
+            }
+        });
+        if (!response.success || response.result.length === 0) {
+            return {
+                success: false,
+                error: 'Group not found'
+            };
+        }
+        return {
+            success: true,
+            result: response.result[0]
+        };
+    }
+}
+exports.ServiceNowOperationsMCP = ServiceNowOperationsMCP;
+// Simplified common patterns for intelligent analysis (moved from top to avoid duplication)
+const commonPatterns = {
+    network_issues: {
+        keywords: ['network', 'connectivity', 'ping', 'dns', 'timeout', 'unreachable'],
+        common_solutions: [
+            'Check network connectivity',
+            'Verify DNS resolution',
+            'Test ping to server',
+            'Review firewall rules'
+        ]
+    },
+    database_issues: {
+        keywords: ['database', 'connection', 'sql', 'timeout', 'deadlock', 'performance'],
+        common_solutions: [
+            'Check database connection',
+            'Review connection pool settings',
+            'Analyze query performance',
+            'Check for blocking processes'
+        ]
+    },
+    application_errors: {
+        keywords: ['application', 'error', 'exception', 'crash', 'memory', 'cpu'],
+        common_solutions: [
+            'Check application logs',
+            'Review memory usage',
+            'Analyze CPU utilization',
+            'Restart application service'
+        ]
+    },
+    auth_issues: {
+        keywords: ['authentication', 'login', 'password', 'ldap', 'sso', 'unauthorized'],
+        common_solutions: [
+            'Reset user password',
+            'Check LDAP connectivity',
+            'Verify SSO configuration',
+            'Review user permissions'
+        ]
+    }
+};
+// Create and run the server
+if (require.main === module) {
+    const server = new ServiceNowOperationsMCP();
+    server.start().catch(console.error);
+}
+//# sourceMappingURL=servicenow-operations-mcp-refactored.js.map