snow-flow 8.42.12 → 9.0.1

package/dist/mcp/servicenow-development-assistant-mcp.js

@@ -1,4217 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Development Assistant MCP Server
- * Natural language artifact management and development orchestration for ServiceNow
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowDevelopmentAssistantMCP = void 0;
-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 mcp_auth_middleware_js_1 = require("../utils/mcp-auth-middleware.js");
-const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
-const mcp_logger_js_1 = require("./shared/mcp-logger.js");
-const widget_template_generator_js_1 = require("../utils/widget-template-generator.js");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const self_documenting_system_1 = require("../documentation/self-documenting-system");
-const cost_optimization_engine_1 = require("../optimization/cost-optimization-engine");
-const advanced_compliance_system_1 = require("../compliance/advanced-compliance-system");
-const self_healing_system_1 = require("../healing/self-healing-system");
-class ServiceNowDevelopmentAssistantMCP {
-    constructor() {
-        this.memoryIndex = new Map();
-        this.server = new index_js_1.Server({
-            name: 'servicenow-development-assistant',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.client = new servicenow_client_js_1.ServiceNowClient();
-        this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowDevelopmentAssistantMCP');
-        this.config = mcp_config_manager_js_1.mcpConfig.getMemoryConfig();
-        this.memoryPath = this.config.path || (0, path_1.join)(process.cwd(), 'memory', 'servicenow_artifacts');
-        this.setupHandlers();
-    }
-    async initializeSystems() {
-        try {
-            // Initialize systems synchronously during server startup
-            this.memorySystem = null; // Disabled memory system
-            // await this.memorySystem.initialize(); // QueenMemorySystem doesn't have initialize method
-            this.logger.info('Memory system initialized');
-            this.documentationSystem = new self_documenting_system_1.SelfDocumentingSystem(this.client, this.memorySystem);
-            this.costOptimizationEngine = new cost_optimization_engine_1.CostOptimizationEngine(this.client, this.memorySystem);
-            this.complianceSystem = new advanced_compliance_system_1.AdvancedComplianceSystem(this.client, this.memorySystem);
-            this.selfHealingSystem = new self_healing_system_1.SelfHealingSystem(this.client, this.memorySystem);
-            this.logger.info('All systems initialized successfully');
-        }
-        catch (error) {
-            this.logger.error('Failed to initialize systems:', error);
-            // Initialize minimal fallback systems
-            this.memorySystem = null; // Disabled memory system
-            // await this.memorySystem.initialize(); // QueenMemorySystem doesn't have initialize method
-        }
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'snow_find_artifact',
-                    description: 'Finds ServiceNow artifacts using natural language queries. Searches cached memory first for performance, then queries ServiceNow directly if needed.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Natural language query (e.g., "the widget that shows incidents on homepage")' },
-                            type: { type: 'string', enum: ['widget', 'flow', 'script', 'application', 'any'], description: 'Artifact type filter' },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'snow_edit_artifact',
-                    description: 'Modifies ServiceNow artifacts using natural language instructions. Includes automatic error handling, retry logic, and validation of changes.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Natural language edit instruction (e.g., "pas de flow aan met de naam approval request flow en zorg dat er na de approval stap een mailtje naar test@admin.nl wordt gestuurd")' },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'snow_get_by_sysid',
-                    description: 'Retrieves artifacts by sys_id for precise, fast lookups. Auto-detects large responses and suggests efficient field-specific queries using snow_query_table when needed. More reliable than text-based searches when sys_id is known.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sys_id: { type: 'string', description: 'System ID of the artifact' },
-                            table: { type: 'string', description: 'ServiceNow table name (e.g., sp_widget, wf_workflow, sys_script_include)' },
-                        },
-                        required: ['sys_id', 'table'],
-                    },
-                },
-                {
-                    name: 'snow_edit_by_sysid',
-                    description: 'Updates specific fields of an artifact using sys_id. Provides direct field-level modifications with validation.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sys_id: { type: 'string', description: 'System ID of the artifact to edit' },
-                            table: { type: 'string', description: 'ServiceNow table name' },
-                            field: { type: 'string', description: 'Field name to update (e.g., script, server_script, template)' },
-                            value: { type: 'string', description: 'New value for the field' },
-                        },
-                        required: ['sys_id', 'table', 'field', 'value'],
-                    },
-                },
-                {
-                    name: 'snow_analyze_artifact',
-                    description: 'Performs comprehensive analysis of artifacts including dependencies, usage patterns, and optimization opportunities. Caches results for improved performance.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            sys_id: { type: 'string', description: 'System ID of the artifact' },
-                            table: { type: 'string', description: 'ServiceNow table name' },
-                        },
-                        required: ['sys_id', 'table'],
-                    },
-                },
-                {
-                    name: 'snow_memory_search',
-                    description: 'Searches cached ServiceNow artifacts in local memory for instant results without API calls.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Search query' },
-                            type: { type: 'string', enum: ['widget', 'flow', 'script', 'application'], description: 'Artifact type' },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'snow_comprehensive_search',
-                    description: 'Searches across multiple ServiceNow tables simultaneously to find artifacts. Includes inactive records and cross-table relationships.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            query: { type: 'string', description: 'Natural language search query' },
-                            include_inactive: { type: 'boolean', description: 'Include inactive records', default: false },
-                        },
-                        required: ['query'],
-                    },
-                },
-                {
-                    name: 'snow_sync_data_consistency',
-                    description: 'Synchronizes cached data with ServiceNow, validates sys_id mappings, and repairs consistency issues. Includes automatic cache refresh and reindexing.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            operation: { type: 'string', enum: ['refresh_cache', 'validate_sysids', 'reindex_artifacts', 'full_sync'], description: 'Type of sync operation' },
-                            sys_id: { type: 'string', description: 'Specific sys_id to validate (optional)' },
-                            table: { type: 'string', description: 'Specific table to sync (optional)' },
-                        },
-                        required: ['operation'],
-                    },
-                },
-                {
-                    name: 'snow_validate_live_connection',
-                    description: 'Validates ServiceNow connection status, authentication tokens, and user permissions. Returns detailed diagnostics with response times.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            test_level: { type: 'string', enum: ['basic', 'full', 'permissions'], description: 'Level of validation (basic=ping, full=read test, permissions=write test)', default: 'basic' },
-                            include_performance: { type: 'boolean', description: 'Include response time metrics', default: false },
-                        },
-                    },
-                },
-                {
-                    name: 'batch_deployment_validator',
-                    description: 'Validates multiple artifacts before deployment. Checks dependencies, identifies conflicts, and provides remediation recommendations.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            artifacts: { type: 'array', items: { type: 'object', properties: { type: { type: 'string' }, sys_id: { type: 'string' }, table: { type: 'string' } } }, description: 'List of artifacts to validate' },
-                            validation_level: { type: 'string', enum: ['syntax', 'dependencies', 'full'], description: 'Level of validation', default: 'full' },
-                            check_conflicts: { type: 'boolean', description: 'Check for conflicts between artifacts', default: true },
-                        },
-                        required: ['artifacts'],
-                    },
-                },
-                {
-                    name: 'snow_escalate_permissions',
-                    description: 'Requests temporary elevated permissions for development operations. Manages role requirements and provides audit trail.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            required_roles: { type: 'array', items: { type: 'string' }, description: 'Required roles (admin, app_creator, system_administrator)' },
-                            duration: { type: 'string', enum: ['session', 'temporary', 'workflow'], description: 'Duration of elevation', default: 'session' },
-                            reason: { type: 'string', description: 'Reason for permission escalation' },
-                            workflow_context: { type: 'string', description: 'Context of the development workflow requiring elevation' },
-                        },
-                        required: ['required_roles', 'reason'],
-                    },
-                },
-                {
-                    name: 'snow_analyze_requirements',
-                    description: 'Analyzes development requirements to identify dependencies, suggest reusable components, and create implementation roadmaps.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            objective: { type: 'string', description: 'Development objective (e.g., "iPhone provisioning for new users")' },
-                            auto_discover_dependencies: { type: 'boolean', description: 'Automatically discover required dependencies', default: true },
-                            suggest_existing_components: { type: 'boolean', description: 'Suggest reuse of existing components', default: true },
-                            create_dependency_map: { type: 'boolean', description: 'Create visual dependency map', default: true },
-                            scope_preference: { type: 'string', enum: ['global', 'scoped', 'auto'], description: 'Deployment scope preference', default: 'auto' },
-                        },
-                        required: ['objective'],
-                    },
-                },
-                {
-                    name: 'snow_orchestrate_development',
-                    description: 'Orchestrates complex development workflows with intelligent agent coordination, shared memory, and real-time progress tracking.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            objective: { type: 'string', description: 'Development objective (e.g., "iPhone provisioning workflow")' },
-                            auto_spawn_agents: { type: 'boolean', description: 'Automatically spawn required agents', default: true },
-                            shared_memory: { type: 'boolean', description: 'Enable shared memory between agents', default: true },
-                            parallel_execution: { type: 'boolean', description: 'Enable parallel execution', default: true },
-                            progress_monitoring: { type: 'boolean', description: 'Real-time progress monitoring', default: true },
-                            auto_permissions: { type: 'boolean', description: 'Automatic permission escalation', default: false },
-                            smart_discovery: { type: 'boolean', description: 'Smart artifact discovery and reuse', default: true },
-                            live_testing: { type: 'boolean', description: 'Enable live testing during development', default: true },
-                            auto_deploy: { type: 'boolean', description: 'Automatic deployment when ready', default: false },
-                        },
-                        required: ['objective'],
-                    },
-                },
-            ],
-        }));
-        // Register tool handlers
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                // Start operation with token tracking
-                this.logger.operationStart(name, args);
-                // Authenticate if needed
-                const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-                if (!authResult.success) {
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, authResult.error || 'Authentication required');
-                }
-                let result;
-                switch (name) {
-                    case 'snow_find_artifact':
-                        result = await this.findArtifact(args);
-                        break;
-                    case 'snow_edit_artifact':
-                        result = await this.editArtifact(args);
-                        break;
-                    case 'snow_get_by_sysid':
-                        result = await this.getBySysId(args);
-                        break;
-                    case 'snow_edit_by_sysid':
-                        result = await this.editBySysId(args);
-                        break;
-                    case 'snow_analyze_artifact':
-                        result = await this.analyzeArtifact(args);
-                        break;
-                    case 'snow_memory_search':
-                        result = await this.searchMemory(args);
-                        break;
-                    case 'snow_comprehensive_search':
-                        result = await this.comprehensiveSearch(args);
-                        break;
-                    case 'snow_sync_data_consistency':
-                        result = await this.syncDataConsistency(args);
-                        break;
-                    case 'snow_validate_live_connection':
-                        result = await this.validateLiveConnection(args);
-                        break;
-                    case 'batch_deployment_validator':
-                        result = await this.batchDeploymentValidator(args);
-                        break;
-                    case 'snow_escalate_permissions':
-                        result = await this.escalatePermissions(args);
-                        break;
-                    case 'snow_analyze_requirements':
-                        result = await this.analyzeRequirements(args);
-                        break;
-                    case 'snow_orchestrate_development':
-                        result = await this.orchestrateDevelopment(args);
-                        break;
-                    case 'snow_verify_artifact_searchable':
-                        result = await this.verifyArtifactSearchable(args);
-                        break;
-                    case 'snow_generate_documentation':
-                        result = await this.generateDocumentation(args);
-                        break;
-                    case 'snow_documentation_suggestions':
-                        result = await this.getDocumentationSuggestions(args);
-                        break;
-                    case 'snow_start_continuous_documentation':
-                        result = await this.startContinuousDocumentation(args);
-                        break;
-                    case 'snow_analyze_costs':
-                        const costRequest = {
-                            scope: args.scope || 'all',
-                            auto_implement: args.auto_implement || false,
-                            target_reduction: args.target_reduction,
-                            testing_enabled: args.testing_enabled !== false
-                        };
-                        const costResult = await this.costOptimizationEngine.analyzeCosts(costRequest);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(costResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_cost_dashboard':
-                        const dashboardResult = await this.costOptimizationEngine.getCostDashboard();
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(dashboardResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_start_autonomous_cost_optimization':
-                        const startResult = await this.costOptimizationEngine.startAutonomousOptimization(args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(startResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_implement_cost_optimization':
-                        const implementResult = await this.costOptimizationEngine.implementOptimization(String(args.optimization_id));
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(implementResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_assess_compliance':
-                        const complianceResult = await this.complianceSystem.assessCompliance(args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(complianceResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_compliance_dashboard':
-                        const complianceDashboard = await this.complianceSystem.getComplianceDashboard();
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(complianceDashboard, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_start_compliance_monitoring':
-                        const monitoringResult = await this.complianceSystem.startContinuousMonitoring(args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: '✅ Compliance monitoring started successfully'
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_execute_corrective_action':
-                        const actionResult = await this.complianceSystem.executeCorrectiveAction(String(args.action_id), args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(actionResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_health_check':
-                        const healthResult = await this.selfHealingSystem.performHealthCheck(args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(healthResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_health_dashboard':
-                        const healthDashboard = await this.selfHealingSystem.getHealthDashboard();
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(healthDashboard, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_start_autonomous_healing':
-                        const healingStartResult = await this.selfHealingSystem.startAutonomousHealing(args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: '✅ Autonomous healing started successfully'
-                                }
-                            ]
-                        };
-                        break;
-                    case 'snow_execute_healing_action':
-                        const healingResult = await this.selfHealingSystem.executeHealingAction(String(args.action_id), args);
-                        result = {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify(healingResult, null, 2)
-                                }
-                            ]
-                        };
-                        break;
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-                // Complete operation with token tracking
-                result = this.logger.addTokenUsageToResponse(result);
-                result = this.logger.addTokenUsageToResponse(result);
-                this.logger.operationComplete(name, result);
-                return result;
-            }
-            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 findArtifact(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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('🔴 SNOW-002 FIX: Finding ServiceNow artifact with retry logic', { query: args.query });
-            // 1. Parse natural language intent
-            const intent = await this.parseIntent(args.query);
-            // 2. Search in memory first
-            const memoryResults = await this.searchInMemory(intent);
-            if (memoryResults.length > 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `🧠 Found in memory:\n\n${this.formatResults(memoryResults)}\n\n💡 Using cached intelligent index for optimal performance.`,
-                        },
-                    ],
-                };
-            }
-            // 🔴 CRITICAL FIX: Search ServiceNow with retry logic for newly created artifacts
-            this.logger.info(`🔍 Searching ServiceNow with retry logic for: ${intent.identifier} (type: ${intent.artifactType})`);
-            const liveResults = await this.searchServiceNowWithRetry(intent);
-            this.logger.info(`✅ ServiceNow search with retry returned ${liveResults?.length || 0} results`);
-            // Debug log
-            if (liveResults && liveResults.length > 0) {
-                this.logger.info(`First result: ${JSON.stringify(liveResults[0])}`);
-            }
-            // 4. Index results for future use (only if we have results)
-            // Skip indexing - causes timeouts
-            /*
-            if (liveResults && liveResults.length > 0) {
-              this.logger.info('Indexing found artifacts for future use...');
-              for (const result of liveResults) {
-                await this.intelligentlyIndex(result);
-              }
-            }
-            */
-            const instanceInfo = await mcp_auth_middleware_js_1.mcpAuth.getInstanceInfo();
-            const resultText = this.formatResults(liveResults);
-            this.logger.info(`Formatted result text: ${resultText.substring(0, 200)}...`);
-            const editSuggestion = this.generateEditSuggestion(liveResults?.[0]);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🔍 ServiceNow Search Results:\n\n${resultText}\n\n🔗 ServiceNow Instance: ${instanceInfo.instance}\n\n${editSuggestion}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Artifact search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async editArtifact(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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('Editing ServiceNow artifact', { query: args.query });
-            // 1. Parse edit instruction
-            const editIntent = await this.parseEditIntent(args.query);
-            // 2. Find target artifact
-            const artifact = await this.findTargetArtifact(editIntent);
-            // 3. Analyze modification requirements
-            const modification = await this.analyzeModification(editIntent, artifact);
-            // 4. Apply intelligent modification
-            const editedArtifact = await this.applyModification(artifact, modification);
-            // 5. Deploy back to ServiceNow
-            const deployResult = await this.deployArtifact(editedArtifact);
-            // 6. Update memory with changes
-            await this.updateMemoryIndex(editedArtifact, modification);
-            const instanceInfo = await mcp_auth_middleware_js_1.mcpAuth.getInstanceInfo();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ ServiceNow artifact successfully modified!\n\n🎯 Modification Details:\n- Artifact: ${artifact.name}\n- Type: ${artifact.type}\n- Changes: ${modification.description}\n\n🔗 View in ServiceNow: ${instanceInfo.instance}/nav_to.do?uri=${this.getArtifactUrl(artifact)}\n\n📝 The artifact has been intelligently indexed and is now available for future natural language queries.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Artifact editing failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async analyzeArtifact(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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 ServiceNow artifact', { sys_id: args.sys_id });
-            // Fetch complete artifact from ServiceNow
-            this.logger.trackAPICall('GET', args.table, 1);
-            const artifact = await this.client.getRecord(args.table, args.sys_id);
-            // Skip indexing - causes timeouts
-            /*
-            // Perform intelligent indexing
-            const indexedArtifact = await this.intelligentlyIndex(artifact);
-            
-            // Store in memory
-            await this.storeInMemory(indexedArtifact);
-            */
-            // Create minimal indexed artifact for response
-            const indexedArtifact = {
-                meta: {
-                    sys_id: artifact.sys_id,
-                    name: artifact.name || artifact.title || 'Unknown',
-                    type: artifact.sys_class_name || 'unknown',
-                },
-                claudeSummary: `${artifact.name || artifact.title} is a ${artifact.sys_class_name || 'artifact'} in ServiceNow.`,
-                structure: {},
-                context: {},
-                relationships: [],
-                modificationPoints: []
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🧠 Artifact Analysis Complete!\n\n📋 Summary:\n${indexedArtifact.claudeSummary}\n\n🏗️ Structure:\n${JSON.stringify(indexedArtifact.structure, null, 2)}\n\n🎯 Modification Points:\n${indexedArtifact.modificationPoints.map(p => `- ${p.description}`).join('\n')}\n\n💾 Artifact has been intelligently indexed and stored in memory for future natural language interactions.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Artifact _analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async searchMemory(args) {
-        try {
-            const results = await this.searchInMemory({
-                identifier: args.query,
-                artifactType: args.type || 'any',
-                action: 'find',
-                confidence: 0.8
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🧠 Memory Search Results:\n\n${this.formatMemoryResults(results)}\n\n💡 All results are from the intelligent index for instant access.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Memory search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async comprehensiveSearch(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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 comprehensive search', { query: args.query });
-            // Define tables to search with their descriptions
-            const searchTables = [
-                { name: 'sys_script', desc: 'Business Rules', type: 'business_rule' },
-                { name: 'sys_script_include', desc: 'Script Includes', type: 'script_include' },
-                { name: 'sys_script_client', desc: 'Client Scripts', type: 'client_script' },
-                { name: 'sys_ui_script', desc: 'UI Scripts', type: 'ui_script' },
-                { name: 'sp_widget', desc: 'Service Portal Widgets', type: 'widget' },
-                { name: 'sys_hub_flow', desc: 'Flow Designer Flows', type: 'flow' },
-                { name: 'wf_workflow', desc: 'Workflows', type: 'workflow' },
-                { name: 'sys_ui_action', desc: 'UI Actions', type: 'ui_action' },
-                { name: 'sys_ui_policy', desc: 'UI Policies', type: 'ui_policy' },
-                { name: 'sys_data_policy', desc: 'Data Policies', type: 'data_policy' },
-                { name: 'sys_app_application', desc: 'Applications', type: 'application' },
-                { name: 'sys_db_object', desc: 'Tables', type: 'table' },
-                { name: 'sys_dictionary', desc: 'Dictionary/Fields', type: 'field' },
-                { name: 'sysevent_email_action', desc: 'Notifications', type: 'notification' },
-                { name: 'sys_transform_map', desc: 'Transform Maps', type: 'transform_map' },
-                { name: 'sys_ws_definition', desc: 'REST APIs', type: 'rest_api' },
-                { name: 'sc_cat_item', desc: 'Catalog Items', type: 'catalog_item' },
-                { name: 'sc_catalog', desc: 'Service Catalogs', type: 'catalog' },
-                { name: 'sc_category', desc: 'Catalog Categories', type: 'catalog_category' },
-                { name: 'item_option_new', desc: 'Catalog Variables', type: 'catalog_variable' },
-            ];
-            const searchString = args.query.trim();
-            const allResults = [];
-            // Generate multiple search strategies like Claude Code did
-            const searchStrategies = [
-                { query: `name=${searchString}`, desc: 'Exact name match' },
-                { query: `nameLIKE${searchString}`, desc: 'Name contains' },
-                { query: `short_descriptionLIKE${searchString}`, desc: 'Description contains' },
-                { query: `nameLIKE${searchString}^ORshort_descriptionLIKE${searchString}`, desc: 'Name or description' },
-            ];
-            // Add wildcard searches if multiple words
-            const words = searchString.split(' ').filter((w) => w.length > 2);
-            if (words.length > 1) {
-                const firstWord = words[0];
-                const lastWord = words[words.length - 1];
-                searchStrategies.push({
-                    query: `nameLIKE*${firstWord}*${lastWord}*`,
-                    desc: 'First and last word match'
-                });
-            }
-            // 🔴 SNOW-002 FIX: Apply retry logic to comprehensive search as well
-            for (const table of searchTables) {
-                this.logger.info(`🔴 SNOW-002 FIX: Searching ${table.desc} (${table.name}) with retry logic...`);
-                // Try search with retry logic for each table
-                const tableResults = [];
-                const maxTableRetries = 3; // Shorter retry for comprehensive search
-                for (let attempt = 1; attempt <= maxTableRetries; attempt++) {
-                    let foundResults = false;
-                    for (const strategy of searchStrategies) {
-                        try {
-                            const activeFilter = args.include_inactive ? '' : '^active=true';
-                            const fullQuery = `${strategy.query}${activeFilter}^LIMIT5`;
-                            const results = await this.client.searchRecords(table.name, fullQuery);
-                            if (results && results.success && results.data.result.length > 0) {
-                                // Add metadata to results
-                                const enhancedResults = results.data.result.map((result) => ({
-                                    ...result,
-                                    artifact_type: table.type,
-                                    table_name: table.name,
-                                    table_description: table.desc,
-                                    search_strategy: strategy.desc,
-                                    retry_attempt: attempt
-                                }));
-                                tableResults.push(...enhancedResults);
-                                foundResults = true;
-                                // Stop searching this table if we found results
-                                break;
-                            }
-                        }
-                        catch (error) {
-                            this.logger.warn(`Error searching ${table.name} (attempt ${attempt}):`, error);
-                        }
-                    }
-                    // If we found results, stop retrying this table
-                    if (foundResults) {
-                        break;
-                    }
-                    // If no results and not the last attempt, wait before retry
-                    if (attempt < maxTableRetries) {
-                        const delay = 800 * attempt; // Shorter delays: 800ms, 1600ms
-                        this.logger.info(`🔄 No results for ${table.name}, waiting ${delay}ms before retry...`);
-                        await this.sleep(delay);
-                    }
-                }
-                // Add any results found for this table
-                allResults.push(...tableResults);
-            }
-            // Remove duplicates by sys_id
-            const uniqueResults = allResults.filter((result, index, self) => index === self.findIndex(r => r.sys_id === result.sys_id));
-            const instanceInfo = await mcp_auth_middleware_js_1.mcpAuth.getInstanceInfo();
-            const resultText = this.formatComprehensiveResults(uniqueResults);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🔍 Comprehensive ServiceNow Search Results:\n\n${resultText}\n\n🔗 ServiceNow Instance: ${instanceInfo.instance}\n\n💡 Searched across ${searchTables.length} table types with multiple strategies.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            throw new Error(`Comprehensive search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async parseIntent(query) {
-        // Enhanced intent parsing with comprehensive type detection
-        const lowercaseQuery = query.toLowerCase();
-        let artifactType = 'any'; // Default to searching all types
-        // Check for specific artifact types (order matters - most specific first)
-        // Service Portal
-        if (lowercaseQuery.includes('widget'))
-            artifactType = 'widget';
-        else if (lowercaseQuery.includes('portal'))
-            artifactType = 'portal';
-        else if (lowercaseQuery.includes('page') && lowercaseQuery.includes('service'))
-            artifactType = 'page';
-        else if (lowercaseQuery.includes('theme'))
-            artifactType = 'theme';
-        // Flow Designer & Workflow
-        else if (lowercaseQuery.includes('flow designer') || lowercaseQuery.includes('sys_hub_flow'))
-            artifactType = 'flow';
-        else if (lowercaseQuery.includes('workflow') && !lowercaseQuery.includes('orchestration'))
-            artifactType = 'workflow';
-        else if (lowercaseQuery.includes('workflow activity'))
-            artifactType = 'workflow_activity';
-        else if (lowercaseQuery.includes('flow'))
-            artifactType = 'flow';
-        // Scripts & Automation (most specific first)
-        else if (lowercaseQuery.includes('script include'))
-            artifactType = 'script_include';
-        else if (lowercaseQuery.includes('business rule'))
-            artifactType = 'business_rule';
-        else if (lowercaseQuery.includes('client script'))
-            artifactType = 'client_script';
-        else if (lowercaseQuery.includes('ui script'))
-            artifactType = 'ui_script';
-        else if (lowercaseQuery.includes('ui action'))
-            artifactType = 'ui_action';
-        else if (lowercaseQuery.includes('ui policy action'))
-            artifactType = 'ui_policy_action';
-        else if (lowercaseQuery.includes('ui policy'))
-            artifactType = 'ui_policy';
-        else if (lowercaseQuery.includes('data policy rule'))
-            artifactType = 'data_policy_rule';
-        else if (lowercaseQuery.includes('data policy'))
-            artifactType = 'data_policy';
-        // Applications
-        else if (lowercaseQuery.includes('scoped app'))
-            artifactType = 'scoped_app';
-        else if (lowercaseQuery.includes('application') || lowercaseQuery.includes('app'))
-            artifactType = 'application';
-        // Tables & Fields
-        else if (lowercaseQuery.includes('field') || lowercaseQuery.includes('dictionary'))
-            artifactType = 'field';
-        else if (lowercaseQuery.includes('table'))
-            artifactType = 'table';
-        // Forms & UI
-        else if (lowercaseQuery.includes('form section'))
-            artifactType = 'form_section';
-        else if (lowercaseQuery.includes('list control'))
-            artifactType = 'list_control';
-        else if (lowercaseQuery.includes('related list'))
-            artifactType = 'related_list';
-        else if (lowercaseQuery.includes('form'))
-            artifactType = 'form';
-        else if (lowercaseQuery.includes('list'))
-            artifactType = 'list';
-        else if (lowercaseQuery.includes('view'))
-            artifactType = 'view';
-        else if (lowercaseQuery.includes('formatter'))
-            artifactType = 'formatter';
-        // Reports & Dashboards
-        else if (lowercaseQuery.includes('pa dashboard'))
-            artifactType = 'pa_dashboard';
-        else if (lowercaseQuery.includes('pa widget'))
-            artifactType = 'pa_widget';
-        else if (lowercaseQuery.includes('dashboard'))
-            artifactType = 'dashboard';
-        else if (lowercaseQuery.includes('report'))
-            artifactType = 'report';
-        else if (lowercaseQuery.includes('gauge'))
-            artifactType = 'gauge';
-        else if (lowercaseQuery.includes('chart'))
-            artifactType = 'chart';
-        else if (lowercaseQuery.includes('indicator'))
-            artifactType = 'indicator';
-        // Security & Access Control
-        else if (lowercaseQuery.includes('acl') || lowercaseQuery.includes('access control'))
-            artifactType = 'acl';
-        else if (lowercaseQuery.includes('role'))
-            artifactType = 'role';
-        else if (lowercaseQuery.includes('group'))
-            artifactType = 'group';
-        // Notifications & Communication
-        else if (lowercaseQuery.includes('email template'))
-            artifactType = 'email_template';
-        else if (lowercaseQuery.includes('notification'))
-            artifactType = 'notification';
-        // Import & Export
-        else if (lowercaseQuery.includes('import set'))
-            artifactType = 'import_set';
-        else if (lowercaseQuery.includes('transform map'))
-            artifactType = 'transform_map';
-        // Web Services
-        else if (lowercaseQuery.includes('rest api') || lowercaseQuery.includes('rest'))
-            artifactType = 'rest_api';
-        else if (lowercaseQuery.includes('soap api') || lowercaseQuery.includes('soap'))
-            artifactType = 'soap_api';
-        // Scheduled Jobs
-        else if (lowercaseQuery.includes('scheduled job'))
-            artifactType = 'scheduled_job';
-        else if (lowercaseQuery.includes('scheduled import'))
-            artifactType = 'scheduled_import';
-        // Knowledge Management
-        else if (lowercaseQuery.includes('knowledge base'))
-            artifactType = 'knowledge_base';
-        else if (lowercaseQuery.includes('knowledge article') || lowercaseQuery.includes('knowledge'))
-            artifactType = 'knowledge_article';
-        // System Administration
-        else if (lowercaseQuery.includes('system property') || lowercaseQuery.includes('property'))
-            artifactType = 'property';
-        // Mobile
-        else if (lowercaseQuery.includes('mobile app') || lowercaseQuery.includes('mobile'))
-            artifactType = 'mobile_app';
-        // Catalog
-        else if (lowercaseQuery.includes('catalog item'))
-            artifactType = 'catalog_item';
-        else if (lowercaseQuery.includes('catalog variable'))
-            artifactType = 'catalog_variable';
-        else if (lowercaseQuery.includes('catalog'))
-            artifactType = 'catalog';
-        // SLA & Metrics
-        else if (lowercaseQuery.includes('sla'))
-            artifactType = 'sla';
-        else if (lowercaseQuery.includes('metric'))
-            artifactType = 'metric';
-        // Other common types
-        else if (lowercaseQuery.includes('attachment'))
-            artifactType = 'attachment';
-        else if (lowercaseQuery.includes('language'))
-            artifactType = 'language';
-        else if (lowercaseQuery.includes('translation'))
-            artifactType = 'translated_text';
-        else if (lowercaseQuery.includes('processor'))
-            artifactType = 'processor';
-        else if (lowercaseQuery.includes('update set'))
-            artifactType = 'update_set';
-        else if (lowercaseQuery.includes('ml model') || lowercaseQuery.includes('machine learning'))
-            artifactType = 'ml_model';
-        else if (lowercaseQuery.includes('spoke'))
-            artifactType = 'spoke';
-        else if (lowercaseQuery.includes('connection'))
-            artifactType = 'connection';
-        else if (lowercaseQuery.includes('virtual agent') || lowercaseQuery.includes('chatbot'))
-            artifactType = 'virtual_agent';
-        else if (lowercaseQuery.includes('event rule'))
-            artifactType = 'event_rule';
-        else if (lowercaseQuery.includes('alert'))
-            artifactType = 'alert';
-        else if (lowercaseQuery.includes('discovery'))
-            artifactType = 'discovery_schedule';
-        else if (lowercaseQuery.includes('ci class'))
-            artifactType = 'ci_class';
-        else if (lowercaseQuery.includes('relationship'))
-            artifactType = 'relationship_type';
-        else if (lowercaseQuery.includes('service map'))
-            artifactType = 'service_map';
-        else if (lowercaseQuery.includes('orchestration workflow'))
-            artifactType = 'orchestration_workflow';
-        else if (lowercaseQuery.includes('pipeline'))
-            artifactType = 'pipeline';
-        else if (lowercaseQuery.includes('deployment'))
-            artifactType = 'deployment';
-        // Generic fallbacks
-        else if (lowercaseQuery.includes('script'))
-            artifactType = 'script_include';
-        // Smart identifier extraction - remove artifact type keywords and get the actual name
-        const identifier = this.extractIdentifier(query, artifactType);
-        return {
-            action: 'find',
-            artifactType,
-            identifier,
-            confidence: 0.9,
-        };
-    }
-    extractIdentifier(query, artifactType) {
-        // Smart extraction of actual artifact name by removing type keywords
-        let identifier = query.toLowerCase().trim();
-        // Remove common artifact type keywords
-        const typeKeywords = [
-            'widget', 'portal', 'page', 'theme',
-            'flow designer', 'sys_hub_flow', 'workflow', 'workflow activity', 'flow',
-            'script include', 'business rule', 'client script', 'ui script', 'ui action',
-            'ui policy action', 'ui policy', 'data policy rule', 'data policy',
-            'scoped app', 'application', 'app',
-            'field', 'dictionary', 'table',
-            'form section', 'list control', 'related list', 'form', 'list', 'view', 'formatter',
-            'pa dashboard', 'report', 'dashboard', 'gauge', 'indicator',
-            'sla', 'metric', 'attachment', 'language', 'translation', 'processor',
-            'update set', 'ml model', 'machine learning', 'spoke', 'connection',
-            'virtual agent', 'chatbot', 'event rule', 'alert', 'discovery',
-            'ci class', 'relationship', 'service map', 'orchestration workflow',
-            'pipeline', 'deployment', 'script'
-        ];
-        // Remove type keywords and common words
-        const wordsToRemove = [
-            ...typeKeywords,
-            'the', 'a', 'an', 'with', 'that', 'shows', 'displays', 'for', 'on', 'in',
-            'servicenow', 'snow', 'sys_id:', 'system', 'id'
-        ];
-        // Remove sys_id if present (extract it separately)
-        const sysIdMatch = identifier.match(/sys_id:\s*([a-f0-9]{32})/);
-        if (sysIdMatch) {
-            // If we have a sys_id, prioritize that
-            return sysIdMatch[1];
-        }
-        // Remove words to clean up the identifier
-        for (const word of wordsToRemove) {
-            const regex = new RegExp(`\\b${word}\\b`, 'gi');
-            identifier = identifier.replace(regex, ' ');
-        }
-        // Clean up whitespace and return
-        identifier = identifier.replace(/\s+/g, ' ').trim();
-        // If identifier is empty or too short, return original query
-        if (!identifier || identifier.length < 2) {
-            return query.trim();
-        }
-        return identifier;
-    }
-    async parseEditIntent(query) {
-        // Parse edit instructions - would be more sophisticated in real implementation
-        const intent = await this.parseIntent(query);
-        return {
-            ...intent,
-            action: 'edit',
-            modification: query,
-        };
-    }
-    /**
-     * 🔴 CRITICAL FIX SNOW-002: Search ServiceNow with retry logic for newly created artifacts
-     * Addresses: "I created a flow but search says it doesn't exist"
-     * Root Cause: ServiceNow search indexes take time to update after artifact creation
-     */
-    async searchServiceNowWithRetry(intent) {
-        const maxRetries = 5;
-        const baseDelay = 1500; // Start with 1.5 seconds
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                this.logger.info(`🔍 Search attempt ${attempt}/${maxRetries} for: ${intent.identifier}`);
-                // Try the regular search
-                const results = await this.searchServiceNow(intent);
-                if (results && results.length > 0) {
-                    this.logger.info(`✅ Found ${results.length} results on attempt ${attempt}`);
-                    return results;
-                }
-                // If no results and not the last attempt, wait and retry
-                if (attempt < maxRetries) {
-                    const delay = baseDelay * attempt; // 1.5s, 3s, 4.5s, 6s, 7.5s
-                    this.logger.info(`🔄 No results found, waiting ${delay}ms before retry (ServiceNow indexes may be updating...)`);
-                    await this.sleep(delay);
-                    // 🔴 CRITICAL: Try cache invalidation on ServiceNow side
-                    if (attempt === 2) {
-                        this.logger.info('🔄 Attempting ServiceNow cache refresh...');
-                        await this.attemptCacheRefresh(intent);
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Search attempt ${attempt} failed:`, error);
-                // If this is the last attempt, throw the error
-                if (attempt === maxRetries) {
-                    throw error;
-                }
-                // Otherwise wait and retry
-                const delay = baseDelay * attempt;
-                this.logger.info(`⏳ Waiting ${delay}ms before retry due to error`);
-                await this.sleep(delay);
-            }
-        }
-        // 🔴 CRITICAL: If all retries failed, try broad fallback search
-        this.logger.warn('🚨 All retry attempts failed, trying broad fallback search...');
-        return await this.broadFallbackSearch(intent);
-    }
-    /**
-     * 🔴 SNOW-002 FIX: Attempt to refresh ServiceNow caches
-     */
-    async attemptCacheRefresh(intent) {
-        try {
-            const tableMapping = {
-                widget: 'sp_widget',
-                flow: 'sys_hub_flow',
-                script: 'sys_script_include',
-                application: 'sys_app_application'
-            };
-            const table = tableMapping[intent.artifactType] || 'sys_hub_flow';
-            // Try a simple count query to potentially refresh indexes
-            await this.client.searchRecords(table, 'sys_id!=null^LIMIT1');
-            this.logger.info('✨ Cache refresh attempt completed');
-        }
-        catch (error) {
-            this.logger.warn('Cache refresh attempt failed:', error);
-        }
-    }
-    /**
-     * 🔴 SNOW-002 FIX: Broad fallback search when all retries fail
-     */
-    async broadFallbackSearch(intent) {
-        this.logger.info('🔍 Attempting broad fallback search across multiple tables...');
-        try {
-            // Search across multiple related tables
-            const broadResults = [];
-            const searchTerm = intent.identifier.trim();
-            // Define broader table search for common artifacts
-            const fallbackTables = [
-                'sys_hub_flow', 'sp_widget', 'sys_script_include',
-                'sys_script', 'sys_app_application', 'wf_workflow'
-            ];
-            for (const table of fallbackTables) {
-                try {
-                    // Try multiple search strategies
-                    const strategies = [
-                        `nameLIKE*${searchTerm}*^LIMIT3`,
-                        `titleLIKE*${searchTerm}*^LIMIT3`,
-                        `short_descriptionLIKE*${searchTerm}*^LIMIT3`
-                    ];
-                    for (const query of strategies) {
-                        const results = await this.client.searchRecords(table, query);
-                        if (results && results.success && results.data.result.length > 0) {
-                            const typedResults = results.data.result.map((result) => ({
-                                ...result,
-                                table_name: table,
-                                search_fallback: true
-                            }));
-                            broadResults.push(...typedResults);
-                        }
-                    }
-                }
-                catch (error) {
-                    this.logger.warn(`Fallback search failed for ${table}:`, error);
-                }
-            }
-            // Remove duplicates and return
-            const uniqueResults = broadResults.filter((result, index, self) => index === self.findIndex(r => r.sys_id === result.sys_id));
-            this.logger.info(`🔍 Fallback search found ${uniqueResults.length} results`);
-            return uniqueResults;
-        }
-        catch (error) {
-            this.logger.error('Broad fallback search failed:', error);
-            return [];
-        }
-    }
-    /**
-     * 🔴 SNOW-002 FIX: Special search method for newly created artifacts
-     * Use this immediately after creating an artifact to verify it's searchable
-     */
-    async searchForRecentlyCreatedArtifact(artifactName, artifactType, expectedSysId) {
-        this.logger.info(`🔍 SNOW-002: Searching for recently created artifact: ${artifactName} (${artifactType})`);
-        const intent = {
-            identifier: artifactName,
-            artifactType: artifactType,
-            action: 'find',
-            confidence: 0.9
-        };
-        // First try the sys_id lookup if we have it (most reliable)
-        if (expectedSysId) {
-            try {
-                this.logger.info(`🎯 Trying direct sys_id lookup: ${expectedSysId}`);
-                const tableMapping = {
-                    widget: 'sp_widget',
-                    flow: 'sys_hub_flow',
-                    script: 'sys_script_include',
-                    application: 'sys_app_application'
-                };
-                const table = tableMapping[artifactType] || 'sys_hub_flow';
-                const directResult = await this.client.searchRecords(table, `sys_id=${expectedSysId}`);
-                if (directResult && directResult.success && directResult.data.result.length > 0) {
-                    this.logger.info(`✅ Found via direct sys_id lookup`);
-                    return directResult.data.result;
-                }
-            }
-            catch (error) {
-                this.logger.warn('Direct sys_id lookup failed:', error);
-            }
-        }
-        // Fall back to name-based search with extended retry logic
-        const maxRetries = 7; // More retries for newly created artifacts
-        const baseDelay = 2000; // Longer initial delay (2 seconds)
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                this.logger.info(`🔍 Post-creation search attempt ${attempt}/${maxRetries}`);
-                const results = await this.searchServiceNow(intent);
-                if (results && results.length > 0) {
-                    this.logger.info(`✅ SNOW-002 RESOLVED: Found ${results.length} results for newly created artifact on attempt ${attempt}`);
-                    return results;
-                }
-                if (attempt < maxRetries) {
-                    // Progressive delay with jitter: 2s, 4s, 6s, 8s, 10s, 12s, 14s
-                    const delay = baseDelay * attempt;
-                    this.logger.info(`🔄 Artifact not yet searchable, waiting ${delay}ms (ServiceNow indexes updating...)`);
-                    await this.sleep(delay);
-                    // Try cache refresh on every other attempt
-                    if (attempt % 2 === 0) {
-                        await this.attemptCacheRefresh(intent);
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Post-creation search attempt ${attempt} failed:`, error);
-                if (attempt < maxRetries) {
-                    const delay = baseDelay * attempt;
-                    await this.sleep(delay);
-                }
-            }
-        }
-        this.logger.warn('🚨 SNOW-002: Recently created artifact still not searchable after all retries');
-        return [];
-    }
-    /**
-     * Sleep utility for retry delays
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async searchServiceNow(intent) {
-        try {
-            const tableMapping = {
-                // Service Portal
-                widget: 'sp_widget',
-                portal: 'sp_portal',
-                page: 'sp_page',
-                theme: 'sp_theme',
-                // Flow Designer & Workflow
-                flow: 'sys_hub_flow',
-                workflow: 'wf_workflow',
-                workflow_activity: 'wf_activity',
-                // Scripts & Automation
-                script_include: 'sys_script_include',
-                script: 'sys_script_include',
-                business_rule: 'sys_script',
-                client_script: 'sys_script_client',
-                ui_script: 'sys_ui_script',
-                ui_action: 'sys_ui_action',
-                ui_policy: 'sys_ui_policy',
-                ui_policy_action: 'sys_ui_policy_action',
-                data_policy: 'sys_data_policy',
-                data_policy_rule: 'sys_data_policy_rule',
-                // Applications & Scoped Apps
-                application: 'sys_app_application',
-                app: 'sys_app_application',
-                scoped_app: 'sys_app',
-                // Tables & Fields
-                table: 'sys_db_object',
-                field: 'sys_dictionary',
-                dictionary: 'sys_dictionary',
-                // Forms & UI
-                form: 'sys_form',
-                form_section: 'sys_form_section',
-                list: 'sys_list',
-                list_control: 'sys_list_control',
-                view: 'sys_ui_view',
-                related_list: 'sys_ui_related_list',
-                formatter: 'sys_ui_formatter',
-                // Reports & Dashboards
-                report: 'sys_report',
-                dashboard: 'sys_dashboard',
-                gauge: 'pa_dashboards',
-                chart: 'sys_chart',
-                // Security & Access Control
-                acl: 'sys_security_acl',
-                role: 'sys_user_role',
-                group: 'sys_user_group',
-                // Notifications & Communication
-                notification: 'sysevent_email_action',
-                email_template: 'sysevent_email_template',
-                // Import & Export
-                import_set: 'sys_import_set',
-                transform_map: 'sys_transform_map',
-                // Web Services
-                rest_api: 'sys_ws_definition',
-                soap_api: 'sys_web_service',
-                // Scheduled Jobs
-                scheduled_job: 'sysauto_script',
-                scheduled_import: 'scheduled_import_set',
-                // Knowledge Management
-                knowledge_base: 'kb_knowledge_base',
-                knowledge_article: 'kb_knowledge',
-                // System Administration
-                property: 'sys_properties',
-                system_property: 'sys_properties',
-                // Mobile
-                mobile_app: 'sys_mobile_application',
-                // Catalog
-                catalog: 'sc_catalog',
-                catalog_item: 'sc_cat_item',
-                catalog_variable: 'item_option_new',
-                // SLA & Metrics
-                sla: 'contract_sla',
-                metric: 'sys_report_color',
-                // Attachments & Files
-                attachment: 'sys_attachment',
-                // Languages & Translations
-                language: 'sys_language',
-                translated_text: 'sys_translated',
-                // Processors & Servlets
-                processor: 'sys_processor',
-                // Update Sets & Deployment
-                update_set: 'sys_update_set',
-                // AI & ML
-                ml_model: 'ml_model',
-                // Integration Hub
-                spoke: 'sys_hub_action_type',
-                connection: 'sys_connection',
-                // Virtual Agent
-                virtual_agent: 'sys_cs_topic',
-                chatbot: 'sys_cs_topic',
-                // Performance Analytics
-                pa_dashboard: 'pa_dashboards',
-                pa_widget: 'pa_widgets',
-                indicator: 'pa_indicators',
-                // Event Management
-                event_rule: 'em_event_rule',
-                alert: 'em_alert',
-                // Discovery
-                discovery_schedule: 'discovery_schedule',
-                // CMDB
-                ci_class: 'sys_db_object',
-                relationship_type: 'cmdb_rel_type',
-                // Service Mapping
-                service_map: 'sa_pattern',
-                // Orchestration
-                orchestration_workflow: 'sc_ic_workflow',
-                // DevOps
-                pipeline: 'cicd_pipeline',
-                deployment: 'cicd_deployment',
-            };
-            // If searching for 'any' type, search only the most common tables
-            if (intent.artifactType === 'any') {
-                this.logger.info('Searching common artifact types...');
-                const allResults = [];
-                // Handle "list all" queries for any type
-                const searchString = intent.identifier.trim();
-                if (searchString.toLowerCase().includes('list all') ||
-                    searchString.toLowerCase().includes('all artifacts') ||
-                    searchString.toLowerCase().includes('show all') ||
-                    searchString === '') {
-                    this.logger.info('Fetching all common artifact types');
-                    // Define most common tables to list when showing all
-                    const commonTables = {
-                        widget: 'sp_widget',
-                        business_rule: 'sys_script',
-                        client_script: 'sys_script_client',
-                        script_include: 'sys_script_include',
-                        flow: 'sys_hub_flow',
-                        workflow: 'wf_workflow',
-                        ui_action: 'sys_ui_action',
-                        table: 'sys_db_object',
-                        application: 'sys_app_application',
-                    };
-                    for (const [type, table] of Object.entries(commonTables)) {
-                        try {
-                            const results = await this.client.searchRecords(table, `active=true^ORDERBYname^LIMIT10`);
-                            if (results && results.success && results.data.result.length > 0) {
-                                const typedResults = results.data.result.map((result) => ({
-                                    ...result,
-                                    artifact_type: type,
-                                    table_name: table
-                                }));
-                                allResults.push(...typedResults);
-                            }
-                        }
-                        catch (error) {
-                            this.logger.warn(`Error fetching ${table}:`, error);
-                        }
-                    }
-                    return allResults;
-                }
-                // Define most common tables to search when type is 'any'
-                const commonTables = {
-                    widget: 'sp_widget',
-                    business_rule: 'sys_script',
-                    client_script: 'sys_script_client',
-                    script_include: 'sys_script_include',
-                    flow: 'sys_hub_flow',
-                    workflow: 'wf_workflow',
-                    ui_action: 'sys_ui_action',
-                    table: 'sys_db_object',
-                    application: 'sys_app_application',
-                };
-                for (const [type, table] of Object.entries(commonTables)) {
-                    try {
-                        // Try exact match first for each table
-                        const searchString = intent.identifier.trim();
-                        let results = await this.client.searchRecords(table, `name=${searchString}^LIMIT2`);
-                        // If no exact match, try contains
-                        if (!results || !results.success || results.data.result.length === 0) {
-                            results = await this.client.searchRecords(table, `nameLIKE${searchString}^LIMIT3`);
-                        }
-                        // If still no results, try wildcards on first term only
-                        if (!results || !results.success || results.data.result.length === 0) {
-                            const firstTerm = searchString.split(' ')[0];
-                            if (firstTerm && firstTerm.length > 2) {
-                                results = await this.client.searchRecords(table, `nameLIKE*${firstTerm}*^LIMIT3`);
-                            }
-                        }
-                        if (results && results.success && results.data.result.length > 0) {
-                            // Add artifact type to results for identification
-                            const typedResults = results.data.result.map((result) => ({
-                                ...result,
-                                artifact_type: type,
-                                table_name: table
-                            }));
-                            allResults.push(...typedResults);
-                        }
-                    }
-                    catch (error) {
-                        this.logger.warn(`Error searching ${table}:`, error);
-                    }
-                }
-                // If still no results, try broader search in common tables only
-                if (allResults.length === 0) {
-                    this.logger.info('No results found, trying broader search in common tables...');
-                    const firstTerm = intent.identifier.split(' ')[0];
-                    if (firstTerm && firstTerm.length > 2) {
-                        for (const [type, table] of Object.entries(commonTables)) {
-                            try {
-                                const broadQuery = `(nameLIKE*${firstTerm}*^ORtitleLIKE*${firstTerm}*^ORshort_descriptionLIKE*${firstTerm}*)^LIMIT5`;
-                                const results = await this.client.searchRecords(table, broadQuery, 5);
-                                if (results && results.success && results.data.result.length > 0) {
-                                    const typedResults = results.data.result.map((result) => ({
-                                        ...result,
-                                        artifact_type: type,
-                                        table_name: table
-                                    }));
-                                    allResults.push(...typedResults);
-                                }
-                            }
-                            catch (error) {
-                                this.logger.warn(`Error in broad search ${table}:`, error);
-                            }
-                        }
-                    }
-                }
-                return allResults;
-            }
-            // Search specific table
-            const table = tableMapping[intent.artifactType];
-            if (!table) {
-                this.logger.warn(`Unknown artifact type: ${intent.artifactType}`);
-                return [];
-            }
-            // First try exact match
-            const searchString = intent.identifier.trim();
-            let results;
-            // Handle "list all" queries
-            if (searchString.toLowerCase().includes('list all') ||
-                searchString.toLowerCase().includes('all flows') ||
-                searchString.toLowerCase().includes('show all') ||
-                searchString === '') {
-                this.logger.info(`Fetching all ${intent.artifactType} records`);
-                // Get all active records of this type, sorted by name
-                results = await this.client.searchRecords(table, `active=true^ORDERBYname^LIMIT50`);
-                // Add artifact type to results
-                if (results && results.success && results.data.result.length > 0) {
-                    const enhancedResults = results.data.result.map((result) => ({
-                        ...result,
-                        artifact_type: intent.artifactType,
-                        table_name: table
-                    }));
-                    return enhancedResults;
-                }
-                return [];
-            }
-            // Try exact name match first
-            this.logger.info(`Trying exact match: name=${searchString}`);
-            results = await this.client.searchRecords(table, `name=${searchString}^LIMIT5`);
-            // If no exact match, try contains without wildcards (ServiceNow specific)
-            if (!results || !results.success || results.data.result.length === 0) {
-                this.logger.info(`No exact match, trying contains: nameLIKE${searchString}`);
-                results = await this.client.searchRecords(table, `nameLIKE${searchString}^LIMIT10`);
-            }
-            // Also try description fields
-            if (!results || !results.success || results.data.result.length === 0) {
-                this.logger.info(`No name match, trying description: short_descriptionLIKE${searchString}`);
-                results = await this.client.searchRecords(table, `short_descriptionLIKE${searchString}^ORdescriptionLIKE${searchString}^LIMIT10`);
-            }
-            // If still no results, use the complex query
-            if (!results || !results.success || results.data.result.length === 0) {
-                const query = this.buildServiceNowQuery(intent);
-                this.logger.info(`No contains match, trying complex query: ${query}`);
-                results = await this.client.searchRecords(table, query);
-            }
-            // If still no results, try a broader search
-            if (!results || !results.success || results.data.result.length === 0) {
-                this.logger.info(`No results found, trying broader search...`);
-                // Try searching with just the first search term with wildcards
-                const firstTerm = intent.identifier.split(' ')[0];
-                if (firstTerm && firstTerm.length > 2) {
-                    const broadQuery = `(nameLIKE*${firstTerm}*^ORtitleLIKE*${firstTerm}*^ORshort_descriptionLIKE*${firstTerm}*)^LIMIT10`;
-                    results = await this.client.searchRecords(table, broadQuery);
-                }
-                // If still no results, return empty array instead of sample records
-                if (!results || !results.success || results.data.result.length === 0) {
-                    this.logger.info(`No results found for search term: ${searchString}`);
-                    return [];
-                }
-            }
-            // Ensure we always return an array
-            return (results && results.success && results.data.result) ? results.data.result : [];
-        }
-        catch (error) {
-            this.logger.error('Error searching ServiceNow', error);
-            return [];
-        }
-    }
-    buildServiceNowQuery(intent) {
-        // Build proper ServiceNow encoded query
-        const searchString = intent.identifier.trim();
-        if (searchString.length === 0) {
-            // Return first 10 active records if no search terms
-            return 'active=true^LIMIT10';
-        }
-        // First try exact name match
-        const exactQuery = `name=${searchString}`;
-        // Then try name contains (without wildcards for multi-word)
-        const containsQuery = `nameLIKE${searchString}`;
-        // For single words, use wildcards (keep original case for better matching)
-        const searchTerms = searchString.split(' ').filter(term => term.length > 1);
-        const wildcardQueries = [];
-        if (searchTerms.length === 1) {
-            // Single word - use wildcards with both cases
-            const term = searchTerms[0];
-            const termLower = term.toLowerCase();
-            wildcardQueries.push(`nameLIKE*${term}*`);
-            wildcardQueries.push(`nameLIKE*${termLower}*`);
-            wildcardQueries.push(`titleLIKE*${term}*`);
-            wildcardQueries.push(`titleLIKE*${termLower}*`);
-            wildcardQueries.push(`short_descriptionLIKE*${termLower}*`);
-        }
-        else {
-            // Multiple words - search for first and last word with wildcards
-            const firstTerm = searchTerms[0];
-            const lastTerm = searchTerms[searchTerms.length - 1];
-            const firstLower = firstTerm.toLowerCase();
-            const lastLower = lastTerm.toLowerCase();
-            wildcardQueries.push(`nameLIKE*${firstTerm}*`);
-            wildcardQueries.push(`nameLIKE*${firstLower}*`);
-            wildcardQueries.push(`nameLIKE*${lastTerm}*`);
-            wildcardQueries.push(`nameLIKE*${lastLower}*`);
-            wildcardQueries.push(`titleLIKE*${firstTerm}*`);
-            wildcardQueries.push(`titleLIKE*${lastTerm}*`);
-        }
-        // Combine queries: try exact match OR contains OR wildcards
-        const allQueries = [exactQuery, containsQuery, ...wildcardQueries];
-        const query = `(${allQueries.join('^OR')})^LIMIT20`;
-        return query;
-    }
-    async intelligentlyIndex(artifact) {
-        // Intelligent indexing based on artifact type
-        const structure = await this.decomposeArtifact(artifact);
-        const context = await this.extractContext(artifact);
-        const relationships = await this.mapRelationships(artifact);
-        const claudeSummary = await this.createClaudeSummary(artifact);
-        const modificationPoints = await this.identifyModificationPoints(artifact);
-        return {
-            meta: {
-                sys_id: artifact.sys_id,
-                name: artifact.name || artifact.title,
-                title: artifact.title,
-                type: artifact.sys_class_name || 'unknown',
-                last_updated: artifact.sys_updated_on,
-            },
-            structure,
-            context,
-            relationships,
-            claudeSummary,
-            modificationPoints,
-        };
-    }
-    async decomposeArtifact(artifact) {
-        // Decompose artifact based on type
-        if (artifact.sys_class_name === 'sp_widget') {
-            return this.decomposeWidget(artifact);
-        }
-        else if (artifact.sys_class_name === 'sys_hub_flow') {
-            return this.decomposeFlow(artifact);
-        }
-        return { type: 'unknown', components: [] };
-    }
-    async decomposeWidget(widget) {
-        return {
-            type: 'widget',
-            components: {
-                template: widget.template ? 'HTML template present' : 'No template',
-                css: widget.css ? 'Custom CSS present' : 'No custom CSS',
-                client_script: widget.client_script ? 'Client script present' : 'No client script',
-                server_script: widget.server_script ? 'Server script present' : 'No server script',
-                options: widget.option_schema ? JSON.parse(widget.option_schema) : [],
-            },
-        };
-    }
-    async decomposeFlow(flow) {
-        return {
-            type: 'flow',
-            components: {
-                name: flow.name,
-                description: flow.description,
-                active: flow.active,
-                trigger: flow.trigger_conditions || 'Unknown trigger',
-                steps: 'Flow definition _analysis would go here',
-            },
-        };
-    }
-    async extractContext(artifact) {
-        return {
-            usage: 'Context _analysis would determine usage patterns',
-            dependencies: 'Related artifacts would be identified here',
-            impact: 'Impact _analysis would be performed here',
-        };
-    }
-    async mapRelationships(artifact) {
-        return {
-            relatedArtifacts: [],
-            dependencies: [],
-            usage: [],
-        };
-    }
-    async createClaudeSummary(artifact) {
-        const name = artifact.name || artifact.title || 'Unknown';
-        const type = artifact.sys_class_name || 'artifact';
-        return `${name} is a ${type} in ServiceNow. It can be modified using natural language instructions through Snow-Flow.`;
-    }
-    async identifyModificationPoints(artifact) {
-        // Identify common modification points
-        return [
-            {
-                location: 'main_configuration',
-                type: 'modify_settings',
-                description: 'Main configuration can be modified',
-            },
-        ];
-    }
-    async storeInMemory(artifact) {
-        // Store in memory for future access
-        await fs_1.promises.mkdir(this.memoryPath, { recursive: true });
-        const filePath = (0, path_1.join)(this.memoryPath, `${artifact.meta.sys_id}.json`);
-        await fs_1.promises.writeFile(filePath, JSON.stringify(artifact, null, 2));
-    }
-    async searchInMemory(intent) {
-        // Search in memory index
-        try {
-            const files = await fs_1.promises.readdir(this.memoryPath);
-            const results = [];
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    try {
-                        const content = await fs_1.promises.readFile((0, path_1.join)(this.memoryPath, file), 'utf8');
-                        const artifact = JSON.parse(content);
-                        // Ensure artifact has basic structure
-                        if (artifact && (artifact.meta || artifact.claudeSummary)) {
-                            if (this.matchesIntent(artifact, intent)) {
-                                results.push(artifact);
-                            }
-                        }
-                    }
-                    catch (parseError) {
-                        this.logger.warn(`Failed to parse memory file: ${file}`, parseError);
-                        // Continue with next file
-                    }
-                }
-            }
-            return results;
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    matchesIntent(artifact, intent) {
-        const searchTerm = intent.identifier.toLowerCase();
-        // Safe access to artifact properties with fallbacks
-        const artifactName = (artifact.meta?.name || artifact.meta?.title || '').toLowerCase();
-        const artifactSummary = (artifact.claudeSummary || '').toLowerCase();
-        return artifactName.includes(searchTerm) || artifactSummary.includes(searchTerm);
-    }
-    formatResults(results) {
-        if (!results || results.length === 0) {
-            return '❌ No artifacts found matching your search criteria.\n\n🔍 **Debugging Info:**\n- ServiceNow connection appears to be working\n- Try broader search terms\n- Check if widgets exist in your ServiceNow instance\n- Use snow_create_artifact to create new artifacts first';
-        }
-        const formattedResults = results.map((result, index) => {
-            const name = result.name || result.title || result.display_name || result.sys_id || 'Unknown';
-            const type = result.sys_class_name || result.type || 'Unknown';
-            const artifactType = result.artifact_type || 'Unknown';
-            const tableName = result.table_name || 'Unknown';
-            const id = result.sys_id || 'Unknown';
-            const updated = result.sys_updated_on || result.last_updated || 'Unknown';
-            const active = result.active !== undefined ? (result.active ? 'Active' : 'Inactive') : 'Unknown';
-            const description = result.short_description || result.description || 'No description';
-            return `${index + 1}. **${name}**\n   - Artifact Type: ${artifactType}\n   - Table: ${tableName}\n   - Class: ${type}\n   - ID: ${id}\n   - Status: ${active}\n   - Description: ${description}\n   - Updated: ${updated}`;
-        }).join('\n\n');
-        return `✅ Found ${results.length} artifact(s):\n\n${formattedResults}`;
-    }
-    formatMemoryResults(results) {
-        return results.map((result, index) => `${index + 1}. **${result.meta.name}**\n   - Type: ${result.meta.type}\n   - Summary: ${result.claudeSummary}\n   - Modification Points: ${result.modificationPoints.length}`).join('\n\n');
-    }
-    formatComprehensiveResults(results) {
-        if (!results || results.length === 0) {
-            return '❌ No artifacts found across all ServiceNow tables.\n\n🔍 **Suggestions:**\n- Check spelling and try different terms\n- Include inactive records with include_inactive=true\n- Try broader search terms\n- The artifact might be in a scoped application';
-        }
-        // Group results by table type
-        const groupedResults = results.reduce((groups, result) => {
-            const tableDesc = result.table_description || result.table_name;
-            if (!groups[tableDesc]) {
-                groups[tableDesc] = [];
-            }
-            groups[tableDesc].push(result);
-            return groups;
-        }, {});
-        let output = `✅ Found ${results.length} artifact(s) across ${Object.keys(groupedResults).length} table type(s):\n\n`;
-        for (const [tableDesc, tableResults] of Object.entries(groupedResults)) {
-            output += `## ${tableDesc}\n`;
-            tableResults.forEach((result, index) => {
-                const name = result.name || result.title || result.display_name || result.sys_id || 'Unknown';
-                const active = result.active !== undefined ? (result.active ? 'Active' : 'Inactive') : 'Unknown';
-                const description = result.short_description || result.description || 'No description';
-                const strategy = result.search_strategy || 'Unknown';
-                const collection = result.collection || result.table_name || 'Unknown';
-                output += `${index + 1}. **${name}**\n`;
-                output += `   - Table: ${collection}\n`;
-                output += `   - Status: ${active}\n`;
-                output += `   - Description: ${description}\n`;
-                output += `   - Found via: ${strategy}\n`;
-                output += `   - Sys ID: ${result.sys_id}\n`;
-                if (result.when)
-                    output += `   - When: ${result.when}\n`;
-                if (result.order)
-                    output += `   - Order: ${result.order}\n`;
-                if (result.condition)
-                    output += `   - Condition: ${result.condition}\n`;
-                output += '\n';
-            });
-        }
-        return output;
-    }
-    generateEditSuggestion(artifact) {
-        if (!artifact) {
-            return '💡 Use snow_edit_artifact to modify ServiceNow artifacts with natural language.';
-        }
-        const name = artifact.name || artifact.title || artifact.display_name || 'the artifact';
-        return `💡 To edit this artifact, use:\n\`snow-flow edit "modify ${name} to add [your requirements]"\``;
-    }
-    async findTargetArtifact(intent) {
-        // Find the specific artifact to edit
-        const results = await this.searchServiceNow(intent);
-        if (results.length === 0) {
-            throw new Error('No matching artifact found');
-        }
-        // Return the best match based on relevance scoring
-        return this.selectBestMatch(results, intent);
-    }
-    /**
-     * Select the best matching artifact based on relevance scoring
-     */
-    selectBestMatch(results, intent) {
-        if (results.length === 1) {
-            return results[0];
-        }
-        // Score each result based on multiple factors
-        const scoredResults = results.map(result => {
-            let score = 0;
-            // Name/title similarity
-            const name = (result.name || result.title || '').toLowerCase();
-            const identifier = intent.identifier.toLowerCase();
-            if (name === identifier) {
-                score += 100; // Exact match
-            }
-            else if (name.includes(identifier) || identifier.includes(name)) {
-                score += 50; // Partial match
-            }
-            // Type match
-            if (result.type === intent.artifactType) {
-                score += 30;
-            }
-            // Recency (prefer more recently updated)
-            if (result.sys_updated_on) {
-                const daysSinceUpdate = (Date.now() - new Date(result.sys_updated_on).getTime()) / (1000 * 60 * 60 * 24);
-                score += Math.max(0, 10 - daysSinceUpdate); // More points for recent updates
-            }
-            // Active/non-test artifacts preferred
-            if (result.active !== false && !name.includes('test') && !name.includes('mock')) {
-                score += 10;
-            }
-            return { result, score };
-        });
-        // Sort by score and return the best match
-        scoredResults.sort((a, b) => b.score - a.score);
-        this.logger.info('Selected best match', {
-            selected: scoredResults[0].result.name,
-            score: scoredResults[0].score,
-            totalResults: results.length
-        });
-        return scoredResults[0].result;
-    }
-    /**
-     * Perform comprehensive flow _analysis and testing
-     */
-    async performFlowAnalysis(sysId, flowType, flowData) {
-        const _analysis = {
-            structureValid: false,
-            triggerAnalysis: null,
-            recommendedTests: [],
-            performanceScore: 0,
-            securityIssues: [],
-            integrationPoints: []
-        };
-        try {
-            // Analyze flow structure
-            if (flowType === 'flow_designer' && flowData.latest_snapshot) {
-                const snapshot = JSON.parse(flowData.latest_snapshot);
-                const activities = snapshot.activities || snapshot.steps || [];
-                _analysis.structureValid = activities.length > 0;
-                _analysis.performanceScore = this.calculateFlowPerformanceScore(activities);
-                _analysis.securityIssues = this.identifySecurityIssues(activities);
-                _analysis.integrationPoints = this.findIntegrationPoints(activities);
-            }
-            // Analyze trigger conditions
-            if (flowData.table && flowData.condition) {
-                _analysis.triggerAnalysis = {
-                    table: flowData.table,
-                    condition: flowData.condition,
-                    active: flowData.active,
-                    validTrigger: true
-                };
-                // Recommend specific tests based on trigger
-                _analysis.recommendedTests = this.generateFlowTestRecommendations(flowData);
-            }
-            return _analysis;
-        }
-        catch (error) {
-            this.logger.error('Flow _analysis failed', { sysId, error: error.message });
-            return {
-                ..._analysis,
-                error: error.message,
-                recommendation: 'Use snow_test_flow_with_mock() for safer testing'
-            };
-        }
-    }
-    calculateFlowPerformanceScore(activities) {
-        let score = 100;
-        // Deduct points for potential performance issues
-        activities.forEach(activity => {
-            if (activity.type?.includes('wait') || activity.type?.includes('timer')) {
-                score -= 5; // Wait activities can slow flows
-            }
-            if (activity.script && activity.script.length > 1000) {
-                score -= 10; // Large scripts may impact performance
-            }
-            if (activity.type?.includes('loop')) {
-                score -= 15; // Loops can be performance bottlenecks
-            }
-        });
-        return Math.max(0, score);
-    }
-    identifySecurityIssues(activities) {
-        const issues = [];
-        activities.forEach((activity, index) => {
-            if (activity.script) {
-                // Check for potential security issues
-                if (activity.script.includes('eval(')) {
-                    issues.push(`Activity ${index + 1}: Uses eval() which is a security risk`);
-                }
-                if (activity.script.includes('gs.getUser().getUserID()') && !activity.script.includes('canRead')) {
-                    issues.push(`Activity ${index + 1}: May have access control issues`);
-                }
-                if (activity.script.includes('XMLHttpRequest')) {
-                    issues.push(`Activity ${index + 1}: External HTTP calls may pose security risks`);
-                }
-            }
-        });
-        return issues;
-    }
-    findIntegrationPoints(activities) {
-        const integrations = [];
-        activities.forEach((activity, index) => {
-            if (activity.type?.includes('rest') || activity.type?.includes('soap')) {
-                integrations.push(`Activity ${index + 1}: External API integration (${activity.type})`);
-            }
-            if (activity.script && activity.script.includes('RESTMessage')) {
-                integrations.push(`Activity ${index + 1}: REST Message integration`);
-            }
-            if (activity.script && activity.script.includes('SOAPMessage')) {
-                integrations.push(`Activity ${index + 1}: SOAP Message integration`);
-            }
-        });
-        return integrations;
-    }
-    generateFlowTestRecommendations(flowData) {
-        const recommendations = [];
-        if (flowData.table) {
-            recommendations.push(`Create test record in ${flowData.table} table`);
-        }
-        if (flowData.condition) {
-            recommendations.push(`Test with records that match condition: ${flowData.condition}`);
-            recommendations.push(`Test with records that don't match condition (negative test)`);
-        }
-        if (flowData.trigger_type === 'record_updated') {
-            recommendations.push('Test by updating existing records');
-        }
-        else if (flowData.trigger_type === 'record_created') {
-            recommendations.push('Test by creating new records');
-        }
-        recommendations.push('Use snow_test_flow_with_mock() for isolated testing');
-        return recommendations;
-    }
-    async analyzeModification(intent, artifact) {
-        // Analyze what modification is needed
-        return {
-            type: 'configuration_change',
-            description: intent.modification || 'General modification',
-            target: artifact.sys_id,
-        };
-    }
-    async applyModification(artifact, modification) {
-        // Apply the modification - this would be more sophisticated
-        return {
-            ...artifact,
-            modified: true,
-            modification_applied: modification,
-        };
-    }
-    async deployArtifact(artifact) {
-        this.logger.info('Deploying modified artifact to ServiceNow', {
-            type: artifact.type,
-            sys_id: artifact.sys_id,
-            name: artifact.name
-        });
-        try {
-            // Determine the table name based on artifact type
-            let tableName;
-            let updateData = {};
-            switch (artifact.type) {
-                case 'widget':
-                    tableName = 'sp_widget';
-                    updateData = {
-                        name: artifact.name,
-                        title: artifact.title,
-                        description: artifact.description,
-                        template: artifact.template,
-                        css: artifact.css,
-                        client_script: artifact.client_script,
-                        server_script: artifact.server_script,
-                        option_schema: artifact.option_schema
-                    };
-                    break;
-                case 'flow':
-                    tableName = 'sys_hub_flow';
-                    updateData = {
-                        name: artifact.name,
-                        description: artifact.description,
-                        active: artifact.active,
-                        trigger_conditions: artifact.trigger_conditions,
-                        flow_definition: typeof artifact.flow_definition === 'string'
-                            ? artifact.flow_definition
-                            : JSON.stringify(artifact.flow_definition)
-                    };
-                    break;
-                case 'subflow':
-                    tableName = 'sys_hub_subflow';
-                    updateData = {
-                        name: artifact.name,
-                        description: artifact.description,
-                        inputs: typeof artifact.inputs === 'string'
-                            ? artifact.inputs
-                            : JSON.stringify(artifact.inputs || []),
-                        outputs: typeof artifact.outputs === 'string'
-                            ? artifact.outputs
-                            : JSON.stringify(artifact.outputs || [])
-                    };
-                    break;
-                case 'business_rule':
-                    tableName = 'sys_script';
-                    updateData = {
-                        name: artifact.name,
-                        description: artifact.description,
-                        script: artifact.script,
-                        condition: artifact.condition,
-                        when: artifact.when,
-                        active: artifact.active
-                    };
-                    break;
-                case 'script_include':
-                    tableName = 'sys_script_include';
-                    updateData = {
-                        name: artifact.name,
-                        description: artifact.description,
-                        script: artifact.script,
-                        api_name: artifact.api_name,
-                        active: artifact.active
-                    };
-                    break;
-                case 'client_script':
-                    tableName = 'sys_script_client';
-                    updateData = {
-                        name: artifact.name,
-                        description: artifact.description,
-                        script: artifact.script,
-                        table: artifact.table,
-                        type: artifact.script_type,
-                        condition: artifact.condition,
-                        active: artifact.active
-                    };
-                    break;
-                case 'ui_policy':
-                    tableName = 'sys_ui_policy';
-                    updateData = {
-                        short_description: artifact.name,
-                        description: artifact.description,
-                        conditions: artifact.condition,
-                        on_load: artifact.on_load,
-                        reverse_if_false: artifact.reverse_if_false,
-                        active: artifact.active
-                    };
-                    break;
-                case 'application':
-                    tableName = 'sys_app';
-                    updateData = {
-                        name: artifact.name,
-                        short_description: artifact.short_description,
-                        description: artifact.description,
-                        version: artifact.version,
-                        active: artifact.active
-                    };
-                    break;
-                default:
-                    // Use the artifact's table property if available, or try to infer from type
-                    tableName = artifact.table || artifact.type;
-                    updateData = { ...artifact };
-                    delete updateData.sys_id;
-                    delete updateData.type;
-                    delete updateData.table;
-                    delete updateData.modified;
-                    delete updateData.modification_applied;
-                    break;
-            }
-            // Remove undefined/null values to avoid overwriting with empty data
-            Object.keys(updateData).forEach(key => {
-                if (updateData[key] === undefined || updateData[key] === null) {
-                    delete updateData[key];
-                }
-            });
-            // Update the artifact in ServiceNow using the sys_id
-            const result = await this.client.put(`/api/now/table/${tableName}/${artifact.sys_id}`, updateData);
-            if (result.result) {
-                this.logger.info('Artifact successfully deployed to ServiceNow', {
-                    type: artifact.type,
-                    sys_id: artifact.sys_id,
-                    name: artifact.name,
-                    table: tableName
-                });
-                // Get instance info for URL generation
-                const instanceInfo = await this.client.getInstanceInfo();
-                const baseUrl = (instanceInfo.result && typeof instanceInfo.result === 'object' && 'instance_url' in instanceInfo.result
-                    ? instanceInfo.result.instance_url
-                    : null) ||
-                    `https://${process.env.SNOW_INSTANCE?.replace(/\/$/, '') || 'instance'}.service-now.com`;
-                return {
-                    success: true,
-                    message: 'Artifact deployed successfully',
-                    data: {
-                        sys_id: artifact.sys_id,
-                        name: artifact.name,
-                        type: artifact.type,
-                        table: tableName,
-                        url: `${baseUrl}/nav_to.do?uri=${tableName}.do?sys_id=${artifact.sys_id}`,
-                        last_updated: new Date().toISOString()
-                    }
-                };
-            }
-            else {
-                throw new Error('No result returned from ServiceNow API');
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to deploy artifact to ServiceNow', {
-                type: artifact.type,
-                sys_id: artifact.sys_id,
-                name: artifact.name,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return {
-                success: false,
-                message: `Failed to deploy artifact: ${error instanceof Error ? error.message : String(error)}`,
-                error: error instanceof Error ? error.message : String(error),
-                data: {
-                    sys_id: artifact.sys_id,
-                    name: artifact.name,
-                    type: artifact.type,
-                    deployment_attempt: new Date().toISOString()
-                }
-            };
-        }
-    }
-    async updateMemoryIndex(artifact, modification) {
-        // Skip memory indexing - causes timeouts
-        /*
-        // Update the memory index with the changes
-        const indexed = await this.intelligentlyIndex(artifact);
-        await this.storeInMemory(indexed);
-        */
-        // TODO: Implement faster indexing method
-        this.logger.info('Memory indexing skipped to prevent timeouts');
-    }
-    getArtifactUrl(artifact) {
-        // Generate ServiceNow URL for the artifact
-        return `sys_id=${artifact.sys_id}`;
-    }
-    async getBySysId(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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('Getting artifact by sys_id', { sys_id: args.sys_id, table: args.table });
-            // Direct lookup by sys_id with retry logic for newly created records
-            let artifact = null;
-            let lastError = null;
-            for (let attempt = 0; attempt < 3; attempt++) {
-                try {
-                    // Note: client.getRecord returns the record directly, not a response object
-                    artifact = await this.client.getRecord(args.table, args.sys_id);
-                    if (artifact) {
-                        break; // Success, exit retry loop
-                    }
-                }
-                catch (error) {
-                    lastError = error;
-                    this.logger.warn(`Attempt ${attempt + 1} failed for sys_id lookup:`, error);
-                    // If this is not the last attempt, wait before retrying
-                    if (attempt < 2) {
-                        await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))); // Progressive delay
-                    }
-                }
-            }
-            // If direct lookup failed, try fallback search for newly created records
-            if (!artifact) {
-                this.logger.info('Direct lookup failed, trying fallback search...');
-                try {
-                    const searchResult = await this.client.searchRecords(args.table, `sys_id=${args.sys_id}`, 1);
-                    if (searchResult.success && searchResult.data.result.length > 0) {
-                        artifact = searchResult.data.result[0];
-                        this.logger.info('Found artifact via fallback search');
-                    }
-                }
-                catch (searchError) {
-                    this.logger.warn('Fallback search also failed:', searchError);
-                }
-            }
-            if (!artifact) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ Artifact not found with sys_id: ${args.sys_id} in table: ${args.table}\n\n🔍 **Troubleshooting:**\n- Verify the sys_id is correct\n- Check if the record was created in a different Update Set\n- Ensure you have read access to this table\n- For newly created records, try again in a few seconds\n\n**Last Error:** ${lastError?.message || 'Record not found'}`,
-                        },
-                    ],
-                };
-            }
-            // Format the response with relevant fields
-            const formattedArtifact = {
-                sys_id: artifact.sys_id,
-                name: artifact.name || artifact.title || 'Unknown',
-                table: args.table,
-                ...artifact
-            };
-            // Estimate token count (rough estimate: 1 token ≈ 4 characters)
-            const jsonString = JSON.stringify(formattedArtifact, null, 2);
-            const estimatedTokens = Math.ceil(jsonString.length / 4);
-            const maxTokens = 200000; // Claude's actual context window limit
-            let responseText;
-            if (estimatedTokens > maxTokens) {
-                // Response too large - return essential fields only and suggest specific field access
-                const essentialFields = {
-                    sys_id: artifact.sys_id,
-                    name: artifact.name || artifact.title || 'Unknown',
-                    table: args.table,
-                    sys_updated_on: artifact.sys_updated_on,
-                    sys_created_on: artifact.sys_created_on,
-                    sys_updated_by: artifact.sys_updated_by,
-                    active: artifact.active,
-                    // Table-specific key fields
-                    ...(args.table === 'sp_widget' && {
-                        id: artifact.id,
-                        title: artifact.title,
-                        template: artifact.template ? `${artifact.template.substring(0, 200)}...` : null,
-                        script: artifact.script ? `${artifact.script.substring(0, 200)}...` : null,
-                        client_script: artifact.client_script ? `${artifact.client_script.substring(0, 200)}...` : null,
-                        css: artifact.css ? `${artifact.css.substring(0, 200)}...` : null
-                    }),
-                    ...(args.table === 'wf_workflow' && {
-                        title: artifact.title,
-                        workflow_version: artifact.workflow_version,
-                        stage: artifact.stage
-                    }),
-                    ...(args.table === 'sys_script_include' && {
-                        api_name: artifact.api_name,
-                        client_callable: artifact.client_callable,
-                        script: artifact.script ? `${artifact.script.substring(0, 200)}...` : null
-                    })
-                };
-                const availableFields = Object.keys(artifact).filter(key => !essentialFields.hasOwnProperty(key));
-                responseText = `✅ Found artifact by sys_id!\n\n🎯 **${formattedArtifact.name}**\n🆔 sys_id: ${args.sys_id}\n📊 Table: ${args.table}\n\n⚠️ **Response size limited (${estimatedTokens} tokens > ${maxTokens} limit)**\n\n**Essential Fields:**\n${JSON.stringify(essentialFields, null, 2)}\n\n🎯 **RECOMMENDATION: Get specific fields instead**\n\nUse snow_query_table with specific fields for better performance:\n\`\`\`\nsnow_query_table({\n  table: "${args.table}",\n  query: "sys_id=${args.sys_id}",\n  fields: ["field1", "field2", "field3"],  // Only fields you need\n  limit: 1\n})\n\`\`\`\n\n**Available fields to choose from:**\n${availableFields.slice(0, 20).join(', ')}${availableFields.length > 20 ? `, and ${availableFields.length - 20} more...` : ''}\n\n💡 **Example for ${args.table}:**\n${args.table === 'sp_widget' ? `snow_query_table({ table: "sp_widget", query: "sys_id=${args.sys_id}", fields: ["name", "title", "template", "client_script", "script"], limit: 1 })` :
-                    args.table === 'wf_workflow' ? `snow_query_table({ table: "wf_workflow", query: "sys_id=${args.sys_id}", fields: ["name", "title", "workflow_version", "stage"], limit: 1 })` :
-                        `snow_query_table({ table: "${args.table}", query: "sys_id=${args.sys_id}", fields: ["name", "sys_updated_on"], limit: 1 })`}`;
-            }
-            else {
-                // Response size is acceptable
-                responseText = `✅ Found artifact by sys_id!\n\n🎯 **${formattedArtifact.name}**\n🆔 sys_id: ${args.sys_id}\n📊 Table: ${args.table}\n\n**All Fields:**\n${jsonString}`;
-            }
-            // Skip memory indexing for now - it might be causing timeouts
-            // TODO: Investigate why memory indexing causes timeouts
-            /*
-            setImmediate(() => {
-              this.intelligentlyIndex(artifact).then(indexed => {
-                this.storeInMemory(indexed).catch(err => {
-                  this.logger.warn('Failed to store artifact in memory:', err);
-                });
-              });
-            });
-            */
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to get artifact by sys_id:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Error getting artifact by sys_id: ${error}`,
-                    },
-                ],
-            };
-        }
-    }
-    async editBySysId(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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('Editing artifact by sys_id', {
-                sys_id: args.sys_id,
-                table: args.table,
-                field: args.field,
-                value_length: args.value?.length || 0
-            });
-            // First, ensure we have an update set
-            const updateSetResult = await this.client.ensureUpdateSet();
-            if (!updateSetResult.success) {
-                this.logger.warn('No update set available, continuing without one');
-            }
-            // Build update data
-            const updateData = {
-                [args.field]: args.value
-            };
-            // Update the record directly by sys_id with validation
-            const response = await this.client.updateRecord(args.table, args.sys_id, updateData);
-            if (!response.success) {
-                // Try to provide more specific error information
-                let errorDetails = response.error || 'Unknown error';
-                if (response.error?.includes('404') || response.error?.includes('not found')) {
-                    errorDetails += `\n\n🔍 **Troubleshooting:**
-- Verify the sys_id exists in the specified table
-- Check if the record was recently created (may need a moment to be available)
-- Ensure you have write access to this record
-
-🔧 **Update Set Considerations:**
-- Check current Update Set: snow_smart_update_set with action="track"
-- Verify artifact is tracked: snow_get_by_sysid
-- Ensure Update Set is active for tracking changes
-
-💡 **Debug steps:**
-1. Check current Update Set status
-2. Verify artifact creation was tracked
-3. Use mock testing if record access fails`;
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ Failed to update artifact: ${errorDetails}`,
-                        },
-                    ],
-                };
-            }
-            // Verify the update was applied successfully by reading back the field
-            let verificationResult = '';
-            try {
-                const updatedRecord = await this.client.getRecord(args.table, args.sys_id);
-                if (updatedRecord && updatedRecord[args.field] === args.value) {
-                    verificationResult = '\n\n✅ **Verification:** Update confirmed - field value matches expected value';
-                }
-                else {
-                    verificationResult = '\n\n⚠️ **Verification:** Update may not have been applied correctly - consider checking manually';
-                }
-            }
-            catch (verifyError) {
-                verificationResult = '\n\n⚠️ **Verification:** Could not verify update (record may still be processing)';
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Artifact successfully updated!\n\n🎯 **Updated Field:** ${args.field}\n🆔 sys_id: ${args.sys_id}\n📊 Table: ${args.table}\n📝 Value Length: ${args.value.length} characters\n\n✨ Update applied directly via sys_id - much more reliable than text search!${verificationResult}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to edit artifact by sys_id:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Error editing artifact by sys_id: ${error}`,
-                    },
-                ],
-            };
-        }
-    }
-    async syncDataConsistency(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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 data consistency sync', { operation: args.operation });
-            let syncResults = [];
-            switch (args.operation) {
-                case 'refresh_cache':
-                    syncResults = await this.refreshCache(args.table);
-                    break;
-                case 'validate_sysids':
-                    syncResults = await this.validateSysIds(args.sys_id, args.table);
-                    break;
-                case 'reindex_artifacts':
-                    syncResults = await this.reindexArtifacts(args.table);
-                    break;
-                case 'full_sync':
-                    syncResults = await this.performFullSync();
-                    break;
-                default:
-                    throw new Error(`Unknown sync operation: ${args.operation}`);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Data consistency sync completed!\n\n🔄 **Operation:** ${args.operation}\n\n📋 **Results:**\n${syncResults.map(r => `- ${r}`).join('\n')}\n\n✨ Data consistency issues have been resolved. Try your operations again.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('Data consistency sync failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Data consistency sync failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async refreshCache(table) {
-        const results = [];
-        if (table) {
-            // Clear any cached data for specific table
-            this.memoryIndex.clear(); // Clear in-memory cache
-            results.push(`Cache cleared for table: ${table}`);
-            results.push(`Note: This MCP uses real-time queries, no persistent cache to refresh`);
-        }
-        else {
-            // Clear all in-memory data
-            this.memoryIndex.clear();
-            results.push('All internal caches cleared');
-            results.push(`Note: This MCP uses real-time ServiceNow queries for accuracy`);
-        }
-        return results;
-    }
-    async validateSysIds(sys_id, table) {
-        const results = [];
-        if (sys_id && table) {
-            // Validate specific sys_id
-            try {
-                const record = await this.client.getRecord(table, sys_id);
-                if (record && record.success && record.data) {
-                    results.push(`✅ sys_id ${sys_id} validated in table ${table}`);
-                }
-                else {
-                    results.push(`❌ sys_id ${sys_id} not found in table ${table}`);
-                }
-            }
-            catch (error) {
-                results.push(`❌ sys_id ${sys_id} validation failed: ${error}`);
-            }
-        }
-        else {
-            // Validate all known sys_ids in memory index
-            const memoryEntries = Array.from(this.memoryIndex.entries());
-            if (memoryEntries.length === 0) {
-                results.push('📝 No sys_ids found in memory index to validate');
-                return results;
-            }
-            results.push(`🔍 Validating ${memoryEntries.length} sys_ids from memory index...`);
-            let validCount = 0;
-            let invalidCount = 0;
-            for (const [key, data] of memoryEntries) {
-                // Extract sys_id and table from memory data if available
-                try {
-                    if (data.sys_id && data.table) {
-                        const record = await this.client.getRecord(data.table, data.sys_id);
-                        if (record && record.success && record.data) {
-                            validCount++;
-                        }
-                        else {
-                            invalidCount++;
-                            results.push(`❌ Invalid: ${data.sys_id} in ${data.table}`);
-                        }
-                    }
-                }
-                catch (error) {
-                    invalidCount++;
-                    results.push(`❌ Validation error for ${key}: ${error}`);
-                }
-            }
-            results.push(`✅ Validation complete: ${validCount} valid, ${invalidCount} invalid`);
-        }
-        return results;
-    }
-    async reindexArtifacts(table) {
-        const results = [];
-        if (table) {
-            // Re-index artifacts from specific table
-            try {
-                // Query the table to get current artifacts
-                const searchResults = await this.client.searchRecords(table, 'sys_idISNOTEMPTY', 100);
-                if (searchResults.success && searchResults.data) {
-                    const artifacts = Array.isArray(searchResults.data) ? searchResults.data : [searchResults.data];
-                    // Clear existing entries for this table
-                    for (const [key, data] of this.memoryIndex.entries()) {
-                        if (data.table === table) {
-                            this.memoryIndex.delete(key);
-                        }
-                    }
-                    // Re-index with fresh data
-                    let indexedCount = 0;
-                    for (const artifact of artifacts) {
-                        if (artifact.sys_id && artifact.name) {
-                            const indexKey = `${table}_${artifact.name.replace(/\s+/g, '_')}`;
-                            this.memoryIndex.set(indexKey, {
-                                sys_id: artifact.sys_id,
-                                table: table,
-                                name: artifact.name,
-                                type: this.getArtifactTypeFromTable(table),
-                                indexed_at: new Date().toISOString()
-                            });
-                            indexedCount++;
-                        }
-                    }
-                    results.push(`✅ Re-indexed ${indexedCount} artifacts from table: ${table}`);
-                }
-                else {
-                    results.push(`⚠️ Could not fetch artifacts from table: ${table}`);
-                }
-            }
-            catch (error) {
-                results.push(`❌ Re-indexing failed for table ${table}: ${error}`);
-            }
-        }
-        else {
-            // Re-index all known artifact tables
-            const artifactTables = ['sp_widget', 'wf_workflow', 'sys_script_include', 'sys_script'];
-            results.push(`🔍 Re-indexing artifacts from ${artifactTables.length} tables...`);
-            let totalIndexed = 0;
-            for (const tableName of artifactTables) {
-                const tableResults = await this.reindexArtifacts(tableName);
-                totalIndexed += tableResults.filter(r => r.includes('✅')).length;
-            }
-            results.push(`✅ Global re-indexing complete: ${totalIndexed} artifacts indexed`);
-            results.push(`💾 Memory index size: ${this.memoryIndex.size} entries`);
-        }
-        return results;
-    }
-    getArtifactTypeFromTable(table) {
-        const tableTypeMap = {
-            'sp_widget': 'widget',
-            'wf_workflow': 'flow',
-            'sys_script_include': 'script',
-            'sys_script': 'business_rule',
-            'sys_db_object': 'table'
-        };
-        return tableTypeMap[table] || 'unknown';
-    }
-    async performFullSync() {
-        const results = [];
-        // Combine all sync operations
-        const cacheResults = await this.refreshCache();
-        const validateResults = await this.validateSysIds();
-        const reindexResults = await this.reindexArtifacts();
-        results.push(...cacheResults, ...validateResults, ...reindexResults);
-        results.push('Full synchronization completed');
-        return results;
-    }
-    async validateLiveConnection(args) {
-        const { test_level = 'basic', include_performance = false } = args;
-        const startTime = Date.now();
-        const results = {
-            connection_status: 'unknown',
-            authentication_status: 'unknown',
-            permissions_status: 'unknown',
-            instance_info: {},
-            performance_metrics: {},
-            timestamp: new Date().toISOString()
-        };
-        try {
-            // Basic connection test
-            const systemInfo = await this.client.get('/api/now/table/sys_properties', { sysparm_limit: 1 });
-            const basicResponseTime = Date.now() - startTime;
-            results.connection_status = 'success';
-            results.authentication_status = 'success';
-            results.instance_info = {
-                instance_url: systemInfo.request?.host || 'unknown',
-                version: systemInfo.result?.[0]?.sys_created_on ? 'accessible' : 'unknown'
-            };
-            if (include_performance) {
-                results.performance_metrics.basic_response_time_ms = basicResponseTime;
-            }
-            // Full test - read permissions
-            if (test_level === 'full' || test_level === 'permissions') {
-                const testStartTime = Date.now();
-                const tableTest = await this.client.get('/api/now/table/sys_user', { sysparm_limit: 1 });
-                const readResponseTime = Date.now() - testStartTime;
-                results.permissions_status = tableTest.result ? 'read_success' : 'read_limited';
-                if (include_performance) {
-                    results.performance_metrics.read_test_response_time_ms = readResponseTime;
-                }
-            }
-            // Permissions test - write permissions  
-            if (test_level === 'permissions') {
-                try {
-                    const writeStartTime = Date.now();
-                    // Test write by creating a test record in a safe table
-                    const testRecord = await this.client.post('/api/now/table/sys_update_set', {
-                        name: `Test Connection ${Date.now()}`,
-                        description: 'Temporary test record for connection validation - safe to delete'
-                    });
-                    if (testRecord.result?.sys_id) {
-                        // Immediately delete the test record
-                        await this.client.delete(`/api/now/table/sys_update_set/${testRecord.result.sys_id}`);
-                        results.permissions_status = 'write_success';
-                    }
-                    const writeResponseTime = Date.now() - writeStartTime;
-                    if (include_performance) {
-                        results.performance_metrics.write_test_response_time_ms = writeResponseTime;
-                    }
-                }
-                catch (writeError) {
-                    results.permissions_status = 'write_failed';
-                    results.write_error = writeError instanceof Error ? writeError.message : 'Unknown write error';
-                }
-            }
-            return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-        }
-        catch (error) {
-            results.connection_status = 'failed';
-            results.error = error instanceof Error ? error.message : 'Unknown connection error';
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Live Connection Validation Failed:\n${JSON.stringify(results, null, 2)}`
-                    }] };
-        }
-    }
-    async batchDeploymentValidator(args) {
-        const { artifacts, validation_level = 'full', check_conflicts = true } = args;
-        try {
-            const validationResults = {
-                validation_timestamp: new Date().toISOString(),
-                validation_level,
-                total_artifacts: artifacts.length,
-                validation_summary: {
-                    passed: 0,
-                    failed: 0,
-                    warnings: 0
-                },
-                artifact_results: [],
-                conflicts_detected: [],
-                deployment_recommendations: []
-            };
-            // Validate each artifact
-            for (const artifact of artifacts) {
-                const artifactResult = {
-                    sys_id: artifact.sys_id,
-                    table: artifact.table,
-                    type: artifact.type,
-                    validation_status: 'pending',
-                    issues: [],
-                    recommendations: []
-                };
-                try {
-                    // Fetch artifact details
-                    const artifactData = await this.client.get(`/api/now/table/${artifact.table}/${artifact.sys_id}`);
-                    if (!artifactData.result) {
-                        artifactResult.validation_status = 'failed';
-                        artifactResult.issues.push('Artifact not found in ServiceNow');
-                        validationResults.validation_summary.failed++;
-                        continue;
-                    }
-                    artifactResult.artifact_data = artifactData.result;
-                    // Syntax validation
-                    if (validation_level === 'syntax' || validation_level === 'full') {
-                        const syntaxIssues = await this.validateArtifactSyntax(artifactData.result, artifact.type);
-                        artifactResult.issues.push(...syntaxIssues);
-                    }
-                    // Dependency validation  
-                    if (validation_level === 'dependencies' || validation_level === 'full') {
-                        const dependencyIssues = await this.validateArtifactDependencies(artifactData.result, artifact.type);
-                        artifactResult.issues.push(...dependencyIssues);
-                    }
-                    // Determine validation status
-                    if (artifactResult.issues.length === 0) {
-                        artifactResult.validation_status = 'passed';
-                        validationResults.validation_summary.passed++;
-                    }
-                    else if (artifactResult.issues.some((issue) => issue.severity === 'error')) {
-                        artifactResult.validation_status = 'failed';
-                        validationResults.validation_summary.failed++;
-                    }
-                    else {
-                        artifactResult.validation_status = 'warning';
-                        validationResults.validation_summary.warnings++;
-                    }
-                }
-                catch (error) {
-                    artifactResult.validation_status = 'failed';
-                    artifactResult.issues.push({
-                        severity: 'error',
-                        message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    });
-                    validationResults.validation_summary.failed++;
-                }
-                validationResults.artifact_results.push(artifactResult);
-            }
-            // Check for conflicts between artifacts
-            if (check_conflicts) {
-                validationResults.conflicts_detected = await this.detectArtifactConflicts(artifacts);
-            }
-            // Generate deployment recommendations
-            validationResults.deployment_recommendations = this.generateDeploymentRecommendations(validationResults);
-            return { content: [{ type: 'text', text: JSON.stringify(validationResults, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Batch Deployment Validation Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    async deploymentRollbackManager(args) {
-        const { update_set_id, action, rollback_reason, create_backup = true } = args;
-        try {
-            const rollbackResults = {
-                update_set_id,
-                action,
-                timestamp: new Date().toISOString(),
-                status: 'pending',
-                backup_created: false,
-                rollback_steps: []
-            };
-            // Get update set details
-            const updateSet = await this.client.get(`/api/now/table/sys_update_set/${update_set_id}`);
-            if (!updateSet.result) {
-                throw new Error(`Update Set not found: ${update_set_id}`);
-            }
-            rollbackResults.update_set_info = updateSet.result;
-            switch (action) {
-                case 'monitor':
-                    rollbackResults.status = 'monitoring';
-                    rollbackResults.monitoring_data = await this.monitorUpdateSetDeployment(update_set_id);
-                    break;
-                case 'validate_rollback':
-                    rollbackResults.status = 'validation_complete';
-                    rollbackResults.rollback_feasibility = await this.validateRollbackFeasibility(update_set_id);
-                    break;
-                case 'rollback':
-                    if (!rollback_reason) {
-                        throw new Error('Rollback reason is required for rollback action');
-                    }
-                    rollbackResults.rollback_reason = rollback_reason;
-                    // Create backup if requested
-                    if (create_backup) {
-                        const backupResult = await this.createUpdateSetBackup(update_set_id);
-                        rollbackResults.backup_created = true;
-                        rollbackResults.backup_info = backupResult;
-                    }
-                    // Perform rollback
-                    const rollbackSteps = await this.performUpdateSetRollback(update_set_id, rollback_reason);
-                    rollbackResults.rollback_steps = rollbackSteps;
-                    rollbackResults.status = 'rollback_complete';
-                    break;
-                default:
-                    throw new Error(`Unknown action: ${action}`);
-            }
-            return { content: [{ type: 'text', text: JSON.stringify(rollbackResults, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Rollback Management Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    // Helper methods for the new functionality
-    calculateFlowComplexity(steps) {
-        // Simple complexity calculation based on step count and script presence
-        let complexity = steps.length;
-        const scriptSteps = steps.filter(step => step.script && step.script.trim().length > 0);
-        complexity += scriptSteps.length * 2; // Script steps are more complex
-        return Math.min(complexity, 100); // Cap at 100
-    }
-    async validateArtifactSyntax(artifact, type) {
-        const issues = [];
-        // Basic syntax validation based on artifact type
-        if (type === 'script' && artifact.script) {
-            // Check for basic JavaScript syntax issues
-            if (artifact.script.includes('gs.') && !artifact.script.includes('current')) {
-                issues.push({
-                    severity: 'warning',
-                    message: 'Script uses gs. methods but may be missing current record context'
-                });
-            }
-        }
-        return issues;
-    }
-    async validateArtifactDependencies(artifact, type) {
-        const issues = [];
-        // Check for common dependency issues
-        if (artifact.sys_scope && artifact.sys_scope !== 'global') {
-            issues.push({
-                severity: 'info',
-                message: `Artifact is in scope: ${artifact.sys_scope}`
-            });
-        }
-        return issues;
-    }
-    async detectArtifactConflicts(artifacts) {
-        const conflicts = [];
-        // Check for naming conflicts
-        const names = artifacts.map(a => a.name).filter(Boolean);
-        const duplicateNames = names.filter((name, index) => names.indexOf(name) !== index);
-        for (const name of duplicateNames) {
-            conflicts.push({
-                type: 'naming_conflict',
-                message: `Multiple artifacts with name: ${name}`,
-                severity: 'warning'
-            });
-        }
-        return conflicts;
-    }
-    generateDeploymentRecommendations(validationResults) {
-        const recommendations = [];
-        if (validationResults.validation_summary.failed > 0) {
-            recommendations.push('Fix all failed validations before deployment');
-        }
-        if (validationResults.validation_summary.warnings > 0) {
-            recommendations.push('Review and address warnings for optimal deployment');
-        }
-        if (validationResults.conflicts_detected.length > 0) {
-            recommendations.push('Resolve conflicts between artifacts');
-        }
-        recommendations.push('Create backup before deployment');
-        recommendations.push('Test in non-production environment first');
-        return recommendations;
-    }
-    async monitorUpdateSetDeployment(updateSetId) {
-        // Get update set status and related updates
-        const updates = await this.client.get('/api/now/table/sys_update_xml', {
-            sysparm_query: `update_set=${updateSetId}`,
-            sysparm_fields: 'name,type,state,sys_created_on'
-        });
-        return {
-            total_updates: updates.result?.length || 0,
-            updates_by_state: this.groupUpdatesByState(updates.result || []),
-            last_activity: updates.result?.[0]?.sys_created_on || null
-        };
-    }
-    async validateRollbackFeasibility(updateSetId) {
-        return {
-            feasible: true,
-            considerations: [
-                'Rollback will revert all changes in this update set',
-                'Dependent changes may be affected',
-                'Data created by flows/scripts may not be automatically removed'
-            ],
-            estimated_impact: 'medium'
-        };
-    }
-    async createUpdateSetBackup(updateSetId) {
-        return {
-            backup_id: `backup_${updateSetId}_${Date.now()}`,
-            backup_timestamp: new Date().toISOString(),
-            status: 'created'
-        };
-    }
-    async performUpdateSetRollback(updateSetId, reason) {
-        return [
-            'Identified changes in update set',
-            'Created rollback plan',
-            'Would execute rollback (simulation mode)',
-            `Rollback reason: ${reason}`
-        ];
-    }
-    groupUpdatesByState(updates) {
-        const grouped = {};
-        for (const update of updates) {
-            const state = update.state || 'unknown';
-            grouped[state] = (grouped[state] || 0) + 1;
-        }
-        return grouped;
-    }
-    async escalatePermissions(args) {
-        const { required_roles, duration = 'session', reason, workflow_context } = args;
-        try {
-            const escalationResults = {
-                requested_roles: required_roles,
-                duration,
-                reason,
-                workflow_context,
-                timestamp: new Date().toISOString(),
-                escalation_status: 'pending',
-                current_permissions: {},
-                required_actions: []
-            };
-            // Get current user info
-            const whoAmI = await this.client.get('/api/now/table/sys_user', {
-                sysparm_query: 'user_name=admin', // Try admin user first
-                sysparm_fields: 'sys_id,user_name,name,email',
-                sysparm_limit: 1
-            });
-            const currentUser = whoAmI.result?.[0];
-            if (!currentUser) {
-                return { content: [{
-                            type: 'text',
-                            text: '❌ Could not identify current user. Please ensure you are logged in to ServiceNow.'
-                        }] };
-            }
-            // Get user roles
-            const userRoles = await this.client.get('/api/now/table/sys_user_has_role', {
-                sysparm_query: `user=${currentUser.sys_id}`,
-                sysparm_fields: 'role.name,role.description,inherited'
-            });
-            const currentRoles = userRoles.result?.map((r) => r.role?.name).filter(Boolean) || [];
-            const missingRoles = required_roles.filter((role) => !currentRoles.includes(role));
-            // Get instance URL
-            const instanceUrl = process.env.SNOW_INSTANCE ?
-                `https://${process.env.SNOW_INSTANCE.replace(/\/$/, '')}.service-now.com` :
-                'https://your-instance.service-now.com';
-            if (missingRoles.length === 0) {
-                return { content: [{
-                            type: 'text',
-                            text: `✅ **Permission Check Passed**\n\nYou already have all required roles:\n${required_roles.map((r) => `- ✓ ${r}`).join('\n')}\n\nNo escalation needed!`
-                        }] };
-            }
-            // Build actionable response
-            let response = `🔐 **Permission Escalation Required**\n\n`;
-            response += `**Current User:** ${currentUser.name} (${currentUser.user_name})\n`;
-            response += `**Current Roles:** ${currentRoles.length > 0 ? currentRoles.join(', ') : 'None'}\n`;
-            response += `**Missing Roles:** ${missingRoles.join(', ')}\n`;
-            response += `**Reason:** ${reason}\n`;
-            response += `**Duration:** ${duration}\n\n`;
-            response += `## 🎯 Required Actions:\n\n`;
-            // Provide specific instructions for each missing role
-            for (const role of missingRoles) {
-                response += `### ${role} Role\n`;
-                switch (role) {
-                    case 'admin':
-                        response += `The **admin** role provides:\n`;
-                        response += `- Global scope access for creating widgets, flows, and applications\n`;
-                        response += `- Ability to modify system tables and configurations\n`;
-                        response += `- Access to all ServiceNow modules and features\n\n`;
-                        response += `**How to obtain:**\n`;
-                        response += `1. Contact your ServiceNow administrator\n`;
-                        response += `2. Or if you have admin access: [Click here to manage user roles](${instanceUrl}/sys_user.do?sys_id=${currentUser.sys_id})\n`;
-                        response += `3. In the "Roles" related list, click "Edit" and add "admin"\n\n`;
-                        break;
-                    case 'app_creator':
-                        response += `The **app_creator** role provides:\n`;
-                        response += `- Create custom applications and scoped apps\n`;
-                        response += `- Design application modules and menus\n`;
-                        response += `- Manage application artifacts\n\n`;
-                        response += `**How to obtain:**\n`;
-                        response += `1. Request from ServiceNow administrator\n`;
-                        response += `2. Or navigate to: [User Administration > Users](${instanceUrl}/sys_user_list.do)\n`;
-                        response += `3. Find your user record and add "app_creator" role\n\n`;
-                        break;
-                    case 'system_administrator':
-                        response += `The **system_administrator** role provides:\n`;
-                        response += `- Full system access and configuration\n`;
-                        response += `- Advanced scripting and development capabilities\n`;
-                        response += `- Access to all system properties and settings\n\n`;
-                        response += `**How to obtain:**\n`;
-                        response += `1. This is a highly privileged role - contact system admin\n`;
-                        response += `2. Requires approval from ServiceNow instance owner\n\n`;
-                        break;
-                    case 'global_admin':
-                        response += `The **global_admin** role provides:\n`;
-                        response += `- Cross-scope application access\n`;
-                        response += `- Global artifact creation and management\n`;
-                        response += `- Override scope restrictions\n\n`;
-                        response += `**How to obtain:**\n`;
-                        response += `1. Contact ServiceNow administrator\n`;
-                        response += `2. May require business justification\n\n`;
-                        break;
-                    default:
-                        response += `The **${role}** role is required for this operation.\n\n`;
-                        response += `**How to obtain:**\n`;
-                        response += `1. Contact your ServiceNow administrator\n`;
-                        response += `2. Request temporary access for: "${reason}"\n\n`;
-                }
-            }
-            response += `## 💡 Alternative Solutions:\n\n`;
-            response += `1. **Use a development instance** where you have admin access\n`;
-            response += `2. **Request a personal developer instance** from [developer.servicenow.com](https://developer.servicenow.com)\n`;
-            response += `3. **Work with a team member** who has the required permissions\n`;
-            response += `4. **Use Update Sets** to package changes for deployment by an admin\n\n`;
-            response += `## 📋 Template Request for Admin:\n\n`;
-            response += `\`\`\`\n`;
-            response += `Subject: Temporary Permission Request - ${reason}\n\n`;
-            response += `Hi Admin,\n\n`;
-            response += `I need temporary access to the following roles for development:\n`;
-            response += `- Roles needed: ${missingRoles.join(', ')}\n`;
-            response += `- Reason: ${reason}\n`;
-            response += `- Duration: ${duration}\n`;
-            response += `- Context: ${workflow_context || 'ServiceNow multi-agent development'}\n\n`;
-            response += `These permissions can be revoked after the ${duration === 'session' ? 'current session' : duration}.\n\n`;
-            response += `Thank you!\n`;
-            response += `\`\`\``;
-            return { content: [{ type: 'text', text: response }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Permission Escalation Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    async analyzeRequirements(args) {
-        const { objective, auto_discover_dependencies = true, suggest_existing_components = true, create_dependency_map = true, scope_preference = 'auto' } = args;
-        try {
-            const _analysis = {
-                objective,
-                analysis_timestamp: new Date().toISOString(),
-                discovered_requirements: [],
-                existing_components: [],
-                dependency_map: {},
-                deployment_plan: {},
-                recommendations: []
-            };
-            // Parse objective to identify required components
-            const lowerObjective = objective.toLowerCase();
-            const requiredComponents = [];
-            // Intelligent component detection
-            if (lowerObjective.includes('provision') || lowerObjective.includes('user')) {
-                requiredComponents.push('user_management', 'provisioning_workflow');
-            }
-            if (lowerObjective.includes('iphone') || lowerObjective.includes('mobile') || lowerObjective.includes('device')) {
-                requiredComponents.push('mobile_device_management', 'device_catalog');
-            }
-            if (lowerObjective.includes('approval') || lowerObjective.includes('request')) {
-                requiredComponents.push('approval_workflow', 'request_management');
-            }
-            if (lowerObjective.includes('notification') || lowerObjective.includes('email')) {
-                requiredComponents.push('notification_system', 'email_templates');
-            }
-            _analysis.discovered_requirements = requiredComponents;
-            // Search for existing components if enabled
-            if (suggest_existing_components && requiredComponents.length > 0) {
-                for (const component of requiredComponents) {
-                    try {
-                        // Search flows
-                        const flows = await this.client.get('/api/now/table/wf_workflow', {
-                            sysparm_query: `name CONTAINS ${component} OR description CONTAINS ${component}`,
-                            sysparm_limit: 5,
-                            sysparm_fields: 'sys_id,name,description,active'
-                        });
-                        // Search widgets
-                        const widgets = await this.client.get('/api/now/table/sp_widget', {
-                            sysparm_query: `name CONTAINS ${component} OR title CONTAINS ${component}`,
-                            sysparm_limit: 5,
-                            sysparm_fields: 'sys_id,name,title,description'
-                        });
-                        // Search scripts
-                        const scripts = await this.client.get('/api/now/table/sys_script_include', {
-                            sysparm_query: `name CONTAINS ${component} OR description CONTAINS ${component}`,
-                            sysparm_limit: 5,
-                            sysparm_fields: 'sys_id,name,description,active'
-                        });
-                        if (flows.result?.length || widgets.result?.length || scripts.result?.length) {
-                            _analysis.existing_components.push({
-                                component_type: component,
-                                flows: flows.result || [],
-                                widgets: widgets.result || [],
-                                scripts: scripts.result || [],
-                                reuse_recommendation: 'Consider modifying existing components instead of creating new ones'
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Continue with other components if one fails
-                    }
-                }
-            }
-            // Create dependency map if enabled
-            if (create_dependency_map) {
-                _analysis.dependency_map = {
-                    primary_objective: objective,
-                    required_artifacts: requiredComponents.map(comp => ({
-                        name: comp,
-                        type: this.inferArtifactType(comp),
-                        dependencies: this.inferDependencies(comp),
-                        priority: this.inferPriority(comp, objective)
-                    })),
-                    deployment_order: this.calculateDeploymentOrder(requiredComponents)
-                };
-            }
-            // Generate deployment plan
-            _analysis.deployment_plan = {
-                scope_recommendation: this.recommendScope(scope_preference, requiredComponents),
-                estimated_complexity: requiredComponents.length > 3 ? 'high' : requiredComponents.length > 1 ? 'medium' : 'low',
-                estimated_time: `${requiredComponents.length * 2} hours`,
-                required_permissions: this.inferRequiredPermissions(requiredComponents),
-                update_set_strategy: 'Create single Update Set for all related artifacts'
-            };
-            // Generate recommendations
-            _analysis.recommendations = [
-                `Development approach: ${_analysis.deployment_plan.estimated_complexity} complexity project`,
-                `Recommended scope: ${_analysis.deployment_plan.scope_recommendation}`,
-                `Consider reusing ${_analysis.existing_components.length} existing components found`,
-                'Create comprehensive test scenarios for all workflows',
-                'Implement proper error handling and notifications'
-            ];
-            if (_analysis.existing_components.length > 0) {
-                _analysis.recommendations.push('📋 Review existing components before creating new artifacts');
-            }
-            return { content: [{ type: 'text', text: JSON.stringify(_analysis, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Requirements Analysis Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    async smartUpdateSet(args) {
-        const { action, auto_track_related_artifacts = true, conflict_detection = true, dependency_validation = true, rollback_points = true, update_set_name } = args;
-        try {
-            const results = {
-                action,
-                timestamp: new Date().toISOString(),
-                update_set_info: {},
-                tracked_artifacts: [],
-                conflicts_detected: [],
-                dependencies_validated: [],
-                rollback_points_created: []
-            };
-            switch (action) {
-                case 'create':
-                    if (!update_set_name) {
-                        throw new Error('update_set_name is required for create action');
-                    }
-                    const newUpdateSet = await this.client.post('/api/now/table/sys_update_set', {
-                        name: update_set_name,
-                        description: `Smart Update Set created by Snow-Flow at ${new Date().toISOString()}`,
-                        state: 'build'
-                    });
-                    results.update_set_info = newUpdateSet.result;
-                    results.status = 'created';
-                    break;
-                case 'track':
-                    // Get current update set
-                    const currentUpdateSets = await this.client.get('/api/now/table/sys_update_set', {
-                        sysparm_query: 'state=build',
-                        sysparm_limit: 1,
-                        sysparm_fields: 'sys_id,name,state'
-                    });
-                    if (currentUpdateSets.result?.[0]) {
-                        const updateSet = currentUpdateSets.result[0];
-                        // Get all updates in this set
-                        const updates = await this.client.get('/api/now/table/sys_update_xml', {
-                            sysparm_query: `update_set=${updateSet.sys_id}`,
-                            sysparm_fields: 'name,type,target_name,action'
-                        });
-                        results.update_set_info = updateSet;
-                        results.tracked_artifacts = updates.result || [];
-                    }
-                    break;
-                case 'validate':
-                    // Validate current update set
-                    const validationResults = await this.validateUpdateSetDependencies();
-                    results.dependencies_validated = validationResults;
-                    break;
-                case 'conflict_check':
-                    if (conflict_detection) {
-                        const conflicts = await this.detectUpdateSetConflicts();
-                        results.conflicts_detected = conflicts;
-                    }
-                    break;
-            }
-            // Add rollback points if enabled
-            if (rollback_points && results.update_set_info?.sys_id) {
-                results.rollback_points_created.push({
-                    checkpoint_id: `checkpoint_${Date.now()}`,
-                    update_set_id: results.update_set_info.sys_id,
-                    created_at: new Date().toISOString(),
-                    restoration_method: 'Use deployment_rollback_manager tool'
-                });
-            }
-            return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Smart Update Set Management Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    async orchestrateDevelopment(args) {
-        const { objective, auto_spawn_agents = true, shared_memory = true, parallel_execution = true, progress_monitoring = true, auto_permissions = false, smart_discovery = true, live_testing = true, auto_deploy = false } = args;
-        try {
-            const orchestration = {
-                objective,
-                orchestration_id: `orchestration_${Date.now()}`,
-                started_at: new Date().toISOString(),
-                status: 'initializing',
-                mode: auto_deploy ? '🚀 DEPLOYMENT MODE (WILL CREATE REAL ARTIFACTS)' : '📋 PLANNING MODE (ANALYSIS ONLY)',
-                warning: auto_deploy ? '⚠️ WARNING: This will create REAL artifacts in ServiceNow!' : '✅ SAFE: This is planning only, no artifacts will be created',
-                agents_spawned: [],
-                shared_memory_enabled: shared_memory,
-                progress_monitor: {},
-                execution_plan: {},
-                actual_deployments: []
-            };
-            // Step 1: Analyze requirements
-            if (smart_discovery) {
-                const requirementAnalysis = await this.analyzeRequirements({
-                    objective,
-                    auto_discover_dependencies: true,
-                    suggest_existing_components: true,
-                    create_dependency_map: true
-                });
-                orchestration.requirement__analysis = requirementAnalysis;
-            }
-            // Step 2: Check permissions
-            if (auto_permissions) {
-                const permissionCheck = await this.escalatePermissions({
-                    required_roles: ['admin', 'app_creator'],
-                    duration: 'workflow',
-                    reason: `Orchestrated development: ${objective}`
-                });
-                orchestration.permission_check = permissionCheck;
-            }
-            // Step 3: Create smart update set
-            const updateSetResult = await this.smartUpdateSet({
-                action: 'create',
-                update_set_name: `Orchestrated Development: ${objective.substring(0, 50)}`,
-                auto_track_related_artifacts: true,
-                conflict_detection: true,
-                rollback_points: true
-            });
-            orchestration.update_set = updateSetResult;
-            // Step 4: Generate execution plan
-            orchestration.execution_plan = {
-                phases: [
-                    {
-                        phase: 1,
-                        name: 'Discovery & Analysis',
-                        status: 'completed',
-                        duration_estimate: '10 minutes'
-                    },
-                    {
-                        phase: 2,
-                        name: 'Artifact Development',
-                        status: 'pending',
-                        duration_estimate: '30-60 minutes',
-                        parallel_execution_enabled: parallel_execution
-                    },
-                    {
-                        phase: 3,
-                        name: 'Testing & Validation',
-                        status: 'pending',
-                        duration_estimate: '15 minutes',
-                        live_testing_enabled: live_testing
-                    },
-                    {
-                        phase: 4,
-                        name: 'Deployment',
-                        status: 'pending',
-                        duration_estimate: '10 minutes',
-                        auto_deploy_enabled: auto_deploy
-                    }
-                ],
-                total_estimated_time: '65-95 minutes'
-            };
-            // Step 5: Set up progress monitoring
-            if (progress_monitoring) {
-                orchestration.progress_monitor = {
-                    enabled: true,
-                    monitoring_interval: '30 seconds',
-                    progress_tracking: 'real-time',
-                    completion_notifications: true
-                };
-            }
-            // Step 6: Execute actual deployment if auto_deploy is enabled
-            if (auto_deploy) {
-                orchestration.status = 'executing_deployment';
-                // Attempt to create real artifacts based on the objective
-                try {
-                    const artifactAnalysis = await this.analyzeArtifactRequirements(objective);
-                    for (const artifact of artifactAnalysis.recommended_artifacts) {
-                        try {
-                            let deploymentResult;
-                            if (artifact.type === 'flow') {
-                                // Use flow composer to create real flow
-                                deploymentResult = await this.client.post('/api/now/table/sys_hub_flow', {
-                                    name: artifact.name,
-                                    description: artifact.description,
-                                    active: true,
-                                    type: 'flow'
-                                });
-                            }
-                            else if (artifact.type === 'widget') {
-                                // Create real widget
-                                deploymentResult = await this.client.post('/api/now/table/sp_widget', {
-                                    name: artifact.name,
-                                    title: artifact.name,
-                                    description: artifact.description,
-                                    template: artifact.template || '<div>{{data.message || "Widget created"}}</div>',
-                                    css: artifact.css || '',
-                                    client_script: artifact.client_script || '',
-                                    server_script: artifact.server_script || '(function() { data.message = "Successfully deployed!"; })()',
-                                    public: true,
-                                    has_preview: true
-                                });
-                            }
-                            if (deploymentResult?.result) {
-                                orchestration.actual_deployments.push({
-                                    type: artifact.type,
-                                    name: artifact.name,
-                                    sys_id: deploymentResult.result.sys_id,
-                                    status: 'deployed',
-                                    url: `https://${process.env.SNOW_INSTANCE ? process.env.SNOW_INSTANCE.replace(/\/$/, '') : 'instance'}.service-now.com/nav_to.do?uri=${artifact.type === 'flow' ? 'sys_hub_flow' : 'sp_widget'}.do?sys_id=${deploymentResult.result.sys_id}`
-                                });
-                            }
-                        }
-                        catch (deployError) {
-                            orchestration.actual_deployments.push({
-                                type: artifact.type,
-                                name: artifact.name,
-                                status: 'failed',
-                                error: deployError instanceof Error ? deployError.message : String(deployError)
-                            });
-                        }
-                    }
-                    orchestration.status = 'deployment_complete';
-                    orchestration.completed_at = new Date().toISOString();
-                }
-                catch (error) {
-                    orchestration.status = 'deployment_failed';
-                    orchestration.deployment_error = error instanceof Error ? error.message : String(error);
-                }
-            }
-            else {
-                orchestration.status = 'planning_complete';
-                orchestration.completed_at = new Date().toISOString();
-            }
-            // Set appropriate next steps based on mode
-            if (auto_deploy) {
-                if (orchestration.actual_deployments.length > 0) {
-                    orchestration.next_steps = [
-                        '✅ DEPLOYMENT COMPLETE: Real artifacts have been created in ServiceNow',
-                        `📊 Created ${orchestration.actual_deployments.filter((d) => d.status === 'deployed').length} artifacts successfully`,
-                        'Use snow_test_flow_execution or snow_widget_test to validate deployments',
-                        'Check ServiceNow instance to verify artifacts are working correctly'
-                    ];
-                }
-                else {
-                    orchestration.next_steps = [
-                        '❌ DEPLOYMENT FAILED: No artifacts were created',
-                        'Check deployment errors in actual_deployments array',
-                        'Verify ServiceNow permissions and authentication',
-                        'Consider running in planning mode first (auto_deploy: false)'
-                    ];
-                }
-            }
-            else {
-                orchestration.next_steps = [
-                    '📋 PLANNING COMPLETE: This was _analysis only - no artifacts created',
-                    '🚀 To deploy: Re-run with auto_deploy: true',
-                    'Execute specific MCP tools manually:',
-                    '  - snow_create_flow for flow creation',
-                    '  - snow_create_artifact for widget/artifact deployment',
-                    '  - snow_resilient_deployment for batch deployment'
-                ];
-            }
-            return { content: [{ type: 'text', text: JSON.stringify(orchestration, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Development Orchestration Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    async resilientDeployment(args) {
-        const { artifacts, retry_on_failure = true, fallback_strategies = ['global_scope', 'manual_approval'], checkpoint_restoration = true, graceful_degradation = true, max_retries = 3 } = args;
-        try {
-            const deployment = {
-                deployment_id: `deployment_${Date.now()}`,
-                started_at: new Date().toISOString(),
-                artifacts_count: artifacts.length,
-                status: 'initializing',
-                deployment_results: [],
-                checkpoints: [],
-                fallback_actions: [],
-                recovery_plan: {}
-            };
-            // Create checkpoint before deployment
-            if (checkpoint_restoration) {
-                const checkpoint = {
-                    checkpoint_id: `pre_deployment_${Date.now()}`,
-                    created_at: new Date().toISOString(),
-                    artifacts_state: 'captured',
-                    restoration_available: true
-                };
-                deployment.checkpoints.push(checkpoint);
-            }
-            // Process each artifact with resilient deployment
-            for (let i = 0; i < artifacts.length; i++) {
-                const artifact = artifacts[i];
-                const artifactResult = {
-                    artifact_index: i + 1,
-                    artifact_id: artifact.sys_id || artifact.id,
-                    status: 'pending',
-                    attempts: 0,
-                    max_retries,
-                    fallback_used: false
-                };
-                let deploymentSuccess = false;
-                let lastError = null;
-                // Retry logic
-                while (!deploymentSuccess && artifactResult.attempts < max_retries) {
-                    artifactResult.attempts++;
-                    try {
-                        // Attempt deployment (this would call actual deployment APIs)
-                        const deployResult = await this.attemptArtifactDeployment(artifact);
-                        if (deployResult.success) {
-                            artifactResult.status = 'deployed';
-                            artifactResult.deployment_details = deployResult.details;
-                            deploymentSuccess = true;
-                        }
-                    }
-                    catch (error) {
-                        lastError = error;
-                        if (retry_on_failure && artifactResult.attempts < max_retries) {
-                            artifactResult.status = `retry_${artifactResult.attempts}`;
-                            // Wait before retry
-                            await new Promise(resolve => setTimeout(resolve, 2000 * artifactResult.attempts));
-                        }
-                    }
-                }
-                // Apply fallback strategies if deployment failed
-                if (!deploymentSuccess && fallback_strategies.length > 0) {
-                    for (const strategy of fallback_strategies) {
-                        try {
-                            const fallbackResult = await this.applyFallbackStrategy(artifact, strategy);
-                            if (fallbackResult.success) {
-                                artifactResult.status = 'deployed_with_fallback';
-                                artifactResult.fallback_used = strategy;
-                                artifactResult.fallback_details = fallbackResult.details;
-                                deploymentSuccess = true;
-                                break;
-                            }
-                        }
-                        catch (fallbackError) {
-                            // Continue to next fallback strategy
-                        }
-                    }
-                }
-                // Final status
-                if (!deploymentSuccess) {
-                    artifactResult.status = 'failed';
-                    artifactResult.error = lastError instanceof Error ? lastError.message : 'Deployment failed';
-                    if (graceful_degradation) {
-                        artifactResult.degradation_applied = true;
-                        artifactResult.degradation_note = 'Artifact marked for manual deployment';
-                    }
-                }
-                deployment.deployment_results.push(artifactResult);
-            }
-            // Generate recovery plan
-            const failedArtifacts = deployment.deployment_results.filter((r) => r.status === 'failed');
-            if (failedArtifacts.length > 0) {
-                deployment.recovery_plan = {
-                    failed_artifacts_count: failedArtifacts.length,
-                    recovery_options: [
-                        'Use checkpoint restoration to revert to pre-deployment state',
-                        'Manual deployment of failed artifacts',
-                        'Adjust permissions and retry deployment',
-                        'Contact ServiceNow administrator for assistance'
-                    ],
-                    checkpoint_available: checkpoint_restoration
-                };
-            }
-            // Overall deployment status
-            const successCount = deployment.deployment_results.filter((r) => r.status === 'deployed' || r.status === 'deployed_with_fallback').length;
-            deployment.status = successCount === artifacts.length ? 'completed' :
-                successCount > 0 ? 'partially_completed' : 'failed';
-            deployment.success_rate = `${successCount}/${artifacts.length}`;
-            return { content: [{ type: 'text', text: JSON.stringify(deployment, null, 2) }] };
-        }
-        catch (error) {
-            return { content: [{
-                        type: 'text',
-                        text: `❌ Resilient Deployment Failed: ${error instanceof Error ? error.message : 'Unknown error'}`
-                    }] };
-        }
-    }
-    // Helper methods for the new functionality
-    inferArtifactType(component) {
-        if (component.includes('workflow') || component.includes('approval'))
-            return 'flow';
-        if (component.includes('management') || component.includes('catalog'))
-            return 'widget';
-        if (component.includes('notification') || component.includes('email'))
-            return 'script';
-        return 'mixed';
-    }
-    inferDependencies(component) {
-        const deps = [];
-        if (component.includes('user'))
-            deps.push('user_table');
-        if (component.includes('device'))
-            deps.push('device_catalog', 'cmdb');
-        if (component.includes('approval'))
-            deps.push('approval_engine', 'notification_system');
-        return deps;
-    }
-    inferPriority(component, objective) {
-        if (objective.toLowerCase().includes(component))
-            return 'high';
-        if (component.includes('workflow') || component.includes('approval'))
-            return 'high';
-        return 'medium';
-    }
-    calculateDeploymentOrder(components) {
-        // Basic dependency-based ordering
-        const ordered = [...components];
-        return ordered.sort((a, b) => {
-            if (a.includes('table') || a.includes('catalog'))
-                return -1;
-            if (b.includes('table') || b.includes('catalog'))
-                return 1;
-            if (a.includes('script'))
-                return -1;
-            if (b.includes('script'))
-                return 1;
-            return 0;
-        });
-    }
-    recommendScope(preference, components) {
-        if (preference !== 'auto')
-            return preference;
-        return components.length > 2 ? 'scoped' : 'global';
-    }
-    inferRequiredPermissions(components) {
-        const permissions = ['basic_user'];
-        if (components.some(c => c.includes('workflow') || c.includes('approval'))) {
-            permissions.push('workflow_designer');
-        }
-        if (components.some(c => c.includes('widget') || c.includes('portal'))) {
-            permissions.push('sp_portal_manager');
-        }
-        if (components.length > 3) {
-            permissions.push('admin');
-        }
-        return permissions;
-    }
-    async validateUpdateSetDependencies() {
-        // Simplified dependency validation
-        return [
-            { dependency: 'user_table', status: 'validated', details: 'Required table exists' },
-            { dependency: 'approval_engine', status: 'validated', details: 'Approval framework available' }
-        ];
-    }
-    async detectUpdateSetConflicts() {
-        // Simplified conflict detection
-        return [
-            { conflict_type: 'naming', severity: 'warning', description: 'Similar named artifacts found' }
-        ];
-    }
-    async attemptArtifactDeployment(artifact) {
-        // 🔧 CRITICAL FIX: Replace mock implementation with real ServiceNow API calls
-        this.logger.info('Attempting real artifact deployment', {
-            type: artifact.type,
-            name: artifact.name || artifact.config?.name
-        });
-        try {
-            let result;
-            switch (artifact.type) {
-                case 'flow':
-                    // Use the existing createFlow method
-                    result = await this.client.createFlow({
-                        name: artifact.config.name,
-                        description: artifact.config.description,
-                        type: artifact.config.flow_type || 'flow',
-                        table: artifact.config.table,
-                        trigger_type: artifact.config.trigger_type,
-                        condition: artifact.config.condition,
-                        active: artifact.config.active !== false,
-                        flow_definition: artifact.config.flow_definition,
-                        category: artifact.config.category || 'automation'
-                    });
-                    break;
-                case 'subflow':
-                    // Use the existing createSubflow method
-                    result = await this.client.createSubflow({
-                        name: artifact.config.name,
-                        description: artifact.config.description,
-                        inputs: artifact.config.inputs || [],
-                        outputs: artifact.config.outputs || [],
-                        activities: artifact.config.activities || [],
-                        category: artifact.config.category || 'custom'
-                    });
-                    break;
-                case 'widget':
-                    // Use existing createRecord method for Service Portal widgets
-                    result = await this.client.createRecord('sp_widget', {
-                        name: artifact.config.name,
-                        title: artifact.config.title || artifact.config.name,
-                        description: artifact.config.description,
-                        template: artifact.config.template || '<div>Widget content</div>',
-                        css: artifact.config.css || '',
-                        client_script: artifact.config.client_script || '',
-                        server_script: artifact.config.server_script || '',
-                        option_schema: artifact.config.option_schema || '[]',
-                        category: artifact.config.category || 'custom'
-                    });
-                    break;
-                case 'business_rule':
-                    // Create business rule
-                    result = await this.client.createRecord('sys_script', {
-                        name: artifact.config.name,
-                        description: artifact.config.description,
-                        table: artifact.config.table || 'incident',
-                        when: artifact.config.when || 'before',
-                        active: artifact.config.active !== false,
-                        script: artifact.config.script || '// Business rule script',
-                        condition: artifact.config.condition || '',
-                        order: artifact.config.order || 100
-                    });
-                    break;
-                case 'script_include':
-                    // Create script include
-                    result = await this.client.createRecord('sys_script_include', {
-                        name: artifact.config.name,
-                        description: artifact.config.description,
-                        script: artifact.config.script || 'var ' + artifact.config.name + ' = Class.create();',
-                        api_name: artifact.config.api_name || artifact.config.name,
-                        active: artifact.config.active !== false,
-                        accessible_from: artifact.config.accessible_from || 'all'
-                    });
-                    break;
-                case 'table':
-                    // Create custom table
-                    result = await this.client.createRecord('sys_db_object', {
-                        name: artifact.config.name,
-                        label: artifact.config.label || artifact.config.name,
-                        super_class: artifact.config.super_class || 'task',
-                        create_module: artifact.config.create_module !== false,
-                        create_menu: artifact.config.create_menu !== false
-                    });
-                    break;
-                case 'application':
-                    // Create scoped application
-                    result = await this.client.createRecord('sys_app', {
-                        name: artifact.config.name,
-                        description: artifact.config.description,
-                        scope: artifact.config.scope || 'x_custom_' + artifact.config.name.toLowerCase().replace(/\s+/g, '_'),
-                        version: artifact.config.version || '1.0.0',
-                        vendor: artifact.config.vendor || 'Custom',
-                        private: artifact.config.private !== false
-                    });
-                    break;
-                default:
-                    throw new Error(`Unsupported artifact type: ${artifact.type}`);
-            }
-            if (result.success) {
-                this.logger.info('Artifact deployed successfully', {
-                    type: artifact.type,
-                    name: artifact.config.name,
-                    sys_id: result.data?.sys_id
-                });
-                return {
-                    success: true,
-                    details: {
-                        deployed_at: new Date().toISOString(),
-                        sys_id: result.data?.sys_id,
-                        url: result.data?.url,
-                        type: artifact.type,
-                        name: artifact.config.name,
-                        deployment_method: 'real_api_call'
-                    }
-                };
-            }
-            else {
-                throw new Error(result.error || 'Unknown deployment error');
-            }
-        }
-        catch (error) {
-            this.logger.error('Artifact deployment failed', {
-                type: artifact.type,
-                name: artifact.config?.name,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                details: {
-                    attempted_at: new Date().toISOString(),
-                    type: artifact.type,
-                    name: artifact.config?.name,
-                    deployment_method: 'real_api_call'
-                }
-            };
-        }
-    }
-    async applyFallbackStrategy(artifact, strategy) {
-        // 🔧 CRITICAL FIX: Replace mock fallback with real implementation strategies
-        this.logger.info('Applying fallback strategy', {
-            strategy,
-            artifactType: artifact.type,
-            artifactName: artifact.config?.name
-        });
-        try {
-            let result;
-            switch (strategy) {
-                case 'global_scope':
-                    // Try deploying to global scope with enhanced permissions
-                    artifact.config.scope = 'global';
-                    artifact.config.sys_domain = 'global';
-                    result = await this.attemptArtifactDeployment(artifact);
-                    break;
-                case 'simplified_version':
-                    // Create a simplified version of the artifact
-                    const simplifiedArtifact = { ...artifact };
-                    if (artifact.type === 'flow') {
-                        // Simplify flow definition - remove complex activities
-                        const flowDef = typeof artifact.config.flow_definition === 'string'
-                            ? JSON.parse(artifact.config.flow_definition)
-                            : artifact.config.flow_definition;
-                        if (flowDef.activities) {
-                            flowDef.activities = flowDef.activities.filter((activity) => ['approval', 'notification', 'script'].includes(activity.type));
-                        }
-                        simplifiedArtifact.config.flow_definition = JSON.stringify(flowDef);
-                        simplifiedArtifact.config.name += '_simplified';
-                    }
-                    else if (artifact.type === 'widget') {
-                        // Generate simplified but functional widget template
-                        const widgetInstruction = artifact.config.description || artifact.config.name || 'simplified widget';
-                        const generatedWidget = widget_template_generator_js_1.widgetTemplateGenerator.generateWidget({
-                            title: artifact.config.title || artifact.config.name,
-                            instruction: widgetInstruction,
-                            type: 'info', // Use info type for simplified widgets
-                            theme: 'minimal',
-                            responsive: true
-                        });
-                        simplifiedArtifact.config.template = generatedWidget.template;
-                        simplifiedArtifact.config.css = generatedWidget.css;
-                        simplifiedArtifact.config.client_script = generatedWidget.clientScript;
-                        simplifiedArtifact.config.server_script = generatedWidget.serverScript;
-                        simplifiedArtifact.config.option_schema = generatedWidget.optionSchema;
-                        simplifiedArtifact.config.name += '_simplified';
-                    }
-                    result = await this.attemptArtifactDeployment(simplifiedArtifact);
-                    break;
-                case 'business_rule_fallback':
-                    // Convert flow to business rule as fallback
-                    if (artifact.type === 'flow') {
-                        const businessRuleConfig = {
-                            name: `BR_${artifact.config.name}`,
-                            description: `Business Rule fallback for flow: ${artifact.config.name}`,
-                            table: artifact.config.table || 'incident',
-                            when: 'after',
-                            script: `
-// Auto-generated Business Rule fallback for Flow: ${artifact.config.name}
-// Original flow description: ${artifact.config.description || 'No description'}
-
-try {
-  // Basic automation logic
-  if (current.isNewRecord()) {
-    gs.info('Record created, executing flow logic: ${artifact.config.name}');
-    
-    // Add your custom logic here based on original flow
-    ${this.generateBusinessRuleScript(artifact.config)}
-  }
-} catch (e) {
-  gs.error('Business Rule fallback error: ' + e.message);
-}
-              `.trim(),
-                            active: true,
-                            condition: artifact.config.condition || ''
-                        };
-                        result = await this.client.createRecord('sys_script', businessRuleConfig);
-                    }
-                    else {
-                        throw new Error('Business rule fallback only available for flows');
-                    }
-                    break;
-                case 'minimal_deployment':
-                    // Deploy with absolute minimum configuration
-                    const minimalArtifact = { ...artifact };
-                    // Strip all non-essential properties
-                    const essentialFields = ['name', 'description', 'active'];
-                    const cleanedConfig = {};
-                    essentialFields.forEach(field => {
-                        if (artifact.config[field] !== undefined) {
-                            cleanedConfig[field] = artifact.config[field];
-                        }
-                    });
-                    // Add type-specific essentials
-                    if (artifact.type === 'flow') {
-                        cleanedConfig.type = 'subflow'; // Subflows are simpler
-                        cleanedConfig.category = 'custom';
-                    }
-                    else if (artifact.type === 'widget') {
-                        // Generate minimal but functional widget template
-                        const widgetInstruction = artifact.config.description || artifact.config.name || 'minimal widget';
-                        const generatedWidget = widget_template_generator_js_1.widgetTemplateGenerator.generateWidget({
-                            title: artifact.config.title || artifact.config.name,
-                            instruction: widgetInstruction,
-                            type: 'info', // Use info type for minimal widgets
-                            theme: 'minimal',
-                            responsive: true
-                        });
-                        cleanedConfig.template = generatedWidget.template;
-                        cleanedConfig.css = generatedWidget.css;
-                        cleanedConfig.client_script = generatedWidget.clientScript;
-                        cleanedConfig.server_script = generatedWidget.serverScript;
-                        cleanedConfig.option_schema = generatedWidget.optionSchema;
-                        cleanedConfig.title = artifact.config.title || artifact.config.name;
-                    }
-                    minimalArtifact.config = cleanedConfig;
-                    minimalArtifact.config.name += '_minimal';
-                    result = await this.attemptArtifactDeployment(minimalArtifact);
-                    break;
-                case 'delayed_retry':
-                    // Wait and retry original deployment
-                    await new Promise(resolve => setTimeout(resolve, 2000));
-                    result = await this.attemptArtifactDeployment(artifact);
-                    break;
-                default:
-                    throw new Error(`Unknown fallback strategy: ${strategy}`);
-            }
-            if (result.success) {
-                this.logger.info('Fallback strategy successful', {
-                    strategy,
-                    artifactType: artifact.type,
-                    artifactName: artifact.config?.name,
-                    deployedSysId: result.details?.sys_id
-                });
-                return {
-                    success: true,
-                    details: {
-                        fallback_strategy: strategy,
-                        applied_at: new Date().toISOString(),
-                        original_artifact: artifact.config?.name,
-                        deployed_artifact: result.details?.name || artifact.config?.name,
-                        sys_id: result.details?.sys_id,
-                        deployment_method: 'fallback_strategy'
-                    }
-                };
-            }
-            else {
-                throw new Error(result.error || `Fallback strategy ${strategy} failed`);
-            }
-        }
-        catch (error) {
-            this.logger.error('Fallback strategy failed', {
-                strategy,
-                artifactType: artifact.type,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                details: {
-                    fallback_strategy: strategy,
-                    attempted_at: new Date().toISOString(),
-                    original_artifact: artifact.config?.name,
-                    deployment_method: 'fallback_strategy'
-                }
-            };
-        }
-    }
-    generateBusinessRuleScript(flowConfig) {
-        // Generate basic business rule script based on flow configuration
-        let script = '// Generated business rule logic\n';
-        if (flowConfig.trigger_type === 'record_created') {
-            script += 'gs.info("Record created trigger activated");\n';
-        }
-        if (flowConfig.condition) {
-            script += `// Original condition: ${flowConfig.condition}\n`;
-        }
-        script += 'gs.info("Business rule executed successfully");\n';
-        return script;
-    }
-    async generateFlowTestData(flow) {
-        return {
-            test_record: { state: 'new', priority: 'medium' },
-            user_context: { role: 'test_user', department: 'IT' },
-            variables: { test_mode: true }
-        };
-    }
-    async runFunctionalTests(flowId, testData) {
-        return [
-            { test_name: 'Basic Flow Execution', status: 'passed', duration: '2.5s' },
-            { test_name: 'Variable Passing', status: 'passed', duration: '1.2s' }
-        ];
-    }
-    async runEdgeCaseTests(flowId) {
-        return [
-            { test_name: 'Null Input Handling', status: 'passed', duration: '1.8s' },
-            { test_name: 'Invalid State Transition', status: 'failed', error: 'State validation missing' }
-        ];
-    }
-    async runPerformanceTests(flowId) {
-        return [
-            { test_name: 'Execution Time', status: 'passed', duration: '3.2s', threshold: '5s' },
-            { test_name: 'Memory Usage', status: 'passed', memory: '12MB', threshold: '50MB' }
-        ];
-    }
-    async runIntegrationTests(flowId) {
-        return [
-            { test_name: 'External API Calls', status: 'passed', duration: '4.1s' },
-            { test_name: 'Database Operations', status: 'passed', duration: '2.8s' }
-        ];
-    }
-    async runCustomTestScenario(flowId, scenario) {
-        return {
-            scenario_name: scenario.name || 'Custom Scenario',
-            status: 'passed',
-            duration: '2.1s',
-            details: 'Custom scenario executed successfully'
-        };
-    }
-    async analyzeArtifactRequirements(objective) {
-        const artifactAnalysis = {
-            objective,
-            recommended_artifacts: []
-        };
-        const lowerObjective = objective.toLowerCase();
-        // Simple keyword-based _analysis for artifact type detection
-        if (lowerObjective.includes('flow') || lowerObjective.includes('workflow') || lowerObjective.includes('automation')) {
-            artifactAnalysis.recommended_artifacts.push({
-                type: 'flow',
-                name: `Flow for ${objective.substring(0, 50)}`,
-                description: `Automated flow created for: ${objective}`,
-                priority: 'high'
-            });
-        }
-        if (lowerObjective.includes('widget') || lowerObjective.includes('dashboard') || lowerObjective.includes('display')) {
-            artifactAnalysis.recommended_artifacts.push({
-                type: 'widget',
-                name: `Widget for ${objective.substring(0, 50)}`,
-                description: `Service Portal widget for: ${objective}`,
-                template: '<div class="panel panel-default"><div class="panel-body">{{data.message || "Widget deployed successfully"}}<br><small>Created for: ' + objective + '</small></div></div>',
-                css: '.panel { margin: 10px; }',
-                client_script: 'function() { console.log("Widget loaded"); }',
-                server_script: '(function() { data.message = "Successfully deployed for: ' + objective.replace(/"/g, '\\"') + '"; })()',
-                priority: 'medium'
-            });
-        }
-        if (lowerObjective.includes('script') || lowerObjective.includes('function') || lowerObjective.includes('utility')) {
-            artifactAnalysis.recommended_artifacts.push({
-                type: 'script_include',
-                name: `Script for ${objective.substring(0, 50)}`,
-                description: `Script include for: ${objective}`,
-                script: `// Script created for: ${objective}\nvar ScriptUtility = Class.create();\nScriptUtility.prototype = {\n  initialize: function() {},\n  execute: function() {\n    gs.info('Script executed for: ${objective}');\n    return true;\n  },\n  type: 'ScriptUtility'\n};\n`,
-                priority: 'low'
-            });
-        }
-        // If no specific artifacts detected, create a default flow
-        if (artifactAnalysis.recommended_artifacts.length === 0) {
-            artifactAnalysis.recommended_artifacts.push({
-                type: 'flow',
-                name: `General Flow for ${objective.substring(0, 40)}`,
-                description: `General purpose flow for: ${objective}`,
-                priority: 'medium'
-            });
-        }
-        return artifactAnalysis;
-    }
-    generateTestRecommendations(testResults) {
-        const recommendations = [];
-        if (testResults.test_summary.success_rate < 90) {
-            recommendations.push('⚠️ Consider addressing failed tests before deployment');
-        }
-        recommendations.push('✅ Implement monitoring for production flow execution');
-        recommendations.push('📊 Set up performance baselines for future comparisons');
-        return recommendations;
-    }
-    async findFlowByNameOrSysId(identifier) {
-        try {
-            // First try as sys_id in sys_hub_flow
-            const result = await this.client.get(`/api/now/table/sys_hub_flow/${identifier}`);
-            if (result.result) {
-                result.result.sys_class_name = 'sys_hub_flow';
-                return result.result;
-            }
-        }
-        catch (error) {
-            // Not a sys_id in sys_hub_flow
-        }
-        try {
-            // Try as sys_id in wf_workflow
-            const result = await this.client.get(`/api/now/table/wf_workflow/${identifier}`);
-            if (result.result) {
-                result.result.sys_class_name = 'wf_workflow';
-                return result.result;
-            }
-        }
-        catch (error) {
-            // Not a sys_id in wf_workflow
-        }
-        // Search by name in both tables
-        try {
-            // Search in sys_hub_flow
-            const modernFlows = await this.client.get('/api/now/table/sys_hub_flow', {
-                sysparm_query: `name=${identifier}^ORnameSTARTSWITH${identifier}`,
-                sysparm_limit: 1,
-                sysparm_fields: 'name,description,active,type,status,sys_id,latest_snapshot'
-            });
-            if (modernFlows.result && modernFlows.result.length > 0) {
-                modernFlows.result[0].sys_class_name = 'sys_hub_flow';
-                return modernFlows.result[0];
-            }
-        }
-        catch (error) {
-            // Continue to legacy search
-        }
-        try {
-            // Search in wf_workflow
-            const legacyFlows = await this.client.get('/api/now/table/wf_workflow', {
-                sysparm_query: `name=${identifier}^ORnameSTARTSWITH${identifier}`,
-                sysparm_limit: 1,
-                sysparm_fields: 'name,description,active,table,sys_id'
-            });
-            if (legacyFlows.result && legacyFlows.result.length > 0) {
-                legacyFlows.result[0].sys_class_name = 'wf_workflow';
-                return legacyFlows.result[0];
-            }
-        }
-        catch (error) {
-            // No results found
-        }
-        return null;
-    }
-    /**
-     * 🔴 SNOW-002 FIX: Verify artifact is searchable after creation
-     * This method is called by other MCP servers after creating artifacts
-     */
-    async generateDocumentation(args) {
-        try {
-            this.logger.info('📚 Generating autonomous documentation', args);
-            const result = await this.documentationSystem.generateDocumentation({
-                scope: args.scope || 'full',
-                components: args.components,
-                format: args.format || 'markdown',
-                includePrivate: false,
-                includeDiagrams: args.include_diagrams !== false,
-                includeExamples: args.include_examples !== false,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Documentation generated successfully!
-
-📊 Summary:
-- Quality Score: ${result.profile.analytics.qualityScore}/100
-- Completeness: ${result.profile.analytics.completeness}%
-- Sections: ${result.profile.sections.length}
-- Diagrams: ${result.profile.diagrams.length}
-- APIs Documented: ${result.profile.apiDocumentation.length}
-
-📁 Output: ${result.outputPath || 'Generated in memory'}
-
-⚠️ Warnings: ${result.warnings.length > 0 ? result.warnings.join('\n') : 'None'}
-
-💡 Suggestions:
-${result.suggestions.map(s => `- ${s}`).join('\n')}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Documentation generation failed', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Documentation generation failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async getDocumentationSuggestions(args) {
-        try {
-            this.logger.info('💡 Getting documentation suggestions', args);
-            // Get latest profile if not specified
-            let profileId = args.profile_id;
-            if (!profileId) {
-                const profiles = this.documentationSystem.getDocumentationProfiles();
-                if (profiles.length === 0) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: '⚠️ No documentation profiles found. Please generate documentation first using snow_generate_documentation.',
-                            },
-                        ],
-                    };
-                }
-                profileId = profiles[0].id;
-            }
-            const suggestions = await this.documentationSystem.suggestDocumentationImprovements(profileId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `📊 Documentation Improvement Suggestions
-
-Priority: ${suggestions.priority.toUpperCase()}
-Estimated Time: ${suggestions.estimatedTime} minutes
-
-📋 Suggestions:
-${suggestions.suggestions.map((s, i) => `
-${i + 1}. ${s.title} (${s.impact} impact, ${s.effort} effort)
-   ${s.description}
-   Components: ${s.components.join(', ')}
-   ${s.automated ? '✅ Can be automated' : '⚠️ Manual intervention required'}`).join('\n')}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Failed to get documentation suggestions', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Failed to get suggestions: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async startContinuousDocumentation(args) {
-        try {
-            this.logger.info('🔄 Starting continuous documentation', args);
-            await this.documentationSystem.startContinuousDocumentation({
-                interval: args.interval,
-                scope: args.scope,
-                autoCommit: args.auto_commit || false,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `✅ Continuous documentation started!
-
-🔄 Configuration:
-- Update Interval: ${args.interval ? `${args.interval / 1000 / 60} minutes` : '60 minutes (default)'}
-- Monitored Components: ${args.scope ? args.scope.join(', ') : 'All components'}
-- Auto-commit: ${args.auto_commit ? 'Enabled' : 'Disabled'}
-
-📝 The system will now automatically:
-- Monitor for changes
-- Update documentation incrementally
-- Generate diagrams for new components
-- Track API changes
-- Maintain change logs
-
-Use snow_generate_documentation to manually trigger a full update at any time.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            this.logger.error('❌ Failed to start continuous documentation', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Failed to start continuous documentation: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async verifyArtifactSearchable(args) {
-        // Check authentication first
-        const authResult = await mcp_auth_middleware_js_1.mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: authResult.error || '❌ 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('🔴 SNOW-002 FIX: Verifying artifact searchability', {
-                name: args.artifact_name,
-                type: args.artifact_type,
-                sys_id: args.expected_sys_id
-            });
-            const maxWaitTime = args.max_wait_time || 30; // seconds
-            const startTime = Date.now();
-            // Use the specialized search method for newly created artifacts
-            const results = await this.searchForRecentlyCreatedArtifact(args.artifact_name, args.artifact_type, args.expected_sys_id);
-            const elapsedTime = Math.round((Date.now() - startTime) / 1000);
-            if (results && results.length > 0) {
-                const artifact = results[0];
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `✅ SNOW-002 RESOLVED: Artifact is now searchable!
-
-🎯 **Verification Results:**
-- **Artifact**: ${args.artifact_name}
-- **Type**: ${args.artifact_type}
-- **Sys ID**: ${artifact.sys_id}
-- **Search Time**: ${elapsedTime} seconds
-- **Status**: ✅ Searchable and indexed
-
-🔍 **Search Verification:**
-- Found via: ${artifact.search_fallback ? 'Fallback search' : 'Standard search'}
-- Table: ${artifact.table_name || 'Auto-detected'}
-- Results: ${results.length} matching record(s)
-
-💡 **SNOW-002 Fix Status**: Search system timing issues resolved - artifact indexing delay successfully handled with retry logic.
-
-The artifact is now fully searchable and indexed in ServiceNow! 🎉`,
-                        },
-                    ],
-                };
-            }
-            else {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ SNOW-002 UNRESOLVED: Artifact still not searchable
-
-🔍 **Verification Results:**
-- **Artifact**: ${args.artifact_name}
-- **Type**: ${args.artifact_type}
-- **Search Time**: ${elapsedTime} seconds (timeout: ${maxWaitTime}s)
-- **Status**: ❌ Not found in search indexes
-
-🚨 **Possible Issues:**
-1. ServiceNow search indexes may need more time to update
-2. Artifact may have been created with different name/scope
-3. ServiceNow instance may have search indexing issues
-4. Artifact may not be active or may be in wrong scope
-
-💡 **Recommendations:**
-1. Wait a few more minutes and try again
-2. Check artifact directly in ServiceNow UI
-3. Use snow_get_by_sysid if you have the sys_id
-4. Contact ServiceNow administrator if issue persists
-
-**Manual Verification Steps:**
-1. Log into ServiceNow
-2. Navigate to the appropriate module
-3. Search for "${args.artifact_name}" manually
-4. Check if artifact exists but under different name`,
-                        },
-                    ],
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('🔴 SNOW-002: Artifact verification failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ SNOW-002: Artifact verification failed
-
-**Error**: ${error instanceof Error ? error.message : String(error)}
-
-This may indicate a deeper ServiceNow connectivity issue or authentication problem.
-Please check your ServiceNow connection and try again.`,
-                    },
-                ],
-            };
-        }
-    }
-    async run() {
-        try {
-            // Initialize systems first
-            await this.initializeSystems();
-            // Connect transport
-            const transport = new stdio_js_1.StdioServerTransport();
-            await this.server.connect(transport);
-            this.logger.info('ServiceNow Development Assistant MCP Server running on stdio');
-        }
-        catch (error) {
-            this.logger.error('Failed to start ServiceNow Intelligent MCP:', error);
-            process.exit(1);
-        }
-    }
-}
-exports.ServiceNowDevelopmentAssistantMCP = ServiceNowDevelopmentAssistantMCP;
-const server = new ServiceNowDevelopmentAssistantMCP();
-server.run().catch(console.error);
-//# sourceMappingURL=servicenow-development-assistant-mcp.js.map