snow-flow 2.6.3 → 2.6.5

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

@@ -1,1770 +0,0 @@
-#!/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_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_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'
-            };
-        }
-        const 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'
-            };
-        }
-        const 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'
-            };
-        }
-        const 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 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