snow-flow 8.42.12 → 9.0.1

package/dist/mcp/servicenow-change-virtualagent-pa-mcp-enhanced.js

@@ -1,816 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Change Management, Virtual Agent & Performance Analytics MCP Server - ENHANCED VERSION
- * With logging, token tracking, and progress indicators
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const enhanced_base_mcp_server_js_1 = require("./shared/enhanced-base-mcp-server.js");
-const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
-class ServiceNowChangeVirtualAgentPAMCPEnhanced extends enhanced_base_mcp_server_js_1.EnhancedBaseMCPServer {
-    constructor() {
-        super('servicenow-change-virtualagent-pa-enhanced', '2.0.0');
-        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                // Change Management Tools
-                {
-                    name: 'snow_create_change_request',
-                    description: 'Creates change request in ServiceNow using change_request table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            short_description: { type: 'string', description: 'Change summary' },
-                            description: { type: 'string', description: 'Detailed description' },
-                            type: { type: 'string', description: 'normal, standard, emergency' },
-                            risk: { type: 'string', description: 'high, moderate, low' },
-                            impact: { type: 'string', description: '1-critical, 2-high, 3-moderate, 4-low' },
-                            implementation_plan: { type: 'string', description: 'Implementation steps' },
-                            backout_plan: { type: 'string', description: 'Rollback steps' },
-                            test_plan: { type: 'string', description: 'Testing steps' },
-                            justification: { type: 'string', description: 'Business justification' },
-                            start_date: { type: 'string', description: 'Planned start (YYYY-MM-DD HH:MM:SS)' },
-                            end_date: { type: 'string', description: 'Planned end (YYYY-MM-DD HH:MM:SS)' }
-                        },
-                        required: ['short_description', 'type']
-                    }
-                },
-                {
-                    name: 'snow_create_change_task',
-                    description: 'Creates change task using change_task table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            change_request: { type: 'string', description: 'Parent change sys_id' },
-                            short_description: { type: 'string', description: 'Task description' },
-                            assignment_group: { type: 'string', description: 'Group sys_id' },
-                            assigned_to: { type: 'string', description: 'User sys_id' },
-                            order: { type: 'number', description: 'Task order' }
-                        },
-                        required: ['change_request', 'short_description']
-                    }
-                },
-                {
-                    name: 'snow_get_change_request',
-                    description: 'Gets change request details from change_request table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sys_id: { type: 'string', description: 'Change request sys_id' },
-                            include_tasks: { type: 'boolean', default: false }
-                        },
-                        required: ['sys_id']
-                    }
-                },
-                {
-                    name: 'snow_update_change_state',
-                    description: 'Updates change request state in change_request table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sys_id: { type: 'string', description: 'Change request sys_id' },
-                            state: { type: 'string', description: 'new, assess, authorize, scheduled, implement, review, closed' },
-                            close_notes: { type: 'string', description: 'Closure notes' }
-                        },
-                        required: ['sys_id', 'state']
-                    }
-                },
-                {
-                    name: 'snow_schedule_cab_meeting',
-                    description: 'Schedules CAB meeting using cab_meeting and cab_agenda_item tables.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            meeting_date: { type: 'string', description: 'Meeting date/time' },
-                            location: { type: 'string', description: 'Meeting location' },
-                            change_requests: { type: 'array', items: { type: 'string' }, description: 'Change sys_ids' }
-                        },
-                        required: ['meeting_date']
-                    }
-                },
-                {
-                    name: 'snow_search_change_requests',
-                    description: 'Searches change requests in change_request table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Search query' },
-                            state: { type: 'string', description: 'Filter by state' },
-                            type: { type: 'string', description: 'Filter by type' },
-                            risk: { type: 'string', description: 'Filter by risk' },
-                            limit: { type: 'number', default: 10 }
-                        }
-                    }
-                },
-                // Virtual Agent Tools
-                {
-                    name: 'snow_create_va_topic',
-                    description: 'Creates virtual agent topic using sys_cs_topic table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Topic name' },
-                            description: { type: 'string', description: 'Topic description' },
-                            trigger_phrases: { type: 'array', items: { type: 'string' } },
-                            category: { type: 'string', description: 'Topic category' },
-                            active: { type: 'boolean', default: true }
-                        },
-                        required: ['name', 'trigger_phrases']
-                    }
-                },
-                {
-                    name: 'snow_create_va_topic_block',
-                    description: 'Creates conversation blocks using sys_cs_topic_block table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            topic: { type: 'string', description: 'Topic sys_id' },
-                            type: { type: 'string', description: 'Block type: text, question, action' },
-                            message: { type: 'string', description: 'Block message' },
-                            order: { type: 'number', description: 'Block order' },
-                            options: { type: 'array', items: { type: 'object' } }
-                        },
-                        required: ['topic', 'type', 'message']
-                    }
-                },
-                {
-                    name: 'snow_get_va_conversation',
-                    description: 'Gets conversation history from sys_cs_conversation table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            conversation_id: { type: 'string', description: 'Conversation sys_id' },
-                            user: { type: 'string', description: 'Filter by user' },
-                            limit: { type: 'number', default: 50 }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_send_va_message',
-                    description: 'Sends message to virtual agent using sys_cs_conversation table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            conversation_id: { type: 'string', description: 'Conversation ID' },
-                            message: { type: 'string', description: 'User message' },
-                            user: { type: 'string', description: 'User sys_id' }
-                        },
-                        required: ['message']
-                    }
-                },
-                {
-                    name: 'snow_handoff_to_agent',
-                    description: 'Escalates conversation to live agent using sys_cs_conversation table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            conversation_id: { type: 'string', description: 'Conversation to escalate' },
-                            reason: { type: 'string', description: 'Escalation reason' },
-                            priority: { type: 'string', description: 'Priority level' }
-                        },
-                        required: ['conversation_id']
-                    }
-                },
-                {
-                    name: 'snow_discover_va_topics',
-                    description: 'Lists all virtual agent topics from sys_cs_topic table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            active_only: { type: 'boolean', default: true },
-                            category: { type: 'string', description: 'Filter by category' }
-                        }
-                    }
-                },
-                // Performance Analytics Tools
-                {
-                    name: 'snow_create_pa_indicator',
-                    description: 'Creates PA indicator using pa_indicators table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Indicator name' },
-                            table: { type: 'string', description: 'Source table' },
-                            aggregate: { type: 'string', description: 'Aggregation: COUNT, SUM, AVG' },
-                            field: { type: 'string', description: 'Field to aggregate' },
-                            conditions: { type: 'string', description: 'Filter conditions' },
-                            frequency: { type: 'string', description: 'daily, weekly, monthly' }
-                        },
-                        required: ['name', 'table', 'aggregate']
-                    }
-                },
-                {
-                    name: 'snow_create_pa_widget',
-                    description: 'Creates PA dashboard widget using pa_widgets table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Widget name' },
-                            indicator: { type: 'string', description: 'Indicator sys_id' },
-                            type: { type: 'string', description: 'line, bar, pie, single_score' },
-                            size: { type: 'string', description: 'small, medium, large' },
-                            time_range: { type: 'string', description: 'Time range' }
-                        },
-                        required: ['name', 'indicator', 'type']
-                    }
-                },
-                {
-                    name: 'snow_create_pa_breakdown',
-                    description: 'Creates PA breakdown using pa_breakdowns table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string', description: 'Breakdown name' },
-                            source_table: { type: 'string', description: 'Source table' },
-                            field: { type: 'string', description: 'Field to break down by' },
-                            related_indicator: { type: 'string', description: 'Related indicator sys_id' }
-                        },
-                        required: ['name', 'source_table', 'field']
-                    }
-                },
-                {
-                    name: 'snow_create_pa_threshold',
-                    description: 'Creates PA threshold using pa_thresholds table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            indicator: { type: 'string', description: 'Indicator sys_id' },
-                            value: { type: 'number', description: 'Threshold value' },
-                            direction: { type: 'string', description: 'above, below' },
-                            color: { type: 'string', description: 'red, yellow, green' },
-                            send_alert: { type: 'boolean', default: false }
-                        },
-                        required: ['indicator', 'value', 'direction']
-                    }
-                },
-                {
-                    name: 'snow_get_pa_scores',
-                    description: 'Gets PA scores from pa_scores table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            indicator: { type: 'string', description: 'Indicator sys_id' },
-                            start_date: { type: 'string', description: 'Start date' },
-                            end_date: { type: 'string', description: 'End date' },
-                            breakdown: { type: 'string', description: 'Breakdown sys_id' }
-                        },
-                        required: ['indicator']
-                    }
-                },
-                {
-                    name: 'snow_create_pa_target',
-                    description: 'Creates PA target using pa_targets table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            indicator: { type: 'string', description: 'Indicator sys_id' },
-                            target_value: { type: 'number', description: 'Target value' },
-                            period: { type: 'string', description: 'monthly, quarterly, yearly' },
-                            start_date: { type: 'string', description: 'Target start date' }
-                        },
-                        required: ['indicator', 'target_value']
-                    }
-                },
-                {
-                    name: 'snow_analyze_pa_trends',
-                    description: 'Analyzes PA trends from pa_scores table.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            indicator: { type: 'string', description: 'Indicator sys_id' },
-                            period: { type: 'string', description: 'Analysis period' },
-                            include_forecast: { type: 'boolean', default: false }
-                        },
-                        required: ['indicator']
-                    }
-                }
-            ]
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            try {
-                const { name, arguments: args } = request.params;
-                // Execute with enhanced tracking
-                return await this.executeTool(name, async () => {
-                    switch (name) {
-                        // Change Management
-                        case 'snow_create_change_request':
-                            return await this.createChangeRequest(args);
-                        case 'snow_create_change_task':
-                            return await this.createChangeTask(args);
-                        case 'snow_get_change_request':
-                            return await this.getChangeRequest(args);
-                        case 'snow_update_change_state':
-                            return await this.updateChangeState(args);
-                        case 'snow_schedule_cab_meeting':
-                            return await this.scheduleCabMeeting(args);
-                        case 'snow_search_change_requests':
-                            return await this.searchChangeRequests(args);
-                        // Virtual Agent
-                        case 'snow_create_va_topic':
-                            return await this.createVATopic(args);
-                        case 'snow_create_va_topic_block':
-                            return await this.createVATopicBlock(args);
-                        case 'snow_get_va_conversation':
-                            return await this.getVAConversation(args);
-                        case 'snow_send_va_message':
-                            return await this.sendVAMessage(args);
-                        case 'snow_handoff_to_agent':
-                            return await this.handoffToAgent(args);
-                        case 'snow_discover_va_topics':
-                            return await this.discoverVATopics(args);
-                        // Performance Analytics
-                        case 'snow_create_pa_indicator':
-                            return await this.createPAIndicator(args);
-                        case 'snow_create_pa_widget':
-                            return await this.createPAWidget(args);
-                        case 'snow_create_pa_breakdown':
-                            return await this.createPABreakdown(args);
-                        case 'snow_create_pa_threshold':
-                            return await this.createPAThreshold(args);
-                        case 'snow_get_pa_scores':
-                            return await this.getPAScores(args);
-                        case 'snow_create_pa_target':
-                            return await this.createPATarget(args);
-                        case 'snow_analyze_pa_trends':
-                            return await this.analyzePATrends(args);
-                        default:
-                            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                    }
-                });
-            }
-            catch (error) {
-                if (error instanceof types_js_1.McpError)
-                    throw error;
-                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Tool execution failed: ${error}`);
-            }
-        });
-    }
-    // Change Management Methods
-    async createChangeRequest(args) {
-        this.logger.info('Creating change request...', {
-            short_description: args.short_description,
-            type: args.type,
-            risk: args.risk
-        });
-        const changeData = {
-            short_description: args.short_description,
-            description: args.description || '',
-            type: args.type,
-            risk: args.risk || 'moderate',
-            impact: args.impact || '3',
-            implementation_plan: args.implementation_plan || '',
-            backout_plan: args.backout_plan || '',
-            test_plan: args.test_plan || '',
-            justification: args.justification || '',
-            start_date: args.start_date || '',
-            end_date: args.end_date || '',
-            state: 'new'
-        };
-        this.logger.progress('Creating change request in ServiceNow...');
-        const response = await this.createRecord('change_request', changeData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create change: ${response.error}`);
-        }
-        const result = response.data;
-        this.logger.info('✅ Change request created', {
-            number: result.number,
-            sys_id: result.sys_id
-        });
-        return this.createResponse(`✅ Change Request created!
-📋 **${result.number}**
-🔧 Type: ${args.type}
-⚠️ Risk: ${args.risk || 'moderate'}
-📊 Impact: ${args.impact || '3-moderate'}
-🆔 sys_id: ${result.sys_id}
-📅 Schedule: ${args.start_date || 'TBD'} - ${args.end_date || 'TBD'}
-
-✨ Change request ready for assessment!`);
-    }
-    async createChangeTask(args) {
-        this.logger.info('Creating change task...', { change_request: args.change_request });
-        const taskData = {
-            change_request: args.change_request,
-            short_description: args.short_description,
-            assignment_group: args.assignment_group || '',
-            assigned_to: args.assigned_to || '',
-            order: args.order || 100,
-            state: 'pending'
-        };
-        this.logger.progress('Creating task...');
-        const response = await this.createRecord('change_task', taskData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create task: ${response.error}`);
-        }
-        this.logger.info('✅ Change task created');
-        return this.createResponse(`✅ Change task created!
-📋 ${args.short_description}
-🆔 sys_id: ${response.data.sys_id}
-📊 Order: ${args.order || 100}`);
-    }
-    async getChangeRequest(args) {
-        this.logger.info('Getting change request...', { sys_id: args.sys_id });
-        const response = await this.getRecord('change_request', args.sys_id);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to get change: ${response.error}`);
-        }
-        const change = response.data;
-        let details = `📋 **${change.number}**
-🔧 Type: ${change.type}
-⚠️ Risk: ${change.risk}
-📊 State: ${change.state}
-📅 Schedule: ${change.start_date} - ${change.end_date}
-🆔 sys_id: ${change.sys_id}`;
-        if (args.include_tasks) {
-            const taskQuery = `change_request=${args.sys_id}`;
-            const taskResponse = await this.queryTable('change_task', taskQuery, 20);
-            if (taskResponse.success && taskResponse.data.result.length > 0) {
-                details += `\n\n📌 Tasks (${taskResponse.data.result.length}):`;
-                taskResponse.data.result.forEach((task) => {
-                    details += `\n  • ${task.short_description} (${task.state})`;
-                });
-            }
-        }
-        this.logger.info('✅ Retrieved change details');
-        return this.createResponse(details);
-    }
-    async updateChangeState(args) {
-        this.logger.info('Updating change state...', {
-            sys_id: args.sys_id,
-            state: args.state
-        });
-        const updateData = { state: args.state };
-        if (args.close_notes)
-            updateData.close_notes = args.close_notes;
-        const response = await this.updateRecord('change_request', args.sys_id, updateData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to update state: ${response.error}`);
-        }
-        this.logger.info('✅ Change state updated');
-        return this.createResponse(`✅ Change state updated to: ${args.state}
-🆔 sys_id: ${args.sys_id}`);
-    }
-    async scheduleCabMeeting(args) {
-        this.logger.info('Scheduling CAB meeting...', { date: args.meeting_date });
-        const meetingData = {
-            meeting_date: args.meeting_date,
-            location: args.location || 'Virtual',
-            state: 'scheduled'
-        };
-        this.logger.progress('Creating CAB meeting...');
-        const response = await this.createRecord('cab_meeting', meetingData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to schedule CAB: ${response.error}`);
-        }
-        const meeting = response.data;
-        // Add change requests to agenda
-        if (args.change_requests && args.change_requests.length > 0) {
-            for (const changeId of args.change_requests) {
-                await this.createRecord('cab_agenda_item', {
-                    cab_meeting: meeting.sys_id,
-                    change_request: changeId
-                });
-            }
-        }
-        this.logger.info('✅ CAB meeting scheduled');
-        return this.createResponse(`✅ CAB Meeting scheduled!
-📅 Date: ${args.meeting_date}
-📍 Location: ${args.location || 'Virtual'}
-📋 Changes: ${args.change_requests?.length || 0} items
-🆔 sys_id: ${meeting.sys_id}`);
-    }
-    async searchChangeRequests(args) {
-        this.logger.info('Searching change requests...', { query: args.query });
-        let query = args.query ? `short_descriptionLIKE${args.query}` : '';
-        if (args.state)
-            query += `^state=${args.state}`;
-        if (args.type)
-            query += `^type=${args.type}`;
-        if (args.risk)
-            query += `^risk=${args.risk}`;
-        this.logger.progress('Searching changes...');
-        const response = await this.queryTable('change_request', query, args.limit || 10);
-        if (!response.success) {
-            return this.createResponse(`❌ Search failed: ${response.error}`);
-        }
-        const changes = response.data.result;
-        if (!changes.length) {
-            return this.createResponse(`❌ No changes found`);
-        }
-        this.logger.info(`Found ${changes.length} changes`);
-        const changeList = changes.map((c) => `📋 **${c.number}** - ${c.short_description}
-  🔧 ${c.type} | ⚠️ ${c.risk} | 📊 ${c.state}`).join('\n\n');
-        return this.createResponse(`🔍 Change Requests:\n\n${changeList}\n\n✨ Found ${changes.length} change(s)`);
-    }
-    // Virtual Agent Methods
-    async createVATopic(args) {
-        this.logger.info('Creating VA topic...', { name: args.name });
-        const topicData = {
-            name: args.name,
-            description: args.description || '',
-            trigger_phrases: args.trigger_phrases.join(','),
-            category: args.category || '',
-            active: args.active !== false
-        };
-        this.logger.progress('Creating topic...');
-        const response = await this.createRecord('sys_cs_topic', topicData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create topic: ${response.error}`);
-        }
-        this.logger.info('✅ VA topic created');
-        return this.createResponse(`✅ Virtual Agent topic created!
-🤖 **${args.name}**
-💬 Triggers: ${args.trigger_phrases.join(', ')}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async createVATopicBlock(args) {
-        this.logger.info('Creating topic block...', { topic: args.topic, type: args.type });
-        const blockData = {
-            topic: args.topic,
-            type: args.type,
-            message: args.message,
-            order: args.order || 100,
-            options: JSON.stringify(args.options || [])
-        };
-        this.logger.progress('Creating block...');
-        const response = await this.createRecord('sys_cs_topic_block', blockData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create block: ${response.error}`);
-        }
-        this.logger.info('✅ Topic block created');
-        return this.createResponse(`✅ Topic block created!
-📝 Type: ${args.type}
-💬 Message: ${args.message}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async getVAConversation(args) {
-        this.logger.info('Getting VA conversation...');
-        let query = '';
-        if (args.conversation_id)
-            query = `sys_id=${args.conversation_id}`;
-        else if (args.user)
-            query = `user=${args.user}`;
-        const response = await this.queryTable('sys_cs_conversation', query, args.limit || 50);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to get conversation: ${response.error}`);
-        }
-        const messages = response.data.result;
-        this.logger.info(`Retrieved ${messages.length} messages`);
-        const conversation = messages.map((msg) => `[${msg.sys_created_on}] ${msg.from_user ? '👤' : '🤖'} ${msg.message}`).join('\n');
-        return this.createResponse(`💬 Conversation History:\n\n${conversation}\n\n✨ ${messages.length} messages`);
-    }
-    async sendVAMessage(args) {
-        this.logger.info('Sending VA message...', { message: args.message });
-        const messageData = {
-            conversation: args.conversation_id || '',
-            message: args.message,
-            user: args.user || 'api_user',
-            from_user: true
-        };
-        this.logger.progress('Sending message...');
-        const response = await this.createRecord('sys_cs_conversation', messageData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to send message: ${response.error}`);
-        }
-        this.logger.info('✅ Message sent');
-        return this.createResponse(`✅ Message sent to Virtual Agent!
-💬 "${args.message}"
-🆔 Conversation: ${response.data.conversation || response.data.sys_id}`);
-    }
-    async handoffToAgent(args) {
-        this.logger.info('Escalating to live agent...', { conversation_id: args.conversation_id });
-        const updateData = {
-            state: 'escalated',
-            escalation_reason: args.reason || 'User requested agent',
-            priority: args.priority || '3'
-        };
-        const response = await this.updateRecord('sys_cs_conversation', args.conversation_id, updateData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to escalate: ${response.error}`);
-        }
-        this.logger.info('✅ Escalated to agent');
-        return this.createResponse(`✅ Conversation escalated to live agent!
-📞 Reason: ${args.reason || 'User requested'}
-⚡ Priority: ${args.priority || '3-moderate'}`);
-    }
-    async discoverVATopics(args) {
-        this.logger.info('Discovering VA topics...');
-        let query = args.active_only ? 'active=true' : '';
-        if (args.category)
-            query += `^category=${args.category}`;
-        const response = await this.queryTable('sys_cs_topic', query, 50);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to discover topics: ${response.error}`);
-        }
-        const topics = response.data.result;
-        this.logger.info(`Found ${topics.length} topics`);
-        const topicList = topics.map((topic) => `🤖 **${topic.name}**
-  📝 ${topic.description || 'No description'}
-  🏷️ ${topic.category || 'Uncategorized'}`).join('\n\n');
-        return this.createResponse(`🤖 Virtual Agent Topics:\n\n${topicList}\n\n✨ Total: ${topics.length} topics`);
-    }
-    // Performance Analytics Methods
-    async createPAIndicator(args) {
-        this.logger.info('Creating PA indicator...', {
-            name: args.name,
-            table: args.table,
-            aggregate: args.aggregate
-        });
-        const indicatorData = {
-            name: args.name,
-            table: args.table,
-            aggregate: args.aggregate,
-            field: args.field || '',
-            conditions: args.conditions || '',
-            frequency: args.frequency || 'daily',
-            active: true
-        };
-        this.logger.progress('Creating indicator...');
-        const response = await this.createRecord('pa_indicators', indicatorData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create indicator: ${response.error}`);
-        }
-        this.logger.info('✅ PA indicator created');
-        return this.createResponse(`✅ PA Indicator created!
-📊 **${args.name}**
-📋 Table: ${args.table}
-📈 Aggregate: ${args.aggregate}${args.field ? ` on ${args.field}` : ''}
-⏰ Frequency: ${args.frequency || 'daily'}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async createPAWidget(args) {
-        this.logger.info('Creating PA widget...', {
-            name: args.name,
-            type: args.type
-        });
-        const widgetData = {
-            name: args.name,
-            indicator: args.indicator,
-            type: args.type,
-            size: args.size || 'medium',
-            time_range: args.time_range || '30 days'
-        };
-        this.logger.progress('Creating widget...');
-        const response = await this.createRecord('pa_widgets', widgetData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create widget: ${response.error}`);
-        }
-        this.logger.info('✅ PA widget created');
-        return this.createResponse(`✅ PA Widget created!
-📊 **${args.name}**
-📈 Type: ${args.type}
-📐 Size: ${args.size || 'medium'}
-⏰ Range: ${args.time_range || '30 days'}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async createPABreakdown(args) {
-        this.logger.info('Creating PA breakdown...', { name: args.name });
-        const breakdownData = {
-            name: args.name,
-            source_table: args.source_table,
-            field: args.field,
-            related_indicator: args.related_indicator || ''
-        };
-        this.logger.progress('Creating breakdown...');
-        const response = await this.createRecord('pa_breakdowns', breakdownData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create breakdown: ${response.error}`);
-        }
-        this.logger.info('✅ PA breakdown created');
-        return this.createResponse(`✅ PA Breakdown created!
-📊 **${args.name}**
-📋 Table: ${args.source_table}
-🔍 Field: ${args.field}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async createPAThreshold(args) {
-        this.logger.info('Creating PA threshold...', {
-            indicator: args.indicator,
-            value: args.value
-        });
-        const thresholdData = {
-            indicator: args.indicator,
-            value: args.value,
-            direction: args.direction,
-            color: args.color || 'yellow',
-            send_alert: args.send_alert || false
-        };
-        this.logger.progress('Creating threshold...');
-        const response = await this.createRecord('pa_thresholds', thresholdData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create threshold: ${response.error}`);
-        }
-        this.logger.info('✅ PA threshold created');
-        return this.createResponse(`✅ PA Threshold created!
-⚠️ Value: ${args.value} (${args.direction})
-🎨 Color: ${args.color || 'yellow'}
-🔔 Alert: ${args.send_alert ? 'Yes' : 'No'}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async getPAScores(args) {
-        this.logger.info('Getting PA scores...', { indicator: args.indicator });
-        let query = `indicator=${args.indicator}`;
-        if (args.start_date)
-            query += `^sys_created_on>=${args.start_date}`;
-        if (args.end_date)
-            query += `^sys_created_on<=${args.end_date}`;
-        if (args.breakdown)
-            query += `^breakdown=${args.breakdown}`;
-        this.logger.progress('Retrieving scores...');
-        const response = await this.queryTable('pa_scores', query, 100);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to get scores: ${response.error}`);
-        }
-        const scores = response.data.result;
-        if (!scores.length) {
-            return this.createResponse(`❌ No scores found for indicator`);
-        }
-        this.logger.info(`Retrieved ${scores.length} scores`);
-        // Calculate statistics
-        const values = scores.map((s) => parseFloat(s.value));
-        const avg = (values.reduce((a, b) => a + b, 0) / values.length).toFixed(2);
-        const min = Math.min(...values);
-        const max = Math.max(...values);
-        return this.createResponse(`📊 PA Scores:
-📈 Average: ${avg}
-⬇️ Min: ${min}
-⬆️ Max: ${max}
-📅 Period: ${scores.length} data points
-✨ Latest: ${values[values.length - 1]}`);
-    }
-    async createPATarget(args) {
-        this.logger.info('Creating PA target...', {
-            indicator: args.indicator,
-            target_value: args.target_value
-        });
-        const targetData = {
-            indicator: args.indicator,
-            target_value: args.target_value,
-            period: args.period || 'monthly',
-            start_date: args.start_date || new Date().toISOString()
-        };
-        this.logger.progress('Creating target...');
-        const response = await this.createRecord('pa_targets', targetData);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to create target: ${response.error}`);
-        }
-        this.logger.info('✅ PA target created');
-        return this.createResponse(`✅ PA Target created!
-🎯 Target: ${args.target_value}
-📅 Period: ${args.period || 'monthly'}
-📆 Start: ${args.start_date || 'Today'}
-🆔 sys_id: ${response.data.sys_id}`);
-    }
-    async analyzePATrends(args) {
-        this.logger.info('Analyzing PA trends...', { indicator: args.indicator });
-        const query = `indicator=${args.indicator}^ORDERBYsys_created_on`;
-        const response = await this.queryTable('pa_scores', query, 100);
-        if (!response.success) {
-            return this.createResponse(`❌ Failed to analyze trends: ${response.error}`);
-        }
-        const scores = response.data.result;
-        if (scores.length < 2) {
-            return this.createResponse(`❌ Insufficient data for trend analysis`);
-        }
-        this.logger.info(`Analyzing ${scores.length} data points`);
-        // Calculate trend
-        const values = scores.map((s) => parseFloat(s.value));
-        const firstHalf = values.slice(0, Math.floor(values.length / 2));
-        const secondHalf = values.slice(Math.floor(values.length / 2));
-        const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
-        const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
-        const trend = ((secondAvg - firstAvg) / firstAvg * 100).toFixed(1);
-        const direction = parseFloat(trend) > 0 ? '📈 Upward' : parseFloat(trend) < 0 ? '📉 Downward' : '➡️ Stable';
-        let analysis = `📊 Trend Analysis:
-${direction} trend: ${Math.abs(parseFloat(trend))}%
-📅 Period: ${scores.length} data points
-📈 Current: ${values[values.length - 1]}
-📉 Previous: ${values[values.length - 2]}`;
-        if (args.include_forecast) {
-            // Simple linear forecast
-            const growthRate = parseFloat(trend) / 100;
-            const forecast = (values[values.length - 1] * (1 + growthRate)).toFixed(2);
-            analysis += `\n🔮 Next Period Forecast: ${forecast}`;
-        }
-        return this.createResponse(analysis);
-    }
-    async start() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        // Log ready state
-        this.logger.info('🚀 ServiceNow Change, VA & PA MCP Server (Enhanced) running');
-        this.logger.info('📊 Token tracking enabled');
-        this.logger.info('⏳ Progress indicators active');
-    }
-}
-// Start the enhanced server
-const server = new ServiceNowChangeVirtualAgentPAMCPEnhanced();
-server.start().catch((error) => {
-    console.error('Failed to start enhanced server:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=servicenow-change-virtualagent-pa-mcp-enhanced.js.map