snow-flow 3.0.9 → 3.0.13

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

@@ -1,3103 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Flow Composer MCP Server
- * Natural language flow creation with multi-artifact orchestration
- */
-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 });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const servicenow_client_js_1 = require("../utils/servicenow-client.js");
-const snow_oauth_js_1 = require("../utils/snow-oauth.js");
-const logger_js_1 = require("../utils/logger.js");
-const flow_composer_js_1 = require("../orchestrator/flow-composer.js");
-const complete_flow_xml_generator_js_1 = require("../utils/complete-flow-xml-generator.js");
-const update_set_importer_js_1 = require("../utils/update-set-importer.js");
-const mcp_tool_registry_js_1 = require("../utils/mcp-tool-registry.js");
-const deployment_metadata_handler_js_1 = require("../utils/deployment-metadata-handler.js");
-class ServiceNowFlowComposerMCP {
-    constructor() {
-        this.server = new index_js_1.Server({
-            name: 'servicenow-flow-composer-enhanced',
-            version: '2.0.0',
-            description: 'Enhanced Flow Composer with Complete Solution - Fixes all critical issues: empty flows, tool registry mapping, and metadata failures',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.oauth = new snow_oauth_js_1.ServiceNowOAuth();
-        this.logger = new logger_js_1.Logger('ServiceNowFlowComposerMCP');
-        this.composer = new flow_composer_js_1.EnhancedFlowComposer();
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_create_flow',
-                    description: '🚀 ENHANCED FLOW TOOL v2.0 - Creates COMPLETE flows with ALL features working! Uses CompleteFlowXMLGenerator for proper v2 tables, Base64+gzip encoding, and full metadata. Fixes all deployment issues. ZERO MANUAL STEPS!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction for the flow (e.g., "maak een flow waarbij we het script include gebruiken waar we de localizatie met LLMs gebruiken om dan de berichten van het support desk mee te vertalen naar engels en deze op te slaan in een tabel aan de hand van een business rule")'
-                            },
-                            deploy_immediately: {
-                                type: 'boolean',
-                                description: '⚠️ DEPLOYMENT MODE - true: Deploy REAL flow to ServiceNow immediately | false: Planning mode only',
-                                default: true
-                            },
-                            create_missing_artifacts: {
-                                type: 'boolean',
-                                description: 'Create missing artifacts as fallbacks',
-                                default: true
-                            },
-                            scope_preference: {
-                                type: 'string',
-                                enum: ['global', 'application', 'auto'],
-                                description: 'Preferred deployment scope',
-                                default: 'auto'
-                            },
-                            enable_intelligent_analysis: {
-                                type: 'boolean',
-                                description: 'Enable intelligent flow vs subflow analysis',
-                                default: true
-                            },
-                            validation_level: {
-                                type: 'string',
-                                enum: ['basic', 'standard', 'comprehensive'],
-                                description: 'Level of validation to perform',
-                                default: 'standard'
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_analyze_flow_instruction',
-                    description: 'AUTONOMOUS analysis - understands complex requirements, identifies all needed artifacts, plans optimal flow structure. SELF-LEARNING from patterns.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction to analyze'
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_discover_flow_artifacts',
-                    description: 'AUTONOMOUS discovery - finds all required artifacts, creates missing ones, ensures compatibility. INTELLIGENT DEPENDENCY RESOLUTION!',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction'
-                            },
-                            artifact_types: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                    enum: ['script_include', 'business_rule', 'table', 'widget', 'ui_script']
-                                },
-                                description: 'Specific artifact types to search for'
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_preview_flow_structure',
-                    description: 'Preview the flow structure before deployment',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction'
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_deploy_composed_flow',
-                    description: 'Deploy a previously composed flow with all its artifacts',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            flow_instruction: {
-                                type: 'object',
-                                description: 'Previously composed flow instruction object'
-                            },
-                            validation_required: {
-                                type: 'boolean',
-                                description: 'Validate all artifacts before deployment',
-                                default: true
-                            },
-                        },
-                        required: ['flow_instruction'],
-                    },
-                },
-                {
-                    name: 'snow_intelligent_flow_analysis',
-                    description: 'INTELLIGENT ANALYSIS - Performs comprehensive flow vs subflow analysis with decision rationale and recommendations',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction to analyze'
-                            },
-                            include_templates: {
-                                type: 'boolean',
-                                description: 'Include template matching analysis',
-                                default: true
-                            },
-                            include_validation: {
-                                type: 'boolean',
-                                description: 'Include validation analysis',
-                                default: true
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_scope_optimization',
-                    description: 'SCOPE OPTIMIZATION - Analyzes and recommends optimal deployment scope with fallback strategies',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            artifact_type: {
-                                type: 'string',
-                                description: 'Type of artifact to analyze'
-                            },
-                            artifact_data: {
-                                type: 'object',
-                                description: 'Artifact data for analysis'
-                            },
-                            environment_type: {
-                                type: 'string',
-                                enum: ['development', 'testing', 'production'],
-                                description: 'Target environment type',
-                                default: 'development'
-                            },
-                        },
-                        required: ['artifact_type', 'artifact_data'],
-                    },
-                },
-                {
-                    name: 'snow_template_matching',
-                    description: 'TEMPLATE MATCHING - Finds and applies best matching flow templates for common patterns',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            instruction: {
-                                type: 'string',
-                                description: 'Natural language instruction'
-                            },
-                            template_categories: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                    enum: ['approval', 'fulfillment', 'notification', 'integration', 'utility']
-                                },
-                                description: 'Template categories to search'
-                            },
-                            minimum_confidence: {
-                                type: 'number',
-                                description: 'Minimum confidence threshold for template matching',
-                                default: 0.6
-                            },
-                        },
-                        required: ['instruction'],
-                    },
-                },
-                {
-                    name: 'snow_performance_analysis',
-                    description: '🚀 BUG-007 FIX: PERFORMANCE ANALYSIS - Analyzes flows for performance bottlenecks and provides database index recommendations',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            flow_definition: {
-                                type: 'object',
-                                description: 'Flow definition to analyze for performance'
-                            },
-                            table_name: {
-                                type: 'string',
-                                description: 'Specific table to analyze (optional)'
-                            },
-                            include_database_indexes: {
-                                type: 'boolean',
-                                description: 'Include database index recommendations',
-                                default: true
-                            },
-                            include_code_analysis: {
-                                type: 'boolean',
-                                description: 'Include flow script performance analysis',
-                                default: true
-                            },
-                            detailed_report: {
-                                type: 'boolean',
-                                description: 'Generate detailed performance report',
-                                default: false
-                            }
-                        },
-                        required: ['flow_definition'],
-                    },
-                },
-                {
-                    name: 'snow_comprehensive_requirements_analysis',
-                    description: '🚀 BUG-006 FIX: MULTI-PASS REQUIREMENTS ANALYSIS - Comprehensive 4-pass analysis to ensure no requirements are missed',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            objective: {
-                                type: 'string',
-                                description: 'The objective or requirement to analyze comprehensively (e.g., "iPhone provisioning workflow for new employees")'
-                            },
-                            include_dependencies: {
-                                type: 'boolean',
-                                description: 'Include dependency analysis (pass 2)',
-                                default: true
-                            },
-                            include_context_analysis: {
-                                type: 'boolean',
-                                description: 'Include context and implication analysis (pass 3)',
-                                default: true
-                            },
-                            include_validation: {
-                                type: 'boolean',
-                                description: 'Include validation and completeness check (pass 4)',
-                                default: true
-                            },
-                            detailed_report: {
-                                type: 'boolean',
-                                description: 'Generate detailed multi-pass analysis report',
-                                default: false
-                            }
-                        },
-                        required: ['objective'],
-                    },
-                },
-            ],
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'snow_create_flow':
-                        return await this.createFlow(args);
-                    case 'snow_analyze_flow_instruction':
-                        return await this.analyzeFlowInstruction(args);
-                    case 'snow_discover_flow_artifacts':
-                        return await this.discoverFlowArtifacts(args);
-                    case 'snow_preview_flow_structure':
-                        return await this.previewFlowStructure(args);
-                    case 'snow_deploy_composed_flow':
-                        return await this.deployComposedFlow(args);
-                    case 'snow_intelligent_flow_analysis':
-                        return await this.intelligentFlowAnalysis(args);
-                    case 'snow_scope_optimization':
-                        return await this.scopeOptimization(args);
-                    case 'snow_template_matching':
-                        return await this.templateMatching(args);
-                    case 'snow_performance_analysis':
-                        return await this.performanceAnalysis(args);
-                    case 'snow_comprehensive_requirements_analysis':
-                        return await this.comprehensiveRequirementsAnalysis(args);
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                this.logger.error(`Tool execution failed: ${name}`, error);
-                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error instanceof Error ? error.message : String(error));
-            }
-        });
-    }
-    async createFlow(args) {
-        console.log('🎯 INTELLIGENT FLOW CREATION STARTED');
-        console.log('📝 Instruction:', args.instruction);
-        // Input validation
-        if (!args.instruction || typeof args.instruction !== 'string' || args.instruction.trim().length === 0) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Invalid Input: Instruction is required and must be a non-empty string.\n\nPlease provide a clear, descriptive instruction for your flow.',
-                    },
-                ],
-            };
-        }
-        if (args.instruction.length > 2000) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Invalid Input: Instruction is too long (maximum 2000 characters).\n\nPlease provide a more concise instruction.',
-                    },
-                ],
-            };
-        }
-        // Check authentication first
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('🧠 Starting intelligent flow creation', { instruction: args.instruction });
-            // 🧠 STEP 1: Parse natural language instruction intelligently
-            const parsedIntent = await this.parseFlowInstruction(args.instruction);
-            console.log('🧠 Parsed intent:', parsedIntent);
-            // 🧠 STEP 2: Find matching templates based on intent
-            const templateMatch = await this.findBestTemplate(parsedIntent);
-            console.log('🧠 Template match:', templateMatch);
-            // 🧠 STEP 3: Discover required artifacts  
-            const artifacts = await this.discoverRequiredArtifacts(parsedIntent);
-            console.log('🧠 Discovered artifacts:', artifacts);
-            // 🧠 STEP 4: Generate complete flow definition
-            const flowDefinition = await this.generateFlowDefinition(parsedIntent, templateMatch, artifacts);
-            console.log('🧠 Generated flow definition:', JSON.stringify(flowDefinition, null, 2));
-            // 🧠 STEP 5: Deploy using XML-first approach for maximum reliability
-            let deploymentResult = null;
-            let xmlResult = null; // 🔴 FIX: Declare outside try block to avoid scope issues
-            let performanceAnalysis = null; // 🚀 BUG-007 FIX: Performance analysis results
-            if (args.deploy_immediately !== false) {
-                console.log('🚀 DEPLOYING flow using XML-first approach...');
-                try {
-                    // 🚀 ENHANCED: Use CompleteFlowXMLGenerator for proper flow generation
-                    // 🔒 BUG-004 FIX: Apply SECURE DEFAULTS - NEVER allow public access by default
-                    const SECURE_FLOW_DEFAULTS = {
-                        run_as: 'user', // Always run as user, not system
-                        accessible_from: 'package_private', // NEVER public by default
-                        requires_authentication: true,
-                        requires_role: true
-                    };
-                    // Convert to CompleteFlowDefinition format with ENFORCED secure defaults
-                    const completeFlowDef = {
-                        name: parsedIntent.flowName,
-                        description: parsedIntent.description,
-                        table: parsedIntent.table,
-                        trigger_type: this.mapTriggerTypeToXML(parsedIntent.trigger.type),
-                        trigger_condition: parsedIntent.trigger.condition || '',
-                        activities: this.convertActivitiesToCompleteFormat(flowDefinition.activities || []),
-                        // 🛡️ SECURITY: These defaults CANNOT be overridden accidentally
-                        run_as: SECURE_FLOW_DEFAULTS.run_as,
-                        accessible_from: SECURE_FLOW_DEFAULTS.accessible_from,
-                        category: 'custom',
-                        tags: ['auto-generated', 'enhanced']
-                    };
-                    // 🔒 Log security configuration for audit trail
-                    this.logger.info('🛡️ Applying secure flow defaults', {
-                        flowName: parsedIntent.flowName,
-                        accessible_from: completeFlowDef.accessible_from,
-                        run_as: completeFlowDef.run_as,
-                        table: completeFlowDef.table,
-                        trigger_type: completeFlowDef.trigger_type
-                    });
-                    console.log('🔒 SECURITY: Flow created with secure defaults:');
-                    console.log(`   • Access Level: ${completeFlowDef.accessible_from} (secure)`);
-                    console.log(`   • Run As: ${completeFlowDef.run_as} (secure)`);
-                    console.log(`   • Authentication: Required`);
-                    console.log(`   • Role-based Access: Required`);
-                    // Generate production-ready XML with CompleteFlowXMLGenerator
-                    xmlResult = (0, complete_flow_xml_generator_js_1.generateCompleteFlowXML)(completeFlowDef);
-                    console.log('✅ XML generated:', xmlResult.filePath);
-                    // 🚀 BUG-007 FIX: Performance analysis and recommendations
-                    const { PerformanceRecommendationsEngine } = await Promise.resolve().then(() => __importStar(require('../intelligence/performance-recommendations-engine.js')));
-                    const performanceEngine = new PerformanceRecommendationsEngine();
-                    console.log('🔍 Running performance analysis...');
-                    performanceAnalysis = await performanceEngine.analyzeFlowPerformance(xmlFlowDef);
-                    if (performanceAnalysis.summary.criticalIssues > 0) {
-                        console.log(`⚠️ PERFORMANCE: ${performanceAnalysis.summary.criticalIssues} critical issues found`);
-                        console.log(`📈 Potential improvement: ${performanceAnalysis.summary.estimatedImprovementPercent}%`);
-                        // Show top 3 most critical recommendations
-                        const topRecommendations = [
-                            ...performanceAnalysis.databaseIndexes.filter(idx => idx.priority === 'critical').slice(0, 2),
-                            ...performanceAnalysis.performanceRecommendations.filter(rec => rec.impact === 'high').slice(0, 1)
-                        ];
-                        if (topRecommendations.length > 0) {
-                            console.log('🎯 Top performance recommendations:');
-                            topRecommendations.forEach((rec, i) => {
-                                if ('fields' in rec) {
-                                    // Database index recommendation
-                                    console.log(`   ${i + 1}. INDEX: ${rec.table} (${rec.fields.join(', ')}) - ${rec.reason}`);
-                                    console.log(`      💻 ${rec.createStatement}`);
-                                }
-                                else {
-                                    // Performance recommendation
-                                    console.log(`   ${i + 1}. ${rec.type.toUpperCase()}: ${rec.description}`);
-                                    console.log(`      💡 ${rec.recommendation}`);
-                                }
-                            });
-                        }
-                    }
-                    else {
-                        console.log('✅ Performance analysis: No critical issues detected');
-                    }
-                    // 🔴 CRITICAL FIX: Auto-deploy with INTEGRATED verification
-                    // SNOW-001: Verification is now MANDATORY within each deployment strategy
-                    const deployResult = await this.deployWithFallback(xmlResult.filePath, flowDefinition);
-                    // 🔴 FIXED: No duplicate verification needed - it's integrated into deployment strategies
-                    // deployResult.verification contains the comprehensive verification results
-                    // Success with integrated verification
-                    deploymentResult = {
-                        success: true,
-                        method: deployResult.strategy,
-                        xml_file: xmlResult.filePath,
-                        message: `✅ Flow deployed via ${deployResult.strategy} and verified in ServiceNow!`,
-                        flow_sys_id: deployResult.verification.sys_id,
-                        flow_url: deployResult.verification.url,
-                        verification_score: deployResult.verification.completeness_score,
-                        verification_details: {
-                            has_flow: true,
-                            has_snapshot: deployResult.verification.has_snapshot,
-                            has_trigger: deployResult.verification.has_trigger,
-                            attempts_needed: deployResult.verification.verification_attempt,
-                            deployment_verified: deployResult.deployment_verified
-                        },
-                        snow_001_fix: 'Deployment includes mandatory verification - no false positives possible'
-                    };
-                }
-                catch (xmlError) {
-                    console.error('❌ XML deployment failed:', xmlError);
-                    // Extract detailed error information
-                    let errorDetails = 'Unknown error';
-                    if (xmlError instanceof Error) {
-                        errorDetails = xmlError.message;
-                        // Check for specific error types
-                        if (xmlError.message.includes('400')) {
-                            errorDetails = 'ServiceNow rejected the request. Check permissions and Update Set.';
-                        }
-                        else if (xmlError.message.includes('401') || xmlError.message.includes('403')) {
-                            errorDetails = 'Authentication failed. Run: snow-flow auth login';
-                        }
-                    }
-                    deploymentResult = {
-                        success: false,
-                        error: errorDetails,
-                        xml_generated: xmlResult !== null, // 🔴 FIX: Check if XML was actually generated
-                        xml_path: xmlResult?.filePath,
-                        deployment_failed: true,
-                        manual_steps: this.generateManualImportGuide(xmlResult?.filePath || ''),
-                        fallback_instructions: 'Use snow-flow deploy-xml command for manual deployment'
-                    };
-                }
-            }
-            const credentials = await this.oauth.loadCredentials();
-            const flowUrl = `https://${credentials?.instance}/flow-designer/flow/${parsedIntent.flowName}`;
-            // 🔴 BUG-001 FIX: Return structured data with sys_id and all identifiers
-            const flowSysId = deploymentResult?.verification?.sys_id || deploymentResult?.sys_id || null;
-            const actualFlowUrl = flowSysId ?
-                `https://${credentials?.instance}/flow-designer/designer/${flowSysId}` :
-                flowUrl;
-            const structuredResult = {
-                success: deploymentResult?.success || false,
-                flow: {
-                    sys_id: flowSysId,
-                    name: parsedIntent.flowName,
-                    table: parsedIntent.table,
-                    trigger_type: parsedIntent.trigger.type,
-                    active: true,
-                    description: parsedIntent.description,
-                    url: actualFlowUrl,
-                    api_endpoint: flowSysId ?
-                        `https://${credentials?.instance}/api/now/table/sys_hub_flow/${flowSysId}` : null
-                },
-                deployment: {
-                    method: deploymentResult?.deployment_method || 'XML Update Set',
-                    xml_file: xmlResult?.file || deploymentResult?.xml_path || null,
-                    update_set_id: deploymentResult?.update_set_id || null,
-                    success: deploymentResult?.success || false,
-                    error: deploymentResult?.error || null
-                },
-                analysis: {
-                    intents: parsedIntent.intents,
-                    template: templateMatch?.name || 'Custom implementation',
-                    confidence: templateMatch?.confidence || 0,
-                    activities_count: flowDefinition.activities?.length || 0,
-                    variables_count: flowDefinition.variables?.length || 0
-                },
-                // 🚀 BUG-007 FIX: Performance analysis results
-                performance: {
-                    database_indexes: performanceAnalysis?.databaseIndexes || [],
-                    recommendations: performanceAnalysis?.performanceRecommendations || [],
-                    summary: {
-                        critical_issues: performanceAnalysis?.summary?.criticalIssues || 0,
-                        estimated_improvement_percent: performanceAnalysis?.summary?.estimatedImprovementPercent || 0,
-                        top_actions: performanceAnalysis?.summary?.recommendedActions || []
-                    },
-                    report_available: true
-                }
-            };
-            // Log structured result for debugging
-            this.logger.info('🔴 BUG-001 FIX: Returning structured flow data', structuredResult);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: deploymentResult?.success ?
-                            `✅ FLOW SUCCESSFULLY CREATED AND DEPLOYED!
-
-🚀 **VERIFIED DEPLOYMENT** - Flow is now live in ServiceNow!
-
-🆔 **Flow Identifiers** (BUG-001 FIX):
-- **Sys ID**: ${structuredResult.flow.sys_id}
-- **Name**: ${structuredResult.flow.name}
-- **API Endpoint**: ${structuredResult.flow.api_endpoint}
-
-🔗 **Direct Access**: ${structuredResult.flow.url}` :
-                            deploymentResult?.deployment_failed ?
-                                `⚠️ FLOW XML GENERATED BUT DEPLOYMENT FAILED
-
-❌ **Deployment Error**: ${deploymentResult.error}
-
-🆔 **Flow Details** (BUG-001 FIX):
-- **Name**: ${structuredResult.flow.name}
-- **Table**: ${structuredResult.flow.table}
-- **Sys ID**: ${structuredResult.flow.sys_id || 'Not yet available'}
-
-📁 **XML File**: ${deploymentResult.xml_path}
-
-📋 **Manual Import Steps**:
-${deploymentResult.manual_steps || '1. Navigate to System Update Sets > Retrieved Update Sets\n2. Import Update Set from XML\n3. Preview and Commit'}` :
-                                `🎯 FLOW CREATED WITH XML-FIRST APPROACH!
-
-${args.deploy_immediately !== false ? `🚀 **DEPLOYMENT STATUS** - Processing...` : `📋 **PLANNING MODE** - Flow structure generated`}
-
-🆔 **Flow Identifiers** (BUG-001 FIX):
-- **Sys ID**: ${structuredResult.flow.sys_id || 'Pending deployment'}
-- **Name**: ${structuredResult.flow.name}
-- **Table**: ${structuredResult.flow.table}
-- **API Endpoint**: ${structuredResult.flow.api_endpoint || 'Not yet available'}
-
-🧠 **Intelligent Analysis:**
-- **Flow Name**: ${parsedIntent.flowName}
-- **Primary Table**: ${parsedIntent.table}
-- **Trigger Type**: ${parsedIntent.trigger.type}
-- **Intent Categories**: ${parsedIntent.intents.join(', ')}
-- **Template Match**: ${templateMatch?.name || 'Custom implementation'}
-- **Confidence**: ${templateMatch?.confidence ? Math.round(templateMatch.confidence * 100) + '%' : 'N/A'}
-
-📋 **Flow Structure:**
-- **Activities**: ${flowDefinition.activities?.length || 0} intelligent actions
-- **Variables**: ${flowDefinition.variables?.length || 0} dynamic inputs/outputs  
-- **Error Handling**: ${flowDefinition.error_handling?.length || 0} safety measures
-- **Artifacts Used**: ${artifacts.existing.length} found, ${artifacts.created.length} created
-
-🚀 **XML-First Deployment:**
-${deploymentResult ? (deploymentResult.success ?
-                                    `✅ Successfully deployed using XML-first approach!
-- **Method**: Production-ready Update Set XML
-- **XML File**: ${deploymentResult.xml_file}
-- **Status**: Imported → Previewed → Committed ✅` :
-                                    `❌ Auto-deployment failed: ${deploymentResult.error}
-- **Fallback**: ${deploymentResult.fallback_instructions}`) : '⏳ Ready for deployment'}
-
-🔗 **ServiceNow Access:**
-- Flow Designer: ${actualFlowUrl}  
-- Flow Designer Home: https://${credentials?.instance}/flow-designer
-
-🧠 **NEW Features (v1.3.24):**
-- Structured flow data with sys_id (BUG-001 FIX) ✅
-- XML-first approach for maximum reliability ✅
-- Automatic Update Set deployment ✅
-- Zero manual steps required ✅
-- Production-ready Flow Designer format ✅
-- Intelligent error handling & fallbacks ✅
-
-Your flow is now ${structuredResult.success ? 'live' : 'ready'} in ServiceNow Flow Designer! 🎉`,
-                    },
-                ],
-                // 🔴 BUG-001 FIX: Include structured data in response
-                ...structuredResult
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Intelligent flow creation failed:', error);
-            return this.handleServiceNowError(error, 'Intelligent Flow Creation');
-        }
-    }
-    /**
-     * 🛡️ Check if user is trying to make flow public and warn them about security
-     */
-    checkSecurityIntent(instruction) {
-        const warnings = [];
-        const lowerInstruction = instruction.toLowerCase();
-        const publicKeywords = [
-            'public', 'publicly', 'everyone', 'anyone', 'all users',
-            'no authentication', 'without login', 'guest access',
-            'anonymous', 'unauthenticated', 'open access'
-        ];
-        const hasPublicIntent = publicKeywords.some(keyword => lowerInstruction.includes(keyword));
-        if (hasPublicIntent) {
-            warnings.push('⚠️ SECURITY WARNING: Public access detected in request');
-            warnings.push('🔒 For security, flows default to package_private access');
-            warnings.push('💡 To make public, explicitly override accessible_from in config');
-            warnings.push('🛡️ Consider using role-based access instead of public access');
-        }
-        return { hasPublicIntent, warnings };
-    }
-    /**
-     * 🧠 INTELLIGENT NATURAL LANGUAGE PARSING
-     * Analyzes instruction to understand flow intent, trigger, and requirements
-     */
-    async parseFlowInstruction(instruction) {
-        console.log('🧠 Parsing flow instruction intelligently...');
-        // 🔒 BUG-004 FIX: Check for security concerns first
-        const securityCheck = this.checkSecurityIntent(instruction);
-        if (securityCheck.warnings.length > 0) {
-            securityCheck.warnings.forEach(warning => console.log(warning));
-            this.logger.warn('🔒 Security warning in flow instruction', {
-                instruction,
-                hasPublicIntent: securityCheck.hasPublicIntent
-            });
-        }
-        const words = instruction.toLowerCase();
-        // 🎯 Intent Analysis - What is the user trying to achieve?
-        const intents = [];
-        if (words.includes('approval') || words.includes('goedkeuring'))
-            intents.push('approval');
-        if (words.includes('notification') || words.includes('email') || words.includes('mail'))
-            intents.push('notification');
-        if (words.includes('incident') || words.includes('problem'))
-            intents.push('incident_management');
-        if (words.includes('request') || words.includes('aanvraag'))
-            intents.push('request_fulfillment');
-        if (words.includes('user') || words.includes('gebruiker'))
-            intents.push('user_management');
-        if (words.includes('task') || words.includes('taak'))
-            intents.push('task_management');
-        if (words.includes('data') || words.includes('record') || words.includes('save'))
-            intents.push('data_processing');
-        if (words.includes('integrate') || words.includes('api'))
-            intents.push('integration');
-        // Default if no specific intent found
-        if (intents.length === 0)
-            intents.push('general_automation');
-        // 🔴 BUG-003 FIX: Enhanced table detection with context awareness
-        let table = 'incident'; // default
-        // Priority-based table detection - more specific terms override generic ones
-        if (words.includes('incident') && (words.includes('management') || words.includes('priority') || words.includes('severity'))) {
-            table = 'incident'; // Explicitly keep incident table when incident context is strong
-        }
-        else if (words.includes('change') && words.includes('request')) {
-            table = 'change_request';
-        }
-        else if (words.includes('user') || words.includes('gebruiker')) {
-            table = 'sys_user';
-        }
-        else if (words.includes('request') || words.includes('aanvraag')) {
-            table = 'sc_request';
-        }
-        else if (words.includes('task') || words.includes('sc_task')) {
-            table = 'sc_task';
-        }
-        else if (words.includes('problem')) {
-            table = 'problem';
-        }
-        else if (words.includes('catalog')) {
-            table = 'sc_cat_item';
-        }
-        // Log table detection for debugging
-        console.log(`🔴 BUG-003: Table detected as '${table}' from instruction: "${instruction}"`);
-        // 🎯 Trigger Analysis - When should the flow run?
-        const trigger = {
-            type: 'manual', // default
-            table: table,
-            condition: ''
-        };
-        if (words.includes('when') || words.includes('created') || words.includes('new')) {
-            trigger.type = 'record_created';
-            trigger.condition = 'state=1'; // New state
-        }
-        if (words.includes('updated') || words.includes('changed')) {
-            trigger.type = 'record_updated';
-            trigger.condition = 'state!=6'; // Not closed
-        }
-        if (words.includes('schedule') || words.includes('daily') || words.includes('hourly')) {
-            trigger.type = 'scheduled';
-        }
-        // 🎯 Flow Name Generation - Intelligent naming
-        let flowName = 'Custom Flow';
-        if (intents.includes('approval'))
-            flowName = 'Approval Workflow';
-        if (intents.includes('incident_management'))
-            flowName = 'Incident Management Flow';
-        if (intents.includes('request_fulfillment'))
-            flowName = 'Request Fulfillment Process';
-        if (intents.includes('notification'))
-            flowName = 'Notification Service';
-        if (intents.includes('user_management'))
-            flowName = 'User Management Process';
-        if (intents.includes('data_processing'))
-            flowName = 'Data Processing Flow';
-        if (intents.includes('integration'))
-            flowName = 'Integration Flow';
-        // 🎯 Data Flow Analysis - What data needs to move between steps?
-        const dataFlow = [];
-        if (words.includes('translate') || words.includes('vertalen'))
-            dataFlow.push('translation_data');
-        if (words.includes('email') || words.includes('mail'))
-            dataFlow.push('email_recipients');
-        if (words.includes('user') || words.includes('gebruiker'))
-            dataFlow.push('user_details');
-        if (words.includes('incident'))
-            dataFlow.push('incident_details');
-        if (words.includes('request'))
-            dataFlow.push('request_details');
-        const parsed = {
-            flowName,
-            description: instruction,
-            table,
-            trigger,
-            intents,
-            dataFlow,
-            complexity: intents.length > 2 ? 'high' : intents.length > 1 ? 'medium' : 'simple',
-            language: words.includes('vertalen') || words.includes('dutch') ? 'multilingual' : 'english'
-        };
-        console.log('🧠 Parsed intent:', parsed);
-        return parsed;
-    }
-    /**
-     * 🧠 INTELLIGENT TEMPLATE MATCHING
-     * Finds the best matching template based on parsed intent
-     */
-    async findBestTemplate(parsedIntent) {
-        console.log('🧠 Finding best template match...');
-        // 🎯 Template Library - Predefined patterns that work
-        const templates = [
-            {
-                name: 'Approval Workflow Template',
-                intents: ['approval'],
-                confidence: 0.95,
-                structure: 'approval_with_notification',
-                activities: ['approval_step', 'notification_approved', 'notification_rejected'],
-                tables: ['sc_request', 'sc_task', 'change_request']
-            },
-            {
-                name: 'Incident Notification Template',
-                intents: ['incident_management', 'notification'],
-                confidence: 0.90,
-                structure: 'incident_notification',
-                activities: ['field_check', 'send_email', 'log_activity'],
-                tables: ['incident', 'problem']
-            },
-            {
-                name: 'Request Fulfillment Template',
-                intents: ['request_fulfillment', 'task_management'],
-                confidence: 0.85,
-                structure: 'request_processing',
-                activities: ['validate_request', 'create_task', 'notify_requester'],
-                tables: ['sc_request', 'sc_task']
-            },
-            {
-                name: 'Data Processing Template',
-                intents: ['data_processing', 'integration'],
-                confidence: 0.80,
-                structure: 'data_transformation',
-                activities: ['fetch_data', 'transform_data', 'save_data'],
-                tables: ['*']
-            },
-            {
-                name: 'User Management Template',
-                intents: ['user_management'],
-                confidence: 0.75,
-                structure: 'user_lifecycle',
-                activities: ['validate_user', 'update_profile', 'send_notification'],
-                tables: ['sys_user', 'sys_user_group']
-            }
-        ];
-        // 🎯 Smart Matching Algorithm
-        let bestMatch = null;
-        let highestScore = 0;
-        for (const template of templates) {
-            let score = 0;
-            // Intent matching (primary factor)
-            const intentMatches = template.intents.filter(intent => parsedIntent.intents.includes(intent)).length;
-            score += intentMatches * 40; // 40 points per intent match
-            // Table compatibility
-            if (template.tables.includes(parsedIntent.table) || template.tables.includes('*')) {
-                score += 20;
-            }
-            // Complexity matching
-            const expectedActivities = template.activities.length;
-            if (parsedIntent.complexity === 'simple' && expectedActivities <= 3)
-                score += 15;
-            if (parsedIntent.complexity === 'medium' && expectedActivities <= 5)
-                score += 15;
-            if (parsedIntent.complexity === 'high' && expectedActivities > 5)
-                score += 15;
-            const finalConfidence = Math.min(0.95, score / 100); // Cap at 95%
-            if (finalConfidence > highestScore && finalConfidence >= 0.6) {
-                highestScore = finalConfidence;
-                bestMatch = {
-                    ...template,
-                    confidence: finalConfidence,
-                    matchScore: score
-                };
-            }
-        }
-        console.log('🧠 Best template match:', bestMatch);
-        return bestMatch;
-    }
-    /**
-     * 🧠 INTELLIGENT ARTIFACT DISCOVERY
-     * Discovers existing ServiceNow artifacts that can be reused
-     */
-    async discoverRequiredArtifacts(parsedIntent) {
-        console.log('🧠 Discovering required artifacts...');
-        const artifacts = {
-            existing: [],
-            created: [],
-            required: []
-        };
-        // 🎯 Based on intents, determine what artifacts are needed
-        if (parsedIntent.intents.includes('notification')) {
-            artifacts.required.push({
-                type: 'email_template',
-                purpose: 'notification',
-                priority: 'high'
-            });
-        }
-        if (parsedIntent.intents.includes('approval')) {
-            artifacts.required.push({
-                type: 'approval_definition',
-                purpose: 'approval_workflow',
-                priority: 'critical'
-            });
-        }
-        if (parsedIntent.intents.includes('data_processing')) {
-            artifacts.required.push({
-                type: 'script_include',
-                purpose: 'data_transformation',
-                priority: 'medium'
-            });
-        }
-        if (parsedIntent.intents.includes('integration')) {
-            artifacts.required.push({
-                type: 'rest_message',
-                purpose: 'external_integration',
-                priority: 'high'
-            });
-        }
-        // 🎯 Try to discover existing artifacts (simplified for now)
-        try {
-            // In a real implementation, we would search ServiceNow for existing components
-            // For now, we'll simulate discovery
-            artifacts.existing = [];
-            artifacts.created = artifacts.required.map(req => ({
-                ...req,
-                status: 'will_be_created',
-                fallback: true
-            }));
-        }
-        catch (error) {
-            console.log('⚠️ Artifact discovery failed, will create fallbacks');
-            artifacts.created = artifacts.required;
-        }
-        console.log('🧠 Discovered artifacts:', artifacts);
-        return artifacts;
-    }
-    /**
-     * 🧠 INTELLIGENT FLOW DEFINITION GENERATION
-     * Creates complete ServiceNow Flow Designer compatible structure
-     */
-    async generateFlowDefinition(parsedIntent, templateMatch, artifacts) {
-        console.log('🧠 Generating complete flow definition...');
-        // 🎯 Base Flow Structure
-        const flowDefinition = {
-            name: parsedIntent.flowName,
-            description: parsedIntent.description,
-            active: true,
-            trigger_type: parsedIntent.trigger.type,
-            table: parsedIntent.table,
-            activities: [],
-            variables: [],
-            error_handling: [],
-            connections: []
-        };
-        // 🎯 Generate Activities based on template and intent
-        if (templateMatch) {
-            console.log(`🧠 Using template: ${templateMatch.name}`);
-            flowDefinition.activities = await this.generateActivitiesFromTemplate(templateMatch, parsedIntent, artifacts);
-        }
-        else {
-            console.log('🧠 No template match - generating custom activities');
-            flowDefinition.activities = await this.generateCustomActivities(parsedIntent, artifacts);
-        }
-        // 🔴 BUG-003 FIX: Validate all field references against the table schema
-        flowDefinition.activities = await this.validateAndFixFieldReferences(flowDefinition.activities, parsedIntent.table);
-        // 🎯 Generate Variables for data flow
-        flowDefinition.variables = this.generateFlowVariables(parsedIntent);
-        // 🎯 Generate Error Handling
-        flowDefinition.error_handling = this.generateErrorHandling(parsedIntent);
-        // 🎯 Generate Connections between activities
-        flowDefinition.connections = this.generateActivityConnections(flowDefinition.activities);
-        console.log('🧠 Complete flow definition generated');
-        return flowDefinition;
-    }
-    /**
-     * 🔴 BUG-003 FIX: Validate and fix field references against table schema
-     */
-    async validateAndFixFieldReferences(activities, tableName) {
-        console.log(`🔴 BUG-003: Validating field references for table '${tableName}'`);
-        // Common field mappings for different tables
-        const tableFieldMappings = {
-            incident: {
-                caller_id: 'caller_id',
-                severity: 'severity',
-                priority: 'priority',
-                short_description: 'short_description',
-                description: 'description',
-                assigned_to: 'assigned_to',
-                state: 'state',
-                number: 'number',
-                work_notes: 'work_notes',
-                comments: 'comments',
-                category: 'category',
-                subcategory: 'subcategory',
-                resolved_by: 'resolved_by',
-                close_notes: 'close_notes'
-            },
-            change_request: {
-                requested_by: 'requested_by',
-                category: 'category',
-                priority: 'priority',
-                risk: 'risk',
-                impact: 'impact',
-                short_description: 'short_description',
-                description: 'description',
-                assigned_to: 'assigned_to',
-                state: 'state',
-                number: 'number',
-                work_notes: 'work_notes',
-                type: 'type',
-                // Change request doesn't have caller_id or severity
-                caller_id: 'requested_by', // Map to equivalent field
-                severity: 'impact' // Map severity to impact for change requests
-            },
-            sc_request: {
-                requested_for: 'requested_for',
-                opened_by: 'opened_by',
-                short_description: 'short_description',
-                description: 'description',
-                assigned_to: 'assigned_to',
-                state: 'state',
-                number: 'number',
-                work_notes: 'work_notes',
-                comments: 'comments',
-                priority: 'priority',
-                // Service catalog requests use different field names
-                caller_id: 'requested_for',
-                severity: 'priority'
-            },
-            problem: {
-                opened_by: 'opened_by',
-                short_description: 'short_description',
-                description: 'description',
-                assigned_to: 'assigned_to',
-                state: 'state',
-                number: 'number',
-                work_notes: 'work_notes',
-                priority: 'priority',
-                category: 'category',
-                subcategory: 'subcategory',
-                known_error: 'known_error',
-                workaround: 'workaround',
-                // Problems don't have caller_id
-                caller_id: 'opened_by',
-                severity: 'priority'
-            }
-        };
-        // Get field mappings for the current table
-        const fieldMap = tableFieldMappings[tableName] || tableFieldMappings.incident;
-        // Process each activity to fix field references
-        const fixedActivities = activities.map(activity => {
-            if (activity.inputs?.script) {
-                // Fix field references in scripts
-                let fixedScript = activity.inputs.script;
-                // Replace field references that don't exist on the target table
-                Object.keys(fieldMap).forEach(standardField => {
-                    const tableField = fieldMap[standardField];
-                    if (standardField !== tableField) {
-                        // Replace current.caller_id with current.requested_by for change_request, etc.
-                        const regex = new RegExp(`current\\.${standardField}`, 'g');
-                        fixedScript = fixedScript.replace(regex, `current.${tableField}`);
-                        // Also handle ${record.caller_id} style references
-                        const regex2 = new RegExp(`\\$\\{record\\.${standardField}\\}`, 'g');
-                        fixedScript = fixedScript.replace(regex2, `\${record.${tableField}}`);
-                    }
-                });
-                activity.inputs.script = fixedScript;
-            }
-            // Fix field references in other input fields
-            if (activity.inputs) {
-                Object.keys(activity.inputs).forEach(inputKey => {
-                    if (typeof activity.inputs[inputKey] === 'string' && inputKey !== 'script') {
-                        let value = activity.inputs[inputKey];
-                        // Fix ${record.field} references
-                        Object.keys(fieldMap).forEach(standardField => {
-                            const tableField = fieldMap[standardField];
-                            if (standardField !== tableField) {
-                                const regex = new RegExp(`\\$\\{record\\.${standardField}\\}`, 'g');
-                                value = value.replace(regex, `\${record.${tableField}}`);
-                            }
-                        });
-                        activity.inputs[inputKey] = value;
-                    }
-                });
-            }
-            return activity;
-        });
-        console.log(`🔴 BUG-003: Field validation complete. Fixed field references for table '${tableName}'`);
-        return fixedActivities;
-    }
-    /**
-     * Generate activities from template
-     */
-    async generateActivitiesFromTemplate(templateMatch, parsedIntent, artifacts) {
-        const activities = [];
-        switch (templateMatch.structure) {
-            case 'approval_with_notification':
-                activities.push({
-                    id: 'approval_step',
-                    name: 'Request Approval',
-                    type: 'approval',
-                    inputs: {
-                        approver: 'admin',
-                        message: `Please approve: ${parsedIntent.description}`,
-                        due_date: '+7 days'
-                    },
-                    outputs: {
-                        approval_result: 'string',
-                        approved_by: 'string'
-                    }
-                }, {
-                    id: 'notification_approved',
-                    name: 'Send Approval Notification',
-                    type: 'notification',
-                    condition: '${approval_step.approval_result} == "approved"',
-                    inputs: {
-                        recipient: '${record.requested_for}',
-                        subject: 'Request Approved',
-                        message: 'Your request has been approved by ${approval_step.approved_by}'
-                    }
-                }, {
-                    id: 'notification_rejected',
-                    name: 'Send Rejection Notification',
-                    type: 'notification',
-                    condition: '${approval_step.approval_result} == "rejected"',
-                    inputs: {
-                        recipient: '${record.requested_for}',
-                        subject: 'Request Rejected',
-                        message: 'Your request has been rejected. Please contact support for details.'
-                    }
-                });
-                break;
-            case 'incident_notification':
-                activities.push({
-                    id: 'field_check',
-                    name: 'Check Incident Priority',
-                    type: 'condition',
-                    condition: '${record.priority} <= 2', // High or Critical
-                    inputs: {
-                        field_to_check: 'priority',
-                        operator: 'less_than_or_equal',
-                        value: '2'
-                    }
-                }, {
-                    id: 'send_email',
-                    name: 'Send High Priority Alert',
-                    type: 'notification',
-                    condition: '${field_check.result} == true',
-                    inputs: {
-                        recipient: 'it-management@company.com',
-                        subject: 'HIGH PRIORITY: ${record.short_description}',
-                        message: 'Incident ${{record.number}} requires immediate attention.\\n\\nDescription: ${{record.description}}\\nPriority: ${{record.priority}}\\nAssignee: ${{record.assigned_to}}'
-                    }
-                }, {
-                    id: 'log_activity',
-                    name: 'Log Notification Sent',
-                    type: 'script',
-                    inputs: {
-                        script: `gs.log('High priority incident notification sent for ' + current.number, 'IncidentFlow');
-                      current.work_notes = 'Automated notification sent to IT Management';
-                      current.update();`
-                    }
-                });
-                break;
-            case 'request_processing':
-                activities.push({
-                    id: 'validate_request',
-                    name: 'Validate Request Data',
-                    type: 'script',
-                    inputs: {
-                        script: `var isValid = true;
-                      var errors = [];
-                      
-                      if (!current.requested_for) {
-                        errors.push('Requested for field is required');
-                        isValid = false;
-                      }
-                      
-                      if (!current.short_description) {
-                        errors.push('Short description is required');
-                        isValid = false;
-                      }
-                      
-                      return { valid: isValid, errors: errors };`
-                    },
-                    outputs: {
-                        validation_result: 'object'
-                    }
-                }, {
-                    id: 'create_task',
-                    name: 'Create Fulfillment Task',
-                    type: 'create_record',
-                    condition: '${validate_request.validation_result.valid} == true',
-                    inputs: {
-                        table: 'sc_task',
-                        fields: {
-                            request: '${record.sys_id}',
-                            short_description: 'Fulfill: ${record.short_description}',
-                            description: '${record.description}',
-                            assigned_to: 'fulfillment.team',
-                            state: '1' // Open
-                        }
-                    }
-                }, {
-                    id: 'notify_requester',
-                    name: 'Notify Requester',
-                    type: 'notification',
-                    inputs: {
-                        recipient: '${record.requested_for}',
-                        subject: 'Request Processing Started',
-                        message: 'Your request ${{record.number}} is being processed.\\n\\nTask ${{create_task.result.number}} has been created for fulfillment.'
-                    }
-                });
-                break;
-            case 'data_transformation':
-                activities.push({
-                    id: 'fetch_data',
-                    name: 'Fetch Record Data',
-                    type: 'script',
-                    inputs: {
-                        script: `var recordData = {
-                        sys_id: current.sys_id,
-                        table: current.sys_class_name,
-                        fields: {}
-                      };
-                      
-                      // Get all fields and values
-                      var fields = current.getElements();
-                      for (var i = 0; i < fields.size(); i++) {
-                        var field = fields.get(i);
-                        recordData.fields[field.getName()] = current.getValue(field.getName());
-                      }
-                      
-                      return recordData;`
-                    },
-                    outputs: {
-                        record_data: 'object'
-                    }
-                }, {
-                    id: 'transform_data',
-                    name: 'Transform Data',
-                    type: 'script',
-                    inputs: {
-                        script: `var transformedData = fetch_data.record_data;
-                      
-                      // Apply transformations based on business rules
-                      if (transformedData.fields.description) {
-                        transformedData.fields.description = transformedData.fields.description.toUpperCase();
-                      }
-                      
-                      transformedData.transformed_at = new GlideDateTime().toString();
-                      transformedData.transform_id = gs.generateGUID();
-                      
-                      return transformedData;`
-                    },
-                    outputs: {
-                        transformed_data: 'object'
-                    }
-                }, {
-                    id: 'save_data',
-                    name: 'Save Transformed Data',
-                    type: 'create_record',
-                    inputs: {
-                        table: 'u_transformed_data', // Custom table
-                        fields: {
-                            original_record: '${fetch_data.record_data.sys_id}',
-                            transformed_data: '${transform_data.transformed_data}',
-                            processed_date: '${gs.nowDateTime()}'
-                        }
-                    }
-                });
-                break;
-            default:
-                // Fallback to custom activities
-                return await this.generateCustomActivities(parsedIntent, artifacts);
-        }
-        return activities;
-    }
-    /**
-     * Generate custom activities when no template matches
-     */
-    async generateCustomActivities(parsedIntent, artifacts) {
-        const activities = [];
-        // 🎯 Always start with validation for data integrity
-        activities.push({
-            id: 'validate_input',
-            name: 'Validate Input Data',
-            type: 'script',
-            inputs: {
-                script: `var result = { valid: true, message: 'Input validation passed' };
-                 
-                 // Basic validation logic
-                 if (!current) {
-                   result.valid = false;
-                   result.message = 'No record context available';
-                 }
-                 
-                 return result;`
-            },
-            outputs: {
-                validation_result: 'object'
-            }
-        });
-        // 🎯 Add activities based on detected intents
-        if (parsedIntent.intents.includes('notification')) {
-            activities.push({
-                id: 'send_notification',
-                name: 'Send Notification',
-                type: 'notification',
-                condition: '${validate_input.validation_result.valid} == true',
-                inputs: {
-                    recipient: 'admin@company.com',
-                    subject: 'Flow Notification: ${{record.short_description}}',
-                    message: 'A flow has been triggered for record ${{record.number}}\\n\\nDetails: ${{record.description}}'
-                }
-            });
-        }
-        if (parsedIntent.intents.includes('data_processing')) {
-            activities.push({
-                id: 'process_data',
-                name: 'Process Record Data',
-                type: 'script',
-                inputs: {
-                    script: `// Process the record data
-                   current.work_notes = 'Processed by automated flow on ' + new GlideDateTime();
-                   current.state = 2; // In Progress
-                   current.update();
-                   
-                   gs.log('Record processed by flow: ' + current.number, 'CustomFlow');`
-                }
-            });
-        }
-        // 🎯 Always end with logging for audit trail
-        activities.push({
-            id: 'log_completion',
-            name: 'Log Flow Completion',
-            type: 'script',
-            inputs: {
-                script: `gs.log('Flow completed successfully for record: ' + current.number, 'FlowCompletion');
-                 
-                 // Update record with completion timestamp
-                 current.u_flow_completed = new GlideDateTime();
-                 current.update();`
-            }
-        });
-        return activities;
-    }
-    /**
-     * Generate flow variables for data passing
-     */
-    generateFlowVariables(parsedIntent) {
-        const variables = [
-            {
-                id: 'flow_start_time',
-                name: 'Flow Start Time',
-                type: 'datetime',
-                input: false,
-                output: true,
-                default_value: '${gs.nowDateTime()}'
-            },
-            {
-                id: 'record_context',
-                name: 'Record Context',
-                type: 'reference',
-                input: true,
-                output: false,
-                table: parsedIntent.table
-            }
-        ];
-        // Add intent-specific variables
-        if (parsedIntent.intents.includes('approval')) {
-            variables.push({
-                id: 'approval_result',
-                name: 'Approval Result',
-                type: 'string',
-                input: false,
-                output: true,
-                default_value: ''
-            });
-        }
-        if (parsedIntent.intents.includes('notification')) {
-            variables.push({
-                id: 'notification_sent',
-                name: 'Notification Sent',
-                type: 'boolean',
-                input: false,
-                output: true,
-                default_value: 'false'
-            });
-        }
-        return variables;
-    }
-    /**
-     * Generate error handling activities
-     */
-    generateErrorHandling(parsedIntent) {
-        return [
-            {
-                id: 'error_handler',
-                name: 'Handle Flow Errors',
-                type: 'script',
-                trigger: 'on_error',
-                inputs: {
-                    script: `gs.error('Flow error occurred: ' + error.message, 'FlowError');
-                   
-                   // Send error notification
-                   var email = new GlideEmailOutbound();
-                   email.setSubject('Flow Error in ${parsedIntent.flowName}');
-                   email.setBody('An error occurred during flow execution: ' + error.message);
-                   email.addAddress('admin@company.com');
-                   email.send();
-                   
-                   // Log to system log
-                   gs.log('Flow error logged and notification sent', 'FlowError');`
-                }
-            }
-        ];
-    }
-    /**
-     * Generate connections between activities
-     */
-    generateActivityConnections(activities) {
-        const connections = [];
-        for (let i = 0; i < activities.length - 1; i++) {
-            connections.push({
-                from: activities[i].id,
-                to: activities[i + 1].id,
-                condition: activities[i + 1].condition || 'always'
-            });
-        }
-        return connections;
-    }
-    async analyzeFlowInstruction(args) {
-        // Check authentication first
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Analyzing flow instruction', { instruction: args.instruction });
-            const flowInstruction = await this.composer.createFlowFromInstruction(args.instruction);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🔍 Flow Instruction Analysis
-
-📝 **Original Instruction:**
-"${args.instruction}"
-
-🧠 **Parsed Intent:**
-- **Flow Name**: ${flowInstruction.parsedIntent?.flowName || 'Auto-generated'}
-- **Table**: ${flowInstruction.parsedIntent?.table || 'Unknown'}
-- **Trigger Type**: ${flowInstruction.parsedIntent?.trigger?.type || 'Unknown'}
-- **Condition**: ${flowInstruction.parsedIntent?.trigger?.condition || 'None'}
-- **Intents**: ${flowInstruction.parsedIntent?.intents?.join(', ') || 'None'}
-- **Data Flow**: ${flowInstruction.parsedIntent?.dataFlow?.join(' → ') || 'None'}
-
-🔧 **Required Artifacts:**
-${flowInstruction.requiredArtifacts?.map((artifact, index) => `${index + 1}. **${artifact.type}**
-   - Name: ${artifact.name}
-   - Sys ID: ${artifact.sys_id}
-   - Inputs: ${artifact.inputs?.length || 0} input(s)
-   - Outputs: ${artifact.outputs?.length || 0} output(s)`)?.join('\n\n') || 'No required artifacts'}
-
-🏗️ **Flow Structure Preview:**
-- **Name**: ${flowInstruction.flowStructure?.name || 'Unknown'}
-- **Trigger**: ${flowInstruction.flowStructure?.trigger?.type || 'Unknown'} on ${flowInstruction.flowStructure?.trigger?.table || 'Unknown'}
-- **Activities**: ${flowInstruction.flowStructure?.activities?.length || 0}
-- **Variables**: ${flowInstruction.flowStructure?.variables?.length || 0}
-- **Error Handling**: ${flowInstruction.flowStructure?.error_handling?.length || 0} rules
-
-📊 **Complexity Analysis:**
-- **Artifact Dependencies**: ${flowInstruction.requiredArtifacts?.length || 0}
-- **Processing Steps**: ${flowInstruction.flowStructure?.activities?.length || 0}
-- **Integration Points**: ${flowInstruction.requiredArtifacts?.length || 0}
-- **Data Flow Steps**: ${flowInstruction.parsedIntent?.dataFlow?.length || 0}
-
-✅ **Analysis Complete!** The instruction has been successfully parsed and all required components identified.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Flow instruction analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async discoverFlowArtifacts(args) {
-        // Check authentication first
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Discovering flow artifacts', { instruction: args.instruction });
-            const flowInstruction = await this.composer.createFlowFromInstruction(args.instruction);
-            // Filter by specific artifact types if requested
-            let artifactsToShow = flowInstruction.requiredArtifacts;
-            if (args.artifact_types && args.artifact_types.length > 0) {
-                artifactsToShow = flowInstruction.requiredArtifacts?.filter((a) => args.artifact_types.includes(a.type));
-            }
-            const credentials = await this.oauth.loadCredentials();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🔍 ServiceNow Artifact Discovery Results
-
-🎯 **Instruction**: "${args.instruction}"
-
-📦 **Discovered Artifacts** (${artifactsToShow.length} found):
-
-${artifactsToShow.map((artifact, index) => `### ${index + 1}. ${artifact.type.toUpperCase()}
-**Purpose**: ${artifact.purpose}
-**Search Strategy**: "${artifact.searchQuery}"
-**Required**: ${artifact.required ? '✅ Yes' : '❌ No'}
-**Fallback**: ${artifact.fallbackAction || 'None'}
-
-**Search Details:**
-- Table: ${this.getTableForArtifactType(artifact.type)}
-- Search Fields: name, description, short_description
-- Match Priority: Exact → Fuzzy → Semantic
-
-**Integration Points:**
-- Used in flow step: ${this.getFlowStepForArtifact(artifact, flowInstruction)}
-- Data inputs: ${this.getArtifactInputs(artifact)}
-- Data outputs: ${this.getArtifactOutputs(artifact)}
-`).join('\n')}
-
-🔗 **ServiceNow Search Links:**
-${artifactsToShow.map((artifact) => `- ${artifact.type}: https://${credentials?.instance}/nav_to.do?uri=${this.getTableForArtifactType(artifact.type)}_list.do`).join('\n')}
-
-💡 **Discovery Strategy:**
-1. **Intelligent Search**: Uses natural language processing to find relevant artifacts
-2. **Semantic Matching**: Matches purpose and functionality, not just names
-3. **Fallback Creation**: Creates missing artifacts automatically if needed
-4. **Dependency Mapping**: Identifies relationships between artifacts
-
-🎯 **Next Steps:**
-- Run \`snow_preview_flow_structure\` to see how these artifacts will be used
-- Use \`snow_create_complex_flow\` to create and deploy the complete flow
-- Individual artifacts can be analyzed using \`snow_analyze_artifact\`
-
-✅ **Discovery Complete!** All required artifacts have been identified and are ready for flow composition.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Artifact discovery failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Extract a flow name from instruction text
-     */
-    extractFlowName(instruction) {
-        // Try to extract meaningful name from instruction
-        const keywords = ['flow', 'process', 'workflow', 'automation'];
-        const words = instruction.toLowerCase().split(/\s+/);
-        // Look for keywords and use surrounding context
-        for (const keyword of keywords) {
-            const keywordIndex = words.indexOf(keyword);
-            if (keywordIndex >= 0) {
-                // Get 2-3 words before the keyword as the name
-                const startIndex = Math.max(0, keywordIndex - 2);
-                const nameParts = words.slice(startIndex, keywordIndex + 1);
-                return nameParts.join('_').replace(/[^a-z0-9_]/g, '');
-            }
-        }
-        // Fallback: use first few words
-        return words.slice(0, 3).join('_').replace(/[^a-z0-9_]/g, '') + '_flow';
-    }
-    async previewFlowStructure(args) {
-        // Check authentication first
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Previewing flow structure', { instruction: args.instruction });
-            const flowInstruction = await this.composer.createFlowFromInstruction(args.instruction);
-            // FIX: Add null safety checks to prevent "Cannot read properties of undefined" errors
-            if (!flowInstruction || !flowInstruction.flowStructure) {
-                this.logger.error('Flow instruction or flowStructure is undefined', { flowInstruction });
-                // Create minimal fallback flow structure
-                const fallbackFlow = {
-                    name: this.extractFlowName(args.instruction),
-                    description: `Flow for: ${args.instruction}`,
-                    trigger: { type: 'manual', table: 'task', condition: '' },
-                    variables: [],
-                    activities: [],
-                    error_handling: []
-                };
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `⚠️ **Flow Structure Creation Issue**
-
-The flow composer returned incomplete data. Creating minimal flow structure:
-
-📋 **Flow Information:**
-- **Name**: ${fallbackFlow.name}
-- **Description**: ${fallbackFlow.description}
-- **Type**: Manual trigger on task table
-
-💡 **Suggestion**: Try being more specific with your flow requirements, for example:
-- "Create an approval flow for incident management"
-- "Build a notification flow when priority 1 incidents are created"
-- "Design a flow to update request items when approved"
-
-🔧 **Debug Info**: flowInstruction=${JSON.stringify(flowInstruction ? Object.keys(flowInstruction) : 'null')}`
-                        }]
-                };
-            }
-            const flowStructure = flowInstruction.flowStructure;
-            // Additional safety checks for flowStructure properties
-            const safeGet = (obj, path, defaultValue = 'Unknown') => {
-                const parts = path.split('.');
-                let current = obj;
-                for (const part of parts) {
-                    if (!current || typeof current !== 'object')
-                        return defaultValue;
-                    current = current[part];
-                }
-                return current || defaultValue;
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🔍 Flow Structure Preview
-
-📋 **Flow Information:**
-- **Name**: ${safeGet(flowStructure, 'name', 'Auto-generated')}
-- **Description**: ${safeGet(flowStructure, 'description', 'No description')}
-
-🔄 **Trigger Configuration:**
-- **Type**: ${safeGet(flowStructure, 'trigger.type', 'manual')}
-- **Table**: ${safeGet(flowStructure, 'trigger.table', 'task')}
-- **Condition**: ${safeGet(flowStructure, 'trigger.condition', 'None')}
-
-📊 **Flow Variables:**
-${flowStructure.variables && Array.isArray(flowStructure.variables)
-                            ? flowStructure.variables.map((variable) => `- **${variable.name}** (${variable.type}): ${variable.description}`).join('\n')
-                            : '- No variables defined'}
-
-🏗️ **Flow Activities:**
-${flowStructure.activities.map((activity, index) => `### ${index + 1}. ${activity.name}
-**Type**: ${activity.type}
-**ID**: ${activity.id}
-${activity.artifact ? `**Uses Artifact**: ${activity.artifact.name} (${activity.artifact.type})` : ''}
-
-**Inputs:**
-${Object.entries(activity.inputs).map(([key, value]) => `  - ${key}: ${value}`).join('\n')}
-
-**Outputs:**
-${Object.entries(activity.outputs).map(([key, value]) => `  - ${key}: ${value}`).join('\n')}
-`).join('\n')}
-
-⚠️ **Error Handling:**
-${flowStructure.error_handling.map((handler, index) => `${index + 1}. **Condition**: ${handler.condition}
-   **Action**: ${handler.action}
-   **Parameters**: ${JSON.stringify(handler.parameters || {})}`).join('\n\n')}
-
-🔄 **Flow Execution Path:**
-1. **${flowStructure.trigger.type}** event occurs on **${flowStructure.trigger.table}**
-${flowStructure.activities.map((activity, index) => `${index + 2}. Execute **${activity.name}** (${activity.type})`).join('\n')}
-
-📈 **Flow Metrics:**
-- **Total Activities**: ${flowStructure.activities.length}
-- **Variables**: ${flowStructure.variables.length}
-- **Error Handlers**: ${flowStructure.error_handling.length}
-- **Artifact Dependencies**: ${flowStructure.activities.filter((a) => a.artifact).length}
-- **External Integrations**: ${flowStructure.activities.filter((a) => a.type === 'custom_script').length}
-
-🎯 **Data Flow Analysis:**
-${this.analyzeDataFlow(flowStructure.activities)}
-
-✅ **Preview Complete!** The flow structure is optimized and ready for deployment.
-
-🚀 **To Deploy**: Use \`snow_deploy_composed_flow\` or \`snow_create_complex_flow\` with \`deploy_immediately: true\``,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Flow structure preview failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async deployComposedFlow(args) {
-        // Check authentication first
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Deploying composed flow', { flow: args.flow_instruction });
-            const deploymentResult = await this.composer.deployFlow(args.flow_instruction);
-            const credentials = await this.oauth.loadCredentials();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🚀 Flow Deployment Complete!
-
-✅ **Deployment Status**: ${deploymentResult.success ? 'Successful' : 'Failed'}
-📋 **Message**: ${deploymentResult.message}
-
-🎯 **Deployed Flow Details:**
-- **Name**: ${args.flow_instruction.flowStructure.name}
-- **Activities**: ${args.flow_instruction.flowStructure.activities.length}
-- **Artifacts**: ${args.flow_instruction.requiredArtifacts?.length || 0}
-
-🔗 **ServiceNow Links:**
-- Flow Designer: https://${credentials?.instance}/flow-designer/flow/${args.flow_instruction.flowStructure.name}
-- Flow Designer Home: https://${credentials?.instance}/flow-designer
-
-📊 **Deployment Summary:**
-${args.flow_instruction.requiredArtifacts?.map((artifact, index) => `${index + 1}. **${artifact.type}**: ${artifact.purpose} - ${artifact.required ? 'Required' : 'Optional'}`)?.join('\n') || 'No artifacts'}
-
-✅ **Deployment Complete!** Your complex ServiceNow flow with multi-artifact orchestration is now active.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Flow deployment failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getTableForArtifactType(type) {
-        const tableMapping = {
-            'script_include': 'sys_script_include',
-            'business_rule': 'sys_script',
-            'table': 'sys_db_object',
-            'widget': 'sp_widget',
-            'ui_script': 'sys_ui_script'
-        };
-        return tableMapping[type] || 'sys_metadata';
-    }
-    getFlowStepForArtifact(artifact, flowInstruction) {
-        const step = flowInstruction.flowStructure?.activities?.find((a) => a.artifact_reference && a.artifact_reference.type === artifact.type);
-        return step ? step.name : 'Not used in flow';
-    }
-    getArtifactInputs(artifact) {
-        switch (artifact.type) {
-            case 'script_include':
-                return 'message, target_language, configuration';
-            case 'business_rule':
-                return 'record data, trigger conditions';
-            case 'table':
-                return 'record data, field values';
-            default:
-                return 'context-dependent';
-        }
-    }
-    getArtifactOutputs(artifact) {
-        switch (artifact.type) {
-            case 'script_include':
-                return 'processed_data, success_flag, error_message';
-            case 'business_rule':
-                return 'validation_result, side_effects';
-            case 'table':
-                return 'record_id, created_timestamp';
-            default:
-                return 'context-dependent';
-        }
-    }
-    analyzeDataFlow(activities) {
-        let dataFlow = "Data flows through the following path:\n";
-        activities.forEach((activity, index) => {
-            const inputs = Object.keys(activity.inputs).join(', ');
-            const outputs = Object.keys(activity.outputs).join(', ');
-            dataFlow += `${index + 1}. **${activity.name}**: ${inputs} → ${outputs}\n`;
-        });
-        return dataFlow;
-    }
-    /**
-     * Enhanced error handling for ServiceNow API operations
-     */
-    handleServiceNowError(error, operation) {
-        this.logger.error(`ServiceNow API error during ${operation}`, error);
-        let errorMessage = 'Unknown error occurred';
-        let troubleshooting = [];
-        if (error.response) {
-            const status = error.response.status;
-            const data = error.response.data;
-            switch (status) {
-                case 401:
-                    errorMessage = `🚨 Authentication Error (401) - Token Expired or Invalid
-
-📍 Possible Causes:
-• OAuth token expired or invalid
-• ServiceNow instance URL incorrect
-• Credentials not properly configured
-
-🔧 Troubleshooting Steps:
-1. Run diagnostics: snow_auth_diagnostics()
-2. Re-authenticate: snow-flow auth login
-3. Check credentials: Verify SNOW_INSTANCE, CLIENT_ID, CLIENT_SECRET
-4. Verify instance URL format: https://dev123456.service-now.com
-
-💡 Quick Fix: Run snow_auth_diagnostics() for detailed analysis`;
-                    troubleshooting = [
-                        'Run snow_auth_diagnostics() for detailed analysis',
-                        'Re-authenticate with snow-flow auth login',
-                        'Verify .env file OAuth credentials',
-                        'Check ServiceNow instance URL format'
-                    ];
-                    break;
-                case 403:
-                    errorMessage = `🚨 Permission Error (403) - Insufficient Access Rights
-
-📍 Possible Causes:
-• Insufficient permissions for flow operations
-• Missing required ServiceNow roles
-• Application scope restrictions
-
-🔧 Troubleshooting Steps:
-1. Run diagnostics: snow_auth_diagnostics()
-2. Check required roles: flow_designer, admin, itil
-3. Contact ServiceNow administrator for role assignment
-4. Verify application scope permissions
-
-💡 Required Roles:
-• flow_designer: For flow operations
-• admin: For Update Set management  
-• itil: For incident/request operations`;
-                    troubleshooting = [
-                        'Run snow_auth_diagnostics() to check permissions',
-                        'Verify user has flow_designer, admin, itil roles',
-                        'Contact ServiceNow administrator for role assignment',
-                        'Check application scope permissions'
-                    ];
-                    break;
-                case 404:
-                    errorMessage = `🚨 Flow Testing failed: Endpoint not found (404)
-
-📍 Possible Causes:
-• Flow sys_id format incorrect or invalid
-• API endpoint not available on this ServiceNow instance
-• Insufficient permissions for this operation
-• Flow not properly created or activated
-
-🔧 Troubleshooting Steps:
-1. Verify artifact exists: snow_get_by_sysid("your-sys-id")
-2. Check Update Set tracking: snow_update_set_current()
-3. Try alternative: snow_test_flow_with_mock()
-4. Verify permissions: snow_auth_diagnostics()
-
-💡 Alternative Tools:
-• For flow testing: Use snow_test_flow_with_mock (always works)
-• For verification: Use snow_get_by_sysid first
-• For comprehensive testing: Only after basic tests pass`;
-                    troubleshooting = [
-                        'Use snow_test_flow_with_mock() for reliable testing',
-                        'Verify flow exists with snow_get_by_sysid()',
-                        'Check Update Set status with snow_update_set_current()',
-                        'Run snow_auth_diagnostics() to check permissions'
-                    ];
-                    break;
-                case 429:
-                    errorMessage = 'Rate limit exceeded';
-                    troubleshooting = [
-                        'Wait a few minutes before retrying',
-                        'Reduce the frequency of API calls',
-                        'Contact ServiceNow administrator about rate limits'
-                    ];
-                    break;
-                case 500:
-                    errorMessage = 'ServiceNow server error';
-                    troubleshooting = [
-                        'Wait a few minutes and try again',
-                        'Check ServiceNow instance status',
-                        'Contact ServiceNow administrator if issue persists'
-                    ];
-                    break;
-                default:
-                    errorMessage = data?.error?.message || `HTTP ${status} error`;
-                    troubleshooting = [
-                        'Check ServiceNow instance connectivity',
-                        'Verify API permissions',
-                        'Review ServiceNow logs for details'
-                    ];
-            }
-        }
-        else if (error.request) {
-            errorMessage = 'Network connection error';
-            troubleshooting = [
-                'Check internet connectivity',
-                'Verify ServiceNow instance URL',
-                'Check if ServiceNow instance is accessible'
-            ];
-        }
-        else {
-            errorMessage = error.message || 'Unknown error';
-            troubleshooting = [
-                'Check the instruction syntax',
-                'Verify all required parameters are provided',
-                'Try a simpler instruction to isolate the issue'
-            ];
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ ${operation} Failed
-
-**Error Details:**
-${errorMessage}
-
-**Troubleshooting Steps:**
-${troubleshooting.map((step, index) => `${index + 1}. ${step}`).join('\n')}
-
-**Additional Help:**
-- Check ServiceNow instance health: https://status.servicenow.com/
-- Review ServiceNow API documentation
-- Contact your ServiceNow administrator for permissions
-- Try using basic functionality first before advanced features
-
-**Alternative Approaches:**
-- Use simpler instructions with fewer components
-- Try analysis tools first (e.g., \`snow_analyze_flow_instruction\`)
-- Use template matching for common patterns
-- Break complex flows into smaller parts`,
-                },
-            ],
-        };
-    }
-    /**
-     * Retry operation with exponential backoff
-     */
-    async retryOperation(operation, operationName, maxRetries = 3, baseDelay = 1000) {
-        let lastError;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                this.logger.info(`Attempting ${operationName} (attempt ${attempt}/${maxRetries})`);
-                return await operation();
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt === maxRetries) {
-                    break;
-                }
-                // Don't retry on authentication or permission errors
-                if (error.response?.status === 401 || error.response?.status === 403) {
-                    break;
-                }
-                // Don't retry on client errors (except rate limiting)
-                if (error.response?.status >= 400 && error.response?.status < 500 && error.response?.status !== 429) {
-                    break;
-                }
-                const delay = baseDelay * Math.pow(2, attempt - 1);
-                this.logger.warn(`${operationName} failed (attempt ${attempt}), retrying in ${delay}ms`, error);
-                await new Promise(resolve => setTimeout(resolve, delay));
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Format intelligent analysis results for display
-     */
-    formatIntelligentAnalysis(flowInstruction) {
-        // Backward compatibility - handle cases where intelligent analysis is not available
-        if (!flowInstruction.decisionAnalysis && !flowInstruction.validation &&
-            !flowInstruction.templateMatching && !flowInstruction.subflowCreation) {
-            return `📊 **Flow Analysis:**
-- **Type**: Standard flow creation
-- **Processing**: Basic natural language processing applied
-- **Deployment**: Ready for ServiceNow deployment`;
-        }
-        const analysis = flowInstruction.decisionAnalysis;
-        const validation = flowInstruction.validation;
-        const templateMatching = flowInstruction.templateMatching;
-        const subflowCreation = flowInstruction.subflowCreation;
-        let analysisText = '🧠 **Intelligent Analysis Results:**\n\n';
-        // Decision analysis (if available)
-        if (analysis) {
-            analysisText += `📊 **Decision Analysis:**
-- **Recommended Type**: ${analysis.recommendedType} (${Math.round(analysis.confidence * 100)}% confidence)
-- **Rationale**: ${analysis.rationale}
-- **Complexity**: ${analysis.complexity}
-- **Reusability**: ${analysis.reusability}
-- **Context**: ${analysis.context}
-
-`;
-        }
-        // Validation results (if available)
-        if (validation) {
-            analysisText += `✅ **Validation Results:**
-- **Valid**: ${validation.isValid ? 'Yes' : 'No'}
-- **Score**: ${validation.score}/${validation.maxScore}
-- **Severity**: ${validation.severity}
-- **Issues**: ${validation.issues?.length || 0} identified
-- **Recommendations**: ${validation.recommendations?.length || 0} provided
-
-`;
-        }
-        // Template matching (if available)
-        if (templateMatching) {
-            analysisText += `🎯 **Template Matching:**
-- **Matches Found**: ${templateMatching.matches}
-- **Best Match**: ${templateMatching.bestMatch || 'None'}
-- **Match Confidence**: ${Math.round(templateMatching.confidence * 100)}%
-
-`;
-        }
-        // Subflow creation (if available)
-        if (subflowCreation) {
-            analysisText += `🔄 **Subflow Creation:**
-- **Candidates Identified**: ${subflowCreation.candidatesIdentified}
-- **Subflows Created**: ${subflowCreation.subflowsCreated}
-- **Success Rate**: ${subflowCreation.candidatesIdentified > 0 ? Math.round((subflowCreation.subflowsCreated / subflowCreation.candidatesIdentified) * 100) : 0}%
-
-`;
-        }
-        // Recommendations
-        analysisText += `💡 **Recommendations:**
-${flowInstruction.recommendations?.map((rec, index) => `${index + 1}. ${rec}`).join('\n') || 'No specific recommendations'}`;
-        return analysisText;
-    }
-    /**
-     * Safe method to access composer features with fallback
-     */
-    async safeComposerOperation(operation, fallbackOperation, operationName) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            this.logger.warn(`${operationName} failed, falling back to basic operation`, error);
-            return await fallbackOperation();
-        }
-    }
-    /**
-     * Intelligent flow analysis tool
-     */
-    async intelligentFlowAnalysis(args) {
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Performing intelligent flow analysis', { instruction: args.instruction });
-            const analysisResult = await this.composer.getFlowAnalysisSummary(args.instruction);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🧠 Intelligent Flow Analysis Results
-
-📝 **Original Instruction:**
-"${args.instruction}"
-
-🎯 **Decision Analysis:**
-- **Recommended Type**: ${analysisResult.decision?.recommendedType || 'Unknown'}
-- **Confidence**: ${analysisResult.decision?.confidence ? Math.round(analysisResult.decision.confidence * 100) + '%' : 'Unknown'}
-- **Rationale**: ${analysisResult.decision?.rationale || 'No rationale provided'}
-
-📊 **Complexity Assessment:**
-- **Level**: ${analysisResult.complexity || 'Unknown'}
-- **Reusability**: ${analysisResult.reusability || 'Unknown'}
-- **Context**: ${analysisResult.context || 'Unknown'}
-
-✅ **Validation Results:**
-- **Valid**: ${analysisResult.validation?.isValid ? 'Yes' : 'No'}
-- **Score**: ${analysisResult.validation?.score || 0}/${analysisResult.validation?.maxScore || 0}
-
-🎯 **Template Matching:**
-- **Matches Found**: ${analysisResult.templates?.matchCount || 0}
-- **Best Match**: ${analysisResult.templates?.bestMatch || 'None'}
-- **Confidence**: ${analysisResult.templates?.confidence ? Math.round(analysisResult.templates.confidence * 100) + '%' : 'N/A'}
-
-🔄 **Subflow Opportunities:**
-- **Candidates Identified**: ${analysisResult.subflowCandidates || 0}
-- **Alternatives Available**: ${analysisResult.alternatives?.length || 0}
-
-💡 **Key Insights:**
-- Flow complexity suggests ${analysisResult.complexity === 'high' ? 'breaking into smaller components' : 'keeping as single flow'}
-- ${analysisResult.reusability === 'high' ? 'High reusability indicates subflow opportunities' : 'Low reusability suggests single-use flow'}
-- ${analysisResult.templates?.matchCount > 0 ? 'Template matching available for consistency' : 'Custom implementation required'}
-
-🚀 **Next Steps:**
-1. Use \`snow_template_matching\` to explore template options
-2. Run \`snow_create_flow\` with deploy_immediately: true to implement the recommended approach
-3. Consider \`snow_scope_optimization\` for deployment strategy
-
-✅ **Analysis Complete!** The instruction has been comprehensively analyzed with intelligent insights.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Intelligent flow analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Scope optimization tool
-     */
-    async scopeOptimization(args) {
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Performing scope optimization analysis', {
-                artifactType: args.artifact_type,
-                environmentType: args.environment_type
-            });
-            // Create a deployment context for analysis
-            const deploymentContext = {
-                artifactType: args.artifact_type,
-                artifactData: args.artifact_data,
-                environmentType: args.environment_type || 'development'
-            };
-            // Use the composer's scope manager for analysis
-            const scopeAnalysis = await this.composer.scopeManagerInstance.makeScopeDecision(deploymentContext);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🎯 Scope Optimization Analysis
-
-📋 **Artifact Information:**
-- **Type**: ${args.artifact_type}
-- **Environment**: ${args.environment_type || 'development'}
-- **Name**: ${args.artifact_data?.name || 'Unknown'}
-
-🎯 **Scope Recommendation:**
-- **Recommended Scope**: ${scopeAnalysis?.selectedScope || 'global'}
-- **Confidence**: ${scopeAnalysis?.confidence ? Math.round(scopeAnalysis.confidence * 100) + '%' : 'Unknown'}
-- **Rationale**: ${scopeAnalysis?.rationale || 'Global scope provides maximum flexibility and reusability'}
-
-🔄 **Fallback Strategy:**
-- **Fallback Scope**: ${scopeAnalysis?.fallbackScope || 'application'}
-- **Fallback Triggers**: Permission issues, compliance requirements, environment restrictions
-
-✅ **Validation Results:**
-- **Permissions**: ${scopeAnalysis?.validationResult?.permissions || 'Valid'}
-- **Compliance**: ${scopeAnalysis?.validationResult?.compliance || 'Compliant'}
-- **Dependencies**: ${scopeAnalysis?.validationResult?.dependencies || 'Resolved'}
-
-💡 **Recommendations:**
-${scopeAnalysis?.recommendations?.map((rec, index) => `${index + 1}. ${rec}`).join('\n') || '1. Deploy to global scope for maximum reusability\n2. Ensure proper naming conventions\n3. Document scope decision for future reference'}
-
-🚀 **Deployment Strategy:**
-1. **Primary**: Deploy to ${scopeAnalysis?.selectedScope || 'global'} scope
-2. **Fallback**: Use ${scopeAnalysis?.fallbackScope || 'application'} scope if primary fails
-3. **Validation**: Comprehensive pre-deployment checks
-4. **Monitoring**: Post-deployment validation and rollback capability
-
-⚠️ **Important Considerations:**
-- Global scope artifacts are shared across all applications
-- Application scope provides isolation but limits reusability
-- Environment-specific considerations may override recommendations
-- Compliance requirements may dictate scope selection
-
-✅ **Analysis Complete!** Scope optimization strategy is ready for implementation.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Scope optimization failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Template matching tool
-     */
-    async templateMatching(args) {
-        const isAuth = await this.oauth.isAuthenticated();
-        if (!isAuth) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-                    },
-                ],
-            };
-        }
-        try {
-            this.logger.info('Performing template matching', {
-                instruction: args.instruction,
-                minimumConfidence: args.minimum_confidence || 0.6
-            });
-            const matchingResults = await this.composer.patternTemplatesInstance.findMatchingTemplates(args.instruction);
-            // Filter by minimum confidence if specified
-            const filteredResults = matchingResults?.filter((result) => result.confidence >= (args.minimum_confidence || 0.6)) || [];
-            // Filter by categories if specified
-            const categoryFilteredResults = args.template_categories ?
-                filteredResults.filter((result) => args.template_categories.includes(result.template.category)) : filteredResults;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🎯 Template Matching Results
-
-📝 **Search Criteria:**
-- **Instruction**: "${args.instruction}"
-- **Minimum Confidence**: ${Math.round((args.minimum_confidence || 0.6) * 100)}%
-- **Categories**: ${args.template_categories?.join(', ') || 'All categories'}
-
-🎯 **Matching Templates (${categoryFilteredResults.length} found):**
-
-${categoryFilteredResults.map((result, index) => `### ${index + 1}. ${result.template.name}
-**Category**: ${result.template.category}
-**Confidence**: ${Math.round(result.confidence * 100)}%
-**Description**: ${result.template.description}
-
-**Template Features:**
-- **Triggers**: ${result.template.triggers?.join(', ') || 'Generic'}
-- **Activities**: ${result.template.activities?.length || 0} predefined activities
-- **Variables**: ${result.template.variables?.length || 0} template variables
-- **Customizable**: ${result.template.customizable ? 'Yes' : 'No'}
-
-**Why this matches:**
-${result.matchingReasons?.map((reason) => `- ${reason}`).join('\n') || '- Pattern similarity with instruction'}
-
-**Confidence Breakdown:**
-- **Keyword Match**: ${Math.round(result.scores?.keywords * 100)}%
-- **Intent Match**: ${Math.round(result.scores?.intent * 100)}%
-- **Structure Match**: ${Math.round(result.scores?.structure * 100)}%
-- **Context Match**: ${Math.round(result.scores?.context * 100)}%`).join('\n\n')}
-
-${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching your criteria.**
-
-**Suggestions:**
-1. Lower the minimum confidence threshold (currently ${Math.round((args.minimum_confidence || 0.6) * 100)}%)
-2. Remove category filters to see all available templates
-3. Try different keywords or phrases in your instruction
-4. Consider creating a custom flow without templates` : ''}
-
-💡 **Template Usage:**
-- **Best Match**: ${categoryFilteredResults[0]?.template.name || 'None'}
-- **Confidence**: ${categoryFilteredResults[0]?.confidence ? Math.round(categoryFilteredResults[0].confidence * 100) + '%' : 'N/A'}
-- **Recommended**: ${categoryFilteredResults[0]?.confidence >= 0.8 ? 'Yes - High confidence match' : 'Consider manual review'}
-
-🚀 **Next Steps:**
-1. Use \`snow_create_flow\` with deploy_immediately: true to implement the best matching template
-2. Review template customization options
-3. Consider \`snow_intelligent_flow_analysis\` for detailed analysis
-4. Modify instruction if no suitable templates found
-
-✅ **Template matching complete!** ${categoryFilteredResults.length > 0 ? 'Templates ready for implementation.' : 'Consider custom flow creation.'}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Template matching failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async start() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Flow Composer MCP Server started');
-    }
-    /**
-     * Map trigger type to XML format
-     */
-    mapTriggerTypeToXML(triggerType) {
-        const mapping = {
-            'record_created': 'record_created',
-            'record_updated': 'record_updated',
-            'manual': 'manual',
-            'scheduled': 'scheduled',
-            'create': 'record_created',
-            'update': 'record_updated',
-            'on_create': 'record_created',
-            'on_update': 'record_updated'
-        };
-        return mapping[triggerType.toLowerCase()] || 'manual';
-    }
-    /**
-     * Convert activities to XML format
-     */
-    convertActivitiesToXML(activities) {
-        return activities.map((activity, index) => ({
-            type: this.mapActivityTypeToXML(activity.type),
-            name: activity.name || `Activity ${index + 1}`,
-            inputs: activity.inputs || {},
-            order: (index + 1) * 100,
-            description: activity.description || activity.name
-        }));
-    }
-    /**
-     * Convert activities to CompleteFlowXMLGenerator format
-     */
-    convertActivitiesToCompleteFormat(activities) {
-        return activities.map((activity, index) => ({
-            name: activity.name || `Activity ${index + 1}`,
-            type: this.mapActivityTypeToXML(activity.type),
-            order: (index + 1) * 100,
-            description: activity.description || activity.name || '',
-            inputs: activity.inputs || {},
-            outputs: activity.outputs || {},
-            condition: activity.condition || '',
-            artifact_reference: activity.artifact_reference,
-            subflow_reference: activity.subflow_reference
-        }));
-    }
-    /**
-     * Map activity type to XML format
-     */
-    mapActivityTypeToXML(activityType) {
-        const mapping = {
-            'approval': 'approval',
-            'notification': 'notification',
-            'email': 'notification',
-            'script': 'script',
-            'create_record': 'create_record',
-            'update_record': 'update_record',
-            'rest_call': 'rest_step',
-            'condition': 'condition',
-            'subflow': 'assign_subflow'
-        };
-        return mapping[activityType.toLowerCase()] || 'script';
-    }
-    /**
-     * Comprehensive flow verification with retry logic
-     */
-    async verifyFlowInServiceNow(flowName) {
-        const maxRetries = 5;
-        const baseDelay = 2000; // Start with 2 seconds
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                // Progressive delay - ServiceNow needs time to process
-                if (attempt > 1) {
-                    const delay = baseDelay * attempt; // 2s, 4s, 6s, 8s, 10s
-                    this.logger.info(`Waiting ${delay}ms before verification attempt ${attempt}/${maxRetries}`);
-                    await this.sleep(delay);
-                }
-                const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
-                const client = new ServiceNowClient();
-                // Multi-table verification for comprehensive check
-                const verificationPromises = [
-                    // Check main flow table
-                    client.makeRequest({
-                        method: 'GET',
-                        url: '/api/now/table/sys_hub_flow',
-                        params: {
-                            sysparm_query: `name=${flowName}^ORsys_name=${flowName}`,
-                            sysparm_fields: 'sys_id,name,sys_name,active,table,description',
-                            sysparm_limit: 5
-                        }
-                    }),
-                    // Check flow snapshots
-                    client.makeRequest({
-                        method: 'GET',
-                        url: '/api/now/table/sys_hub_flow_snapshot',
-                        params: {
-                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
-                            sysparm_fields: 'sys_id,flow,name,active',
-                            sysparm_limit: 5
-                        }
-                    }),
-                    // Check trigger instances
-                    client.makeRequest({
-                        method: 'GET',
-                        url: '/api/now/table/sys_hub_trigger_instance',
-                        params: {
-                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
-                            sysparm_fields: 'sys_id,flow,trigger_type',
-                            sysparm_limit: 5
-                        }
-                    })
-                ];
-                const [flowCheck, snapshotCheck, triggerCheck] = await Promise.allSettled(verificationPromises);
-                // Analyze results
-                const flowExists = flowCheck.status === 'fulfilled' &&
-                    flowCheck.value.result &&
-                    flowCheck.value.result.length > 0;
-                const snapshotExists = snapshotCheck.status === 'fulfilled' &&
-                    snapshotCheck.value.result &&
-                    snapshotCheck.value.result.length > 0;
-                const triggerExists = triggerCheck.status === 'fulfilled' &&
-                    triggerCheck.value.result &&
-                    triggerCheck.value.result.length > 0;
-                // Comprehensive verification result
-                if (flowExists) {
-                    const flowData = flowCheck.value.result[0];
-                    return {
-                        verified: true,
-                        sys_id: flowData.sys_id,
-                        name: flowData.name || flowData.sys_name,
-                        active: flowData.active,
-                        table: flowData.table,
-                        has_snapshot: snapshotExists,
-                        has_trigger: triggerExists,
-                        verification_attempt: attempt,
-                        verification_method: 'multi_table_comprehensive',
-                        completeness_score: (flowExists ? 1 : 0) + (snapshotExists ? 1 : 0) + (triggerExists ? 1 : 0),
-                        url: `https://${await this.getInstanceUrl()}/flow-designer/flow/${flowData.sys_id}`
-                    };
-                }
-                // Log partial results for debugging
-                this.logger.warn(`Verification attempt ${attempt}: Flow=${flowExists}, Snapshot=${snapshotExists}, Trigger=${triggerExists}`);
-                // If this is the last attempt, return detailed failure info
-                if (attempt === maxRetries) {
-                    return {
-                        verified: false,
-                        reason: 'Flow not found after comprehensive verification',
-                        attempts: maxRetries,
-                        partial_results: {
-                            flow_found: flowExists,
-                            snapshot_found: snapshotExists,
-                            trigger_found: triggerExists
-                        },
-                        search_query: `name=${flowName}`,
-                        recommendation: 'Check ServiceNow Flow Designer manually or verify deployment was successful'
-                    };
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Verification attempt ${attempt} failed:`, error);
-                // If this is the last attempt, include error details
-                if (attempt === maxRetries) {
-                    return {
-                        verified: false,
-                        reason: 'Verification failed due to error',
-                        error: error instanceof Error ? error.message : String(error),
-                        attempts: maxRetries
-                    };
-                }
-            }
-        }
-        return {
-            verified: false,
-            reason: 'Max verification attempts exceeded',
-            attempts: maxRetries
-        };
-    }
-    /**
-     * Helper to get instance URL for flow links
-     */
-    async getInstanceUrl() {
-        try {
-            const credentials = await this.oauth.loadCredentials();
-            return credentials?.instance || 'your-instance.service-now.com';
-        }
-        catch {
-            return 'your-instance.service-now.com';
-        }
-    }
-    /**
-     * Sleep utility
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Generate manual import guide for failed deployments
-     */
-    generateManualImportGuide(xmlFilePath) {
-        // BUG-004 FIX: Handle undefined or empty file paths properly
-        if (!xmlFilePath || xmlFilePath.trim() === '') {
-            return `
-**⚠️ No XML file was generated**
-
-Since the flow XML generation failed, you'll need to:
-
-1. **Create the flow manually in ServiceNow**:
-   - Navigate to Flow Designer
-   - Click "New" > "Flow"
-   - Build the flow based on your requirements
-   
-2. **Alternative: Use the deployment tool**:
-   - Run: snow-flow deploy --retry
-   - This will attempt to regenerate and deploy the flow
-   
-3. **Check error logs**:
-   - Review the error details above to understand why XML generation failed
-   - Common causes: missing artifacts, permission issues, or invalid flow structure`;
-        }
-        return `
-1. **Navigate to ServiceNow**:
-   - System Update Sets > Retrieved Update Sets
-   
-2. **Import XML**:
-   - Click "Import Update Set from XML"
-   - Select file: ${xmlFilePath}
-   - Click "Upload"
-   
-3. **Preview**:
-   - Find your imported update set
-   - Click "Preview Update Set"
-   - Review any conflicts or issues
-   
-4. **Commit**:
-   - If preview is clean, click "Commit Update Set"
-   - Your flow will be available in Flow Designer
-   
-5. **Verify**:
-   - Navigate to Flow Designer
-   - Check "My Flows" for your new flow`;
-    }
-    /**
-     * Deploy with fallback strategies + MANDATORY VERIFICATION
-     * 🔴 CRITICAL FIX: SNOW-001 Silent Deployment Failures
-     * Each strategy now MUST verify that the flow actually exists before claiming success
-     */
-    async deployWithFallback(xmlFilePath, flowDefinition) {
-        // 🚀 ENHANCED: Use our complete solution components
-        const toolRegistry = (0, mcp_tool_registry_js_1.getToolRegistry)();
-        try {
-            // Use our enhanced deployment system
-            this.logger.info('🚀 Using enhanced deployment system with complete solution');
-            // Deploy using UpdateSetImporter
-            const importResult = await (0, update_set_importer_js_1.deployFlowXML)(xmlFilePath, true);
-            if (importResult.success) {
-                // Extract complete metadata using DeploymentMetadataHandler
-                const metadataResult = await (0, deployment_metadata_handler_js_1.ensureDeploymentMetadata)('flow', { success: true, flow: { sys_id: importResult.flowSysId } }, {
-                    flowSysId: importResult.flowSysId,
-                    name: flowDefinition.name,
-                    update_set_id: importResult.localUpdateSetId
-                });
-                if (metadataResult.success && metadataResult.metadata) {
-                    return {
-                        success: true,
-                        strategy: 'Enhanced XML Update Set',
-                        result: importResult,
-                        verification: {
-                            verified: true,
-                            sys_id: metadataResult.metadata.sys_id,
-                            url: metadataResult.metadata.ui_url,
-                            api_endpoint: metadataResult.metadata.api_endpoint,
-                            has_flow: true,
-                            has_snapshot: true,
-                            has_trigger: true,
-                            completeness_score: 100,
-                            verification_attempt: 1,
-                            reason: 'Complete deployment with metadata verification'
-                        },
-                        deployment_verified: true,
-                        metadata: metadataResult.metadata
-                    };
-                }
-            }
-            // If enhanced deployment fails, try legacy methods
-            this.logger.warn('Enhanced deployment failed, trying fallback strategies');
-        }
-        catch (error) {
-            this.logger.warn('Enhanced deployment error:', error);
-        }
-        // Fallback to legacy strategies
-        const strategies = [
-            {
-                name: 'XML Remote Update Set',
-                fn: async () => await this.deployXMLToServiceNowWithVerification(xmlFilePath, flowDefinition.name)
-            },
-            {
-                name: 'Direct Table API',
-                fn: async () => await this.deployViaTableAPIWithVerification(flowDefinition)
-            }
-        ];
-        let lastError;
-        for (const strategy of strategies) {
-            try {
-                this.logger.info(`Trying deployment strategy: ${strategy.name}`);
-                const result = await strategy.fn();
-                // 🔴 CRITICAL: Strategy can only return if it includes verification proof
-                if (!result.verification || !result.verification.verified) {
-                    throw new Error(`${strategy.name} completed but verification failed: ${result.verification?.reason || 'Unknown verification failure'}`);
-                }
-                return {
-                    success: true,
-                    strategy: strategy.name,
-                    result,
-                    verification: result.verification,
-                    deployment_verified: true
-                };
-            }
-            catch (error) {
-                this.logger.warn(`Strategy ${strategy.name} failed:`, error);
-                lastError = error;
-            }
-        }
-        throw lastError || new Error('All deployment strategies failed');
-    }
-    /**
-     * 🔴 CRITICAL FIX: Deploy XML with MANDATORY verification
-     * SNOW-001: Prevents false positive where XML import succeeds but flow doesn't exist
-     */
-    async deployXMLToServiceNowWithVerification(xmlFilePath, flowName) {
-        this.logger.info(`🔴 CRITICAL FIX: XML deployment with mandatory verification for: ${flowName}`);
-        // Step 1: Deploy the XML (existing logic)
-        await this.deployXMLToServiceNow(xmlFilePath);
-        // Step 2: MANDATORY verification - wait for ServiceNow to process
-        this.logger.info('🔍 Starting mandatory post-deployment verification...');
-        const verification = await this.verifyFlowInServiceNow(flowName);
-        if (!verification.verified) {
-            // 🔴 CRITICAL: XML deployment succeeded but flow doesn't exist
-            const errorMsg = `🔴 CRITICAL: XML deployment appeared to succeed but flow verification failed: ${verification.reason}`;
-            this.logger.error('SNOW-001 detected: Silent deployment failure', {
-                xmlFilePath,
-                flowName,
-                verificationResult: verification,
-                issue: 'XML import/commit succeeded but no flow created'
-            });
-            throw new Error(errorMsg);
-        }
-        this.logger.info(`✅ XML deployment verified successfully: ${flowName} found with sys_id ${verification.sys_id}`);
-        return {
-            deployment_method: 'XML Remote Update Set',
-            xml_file: xmlFilePath,
-            verification: verification,
-            success_message: `XML deployment completed and verified: Flow ${flowName} is live in ServiceNow`
-        };
-    }
-    /**
-     * 🔴 CRITICAL FIX: Deploy via Table API with MANDATORY verification
-     * SNOW-001: Prevents false positive where API call succeeds but flow doesn't exist
-     */
-    async deployViaTableAPIWithVerification(flowDefinition) {
-        this.logger.info(`🔴 CRITICAL FIX: Table API deployment with mandatory verification for: ${flowDefinition.name}`);
-        // Step 1: Deploy via Table API (existing logic)
-        await this.deployViaTableAPI(flowDefinition);
-        // Step 2: MANDATORY verification
-        this.logger.info('🔍 Starting mandatory post-deployment verification...');
-        const verification = await this.verifyFlowInServiceNow(flowDefinition.name);
-        if (!verification.verified) {
-            // 🔴 CRITICAL: Table API deployment succeeded but flow doesn't exist
-            const errorMsg = `🔴 CRITICAL: Table API deployment appeared to succeed but flow verification failed: ${verification.reason}`;
-            this.logger.error('SNOW-001 detected: Silent deployment failure', {
-                flowName: flowDefinition.name,
-                verificationResult: verification,
-                issue: 'Table API call succeeded but no flow created'
-            });
-            throw new Error(errorMsg);
-        }
-        this.logger.info(`✅ Table API deployment verified successfully: ${flowDefinition.name} found with sys_id ${verification.sys_id}`);
-        return {
-            deployment_method: 'Direct Table API',
-            verification: verification,
-            success_message: `Table API deployment completed and verified: Flow ${flowDefinition.name} is live in ServiceNow`
-        };
-    }
-    /**
-     * Deploy via direct table API (LEGACY METHOD - used by new verified method)
-     */
-    async deployViaTableAPI(flowDefinition) {
-        const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
-        const client = new ServiceNowClient();
-        // Try to create flow directly in sys_hub_flow
-        const flowResponse = await client.makeRequest({
-            method: 'POST',
-            url: '/api/now/table/sys_hub_flow',
-            data: {
-                name: flowDefinition.name,
-                description: flowDefinition.description,
-                active: true,
-                // Additional flow properties
-                table: flowDefinition.table
-            }
-        });
-        if (!flowResponse.result || !flowResponse.result.sys_id) {
-            throw new Error('Failed to create flow via Table API');
-        }
-        this.logger.info(`Flow created via Table API: ${flowResponse.result.sys_id}`);
-    }
-    /**
-     * Deploy XML file to ServiceNow automatically
-     */
-    async deployXMLToServiceNow(xmlFilePath) {
-        // 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
-        const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
-        const client = new ServiceNowClient();
-        // Check for active Update Set first
-        let currentUpdateSet;
-        try {
-            const updateSetResponse = await client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_update_set',
-                params: {
-                    sysparm_query: 'state=in progress^nameNOT LIKEDefault',
-                    sysparm_limit: 1
-                }
-            });
-            if (!updateSetResponse.result || updateSetResponse.result.length === 0) {
-                this.logger.warn('No active Update Set found. Flow will be imported but not tracked properly.');
-                // Continue anyway - let ServiceNow handle it
-            }
-            else {
-                currentUpdateSet = updateSetResponse.result[0];
-                this.logger.info(`Active Update Set found: ${currentUpdateSet.name}`);
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not check for active Update Set:', error);
-            // Continue anyway
-        }
-        // Read the XML file
-        const fs = require('fs').promises;
-        const xmlContent = await fs.readFile(xmlFilePath, 'utf-8');
-        // Import XML as remote update set
-        let importResponse;
-        try {
-            importResponse = await client.makeRequest({
-                method: 'POST',
-                url: '/api/now/table/sys_remote_update_set',
-                headers: {
-                    'Content-Type': 'application/xml',
-                    'Accept': 'application/json'
-                },
-                data: xmlContent
-            });
-        }
-        catch (error) {
-            // Enhanced error handling with detailed messages
-            if (error.response?.status === 400) {
-                const errorDetail = error.response.data?.error?.detail ||
-                    error.response.data?.error?.message ||
-                    'Unknown error';
-                this.logger.error('ServiceNow 400 Error:', {
-                    status: error.response.status,
-                    statusText: error.response.statusText,
-                    data: error.response.data,
-                    headers: error.response.headers
-                });
-                throw new Error(`ServiceNow rejected the XML: ${errorDetail}. Check if you have an active Update Set.`);
-            }
-            else if (error.response?.status === 401 || error.response?.status === 403) {
-                throw new Error('Authentication failed. Your session may have expired. Run: snow-flow auth login');
-            }
-            else {
-                throw new Error(`Failed to import XML: ${error.message}`);
-            }
-        }
-        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
-        try {
-            await client.makeRequest({
-                method: 'PUT',
-                url: `/api/now/table/sys_remote_update_set/${remoteUpdateSetId}`,
-                data: {
-                    state: 'loaded'
-                }
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to load update set:', error);
-            throw new Error(`Failed to load update set: ${error.message}. You may need to load it manually.`);
-        }
-        // 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
-        try {
-            await client.makeRequest({
-                method: 'POST',
-                url: `/api/now/table/sys_update_set/${updateSetId}/preview`
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to preview update set:', error);
-            // Continue anyway, as preview might fail but commit could still work
-        }
-        // 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
-        try {
-            await client.makeRequest({
-                method: 'POST',
-                url: `/api/now/table/sys_update_set/${updateSetId}/commit`
-            });
-            this.logger.info(`✅ Update set committed successfully: ${updateSetName}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to commit update set:', error);
-            throw new Error(`Failed to commit update set. Manual intervention required in ServiceNow UI.`);
-        }
-    }
-    /**
-     * 🚀 BUG-007 FIX: Performance Analysis Tool
-     * Analyze flows for performance bottlenecks and provide database index recommendations
-     */
-    async performanceAnalysis(args) {
-        try {
-            this.logger.info('🔍 Running performance analysis', {
-                flowDefinition: !!args.flow_definition,
-                tableName: args.table_name,
-                includeIndexes: args.include_database_indexes,
-                includeCode: args.include_code_analysis
-            });
-            // Import the performance engine
-            const { PerformanceRecommendationsEngine } = await Promise.resolve().then(() => __importStar(require('../intelligence/performance-recommendations-engine.js')));
-            const performanceEngine = new PerformanceRecommendationsEngine();
-            // Run performance analysis
-            const analysisResult = await performanceEngine.analyzeFlowPerformance(args.flow_definition);
-            let responseText = `🚀 **Performance Analysis Results**
-
-📊 **SUMMARY:**
-• Critical Issues: ${analysisResult.summary.criticalIssues}
-• Estimated Performance Improvement: ${analysisResult.summary.estimatedImprovementPercent}%
-• Total Recommendations: ${analysisResult.databaseIndexes.length + analysisResult.performanceRecommendations.length}
-
-`;
-            // Add database index recommendations if requested
-            if (args.include_database_indexes !== false && analysisResult.databaseIndexes.length > 0) {
-                responseText += `🗄️ **DATABASE INDEX RECOMMENDATIONS:**
-
-${analysisResult.databaseIndexes.map((idx, i) => `**${i + 1}. ${idx.table} - ${idx.fields.join(', ')} [${idx.priority.toUpperCase()}]**
-💡 **Reason**: ${idx.reason}
-📈 **Expected Improvement**: ${idx.estimatedImprovement}%
-💻 **SQL**: \`${idx.createStatement}\`
-📊 **Impact**: ${idx.impactAnalysis.queryImpact.join(', ')}
-💾 **Storage**: ${idx.impactAnalysis.storageImpact}
-🔧 **Maintenance**: ${idx.impactAnalysis.maintenanceImpact}
-`).join('\n')}
-
-`;
-            }
-            // Add performance recommendations if requested
-            if (args.include_code_analysis !== false && analysisResult.performanceRecommendations.length > 0) {
-                responseText += `⚡ **PERFORMANCE RECOMMENDATIONS:**
-
-${analysisResult.performanceRecommendations.map((rec, i) => `**${i + 1}. ${rec.type.replace(/_/g, ' ').toUpperCase()} [${rec.impact.toUpperCase()} IMPACT]**
-📋 **Issue**: ${rec.description}
-💡 **Recommendation**: ${rec.recommendation}
-⏱️ **Time Savings**: ${rec.estimated_time_savings}
-${rec.code_example ? `\n💻 **Example Code**:\n\`\`\`javascript\n${rec.code_example}\n\`\`\`` : ''}
-`).join('\n')}
-
-`;
-            }
-            // Add top priority actions
-            if (analysisResult.summary.recommendedActions.length > 0) {
-                responseText += `🎯 **TOP PRIORITY ACTIONS:**
-${analysisResult.summary.recommendedActions.map((action, i) => `${i + 1}. ${action}`).join('\n')}
-
-`;
-            }
-            // Add detailed report if requested
-            if (args.detailed_report) {
-                responseText += `📋 **DETAILED PERFORMANCE REPORT:**
-
-${performanceEngine.generatePerformanceReport(analysisResult)}`;
-            }
-            responseText += `
-🔍 **NEXT STEPS:**
-1. Implement critical database indexes first (highest ROI)
-2. Review and optimize flow scripts for performance issues
-3. Consider implementing caching for frequently accessed data
-4. Monitor performance metrics after implementing changes
-5. Schedule regular performance reviews for optimal results
-
-⚠️ **IMPORTANT**: Test all database changes in a development environment first!
-
-✅ **Performance analysis complete!** Review recommendations and implement changes for optimal performance.`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('Performance analysis failed:', error);
-            throw new Error(`Performance analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * 🚀 BUG-006 FIX: Comprehensive Requirements Analysis Tool
-     * Multi-pass analysis to ensure comprehensive requirements coverage
-     */
-    async comprehensiveRequirementsAnalysis(args) {
-        try {
-            this.logger.info('🔍 Running comprehensive multi-pass requirements analysis', {
-                objective: args.objective,
-                includeDependencies: args.include_dependencies,
-                includeContext: args.include_context_analysis,
-                includeValidation: args.include_validation
-            });
-            // Import the multi-pass analyzer
-            const { MultiPassRequirementsAnalyzer } = await Promise.resolve().then(() => __importStar(require('../intelligence/multi-pass-requirements-analyzer.js')));
-            const analyzer = new MultiPassRequirementsAnalyzer();
-            // Run comprehensive multi-pass analysis
-            const analysisResult = await analyzer.analyzeRequirements(args.objective);
-            let responseText = `🚀 **Comprehensive Requirements Analysis Results**
-
-📝 **OBJECTIVE**: ${args.objective}
-
-📊 **ANALYSIS SUMMARY:**
-• Total Requirements Identified: ${analysisResult.totalRequirements}
-• MCP Coverage: ${analysisResult.mcpCoveredCount}/${analysisResult.totalRequirements} (${analysisResult.mcpCoveragePercentage}%)
-• Gap Requirements: ${analysisResult.gapCount}
-• Estimated Complexity: ${analysisResult.estimatedComplexity.toUpperCase()}
-• Risk Assessment: ${analysisResult.riskAssessment.toUpperCase()}
-• Completeness Score: ${analysisResult.completenessScore}/100
-• Confidence Level: ${analysisResult.confidenceLevel.toUpperCase()}
-
-`;
-            // Add multi-pass analysis breakdown
-            responseText += `🔍 **MULTI-PASS ANALYSIS BREAKDOWN:**
-
-${Object.entries(analysisResult.analysisPassesData).map(([passKey, passData]) => `**${passData.passName} (Pass ${passData.passNumber})**
-• Requirements Found: ${passData.newRequirementsAdded}
-• Analysis Method: ${passData.analysisMethod}
-• Processing Time: ${passData.processingTime}ms
-• Confidence: ${Math.round(passData.confidence * 100)}%
-• Key Findings: ${passData.keyFindings.length > 0 ? passData.keyFindings.slice(0, 3).join('; ') : 'No specific findings'}
-`).join('\n')}
-
-`;
-            // Add requirements by category
-            const categorizedRequirements = analysisResult.requirements.reduce((acc, req) => {
-                if (!acc[req.category])
-                    acc[req.category] = [];
-                acc[req.category].push(req);
-                return acc;
-            }, {});
-            responseText += `📋 **REQUIREMENTS BY CATEGORY:**
-
-${Object.entries(categorizedRequirements).map(([category, reqs]) => `**${category.replace(/_/g, ' ').toUpperCase()}** (${reqs.length} items)
-${reqs.slice(0, 5).map(req => `• ${req.name} [${req.priority.toUpperCase()}] ${req.mcpCoverage ? '✅ MCP' : '⚠️ Manual'} - ${req.description.substring(0, 80)}...`).join('\n')}
-${reqs.length > 5 ? `... and ${reqs.length - 5} more items` : ''}
-`).join('\n')}
-
-`;
-            // Add critical path analysis
-            if (analysisResult.criticalPath.length > 0) {
-                responseText += `🎯 **CRITICAL PATH REQUIREMENTS:**
-${analysisResult.criticalPath.map((req, i) => `${i + 1}. ${req}`).join('\n')}
-
-`;
-            }
-            // Add cross-domain impacts
-            if (analysisResult.crossDomainImpacts.length > 0) {
-                responseText += `🌐 **CROSS-DOMAIN IMPACTS:**
-${analysisResult.crossDomainImpacts.map((impact, i) => `${i + 1}. ${impact}`).join('\n')}
-
-`;
-            }
-            // Add implicit dependencies
-            if (analysisResult.implicitDependencies.length > 0) {
-                responseText += `🔗 **IMPLICIT DEPENDENCIES:**
-${analysisResult.implicitDependencies.slice(0, 5).map((dep, i) => `${i + 1}. ${dep}`).join('\n')}
-
-`;
-            }
-            // Add missing requirements detected
-            if (analysisResult.missingRequirementsDetected.length > 0) {
-                responseText += `⚠️ **MISSING REQUIREMENTS DETECTED:**
-${analysisResult.missingRequirementsDetected.slice(0, 3).map((req, i) => `${i + 1}. **${req.name}** [${req.priority.toUpperCase()}]
-   ${req.description}
-   Effort: ${req.estimatedEffort} | Risk: ${req.riskLevel} | MCP: ${req.mcpCoverage ? 'Yes' : 'No'}`).join('\n\n')}
-
-`;
-            }
-            // Add detailed report if requested
-            if (args.detailed_report) {
-                responseText += `📋 **DETAILED ANALYSIS REPORT:**
-
-**COMPLETENESS ANALYSIS:**
-The analysis achieved a completeness score of ${analysisResult.completenessScore}/100 with ${analysisResult.confidenceLevel} confidence.
-
-**PASS-BY-PASS BREAKDOWN:**
-${Object.entries(analysisResult.analysisPassesData).map(([passKey, passData]) => `
-**${passData.passName}:**
-- New requirements identified: ${passData.newRequirementsAdded}
-- Key insights: ${passData.keyFindings.join('; ')}
-- Analysis approach: ${passData.analysisMethod}
-- Processing efficiency: ${passData.processingTime}ms
-`).join('')}
-
-**RISK ASSESSMENT:**
-${analysisResult.riskAssessment === 'high' ? '⚠️ HIGH RISK: This objective involves complex integrations and significant system changes.' :
-                    analysisResult.riskAssessment === 'medium' ? '🔶 MEDIUM RISK: Standard complexity with some integration challenges.' :
-                        '✅ LOW RISK: Straightforward implementation with minimal system impact.'}
-
-**COMPLEXITY BREAKDOWN:**
-The ${analysisResult.estimatedComplexity} complexity rating is based on:
-- Number of components: ${analysisResult.totalRequirements}
-- Integration points: ${analysisResult.categories.length} different categories
-- Estimated duration: ${analysisResult.estimatedDuration}
-- Cross-domain impacts: ${analysisResult.crossDomainImpacts.length} identified
-
-`;
-            }
-            responseText += `
-🔍 **NEXT STEPS:**
-1. **Immediate Actions**: Focus on ${analysisResult.criticalPath.length > 0 ? 'critical path requirements' : 'high-priority items'}
-2. **MCP Coverage**: ${analysisResult.mcpCoveragePercentage}% can be automated, ${100 - analysisResult.mcpCoveragePercentage}% requires manual work
-3. **Resource Planning**: Estimated ${analysisResult.estimatedDuration} development time
-4. **Risk Mitigation**: Address ${analysisResult.riskAssessment} risk items first
-5. **Quality Assurance**: Validate completeness score of ${analysisResult.completenessScore}/100
-
-💡 **RECOMMENDATIONS:**
-• Start with MCP-covered requirements for quick wins
-• Address security and compliance requirements early
-• Plan for cross-domain impact testing
-• Consider phased implementation for complex scenarios
-
-✅ **Comprehensive analysis complete!** This ${analysisResult.analysisPassesData.pass1_initial.requirementsFound + analysisResult.analysisPassesData.pass2_dependencies.newRequirementsAdded + analysisResult.analysisPassesData.pass3_context.newRequirementsAdded + analysisResult.analysisPassesData.pass4_validation.newRequirementsAdded}-requirement analysis ensures nothing is missed.`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('Comprehensive requirements analysis failed:', error);
-            throw new Error(`Comprehensive requirements analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-// Start the server
-const server = new ServiceNowFlowComposerMCP();
-server.start().catch((error) => {
-    console.error('Failed to start ServiceNow Flow Composer MCP:', error);
-    process.exit(1);
-});