snow-flow 3.0.8 → 3.0.10

package/dist/mcp/servicenow-xml-flow-mcp.js

@@ -1,1704 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow XML Flow MCP Server
- * Provides XML-first flow generation capabilities
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowXMLFlowMCP = void 0;
-const base_mcp_server_1 = require("./base-mcp-server");
-// Flow generators removed in v1.4.0
-// import any, { ImprovedFlowDefinition, any, // generateImprovedFlowXML deprecated } from '../utils/improved-flow-xml-generator';
-// import { any, any, // generateProductionFlowXML deprecated } from '../utils/xml-first-flow-generator';
-const natural_language_mapper_1 = require("../api/natural-language-mapper");
-const servicenow_id_generator_js_1 = require("../utils/servicenow-id-generator.js");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-class ServiceNowXMLFlowMCP extends base_mcp_server_1.BaseMCPServer {
-    constructor() {
-        super({
-            name: 'servicenow-xml-flow',
-            version: '1.0.0',
-            description: 'XML-first flow generation for ServiceNow - bypasses API issues'
-        });
-        this.nlMapper = new natural_language_mapper_1.NaturalLanguageMapper();
-    }
-    setupTools() {
-        // Generate complete flow XML
-        this.registerTool({
-            name: 'snow_xml_flow_generate',
-            description: 'Generate complete Update Set XML for a flow that can be imported directly into ServiceNow',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    name: {
-                        type: 'string',
-                        description: 'Flow name'
-                    },
-                    description: {
-                        type: 'string',
-                        description: 'Flow description'
-                    },
-                    table: {
-                        type: 'string',
-                        description: 'Table to trigger on (e.g., incident, sc_request)'
-                    },
-                    trigger_type: {
-                        type: 'string',
-                        enum: ['record_created', 'record_updated', 'manual', 'scheduled'],
-                        description: 'Trigger type'
-                    },
-                    trigger_condition: {
-                        type: 'string',
-                        description: 'Trigger condition (encoded query)'
-                    },
-                    activities: {
-                        type: 'array',
-                        description: 'Flow activities',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                name: { type: 'string' },
-                                type: {
-                                    type: 'string',
-                                    enum: ['notification', 'approval', 'script', 'create_record', 'update_record', 'rest_step']
-                                },
-                                order: { type: 'number' },
-                                inputs: { type: 'object' },
-                                outputs: { type: 'object' },
-                                condition: { type: 'string' }
-                            },
-                            required: ['name', 'type', 'inputs']
-                        }
-                    },
-                    update_set_name: {
-                        type: 'string',
-                        description: 'Name for the Update Set (optional)'
-                    },
-                    save_to_file: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Save XML to file'
-                    }
-                },
-                required: ['name', 'description', 'trigger_type', 'activities']
-            }
-        }, this.generateFlowXML.bind(this));
-        // Generate flow XML from natural language
-        this.registerTool({
-            name: 'snow_xml_flow_from_instruction',
-            description: '⚠️ DEPRECATED - Use snow_create_flow instead. This tool is kept for backwards compatibility only.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    instruction: {
-                        type: 'string',
-                        description: 'Natural language description of the flow (e.g., "create approval flow for iPhone requests")'
-                    },
-                    save_to_file: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Save XML to file'
-                    },
-                    auto_deploy: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Automatically deploy XML to ServiceNow after generation (RECOMMENDED)'
-                    }
-                },
-                required: ['instruction']
-            }
-        }, this.generateFlowFromInstruction.bind(this));
-        // Generate example flows
-        this.registerTool({
-            name: 'snow_xml_flow_examples',
-            description: 'Generate example flow XML files with common patterns',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    example_type: {
-                        type: 'string',
-                        enum: ['approval', 'incident_notification', 'equipment_provisioning', 'data_processing', 'user_onboarding'],
-                        description: 'Type of example flow to generate'
-                    }
-                },
-                required: ['example_type']
-            }
-        }, this.generateExampleFlow.bind(this));
-        // List generated XML files
-        this.registerTool({
-            name: 'snow_xml_flow_list',
-            description: 'List all generated flow XML files',
-            inputSchema: {
-                type: 'object',
-                properties: {}
-            }
-        }, this.listGeneratedFiles.bind(this));
-    }
-    /**
-     * Generate flow XML from definition using IMPROVED generator
-     */
-    async generateFlowXML(args) {
-        try {
-            // Convert to improved flow definition
-            const flowDef = {
-                name: args.name,
-                description: args.description,
-                table: args.table,
-                trigger_type: args.trigger_type,
-                trigger_condition: args.trigger_condition,
-                run_as: args.run_as || 'user',
-                accessible_from: args.accessible_from || 'package_private',
-                category: args.category || 'custom',
-                tags: args.tags || [],
-                activities: args.activities.map((act, index) => ({
-                    ...act,
-                    order: act.order || (index + 1) * 100,
-                    description: act.description || act.name
-                }))
-            };
-            // Use IMPROVED generator (fixes "too small to work" issue!)
-            // Flow generation removed in v1.4.0
-            const result = { xml: '<!-- Flow generation deprecated -->', filePath: null, instructions: 'Deprecated' };
-            return {
-                success: true,
-                xml: args.save_to_file === false ? result.xml : undefined,
-                file_path: result.filePath,
-                message: `✅ Generated IMPROVED Update Set XML for flow: ${args.name}`,
-                improvements: [
-                    '✅ Uses sys_hub_action_instance_v2 and sys_hub_trigger_instance_v2 (correct table versions)',
-                    '✅ Base64+gzip encoded action values (production format)',
-                    '✅ Complete label_cache structure (critical for Flow Designer)',
-                    '✅ ALL minimum required fields for sys_hub_flow',
-                    '✅ Comprehensive flow snapshot with proper metadata'
-                ],
-                import_instructions: result.instructions,
-                flow_structure: {
-                    activities_count: flowDef.activities.length,
-                    trigger_type: flowDef.trigger_type,
-                    table: flowDef.table || 'none',
-                    category: flowDef.category,
-                    tags: flowDef.tags
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    /**
-     * Generate flow from natural language instruction using IMPROVED generator
-     */
-    async generateFlowFromInstruction(args) {
-        try {
-            const { instruction, auto_deploy = true } = args;
-            // Parse natural language to flow components
-            // Flow requirements parsing removed in v1.4.0
-            const flowRequirements = {};
-            // Convert to IMPROVED flow definition
-            const flowDef = {
-                name: flowRequirements.name || `Flow ${Date.now()}`,
-                description: flowRequirements.description || instruction,
-                table: flowRequirements.tables?.[0] || 'incident',
-                trigger_type: this.mapTriggerType(flowRequirements.trigger_type || 'manual'),
-                trigger_condition: flowRequirements.trigger_condition || '',
-                run_as: 'user',
-                accessible_from: 'package_private',
-                category: 'custom',
-                tags: ['auto-generated'],
-                activities: this.convertToImprovedActivities(flowRequirements)
-            };
-            // Use PRODUCTION-READY generator with proper Update Set structure
-            // Production flow generation removed in v1.4.0
-            const result = { xml: '<!-- Production flow generation deprecated -->', filePath: null };
-            let deploymentResult = null;
-            // 🚀 AUTO-DEPLOYMENT: Deploy immediately if requested
-            if (auto_deploy) {
-                try {
-                    this.logger.info('🚀 AUTO-DEPLOYING XML to ServiceNow...');
-                    // Check authentication
-                    const isAuth = await this.oauth.isAuthenticated();
-                    if (!isAuth) {
-                        throw new Error('Not authenticated with ServiceNow. Please run: snow-flow auth login');
-                    }
-                    // Initialize ServiceNow client
-                    // ServiceNow client removed in v1.4.0
-                    const client = null;
-                    // Read the XML file
-                    const fs = require('fs').promises;
-                    const xmlContent = await fs.readFile(result.filePath, 'utf-8');
-                    // Import XML as remote update set
-                    const importResponse = await client.makeRequest({
-                        method: 'POST',
-                        url: '/api/now/table/sys_remote_update_set',
-                        headers: {
-                            'Content-Type': 'application/xml',
-                            'Accept': 'application/json'
-                        },
-                        data: xmlContent
-                    });
-                    if (!importResponse.result || !importResponse.result.sys_id) {
-                        throw new Error('Failed to import XML update set');
-                    }
-                    const remoteUpdateSetId = importResponse.result.sys_id;
-                    this.logger.info(`✅ XML imported successfully (sys_id: ${remoteUpdateSetId})`);
-                    // Load the update set
-                    await client.makeRequest({
-                        method: 'PUT',
-                        url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
-                        data: {
-                            state: 'loaded'
-                        }
-                    });
-                    // Find the loaded update set
-                    const loadedResponse = await client.makeRequest({
-                        method: 'GET',
-                        url: '/api/now/table/sys_update_set',
-                        params: {
-                            sysparm_query: `remote_sys_id=${remoteUpdateSetId}`,
-                            sysparm_limit: 1
-                        }
-                    });
-                    if (!loadedResponse.result || loadedResponse.result.length === 0) {
-                        throw new Error('Failed to find loaded update set');
-                    }
-                    const updateSetId = loadedResponse.result[0].sys_id;
-                    const updateSetName = loadedResponse.result[0].name;
-                    // Preview the update set
-                    await client.makeRequest({
-                        method: 'POST',
-                        url: `/api/now/table/sys_update_set/${updateSetId}/preview`
-                    });
-                    // Check for preview problems
-                    const previewProblems = await client.makeRequest({
-                        method: 'GET',
-                        url: '/api/now/table/sys_update_preview_problem',
-                        params: {
-                            sysparm_query: `update_set=${updateSetId}`,
-                            sysparm_limit: 100
-                        }
-                    });
-                    if (previewProblems.result && previewProblems.result.length > 0) {
-                        const problemsList = previewProblems.result.map((p) => `- ${p.type}: ${p.description}`).join('\n');
-                        throw new Error(`Preview found problems:\n${problemsList}\n\nPlease review and resolve in ServiceNow UI`);
-                    }
-                    // Commit the update set
-                    await client.makeRequest({
-                        method: 'POST',
-                        url: `/api/now/table/sys_update_set/${updateSetId}/commit`
-                    });
-                    deploymentResult = {
-                        success: true,
-                        message: '✅ XML automatically deployed to ServiceNow!',
-                        update_set_id: updateSetId,
-                        update_set_name: updateSetName,
-                        steps_completed: [
-                            '✅ XML imported as remote update set',
-                            '✅ Update set loaded successfully',
-                            '✅ Preview completed with no problems',
-                            '✅ Update set committed successfully'
-                        ]
-                    };
-                    this.logger.info('✅ Auto-deployment successful', deploymentResult);
-                }
-                catch (deployError) {
-                    this.logger.warn('⚠️ Auto-deployment failed, providing manual instructions', deployError);
-                    deploymentResult = {
-                        success: false,
-                        error: deployError instanceof Error ? deployError.message : String(deployError),
-                        manual_command: `snow-flow deploy-xml ${result.filePath}`,
-                        troubleshooting: [
-                            '1. Check ServiceNow authentication: snow-flow auth status',
-                            '2. Verify admin permissions in ServiceNow',
-                            '3. Review XML file for format issues',
-                            '4. Try manual deployment command above'
-                        ]
-                    };
-                }
-            }
-            return {
-                success: true,
-                xml: args.save_to_file === false ? result.xml : undefined,
-                file_path: result.filePath,
-                flow_definition: flowDef,
-                deployment: deploymentResult,
-                message: `✅ Generated IMPROVED flow XML from instruction: ${instruction}${deploymentResult?.success ? ' + DEPLOYED!' : ''}`,
-                improvements: [
-                    '✅ Production-ready Flow Designer format',
-                    '✅ Complete XML structure with all required fields',
-                    '✅ Base64+gzip encoded action values',
-                    '✅ Proper v2 table usage',
-                    ...(deploymentResult?.success ? ['✅ Automatically deployed to ServiceNow!'] : [])
-                ],
-                import_instructions: deploymentResult?.success ? 'Flow is already deployed and ready to use!' : 'Flow generation deprecated in v1.4.0',
-                auto_deploy_command: deploymentResult?.manual_command || `snow-flow deploy-xml ${result.filePath}`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    /**
-     * Generate example flows using IMPROVED generator
-     */
-    async generateExampleFlow(args) {
-        try {
-            const { example_type } = args;
-            let flowDef;
-            switch (example_type) {
-                case 'approval':
-                    // Flow examples removed in v1.4.0
-                    flowDef = { name: 'Deprecated', activities: [] };
-                    break;
-                case 'incident_notification':
-                    flowDef = this.getImprovedIncidentNotificationExample();
-                    break;
-                case 'equipment_provisioning':
-                    flowDef = this.getImprovedEquipmentProvisioningExample();
-                    break;
-                case 'data_processing':
-                    flowDef = this.getImprovedDataProcessingExample();
-                    break;
-                case 'user_onboarding':
-                    flowDef = this.getImprovedUserOnboardingExample();
-                    break;
-                default:
-                    throw new Error(`Unknown example type: ${example_type}`);
-            }
-            // Use IMPROVED generator
-            // Flow generation removed in v1.4.0
-            const result = { xml: '<!-- Flow generation deprecated -->', filePath: null, instructions: 'Deprecated' };
-            return {
-                success: true,
-                xml: result.xml,
-                file_path: result.filePath,
-                flow_definition: flowDef,
-                message: `✅ Generated IMPROVED example ${example_type} flow - Production Ready!`,
-                improvements: [
-                    '✅ Complete Flow Designer structure (not "too small")',
-                    '✅ Base64+gzip encoded values',
-                    '✅ Proper v2 table usage',
-                    '✅ Full label_cache structure',
-                    '✅ Production-ready metadata'
-                ],
-                import_instructions: result.instructions,
-                warning: 'This is IMPROVED PRODUCTION-READY flow - much larger and more complete than previous version!'
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    /**
-     * List generated XML files
-     */
-    async listGeneratedFiles(args) {
-        try {
-            const outputDir = path.join(process.cwd(), 'flow-update-sets');
-            if (!fs.existsSync(outputDir)) {
-                return {
-                    success: true,
-                    files: [],
-                    message: 'No flow XML files generated yet'
-                };
-            }
-            const files = fs.readdirSync(outputDir)
-                .filter(file => file.endsWith('.xml'))
-                .map(file => {
-                const filePath = path.join(outputDir, file);
-                const stats = fs.statSync(filePath);
-                return {
-                    name: file,
-                    path: filePath,
-                    size: stats.size,
-                    created: stats.birthtime,
-                    modified: stats.mtime
-                };
-            })
-                .sort((a, b) => b.modified.getTime() - a.modified.getTime());
-            return {
-                success: true,
-                files: files,
-                count: files.length,
-                directory: outputDir,
-                message: `Found ${files.length} flow XML files`
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    /**
-     * Helper methods for examples
-     */
-    getApprovalFlowExample() {
-        return {
-            name: 'Multi-Level Approval Flow',
-            description: 'Production-ready multi-level approval workflow',
-            internal_name: 'multi_level_approval',
-            table: 'sc_request',
-            trigger_type: 'record_created',
-            trigger_condition: 'approval=requested',
-            run_as: 'user',
-            activities: [
-                {
-                    name: 'Manager Approval',
-                    type: 'approval',
-                    order: 100,
-                    inputs: {
-                        table: 'sc_request',
-                        record: '{{trigger.current.sys_id}}',
-                        approver: '{{trigger.current.requested_for.manager}}',
-                        approval_field: 'approval',
-                        message: 'Please approve request {{trigger.current.number}} for {{trigger.current.requested_for.name}}'
-                    },
-                    outputs: {
-                        state: 'string',
-                        approver_sys_id: 'string'
-                    }
-                },
-                {
-                    name: 'Director Approval',
-                    type: 'approval',
-                    order: 200,
-                    condition: '{{manager_approval.state}} == "approved" && {{trigger.current.price}} > 5000',
-                    inputs: {
-                        table: 'sc_request',
-                        record: '{{trigger.current.sys_id}}',
-                        approver: '{{trigger.current.requested_for.manager.manager}}',
-                        approval_field: 'approval',
-                        message: 'High-value request requires director approval: {{trigger.current.number}}'
-                    },
-                    outputs: {
-                        state: 'string',
-                        approver_sys_id: 'string'
-                    }
-                },
-                {
-                    name: 'Send Result Notification',
-                    type: 'notification',
-                    order: 300,
-                    inputs: {
-                        notification_id: (0, servicenow_id_generator_js_1.getNotificationTemplateSysId)('generic_notification'),
-                        recipients: '{{trigger.current.requested_for}}',
-                        values: {
-                            request_number: '{{trigger.current.number}}',
-                            final_status: '{{director_approval.state || manager_approval.state}}'
-                        }
-                    },
-                    outputs: {
-                        sent: 'boolean'
-                    }
-                }
-            ]
-        };
-    }
-    getIncidentNotificationExample() {
-        return {
-            name: 'High Priority Incident Notification',
-            description: 'Notifies management of high priority incidents',
-            table: 'incident',
-            trigger_type: 'record_created',
-            trigger_condition: 'priority<=2',
-            activities: [
-                {
-                    name: 'Check Business Hours',
-                    type: 'script',
-                    order: 100,
-                    inputs: {
-                        script: `
-var isBusinessHours = gs.isBusinessHours();
-current.u_notified_outside_hours = !isBusinessHours;
-return { is_business_hours: isBusinessHours };
-            `.trim()
-                    },
-                    outputs: {
-                        is_business_hours: 'boolean'
-                    }
-                },
-                {
-                    name: 'Send Management Alert',
-                    type: 'notification',
-                    order: 200,
-                    inputs: {
-                        recipient: 'it-management@company.com',
-                        subject: 'URGENT: P${current.priority} Incident Created',
-                        message: 'High priority incident ${current.number} requires attention'
-                    }
-                },
-                {
-                    name: 'Create War Room Task',
-                    type: 'create_record',
-                    order: 300,
-                    condition: '${current.priority} == 1',
-                    inputs: {
-                        table: 'task',
-                        fields: {
-                            short_description: 'War Room: ${current.number}',
-                            description: 'Coordinate response for critical incident',
-                            assigned_to: '${current.assignment_group.manager}'
-                        }
-                    }
-                }
-            ]
-        };
-    }
-    getEquipmentProvisioningExample() {
-        return {
-            name: 'IT Equipment Provisioning',
-            description: 'Automated provisioning of IT equipment',
-            table: 'sc_request',
-            trigger_type: 'record_updated',
-            trigger_condition: 'state=approved^cat_item.category=hardware',
-            activities: [
-                {
-                    name: 'Check Inventory',
-                    type: 'rest_step',
-                    order: 100,
-                    inputs: {
-                        endpoint: '${system.property.inventory_api_url}/check',
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': 'Bearer ${system.property.inventory_api_token}'
-                        },
-                        body: {
-                            item_code: '${current.cat_item.model_number}',
-                            quantity: '${current.quantity}'
-                        }
-                    },
-                    outputs: {
-                        in_stock: 'boolean',
-                        available_quantity: 'integer'
-                    }
-                },
-                {
-                    name: 'Create Asset Record',
-                    type: 'create_record',
-                    order: 200,
-                    condition: '${check_inventory.in_stock} == true',
-                    inputs: {
-                        table: 'alm_asset',
-                        fields: {
-                            display_name: '${current.cat_item.name} - ${current.requested_for.name}',
-                            assigned_to: '${current.requested_for}',
-                            state: 'In use',
-                            po_number: '${current.number}'
-                        }
-                    }
-                },
-                {
-                    name: 'Send Delivery Instructions',
-                    type: 'notification',
-                    order: 300,
-                    inputs: {
-                        recipient: '${current.requested_for.email}',
-                        subject: 'Equipment Ready for Pickup',
-                        message: 'Your ${current.cat_item.name} is ready. Pickup location: ${pickup_location}'
-                    }
-                }
-            ]
-        };
-    }
-    getDataProcessingExample() {
-        return {
-            name: 'Daily Data Processing',
-            description: 'Process and analyze daily operational data',
-            trigger_type: 'scheduled',
-            trigger_condition: '0 2 * * *', // 2 AM daily
-            activities: [
-                {
-                    name: 'Extract Yesterday Data',
-                    type: 'script',
-                    order: 100,
-                    inputs: {
-                        script: `
-var yesterday = new GlideDateTime();
-yesterday.addDays(-1);
-var gr = new GlideRecord('incident');
-gr.addQuery('opened_at', '>=', yesterday.getDate());
-gr.query();
-var count = gr.getRowCount();
-return { record_count: count, date: yesterday.getDate() };
-            `.trim()
-                    },
-                    outputs: {
-                        record_count: 'integer',
-                        date: 'string'
-                    }
-                },
-                {
-                    name: 'Generate Report',
-                    type: 'script',
-                    order: 200,
-                    inputs: {
-                        script: `
-// Generate daily report logic
-var report = generateDailyReport(current.record_count);
-return { report_id: report.sys_id };
-            `.trim()
-                    }
-                },
-                {
-                    name: 'Send Report',
-                    type: 'notification',
-                    order: 300,
-                    inputs: {
-                        recipient: 'operations@company.com',
-                        subject: 'Daily Operations Report - ${date}',
-                        message: 'Daily report is ready. ${record_count} incidents processed.',
-                        attachments: '${report_id}'
-                    }
-                }
-            ]
-        };
-    }
-    getUserOnboardingExample() {
-        return {
-            name: 'Employee Onboarding Workflow',
-            description: 'Automated onboarding process for new employees',
-            table: 'sys_user',
-            trigger_type: 'record_created',
-            trigger_condition: 'employee_number!=NULL',
-            activities: [
-                {
-                    name: 'Create AD Account',
-                    type: 'rest_step',
-                    order: 100,
-                    inputs: {
-                        endpoint: '${system.property.ad_api_url}/users',
-                        method: 'POST',
-                        body: {
-                            username: '${current.user_name}',
-                            email: '${current.email}',
-                            department: '${current.department}'
-                        }
-                    }
-                },
-                {
-                    name: 'Assign Equipment',
-                    type: 'create_record',
-                    order: 200,
-                    inputs: {
-                        table: 'sc_request',
-                        fields: {
-                            requested_for: '${current.sys_id}',
-                            cat_item: '${system.property.standard_laptop_item}',
-                            short_description: 'New Employee Equipment - ${current.name}'
-                        }
-                    }
-                },
-                {
-                    name: 'Schedule Training',
-                    type: 'create_record',
-                    order: 300,
-                    inputs: {
-                        table: 'task',
-                        fields: {
-                            short_description: 'Onboarding Training - ${current.name}',
-                            assigned_to: '${current.department.training_coordinator}',
-                            due_date: '+7 days'
-                        }
-                    }
-                },
-                {
-                    name: 'Send Welcome Email',
-                    type: 'notification',
-                    order: 400,
-                    inputs: {
-                        recipient: '${current.email}',
-                        cc: '${current.manager.email}',
-                        subject: 'Welcome to the Team!',
-                        message: 'Welcome ${current.first_name}! Your accounts are being set up.'
-                    }
-                }
-            ]
-        };
-    }
-    /**
-     * Helper methods
-     */
-    mapTriggerType(type) {
-        const typeMap = {
-            'create': 'record_created',
-            'update': 'record_updated',
-            'manual': 'manual',
-            'scheduled': 'scheduled',
-            'cron': 'scheduled'
-        };
-        return typeMap[type.toLowerCase()] || 'manual';
-    }
-    convertToXMLActivities(requirements) {
-        const activities = [];
-        // Convert actions to activities
-        if (requirements.actions && Array.isArray(requirements.actions)) {
-            requirements.actions.forEach((action, index) => {
-                activities.push({
-                    name: action.name || `Activity ${index + 1}`,
-                    type: this.mapActionType(action.type || 'script'),
-                    order: (index + 1) * 100,
-                    inputs: action.config || action.inputs || {},
-                    outputs: action.outputs,
-                    condition: action.condition
-                });
-            });
-        }
-        // If no activities but has requirements, generate default activities
-        if (activities.length === 0 && requirements.description) {
-            activities.push({
-                name: 'Process Request',
-                type: 'script',
-                order: 100,
-                inputs: {
-                    script: '// Process logic here\ngs.info("Processing: " + current.number);'
-                }
-            });
-        }
-        return activities;
-    }
-    /**
-     * Convert requirements to IMPROVED activities (with enhanced structure)
-     */
-    convertToImprovedActivities(requirements) {
-        const activities = [];
-        // Convert actions to improved activities
-        if (requirements.actions && Array.isArray(requirements.actions)) {
-            requirements.actions.forEach((action, index) => {
-                activities.push({
-                    name: action.name || `Activity ${index + 1}`,
-                    type: this.mapActionType(action.type || 'script'),
-                    order: (index + 1) * 100,
-                    inputs: action.config || action.inputs || {},
-                    outputs: action.outputs,
-                    condition: action.condition,
-                    description: action.description || action.name || `Enhanced activity ${index + 1}`,
-                    exit_conditions: action.exit_conditions || { success: true }
-                });
-            });
-        }
-        // If no activities but has requirements, generate default enhanced activities
-        if (activities.length === 0 && requirements.description) {
-            activities.push({
-                name: 'Process Request',
-                type: 'script',
-                order: 100,
-                description: 'Process the request with enhanced logging and error handling',
-                inputs: {
-                    script: `// Enhanced processing logic
-try {
-  gs.info("Processing request: " + current.number);
-  // Add your business logic here
-  return { success: true, message: "Request processed successfully" };
-} catch (error) {
-  gs.error("Error processing request: " + error.message);
-  return { success: false, error: error.message };
-}`,
-                    timeout: 30
-                },
-                outputs: {
-                    success: 'boolean',
-                    message: 'string',
-                    error: 'string'
-                },
-                exit_conditions: { success: true }
-            });
-        }
-        return activities;
-    }
-    mapActionType(type) {
-        const typeMap = {
-            'email': 'notification',
-            'notify': 'notification',
-            'approve': 'approval',
-            'script': 'script',
-            'create': 'create_record',
-            'update': 'update_record',
-            'rest': 'rest_step',
-            'api': 'rest_step'
-        };
-        return typeMap[type.toLowerCase()] || 'script';
-    }
-    /**
-     * IMPROVED example methods (enhanced with better structure)
-     */
-    getImprovedIncidentNotificationExample() {
-        return {
-            name: 'Enhanced High Priority Incident Notification',
-            description: 'Advanced notification system for high priority incidents with escalation logic',
-            table: 'incident',
-            trigger_type: 'record_created',
-            trigger_condition: 'priority<=2^active=true',
-            run_as: 'user',
-            accessible_from: 'package_private',
-            category: 'notification',
-            tags: ['incident', 'notification', 'escalation', 'high-priority'],
-            activities: [
-                {
-                    name: 'Analyze Incident Severity',
-                    type: 'script',
-                    order: 100,
-                    description: 'Comprehensive incident _analysis with business impact assessment',
-                    inputs: {
-                        script: `// Enhanced incident analysis
-var _analysis = {
-  severity_score: 0,
-  business_impact: 'low',
-  escalation_required: false,
-  notification_channels: [],
-  estimated_resolution_time: '4 hours'
-};
-
-// Calculate severity score
-if (current.priority == 1) _analysis.severity_score = 100;
-else if (current.priority == 2) _analysis.severity_score = 80;
-
-// Business impact assessment
-if (current.category && current.category.toString().includes('business_critical')) {
-  _analysis.business_impact = 'critical';
-  _analysis.escalation_required = true;
-}
-
-// Determine notification channels
-_analysis.notification_channels = ['email'];
-if (_analysis.severity_score >= 90) {
-  _analysis.notification_channels.push('sms', 'teams');
-}
-
-// Check for after-hours escalation
-var isAfterHours = !gs.isBusinessHours();
-if (isAfterHours && _analysis.severity_score >= 80) {
-  _analysis.escalation_required = true;
-  _analysis.notification_channels.push('emergency_contact');
-}
-
-return _analysis;`,
-                        timeout: 30
-                    },
-                    outputs: {
-                        severity_score: 'number',
-                        business_impact: 'string',
-                        escalation_required: 'boolean',
-                        notification_channels: 'object',
-                        estimated_resolution_time: 'string'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Send Multi-Channel Notifications',
-                    type: 'notification',
-                    order: 200,
-                    description: 'Send notifications via multiple channels based on severity',
-                    inputs: {
-                        recipients: '{{trigger.current.assignment_group.manager}},it-management@company.com',
-                        cc: '{{trigger.current.caller_id}}',
-                        subject: 'URGENT P{{trigger.current.priority}} Incident: {{trigger.current.short_description}}',
-                        message: `High Priority Incident Alert
-
-Incident: {{trigger.current.number}}
-Priority: P{{trigger.current.priority}}
-Severity Score: {{analyze_incident_severity.severity_score}}
-Business Impact: {{analyze_incident_severity.business_impact}}
-Category: {{trigger.current.category}}
-Affected User: {{trigger.current.caller_id.name}}
-Assignment Group: {{trigger.current.assignment_group.name}}
-
-Short Description: {{trigger.current.short_description}}
-
-Estimated Resolution: {{analyze_incident_severity.estimated_resolution_time}}
-Escalation Required: {{analyze_incident_severity.escalation_required}}
-
-Please take immediate action to resolve this incident.
-
-View Incident: {{sys.url_base}}/incident.do?sys_id={{trigger.current.sys_id}}`,
-                        notification_type: 'urgent',
-                        channels: '{{analyze_incident_severity.notification_channels}}'
-                    },
-                    outputs: {
-                        sent: 'boolean',
-                        channels_used: 'object',
-                        notification_id: 'string'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Create Emergency Response Task',
-                    type: 'create_record',
-                    order: 300,
-                    description: 'Create emergency response coordination task for critical incidents',
-                    condition: '{{analyze_incident_severity.escalation_required}} == true',
-                    inputs: {
-                        table: 'task',
-                        fields: [
-                            {
-                                field: 'short_description',
-                                value: 'EMERGENCY RESPONSE: {{trigger.current.number}} - {{trigger.current.short_description}}'
-                            },
-                            {
-                                field: 'description',
-                                value: `Emergency Response Coordination
-
-Related Incident: {{trigger.current.number}}
-Severity Score: {{analyze_incident_severity.severity_score}}
-Business Impact: {{analyze_incident_severity.business_impact}}
-Channels Notified: {{send_multi_channel_notifications.channels_used}}
-
-Actions Required:
-1. Establish incident command center
-2. Coordinate with technical teams
-3. Prepare stakeholder communications
-4. Monitor resolution progress
-
-Escalation Triggered: {{sys.now}}`
-                            },
-                            { field: 'priority', value: '1' },
-                            { field: 'assignment_group', value: 'incident_management' },
-                            { field: 'parent', value: '{{trigger.current.sys_id}}' },
-                            { field: 'due_date', value: '+1 hour' },
-                            { field: 'work_notes', value: 'Auto-created for emergency incident response coordination' }
-                        ]
-                    },
-                    outputs: {
-                        task_sys_id: 'string',
-                        task_number: 'string',
-                        assigned_to: 'string'
-                    },
-                    exit_conditions: { success: true }
-                }
-            ]
-        };
-    }
-    getImprovedEquipmentProvisioningExample() {
-        return {
-            name: 'Advanced IT Equipment Provisioning',
-            description: 'Comprehensive equipment provisioning with inventory management and asset tracking',
-            table: 'sc_request',
-            trigger_type: 'record_updated',
-            trigger_condition: 'state=approved^cat_item.category=hardware^active=true',
-            run_as: 'user',
-            accessible_from: 'package_private',
-            category: 'provisioning',
-            tags: ['equipment', 'provisioning', 'inventory', 'asset-management'],
-            activities: [
-                {
-                    name: 'Enhanced Inventory Check',
-                    type: 'script',
-                    order: 100,
-                    description: 'Comprehensive inventory check with alternative options',
-                    inputs: {
-                        script: `// Advanced inventory management
-var inventoryCheck = {
-  primary_item_available: false,
-  alternative_options: [],
-  delivery_estimate: '',
-  procurement_required: false,
-  total_cost: 0
-};
-
-// Check primary item availability
-var itemGR = new GlideRecord('alm_consumable');
-itemGR.addQuery('model_number', current.cat_item.model_number);
-itemGR.query();
-
-if (itemGR.next()) {
-  var availableQty = parseInt(itemGR.quantity);
-  var requestedQty = parseInt(current.quantity || 1);
-  
-  if (availableQty >= requestedQty) {
-    inventoryCheck.primary_item_available = true;
-    inventoryCheck.delivery_estimate = '2-3 business days';
-  } else {
-    // Find alternatives
-    var altGR = new GlideRecord('alm_consumable');
-    altGR.addQuery('category', itemGR.category);
-    altGR.addQuery('quantity', '>', requestedQty);
-    altGR.query();
-    
-    while (altGR.next() && inventoryCheck.alternative_options.length < 3) {
-      inventoryCheck.alternative_options.push({
-        name: altGR.display_name.toString(),
-        model: altGR.model_number.toString(),
-        quantity: altGR.quantity.toString(),
-        cost: altGR.cost.toString()
-      });
-    }
-    
-    if (inventoryCheck.alternative_options.length === 0) {
-      inventoryCheck.procurement_required = true;
-      inventoryCheck.delivery_estimate = '10-15 business days';
-    }
-  }
-}
-
-return inventoryCheck;`,
-                        timeout: 60
-                    },
-                    outputs: {
-                        primary_item_available: 'boolean',
-                        alternative_options: 'object',
-                        delivery_estimate: 'string',
-                        procurement_required: 'boolean',
-                        total_cost: 'number'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Create Comprehensive Asset Record',
-                    type: 'create_record',
-                    order: 200,
-                    description: 'Create detailed asset record with full lifecycle tracking',
-                    condition: '{{enhanced_inventory_check.primary_item_available}} == true',
-                    inputs: {
-                        table: 'alm_asset',
-                        fields: [
-                            {
-                                field: 'display_name',
-                                value: '{{trigger.current.cat_item.name}} - {{trigger.current.requested_for.name}}'
-                            },
-                            { field: 'assigned_to', value: '{{trigger.current.requested_for}}' },
-                            { field: 'state', value: 'On order' },
-                            { field: 'substatus', value: 'Approved for deployment' },
-                            { field: 'po_number', value: '{{trigger.current.number}}' },
-                            { field: 'cost', value: '{{trigger.current.price}}' },
-                            { field: 'delivery_date', value: '{{enhanced_inventory_check.delivery_estimate}}' },
-                            { field: 'location', value: '{{trigger.current.requested_for.location}}' },
-                            { field: 'department', value: '{{trigger.current.requested_for.department}}' },
-                            { field: 'justification', value: '{{trigger.current.business_justification}}' },
-                            {
-                                field: 'work_notes',
-                                value: 'Asset provisioned via automated workflow. Request: {{trigger.current.number}}. Delivery estimate: {{enhanced_inventory_check.delivery_estimate}}'
-                            }
-                        ]
-                    },
-                    outputs: {
-                        asset_sys_id: 'string',
-                        asset_tag: 'string',
-                        tracking_number: 'string'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Send Enhanced Delivery Notification',
-                    type: 'notification',
-                    order: 300,
-                    description: 'Comprehensive delivery notification with tracking information',
-                    inputs: {
-                        recipients: '{{trigger.current.requested_for}}',
-                        cc: '{{trigger.current.requested_for.manager}},{{trigger.current.opened_by}}',
-                        subject: 'Equipment Approved & Scheduled for Delivery - {{trigger.current.number}}',
-                        message: `Equipment Provisioning Update
-
-Request Details:
-- Request Number: {{trigger.current.number}}
-- Item: {{trigger.current.cat_item.name}}
-- Status: Approved and scheduled for delivery
-- Asset Tag: {{create_comprehensive_asset_record.asset_tag}}
-
-Delivery Information:
-- Estimated Delivery: {{enhanced_inventory_check.delivery_estimate}}
-- Delivery Location: {{trigger.current.requested_for.location.name}}
-- Tracking Number: {{create_comprehensive_asset_record.tracking_number}}
-
-Next Steps:
-1. You will receive a delivery confirmation email
-2. Please be available during business hours for delivery
-3. Asset setup appointment will be scheduled separately if required
-
-Important Notes:
-- Please have your employee ID ready for delivery verification
-- Any delivery issues should be reported to IT Service Desk immediately
-- Training materials will be provided with your equipment
-
-For questions or concerns, please contact:
-IT Service Desk: {{sys.property.it_service_desk_phone}}
-Email: {{sys.property.it_service_desk_email}}
-
-Thank you!
-IT Service Management Team`,
-                        notification_type: 'information',
-                        attachments: '{{create_comprehensive_asset_record.asset_sys_id}}'
-                    },
-                    outputs: {
-                        sent: 'boolean',
-                        delivery_confirmed: 'boolean',
-                        notification_id: 'string'
-                    },
-                    exit_conditions: { success: true }
-                }
-            ]
-        };
-    }
-    getImprovedDataProcessingExample() {
-        return {
-            name: 'Advanced Daily Data Processing & Analytics',
-            description: 'Comprehensive data processing with analytics, reporting, and alerting',
-            trigger_type: 'scheduled',
-            trigger_condition: '0 2 * * *', // 2 AM daily
-            run_as: 'system',
-            accessible_from: 'private',
-            category: 'automation',
-            tags: ['data-processing', 'analytics', 'reporting', 'scheduled'],
-            activities: [
-                {
-                    name: 'Comprehensive Data Extraction',
-                    type: 'script',
-                    order: 100,
-                    description: 'Extract and process data from multiple sources with validation',
-                    inputs: {
-                        script: `// Advanced data extraction and processing
-var processingResults = {
-  extraction_timestamp: new GlideDateTime().toString(),
-  datasets: {},
-  validation_errors: [],
-  processing_summary: {},
-  recommendations: []
-};
-
-// Extract incidents data
-var incidentGR = new GlideRecord('incident');
-var yesterday = new GlideDateTime();
-yesterday.addDays(-1);
-incidentGR.addQuery('opened_at', '>=', yesterday.getDate());
-incidentGR.query();
-
-var incidentData = {
-  total_count: incidentGR.getRowCount(),
-  priority_breakdown: { p1: 0, p2: 0, p3: 0, p4: 0 },
-  category_breakdown: {},
-  resolution_times: []
-};
-
-while (incidentGR.next()) {
-  // Priority analysis
-  var priority = 'p' + incidentGR.priority;
-  incidentData.priority_breakdown[priority]++;
-  
-  // Category analysis
-  var category = incidentGR.category.toString();
-  if (!incidentData.category_breakdown[category]) {
-    incidentData.category_breakdown[category] = 0;
-  }
-  incidentData.category_breakdown[category]++;
-  
-  // Resolution time analysis
-  if (incidentGR.resolved_at) {
-    var openTime = new GlideDateTime(incidentGR.opened_at);
-    var resolveTime = new GlideDateTime(incidentGR.resolved_at);
-    var duration = resolveTime.getNumericValue() - openTime.getNumericValue();
-    incidentData.resolution_times.push(duration);
-  }
-}
-
-processingResults.datasets.incidents = incidentData;
-
-// Extract service requests data
-var requestGR = new GlideRecord('sc_request');
-requestGR.addQuery('opened_at', '>=', yesterday.getDate());
-requestGR.query();
-
-var requestData = {
-  total_count: requestGR.getRowCount(),
-  state_breakdown: {},
-  fulfillment_times: []
-};
-
-while (requestGR.next()) {
-  var state = requestGR.state.getDisplayValue();
-  if (!requestData.state_breakdown[state]) {
-    requestData.state_breakdown[state] = 0;
-  }
-  requestData.state_breakdown[state]++;
-}
-
-processingResults.datasets.requests = requestData;
-
-// Generate insights and recommendations
-if (incidentData.priority_breakdown.p1 > 5) {
-  processingResults.recommendations.push('High number of P1 incidents detected. Consider incident management review.');
-}
-
-if (incidentData.total_count > 50) {
-  processingResults.recommendations.push('Incident volume above threshold. Monitor for trends.');
-}
-
-return processingResults;`,
-                        timeout: 300
-                    },
-                    outputs: {
-                        extraction_timestamp: 'string',
-                        datasets: 'object',
-                        validation_errors: 'object',
-                        processing_summary: 'object',
-                        recommendations: 'object'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Generate Advanced Analytics Report',
-                    type: 'script',
-                    order: 200,
-                    description: 'Create comprehensive analytics report with visualizations',
-                    inputs: {
-                        script: `// Advanced report generation
-var reportData = {
-  report_id: gs.generateGUID(),
-  generated_at: new GlideDateTime().toString(),
-  metrics: {},
-  charts: {},
-  alerts: [],
-  export_ready: false
-};
-
-var datasets = JSON.parse(current.datasets || '{}');
-
-// Calculate key metrics
-if (datasets.incidents) {
-  reportData.metrics.incident_volume_trend = calculateTrend(datasets.incidents.total_count);
-  reportData.metrics.avg_resolution_time = calculateAverage(datasets.incidents.resolution_times);
-  reportData.metrics.priority_distribution = datasets.incidents.priority_breakdown;
-}
-
-if (datasets.requests) {
-  reportData.metrics.request_volume = datasets.requests.total_count;
-  reportData.metrics.fulfillment_rate = calculateFulfillmentRate(datasets.requests.state_breakdown);
-}
-
-// Generate alerts for anomalies
-if (reportData.metrics.incident_volume_trend > 20) {
-  reportData.alerts.push({
-    type: 'warning',
-    message: 'Incident volume increased by ' + reportData.metrics.incident_volume_trend + '%'
-  });
-}
-
-// Create chart data
-reportData.charts.incident_trend = generateTrendChart(datasets.incidents);
-reportData.charts.priority_pie = generatePieChart(datasets.incidents.priority_breakdown);
-
-reportData.export_ready = true;
-
-function calculateTrend(currentValue) {
-  // Simplified trend calculation
-  return Math.floor(Math.random() * 30) - 10; // Placeholder
-}
-
-function calculateAverage(values) {
-  if (!values || values.length === 0) return 0;
-  var sum = values.reduce(function(a, b) { return a + b; }, 0);
-  return Math.round(sum / values.length / 3600000); // Convert to hours
-}
-
-function calculateFulfillmentRate(stateBreakdown) {
-  var completed = stateBreakdown['Completed'] || 0;
-  var total = Object.values(stateBreakdown).reduce(function(a, b) { return a + b; }, 0);
-  return total > 0 ? Math.round((completed / total) * 100) : 0;
-}
-
-function generateTrendChart(data) {
-  return { type: 'line', data: data.priority_breakdown };
-}
-
-function generatePieChart(data) {
-  return { type: 'pie', data: data };
-}
-
-return reportData;`,
-                        timeout: 180
-                    },
-                    outputs: {
-                        report_id: 'string',
-                        generated_at: 'string',
-                        metrics: 'object',
-                        charts: 'object',
-                        alerts: 'object',
-                        export_ready: 'boolean'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Send Comprehensive Analytics Report',
-                    type: 'notification',
-                    order: 300,
-                    description: 'Distribute detailed analytics report to stakeholders',
-                    inputs: {
-                        recipients: 'operations@company.com,it-management@company.com',
-                        cc: 'service-desk@company.com',
-                        subject: 'Daily Operations Analytics Report - {{comprehensive_data_extraction.extraction_timestamp}}',
-                        message: `Daily Operations Analytics Report
-
-Report Generated: {{generate_advanced_analytics_report.generated_at}}
-Report ID: {{generate_advanced_analytics_report.report_id}}
-
-== KEY METRICS ==
-Incident Volume: {{comprehensive_data_extraction.datasets.incidents.total_count}}
-Request Volume: {{comprehensive_data_extraction.datasets.requests.total_count}}
-Average Resolution Time: {{generate_advanced_analytics_report.metrics.avg_resolution_time}} hours
-Fulfillment Rate: {{generate_advanced_analytics_report.metrics.fulfillment_rate}}%
-
-== PRIORITY BREAKDOWN ==
-P1 Incidents: {{comprehensive_data_extraction.datasets.incidents.priority_breakdown.p1}}
-P2 Incidents: {{comprehensive_data_extraction.datasets.incidents.priority_breakdown.p2}}
-P3 Incidents: {{comprehensive_data_extraction.datasets.incidents.priority_breakdown.p3}}
-P4 Incidents: {{comprehensive_data_extraction.datasets.incidents.priority_breakdown.p4}}
-
-== ALERTS & RECOMMENDATIONS ==
-{{#each generate_advanced_analytics_report.alerts}}
-⚠️ {{this.message}}
-{{/each}}
-
-{{#each comprehensive_data_extraction.recommendations}}
-💡 {{this}}
-{{/each}}
-
-== DATA QUALITY ==
-Validation Errors: {{comprehensive_data_extraction.validation_errors.length}}
-Processing Status: Complete
-
-Access full report dashboard: {{sys.url_base}}/analytics_dashboard.do?report={{generate_advanced_analytics_report.report_id}}
-
-Next Report: Tomorrow at 2:00 AM
-
----
-Generated by ServiceNow Automated Analytics
-Questions? Contact IT Operations Team`,
-                        notification_type: 'daily_report',
-                        priority: 'normal'
-                    },
-                    outputs: {
-                        sent: 'boolean',
-                        report_distributed: 'boolean',
-                        notification_id: 'string'
-                    },
-                    exit_conditions: { success: true }
-                }
-            ]
-        };
-    }
-    getImprovedUserOnboardingExample() {
-        return {
-            name: 'Comprehensive Employee Onboarding Workflow',
-            description: 'End-to-end automated onboarding with multi-system integration and tracking',
-            table: 'sys_user',
-            trigger_type: 'record_created',
-            trigger_condition: 'employee_number!=NULL^active=true^internal_type=employee',
-            run_as: 'system',
-            accessible_from: 'package_private',
-            category: 'onboarding',
-            tags: ['onboarding', 'employee', 'automation', 'integration'],
-            activities: [
-                {
-                    name: 'Comprehensive User Account Setup',
-                    type: 'script',
-                    order: 100,
-                    description: 'Complete user account provisioning with role assignment and access control',
-                    inputs: {
-                        script: `// Comprehensive onboarding setup
-var onboardingResults = {
-  user_sys_id: current.sys_id,
-  account_setup: {},
-  role_assignments: [],
-  access_requests: [],
-  setup_errors: [],
-  completion_status: 'in_progress'
-};
-
-try {
-  // Set up basic user attributes
-  current.employee_number = current.employee_number || generateEmployeeNumber();
-  current.user_name = current.user_name || generateUsername(current.first_name, current.last_name);
-  current.email = current.email || (current.user_name + '@company.com');
-  current.active = true;
-  current.locked_out = false;
-  
-  // Assign default roles based on department
-  var defaultRoles = getDepartmentRoles(current.department.toString());
-  defaultRoles.forEach(function(role) {
-    var userRoleGR = new GlideRecord('sys_user_has_role');
-    userRoleGR.user = current.sys_id;
-    userRoleGR.role = role.sys_id;
-    userRoleGR.insert();
-    onboardingResults.role_assignments.push(role.name);
-  });
-  
-  // Create access requests for department-specific systems
-  var accessSystems = getDepartmentSystems(current.department.toString());
-  accessSystems.forEach(function(system) {
-    var accessReqGR = new GlideRecord('access_request');
-    accessReqGR.user = current.sys_id;
-    accessReqGR.system = system.sys_id;
-    accessReqGR.requested_by = current.manager;
-    accessReqGR.business_justification = 'New employee onboarding';
-    accessReqGR.state = 'pending_approval';
-    var reqSysId = accessReqGR.insert();
-    onboardingResults.access_requests.push({
-      system: system.name,
-      request_id: reqSysId
-    });
-  });
-  
-  onboardingResults.account_setup.username = current.user_name;
-  onboardingResults.account_setup.email = current.email;
-  onboardingResults.account_setup.employee_number = current.employee_number;
-  onboardingResults.completion_status = 'completed';
-  
-} catch (error) {
-  onboardingResults.setup_errors.push(error.message);
-  onboardingResults.completion_status = 'failed';
-}
-
-function generateEmployeeNumber() {
-  return 'EMP' + Date.now().toString().substr(-6);
-}
-
-function generateUsername(firstName, lastName) {
-  return (firstName.charAt(0) + lastName).toLowerCase().replace(/[^a-z0-9]/g, '');
-}
-
-function getDepartmentRoles(department) {
-  // Simplified role mapping
-  var roleMap = {
-    'IT': [{ sys_id: 'role1', name: 'itil' }, { sys_id: 'role2', name: 'catalog_editor' }],
-    'HR': [{ sys_id: 'role3', name: 'hr_admin' }],
-    'Finance': [{ sys_id: 'role4', name: 'finance_user' }]
-  };
-  return roleMap[department] || [{ sys_id: 'role5', name: 'employee' }];
-}
-
-function getDepartmentSystems(department) {
-  // Simplified system mapping
-  var systemMap = {
-    'IT': [{ sys_id: 'sys1', name: 'ServiceNow Admin' }, { sys_id: 'sys2', name: 'Network Management' }],
-    'HR': [{ sys_id: 'sys3', name: 'HRIS System' }],
-    'Finance': [{ sys_id: 'sys4', name: 'ERP System' }]
-  };
-  return systemMap[department] || [];
-}
-
-return onboardingResults;`,
-                        timeout: 120
-                    },
-                    outputs: {
-                        user_sys_id: 'string',
-                        account_setup: 'object',
-                        role_assignments: 'object',
-                        access_requests: 'object',
-                        setup_errors: 'object',
-                        completion_status: 'string'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Equipment & Workspace Provisioning',
-                    type: 'create_record',
-                    order: 200,
-                    description: 'Automated equipment request and workspace setup',
-                    condition: '{{comprehensive_user_account_setup.completion_status}} == "completed"',
-                    inputs: {
-                        table: 'sc_request',
-                        fields: [
-                            {
-                                field: 'requested_for',
-                                value: '{{trigger.current.sys_id}}'
-                            },
-                            {
-                                field: 'cat_item',
-                                value: '{{sys.property.standard_employee_package}}'
-                            },
-                            {
-                                field: 'short_description',
-                                value: 'New Employee Equipment Package - {{trigger.current.first_name}} {{trigger.current.last_name}}'
-                            },
-                            {
-                                field: 'description',
-                                value: `Comprehensive equipment package for new employee:
-
-Employee Details:
-- Name: {{trigger.current.first_name}} {{trigger.current.last_name}}
-- Employee Number: {{comprehensive_user_account_setup.account_setup.employee_number}}
-- Department: {{trigger.current.department.name}}
-- Location: {{trigger.current.location.name}}
-- Manager: {{trigger.current.manager.name}}
-- Start Date: {{trigger.current.start_date}}
-
-Equipment Package Includes:
-- Standard laptop configuration
-- Monitor and accessories
-- Mobile device (if applicable)
-- Security badge and access card
-- Office supplies starter kit
-
-Workspace Setup:
-- Desk assignment in {{trigger.current.location.name}}
-- Phone extension setup
-- Parking assignment (if applicable)
-- Building access configuration
-
-Special Requirements:
-{{trigger.current.special_requirements}}
-
-Delivery Target: {{trigger.current.start_date}}`
-                            },
-                            { field: 'priority', value: '3' },
-                            { field: 'state', value: '1' },
-                            { field: 'approval', value: 'approved' },
-                            { field: 'business_justification', value: 'New employee onboarding equipment provisioning' },
-                            { field: 'requested_by', value: '{{trigger.current.manager}}' },
-                            { field: 'opened_by', value: 'system' },
-                            { field: 'due_date', value: '{{trigger.current.start_date}}' }
-                        ]
-                    },
-                    outputs: {
-                        equipment_request_id: 'string',
-                        request_number: 'string',
-                        estimated_delivery: 'string'
-                    },
-                    exit_conditions: { success: true }
-                },
-                {
-                    name: 'Send Comprehensive Welcome Notification',
-                    type: 'notification',
-                    order: 300,
-                    description: 'Multi-recipient welcome notification with complete onboarding information',
-                    inputs: {
-                        recipients: '{{trigger.current.email}}',
-                        cc: '{{trigger.current.manager.email}},hr-team@company.com',
-                        bcc: 'it-onboarding@company.com',
-                        subject: 'Welcome to {{sys.property.company_name}} - Your Onboarding Information',
-                        message: `Welcome to {{sys.property.company_name}}, {{trigger.current.first_name}}!
-
-We're excited to have you join our team. Your onboarding process has been initiated automatically.
-
-== YOUR ACCOUNT INFORMATION ==
-Employee Number: {{comprehensive_user_account_setup.account_setup.employee_number}}
-Username: {{comprehensive_user_account_setup.account_setup.username}}
-Email: {{comprehensive_user_account_setup.account_setup.email}}
-Start Date: {{trigger.current.start_date}}
-
-== ACCOUNT ACCESS ==
-Your account has been provisioned with the following roles:
-{{#each comprehensive_user_account_setup.role_assignments}}
-• {{this}}
-{{/each}}
-
-System access requests have been submitted for:
-{{#each comprehensive_user_account_setup.access_requests}}
-• {{this.system}} (Request: {{this.request_id}})
-{{/each}}
-
-== EQUIPMENT & WORKSPACE ==
-Equipment Request: {{equipment_workspace_provisioning.request_number}}
-Estimated Delivery: {{equipment_workspace_provisioning.estimated_delivery}}
-Workspace Location: {{trigger.current.location.name}}
-
-Your equipment package will be delivered by your start date and includes:
-• Laptop with standard software configuration
-• Monitor and accessories
-• Mobile device and accessories
-• Security badge and building access
-• Office supplies starter kit
-
-== FIRST DAY CHECKLIST ==
-□ Arrive at reception by 9:00 AM
-□ Collect your security badge and equipment
-□ Meet with your manager: {{trigger.current.manager.name}}
-□ Complete required training modules
-□ Attend new employee orientation
-□ Set up your workspace
-□ Schedule one-on-one meetings with team members
-
-== IMPORTANT CONTACTS ==
-Direct Manager: {{trigger.current.manager.name}} ({{trigger.current.manager.email}})
-HR Representative: {{trigger.current.hr_contact.name}} ({{trigger.current.hr_contact.email}})
-IT Support: {{sys.property.it_service_desk_email}} | {{sys.property.it_service_desk_phone}}
-Facilities: {{sys.property.facilities_email}}
-
-== RESOURCES ==
-Employee Handbook: {{sys.property.employee_handbook_url}}
-IT Support Portal: {{sys.property.it_portal_url}}
-Company Directory: {{sys.property.directory_url}}
-Benefits Information: {{sys.property.benefits_url}}
-
-== TRAINING SCHEDULE ==
-Your manager will provide your specific training schedule, but expect to complete:
-• Company orientation (Day 1)
-• Department-specific training (Week 1)
-• System training sessions (Week 1-2)
-• Safety and compliance training (Week 2)
-
-If you have any questions before your start date, please don't hesitate to reach out to your manager or HR team.
-
-Welcome aboard!
-
-{{sys.property.company_name}} People Team
-
----
-This message was generated automatically as part of your onboarding process.
-Onboarding ID: {{trigger.current.sys_id}}`,
-                        notification_type: 'welcome',
-                        priority: 'normal',
-                        tracking_enabled: true
-                    },
-                    outputs: {
-                        sent: 'boolean',
-                        welcome_confirmed: 'boolean',
-                        notification_id: 'string',
-                        recipients_notified: 'number'
-                    },
-                    exit_conditions: { success: true }
-                }
-            ]
-        };
-    }
-}
-exports.ServiceNowXMLFlowMCP = ServiceNowXMLFlowMCP;
-// Start the server
-const server = new ServiceNowXMLFlowMCP();
-server.start().catch(error => {
-    console.error('Failed to start XML Flow MCP server:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=servicenow-xml-flow-mcp.js.map