snow-flow 3.0.8 → 3.0.10

package/dist/agents/teams/widget/widget-platform.agent.js

@@ -1,1190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetPlatformAgent = void 0;
-/**
- * Widget Platform Agent - ServiceNow Platform Integration Specialist
- * Handles ServiceNow-specific integrations, platform APIs, and deployment coordination
- */
-const base_team_1 = require("../base-team");
-class WidgetPlatformAgent extends base_team_1.BaseSnowAgent {
-    constructor(config) {
-        const capabilities = [
-            {
-                name: 'servicenow_platform_integration',
-                description: 'Deep ServiceNow platform knowledge and integration',
-                proficiency: 0.95,
-                tools: ['servicenow_apis', 'platform_dependencies', 'update_sets']
-            },
-            {
-                name: 'widget_deployment',
-                description: 'Deploy and configure widgets in ServiceNow',
-                proficiency: 0.9,
-                tools: ['service_portal', 'widget_dependencies', 'page_configuration']
-            },
-            {
-                name: 'platform_optimization',
-                description: 'Optimize for ServiceNow platform performance',
-                proficiency: 0.88,
-                tools: ['performance_tuning', 'caching_strategies', 'api_optimization']
-            },
-            {
-                name: 'security_compliance',
-                description: 'Ensure ServiceNow security and compliance standards',
-                proficiency: 0.85,
-                tools: ['acl_management', 'security_policies', 'compliance_validation']
-            },
-            {
-                name: 'dependency_management',
-                description: 'Manage platform dependencies and integrations',
-                proficiency: 0.83,
-                tools: ['dependency_resolution', 'api_discovery', 'integration_testing']
-            }
-        ];
-        const specialization = {
-            primary: ['servicenow_platform', 'widget_deployment', 'platform_integration'],
-            secondary: ['performance_optimization', 'security', 'dependency_management'],
-            tools: ['ServiceNow APIs', 'Service Portal', 'Update Sets', 'Platform Performance Tools'],
-            experience: 0.88
-        };
-        super('widget-platform-001', 'Widget Platform Specialist', 'platform_specialist', capabilities, specialization, config);
-    }
-    /**
-     * Analyze platform requirements and integration needs
-     */
-    async analyzeRequirements(requirements) {
-        try {
-            this.setStatus('busy');
-            console.log('Platform Agent: Analyzing platform requirements...');
-            const analysis = {
-                platformIntegration: this.analyzePlatformIntegration(requirements),
-                deploymentStrategy: this.analyzeDeploymentNeeds(requirements),
-                securityRequirements: this.analyzeSecurityNeeds(requirements),
-                performanceOptimization: this.analyzePerformanceNeeds(requirements),
-                dependencyMapping: this.analyzeDependencies(requirements)
-            };
-            console.log('Platform Agent: Platform analysis complete');
-            return analysis;
-        }
-        catch (error) {
-            console.error('Platform Agent: Error analyzing requirements:', error);
-            throw error;
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Execute platform integration and deployment tasks
-     */
-    async execute(requirements) {
-        try {
-            this.setStatus('busy');
-            console.log('Platform Agent: Starting platform integration...');
-            // Setup platform dependencies
-            const platformSetup = await this.setupPlatformDependencies(requirements);
-            // Configure ServiceNow integrations
-            const integrationConfig = await this.configureServiceNowIntegrations(requirements);
-            // Setup security and permissions
-            const securityConfig = await this.setupSecurityConfiguration(requirements);
-            // Create deployment configuration
-            const deploymentConfig = await this.createDeploymentConfiguration(requirements);
-            // Optimize for platform performance
-            const performanceConfig = await this.createPerformanceConfiguration(requirements);
-            // Validate platform compatibility
-            const validation = await this.validatePlatformCompatibility({
-                platformSetup,
-                integrationConfig,
-                securityConfig,
-                requirements
-            });
-            console.log('Platform Agent: Platform integration completed');
-            return {
-                success: true,
-                artifact: {
-                    platformSetup,
-                    integrationConfig,
-                    securityConfig,
-                    deploymentConfig,
-                    performanceConfig,
-                    validation
-                },
-                metadata: {
-                    duration: 0,
-                    performance: {
-                        integration_efficiency: this.assessIntegrationEfficiency(integrationConfig),
-                        deployment_readiness: this.assessDeploymentReadiness(deploymentConfig),
-                        security_compliance: this.assessSecurityCompliance(securityConfig)
-                    },
-                    quality: {
-                        platform_compatibility: validation.compatibility,
-                        dependency_resolution: validation.dependencies,
-                        performance_optimization: validation.performance
-                    }
-                }
-            };
-        }
-        catch (error) {
-            console.error('Platform Agent: Error in platform integration:', error);
-            return this.handleError(error);
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Setup platform dependencies and requirements
-     */
-    async setupPlatformDependencies(requirements) {
-        console.log('Platform Agent: Setting up platform dependencies...');
-        const dependencies = {
-            servicePortal: await this.setupServicePortalDependencies(requirements),
-            apis: await this.setupAPIAccess(requirements),
-            libraries: await this.setupLibraryDependencies(requirements),
-            tables: await this.setupTableAccess(requirements),
-            roles: await this.setupRoleRequirements(requirements)
-        };
-        return dependencies;
-    }
-    /**
-     * Configure ServiceNow platform integrations
-     */
-    async configureServiceNowIntegrations(requirements) {
-        console.log('Platform Agent: Configuring ServiceNow integrations...');
-        const integrations = {
-            tableAPI: this.createTableAPIIntegration(requirements),
-            restAPI: this.createRESTAPIIntegration(requirements),
-            glideAjax: this.createGlideAjaxIntegration(requirements),
-            webServices: this.createWebServiceIntegrations(requirements),
-            eventHandling: this.createEventHandlingIntegration(requirements)
-        };
-        return integrations;
-    }
-    /**
-     * Setup security configuration and permissions
-     */
-    async setupSecurityConfiguration(requirements) {
-        console.log('Platform Agent: Setting up security configuration...');
-        const security = {
-            accessControls: this.createAccessControls(requirements),
-            roleConfiguration: this.createRoleConfiguration(requirements),
-            dataValidation: this.createDataValidation(requirements),
-            auditConfiguration: this.createAuditConfiguration(requirements),
-            complianceSettings: this.createComplianceSettings(requirements)
-        };
-        return security;
-    }
-    /**
-     * Create deployment configuration for ServiceNow
-     */
-    async createDeploymentConfiguration(requirements) {
-        console.log('Platform Agent: Creating deployment configuration...');
-        const deployment = {
-            updateSetConfig: this.createUpdateSetConfiguration(requirements),
-            widgetConfiguration: this.createWidgetConfiguration(requirements),
-            pageConfiguration: this.createPageConfiguration(requirements),
-            menuConfiguration: this.createMenuConfiguration(requirements),
-            testingConfiguration: this.createTestingConfiguration(requirements)
-        };
-        return deployment;
-    }
-    /**
-     * Create performance optimization configuration
-     */
-    async createPerformanceConfiguration(requirements) {
-        console.log('Platform Agent: Creating performance configuration...');
-        const performance = {
-            cachingStrategy: this.createCachingStrategy(requirements),
-            queryOptimization: this.createQueryOptimization(requirements),
-            loadBalancing: this.createLoadBalancingStrategy(requirements),
-            assetOptimization: this.createAssetOptimization(requirements),
-            monitoring: this.createPerformanceMonitoring(requirements)
-        };
-        return performance;
-    }
-    // Platform dependency setup methods
-    async setupServicePortalDependencies(requirements) {
-        return {
-            portalConfiguration: {
-                theme: 'Stock Theme',
-                branding: 'ServiceNow Default',
-                customization: requirements.customization || 'minimal'
-            },
-            widgetDependencies: [
-                'sp-angular-provider',
-                'sp-server-utilities',
-                'sp-client-utilities'
-            ],
-            pageTemplates: this.identifyRequiredPageTemplates(requirements),
-            cssFrameworks: ['Bootstrap 4', 'ServiceNow UI Framework'],
-            jsLibraries: this.identifyRequiredJSLibraries(requirements)
-        };
-    }
-    async setupAPIAccess(requirements) {
-        return {
-            tableAPI: {
-                tables: this.identifyRequiredTables(requirements),
-                operations: ['read', 'write', 'create', 'delete'],
-                authentication: 'session_based'
-            },
-            restAPI: {
-                endpoints: this.identifyRequiredEndpoints(requirements),
-                authentication: 'oauth2_or_basic',
-                rateLimit: 'platform_default'
-            },
-            glideAPI: {
-                classes: ['GlideRecord', 'GlideSystem', 'GlideUser', 'GlideDateTime'],
-                serverSide: true,
-                clientSide: false
-            }
-        };
-    }
-    async setupLibraryDependencies(requirements) {
-        const libraries = [];
-        // Chart library if needed
-        if (requirements.integration?.apis?.includes('chart') ||
-            requirements.type === 'chart') {
-            libraries.push({
-                name: 'Chart.js',
-                version: '3.x',
-                cdn: 'https://cdn.jsdelivr.net/npm/chart.js',
-                local: '/scripts/lib/chart.js'
-            });
-        }
-        // Date library if needed
-        if (requirements.data?.fields?.some((f) => f.includes('date'))) {
-            libraries.push({
-                name: 'Moment.js',
-                version: '2.x',
-                cdn: 'https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.4/moment.min.js',
-                local: '/scripts/lib/moment.js'
-            });
-        }
-        // Export library if needed
-        if (requirements.functionality?.export) {
-            libraries.push({
-                name: 'SheetJS',
-                version: '0.18.x',
-                cdn: 'https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js',
-                local: '/scripts/lib/xlsx.js'
-            });
-        }
-        return libraries;
-    }
-    async setupTableAccess(requirements) {
-        const tables = this.identifyRequiredTables(requirements);
-        return tables.map(table => ({
-            name: table,
-            access: {
-                read: true,
-                write: requirements.functionality?.interactive || false,
-                create: false,
-                delete: false
-            },
-            fields: this.getTableFields(table, requirements),
-            security: {
-                acl_required: true,
-                role_based: true,
-                field_level: false
-            }
-        }));
-    }
-    async setupRoleRequirements(requirements) {
-        const baseRoles = ['service_portal_user'];
-        // Add specific roles based on functionality
-        if (requirements.functionality?.interactive) {
-            baseRoles.push('service_portal_contributor');
-        }
-        if (requirements.data?.source === 'incident') {
-            baseRoles.push('incident_reader');
-        }
-        if (requirements.functionality?.export) {
-            baseRoles.push('report_viewer');
-        }
-        return {
-            required: baseRoles,
-            optional: ['admin', 'service_portal_admin'],
-            custom: this.identifyCustomRoles(requirements)
-        };
-    }
-    // ServiceNow integration methods
-    createTableAPIIntegration(requirements) {
-        return {
-            implementation: `
-// Table API Integration
-var TableAPIIntegration = {
-  query: function(table, query, fields, limit) {
-    try {
-      var gr = new GlideRecord(table);
-      
-      if (query) {
-        gr.addEncodedQuery(query);
-      }
-      
-      if (limit) {
-        gr.setLimit(limit);
-      }
-      
-      gr.query();
-      
-      var results = [];
-      while (gr.next()) {
-        var item = {
-          sys_id: gr.getUniqueValue(),
-          display_value: gr.getDisplayValue()
-        };
-        
-        if (fields && fields.length > 0) {
-          fields.forEach(function(field) {
-            item[field] = gr.getDisplayValue(field);
-            item[field + '_value'] = gr.getValue(field);
-          });
-        }
-        
-        results.push(item);
-      }
-      
-      return {
-        success: true,
-        data: results,
-        total: results.length
-      };
-      
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  },
-  
-  update: function(table, sysId, data) {
-    try {
-      var gr = new GlideRecord(table);
-      if (gr.get(sysId)) {
-        for (var field in data) {
-          if (gr.isValidField(field)) {
-            gr.setValue(field, data[field]);
-          }
-        }
-        
-        var updated = gr.update();
-        
-        return {
-          success: !!updated,
-          sys_id: sysId
-        };
-      }
-      
-      return {
-        success: false,
-        error: 'Record not found'
-      };
-      
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-};`,
-            usage: 'Server-side data operations',
-            security: 'ACL protected',
-            caching: 'Application level'
-        };
-    }
-    createRESTAPIIntegration(requirements) {
-        return {
-            implementation: `
-// REST API Integration
-var RESTAPIIntegration = {
-  call: function(endpoint, method, data, headers) {
-    try {
-      var request = new sn_ws.RESTMessageV2();
-      request.setEndpoint(endpoint);
-      request.setHttpMethod(method || 'GET');
-      
-      // Add headers
-      if (headers) {
-        for (var header in headers) {
-          request.setRequestHeader(header, headers[header]);
-        }
-      }
-      
-      // Add authentication
-      this.addAuthentication(request);
-      
-      // Add request body for POST/PUT
-      if (data && (method === 'POST' || method === 'PUT')) {
-        request.setRequestBody(JSON.stringify(data));
-        request.setRequestHeader('Content-Type', 'application/json');
-      }
-      
-      var response = request.execute();
-      var responseBody = response.getBody();
-      var statusCode = response.getStatusCode();
-      
-      return {
-        success: statusCode >= 200 && statusCode < 300,
-        data: responseBody ? JSON.parse(responseBody) : null,
-        statusCode: statusCode,
-        headers: this.parseResponseHeaders(response)
-      };
-      
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        statusCode: 0
-      };
-    }
-  },
-  
-  addAuthentication: function(request) {
-    // Add OAuth or Basic authentication based on configuration
-    var authType = gs.getProperty('widget.api.auth.type', 'none');
-    
-    switch (authType) {
-      case 'bearer':
-        var token = gs.getProperty('widget.api.auth.token');
-        if (token) {
-          request.setRequestHeader('Authorization', 'Bearer ' + token);
-        }
-        break;
-      case 'basic':
-        var username = gs.getProperty('widget.api.auth.username');
-        var password = gs.getProperty('widget.api.auth.password');
-        if (username && password) {
-          request.setBasicAuth(username, password);
-        }
-        break;
-    }
-  },
-  
-  parseResponseHeaders: function(response) {
-    var headers = {};
-    var headerNames = response.getHeaderNames();
-    
-    for (var i = 0; i < headerNames.size(); i++) {
-      var name = headerNames.get(i);
-      headers[name] = response.getHeader(name);
-    }
-    
-    return headers;
-  }
-};`,
-            endpoints: this.identifyRequiredEndpoints(requirements),
-            authentication: 'Configurable (OAuth2, Basic, API Key)',
-            errorHandling: 'Comprehensive with retry logic'
-        };
-    }
-    createGlideAjaxIntegration(requirements) {
-        return {
-            implementation: `
-// GlideAjax Integration for client-server communication
-var WidgetGlideAjax = Class.create();
-WidgetGlideAjax.prototype = Object.extendsObject(AbstractAjaxProcessor, {
-  
-  processWidgetAction: function() {
-    var action = this.getParameter('action');
-    var data = JSON.parse(this.getParameter('data') || '{}');
-    
-    try {
-      switch (action) {
-        case 'validate_data':
-          return this.validateData(data);
-        case 'process_action':
-          return this.processAction(data);
-        case 'get_metadata':
-          return this.getMetadata(data);
-        default:
-          return this.error('Unknown action: ' + action);
-      }
-    } catch (error) {
-      gs.error('Widget GlideAjax error: ' + error.message);
-      return this.error(error.message);
-    }
-  },
-  
-  validateData: function(data) {
-    // Implement data validation logic
-    var validationRules = this.getValidationRules();
-    var errors = [];
-    
-    for (var field in validationRules) {
-      var rule = validationRules[field];
-      var value = data[field];
-      
-      if (rule.required && (!value || value === '')) {
-        errors.push(field + ' is required');
-      }
-      
-      if (value && rule.type && !this.validateType(value, rule.type)) {
-        errors.push(field + ' must be of type ' + rule.type);
-      }
-    }
-    
-    return this.success({
-      valid: errors.length === 0,
-      errors: errors
-    });
-  },
-  
-  processAction: function(data) {
-    // Implement action processing
-    var result = TableAPIIntegration.update(data.table, data.sys_id, data.values);
-    
-    if (result.success) {
-      return this.success(result);
-    } else {
-      return this.error(result.error);
-    }
-  },
-  
-  getMetadata: function(data) {
-    // Return widget metadata
-    return this.success({
-      version: '1.0.0',
-      lastUpdated: new GlideDateTime().getDisplayValue(),
-      capabilities: ['read', 'write', 'validate']
-    });
-  },
-  
-  validateType: function(value, type) {
-    switch (type) {
-      case 'email':
-        return /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(value);
-      case 'number':
-        return !isNaN(parseFloat(value));
-      case 'date':
-        return new GlideDateTime(value).isValid();
-      default:
-        return true;
-    }
-  },
-  
-  getValidationRules: function() {
-    // Return validation rules based on configuration
-    return {
-      email: { required: false, type: 'email' },
-      priority: { required: true, type: 'number' },
-      due_date: { required: false, type: 'date' }
-    };
-  },
-  
-  success: function(data) {
-    return JSON.stringify({
-      success: true,
-      data: data
-    });
-  },
-  
-  error: function(message) {
-    return JSON.stringify({
-      success: false,
-      error: message
-    });
-  },
-  
-  type: 'WidgetGlideAjax'
-});`,
-            clientUsage: `
-// Client-side usage
-function callServerSide(action, data, callback) {
-  var ga = new GlideAjax('WidgetGlideAjax');
-  ga.addParam('sysparm_name', 'processWidgetAction');
-  ga.addParam('action', action);
-  ga.addParam('data', JSON.stringify(data));
-  
-  ga.getXML(function(response) {
-    try {
-      var result = JSON.parse(response.responseText);
-      callback(result);
-    } catch (error) {
-      callback({
-        success: false,
-        error: 'Failed to parse server response'
-      });
-    }
-  });
-}`,
-            security: 'Session-based authentication',
-            performance: 'Asynchronous with error handling'
-        };
-    }
-    createWebServiceIntegrations(requirements) {
-        return {
-            soap: {
-                implementation: 'SOAPMessage for legacy system integration',
-                authentication: 'WS-Security or basic authentication',
-                errorHandling: 'SOAP fault processing'
-            },
-            rest: {
-                implementation: 'RESTMessageV2 for modern API integration',
-                authentication: 'OAuth2, Bearer token, or API key',
-                errorHandling: 'HTTP status code and response parsing'
-            },
-            webhooks: {
-                implementation: 'Outbound webhook notifications',
-                retry: 'Exponential backoff retry mechanism',
-                security: 'HMAC signature verification'
-            }
-        };
-    }
-    createEventHandlingIntegration(requirements) {
-        return {
-            businessRules: {
-                triggers: ['insert', 'update', 'delete'],
-                events: ['widget.data.changed', 'widget.user.action'],
-                async: true
-            },
-            notifications: {
-                email: 'Email notification on specific events',
-                push: 'Push notification to mobile devices',
-                webhook: 'Webhook notification to external systems'
-            },
-            workflow: {
-                triggers: 'Workflow trigger on data changes',
-                approval: 'Approval workflow integration',
-                automation: 'Automated task creation'
-            }
-        };
-    }
-    // Security configuration methods
-    createAccessControls(requirements) {
-        const tables = this.identifyRequiredTables(requirements);
-        return tables.map(table => ({
-            table: table,
-            operation: 'read',
-            roles: ['service_portal_user'],
-            condition: 'gs.hasRole("service_portal_user")',
-            script: `
-// ACL Script for ${table} read access
-function checkAccess() {
-  // Check if user has basic portal access
-  if (!gs.hasRole('service_portal_user')) {
-    return false;
-  }
-  
-  // Check if user can read this specific table
-  var gr = new GlideRecord('${table}');
-  return gr.canRead();
-}
-
-// Execute access check
-answer = checkAccess();`
-        }));
-    }
-    createRoleConfiguration(requirements) {
-        return {
-            baseRoles: [
-                {
-                    name: 'widget_user',
-                    description: 'Basic widget access',
-                    contains: ['service_portal_user']
-                }
-            ],
-            conditionalRoles: this.generateConditionalRoles(requirements),
-            delegation: {
-                enabled: false,
-                roles: [],
-                conditions: []
-            }
-        };
-    }
-    createDataValidation(requirements) {
-        return {
-            inputValidation: {
-                client: 'Real-time validation with JavaScript',
-                server: 'Server-side validation with GlideRecord',
-                sanitization: 'XSS and injection prevention'
-            },
-            businessRules: {
-                validation: 'Custom validation business rules',
-                formatting: 'Data formatting and normalization',
-                enrichment: 'Data enrichment from related records'
-            },
-            errorHandling: {
-                validation: 'Clear validation error messages',
-                logging: 'Error logging for debugging',
-                recovery: 'Data recovery mechanisms'
-            }
-        };
-    }
-    createAuditConfiguration(requirements) {
-        return {
-            tableAudit: {
-                enabled: true,
-                tables: this.identifyRequiredTables(requirements),
-                fields: 'All fields with PII flagged'
-            },
-            userActions: {
-                login: 'Track user login and logout',
-                dataAccess: 'Track data access and modifications',
-                exports: 'Track data export activities'
-            },
-            retention: {
-                period: '90 days',
-                archival: 'Automatic archival to cold storage',
-                deletion: 'Secure deletion after retention period'
-            }
-        };
-    }
-    createComplianceSettings(requirements) {
-        return {
-            gdpr: {
-                enabled: true,
-                dataMapping: 'Map personal data fields',
-                consent: 'Track user consent for data processing',
-                rightToDelete: 'Support for data deletion requests'
-            },
-            sox: {
-                enabled: false,
-                controls: 'Financial data access controls',
-                segregation: 'Separation of duties enforcement'
-            },
-            hipaa: {
-                enabled: false,
-                encryption: 'PHI data encryption',
-                accessLogging: 'Detailed access logging for PHI'
-            }
-        };
-    }
-    // Deployment configuration methods
-    createUpdateSetConfiguration(requirements) {
-        return {
-            name: `Widget_${requirements.name || 'Custom'}_${new Date().getTime()}`,
-            description: `Update set for ${requirements.name || 'Custom'} widget deployment`,
-            state: 'in_progress',
-            application: requirements.application || 'Global',
-            artifacts: [
-                'Service Portal Widget',
-                'Widget Dependencies',
-                'CSS Includes',
-                'Script Includes',
-                'UI Scripts'
-            ],
-            deployment: {
-                automatic: true,
-                validation: 'Full validation before deployment',
-                rollback: 'Automatic rollback on failure'
-            }
-        };
-    }
-    createWidgetConfiguration(requirements) {
-        return {
-            portal: 'Service Portal',
-            category: requirements.category || 'Custom',
-            public: true,
-            roles: this.identifyRequiredRoles(requirements),
-            dependencies: this.identifyWidgetDependencies(requirements),
-            options: {
-                configurable: true,
-                schema: 'Auto-generated from requirements',
-                validation: 'Client and server-side validation'
-            }
-        };
-    }
-    createPageConfiguration(requirements) {
-        return {
-            template: 'Standard Service Portal Template',
-            layout: 'Responsive grid layout',
-            widgets: [
-                {
-                    position: 'main',
-                    widget: requirements.name || 'custom_widget',
-                    configuration: requirements.options || {}
-                }
-            ],
-            css: 'Include widget-specific CSS',
-            js: 'Include widget-specific JavaScript'
-        };
-    }
-    createMenuConfiguration(requirements) {
-        return {
-            module: {
-                name: `${requirements.name || 'Custom'} Widget`,
-                table: 'sp_widget',
-                roles: ['service_portal_admin'],
-                order: 100
-            },
-            navigation: {
-                portal: 'Service Portal navigation',
-                category: 'Widgets',
-                visibility: 'Role-based'
-            }
-        };
-    }
-    createTestingConfiguration(requirements) {
-        return {
-            unitTests: {
-                server: 'Server-side script testing',
-                client: 'Client-side script testing',
-                integration: 'API integration testing'
-            },
-            e2eTests: {
-                userFlows: 'End-to-end user flow testing',
-                accessibility: 'Accessibility compliance testing',
-                performance: 'Load and performance testing'
-            },
-            automation: {
-                ci: 'Continuous integration testing',
-                regression: 'Automated regression testing',
-                deployment: 'Deployment validation testing'
-            }
-        };
-    }
-    // Performance configuration methods
-    createCachingStrategy(requirements) {
-        return {
-            serverSide: {
-                type: 'Application cache',
-                ttl: 300, // 5 minutes
-                keys: ['user_data', 'table_data', 'metadata'],
-                invalidation: 'Event-based and TTL-based'
-            },
-            clientSide: {
-                type: 'Browser cache',
-                storage: 'sessionStorage for session data, localStorage for preferences',
-                compression: 'Gzip compression for large datasets'
-            },
-            cdn: {
-                enabled: true,
-                assets: ['CSS', 'JavaScript', 'Images'],
-                location: 'ServiceNow CDN'
-            }
-        };
-    }
-    createQueryOptimization(requirements) {
-        return {
-            indexing: {
-                strategy: 'Create indexes on frequently queried fields',
-                fields: this.identifyIndexFields(requirements),
-                monitoring: 'Query performance monitoring'
-            },
-            pagination: {
-                enabled: true,
-                pageSize: 25,
-                strategy: 'Cursor-based pagination for large datasets'
-            },
-            lazy: {
-                loading: 'Lazy load non-critical data',
-                images: 'Lazy load images and heavy content',
-                apis: 'Lazy load external API data'
-            }
-        };
-    }
-    createLoadBalancingStrategy(requirements) {
-        return {
-            distribution: 'ServiceNow managed load balancing',
-            session: 'Sticky sessions for stateful operations',
-            failover: 'Automatic failover to healthy instances',
-            monitoring: 'Real-time load monitoring'
-        };
-    }
-    createAssetOptimization(requirements) {
-        return {
-            css: {
-                minification: 'Minify CSS for production',
-                concatenation: 'Combine CSS files',
-                purging: 'Remove unused CSS classes'
-            },
-            javascript: {
-                minification: 'Minify JavaScript for production',
-                compression: 'Gzip compression',
-                bundling: 'Bundle related scripts'
-            },
-            images: {
-                optimization: 'Optimize image sizes and formats',
-                responsive: 'Serve appropriate image sizes',
-                lazy: 'Lazy load images below the fold'
-            }
-        };
-    }
-    createPerformanceMonitoring(requirements) {
-        return {
-            metrics: [
-                'Page load time',
-                'Time to first byte',
-                'First contentful paint',
-                'Largest contentful paint',
-                'Cumulative layout shift'
-            ],
-            alerts: {
-                thresholds: 'Performance threshold alerts',
-                escalation: 'Automatic escalation for critical issues',
-                reporting: 'Regular performance reports'
-            },
-            optimization: {
-                continuous: 'Continuous performance optimization',
-                profiling: 'Regular performance profiling',
-                tuning: 'Automatic performance tuning'
-            }
-        };
-    }
-    // Validation methods
-    async validatePlatformCompatibility(config) {
-        console.log('Platform Agent: Validating platform compatibility...');
-        return {
-            compatibility: this.validateCompatibility(config),
-            dependencies: this.validateDependencies(config),
-            performance: this.validatePerformance(config),
-            security: this.validateSecurity(config)
-        };
-    }
-    validateCompatibility(config) {
-        // Check ServiceNow version compatibility
-        const hasServicePortal = !!config.platformSetup.servicePortal;
-        const hasAPIAccess = !!config.platformSetup.apis;
-        const hasSecurityConfig = !!config.securityConfig;
-        let score = 0.5;
-        if (hasServicePortal)
-            score += 0.2;
-        if (hasAPIAccess)
-            score += 0.2;
-        if (hasSecurityConfig)
-            score += 0.1;
-        return Math.min(score, 1.0);
-    }
-    validateDependencies(config) {
-        // Check if all dependencies are properly configured
-        const hasLibraries = config.platformSetup.libraries?.length > 0;
-        const hasTableAccess = config.platformSetup.tables?.length > 0;
-        const hasRoles = config.platformSetup.roles?.required?.length > 0;
-        let score = 0.4;
-        if (hasLibraries)
-            score += 0.2;
-        if (hasTableAccess)
-            score += 0.25;
-        if (hasRoles)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    validatePerformance(config) {
-        // Check performance configuration completeness
-        const hasCaching = !!config.performanceConfig?.cachingStrategy;
-        const hasOptimization = !!config.performanceConfig?.queryOptimization;
-        const hasMonitoring = !!config.performanceConfig?.monitoring;
-        let score = 0.4;
-        if (hasCaching)
-            score += 0.25;
-        if (hasOptimization)
-            score += 0.2;
-        if (hasMonitoring)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    validateSecurity(config) {
-        // Check security configuration completeness
-        const hasAccessControls = !!config.securityConfig?.accessControls;
-        const hasValidation = !!config.securityConfig?.dataValidation;
-        const hasAudit = !!config.securityConfig?.auditConfiguration;
-        let score = 0.3;
-        if (hasAccessControls)
-            score += 0.3;
-        if (hasValidation)
-            score += 0.25;
-        if (hasAudit)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    // Assessment methods
-    assessIntegrationEfficiency(integrationConfig) {
-        // Assess the efficiency of integrations
-        const configString = JSON.stringify(integrationConfig);
-        const hasErrorHandling = configString.includes('error');
-        const hasAuthentication = configString.includes('auth');
-        const hasCaching = configString.includes('cache');
-        let score = 0.4;
-        if (hasErrorHandling)
-            score += 0.25;
-        if (hasAuthentication)
-            score += 0.2;
-        if (hasCaching)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    assessDeploymentReadiness(deploymentConfig) {
-        // Assess deployment configuration completeness
-        const hasUpdateSet = !!deploymentConfig?.updateSetConfig;
-        const hasWidgetConfig = !!deploymentConfig?.widgetConfiguration;
-        const hasTesting = !!deploymentConfig?.testingConfiguration;
-        let score = 0.3;
-        if (hasUpdateSet)
-            score += 0.3;
-        if (hasWidgetConfig)
-            score += 0.25;
-        if (hasTesting)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    assessSecurityCompliance(securityConfig) {
-        // Assess security compliance level
-        const hasCompliance = !!securityConfig?.complianceSettings;
-        const hasAudit = !!securityConfig?.auditConfiguration;
-        const hasValidation = !!securityConfig?.dataValidation;
-        let score = 0.4;
-        if (hasCompliance)
-            score += 0.25;
-        if (hasAudit)
-            score += 0.2;
-        if (hasValidation)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    // Analysis helper methods
-    analyzePlatformIntegration(requirements) {
-        return {
-            complexity: requirements.integrations?.length > 2 ? 'high' : 'medium',
-            apis: requirements.integrations || [],
-            tables: this.identifyRequiredTables(requirements)
-        };
-    }
-    analyzeDeploymentNeeds(requirements) {
-        return {
-            strategy: 'update_set',
-            scope: requirements.scope || 'global',
-            testing: 'comprehensive'
-        };
-    }
-    analyzeSecurityNeeds(requirements) {
-        return {
-            level: 'standard',
-            compliance: requirements.compliance || [],
-            audit: true
-        };
-    }
-    analyzePerformanceNeeds(requirements) {
-        return {
-            caching: requirements.data?.fields?.length > 10,
-            optimization: requirements.data?.fields?.length > 20,
-            monitoring: true
-        };
-    }
-    analyzeDependencies(requirements) {
-        return {
-            external: this.identifyExternalDependencies(requirements),
-            internal: this.identifyInternalDependencies(requirements),
-            optional: this.identifyOptionalDependencies(requirements)
-        };
-    }
-    // Helper methods for identification
-    identifyRequiredTables(requirements) {
-        const tables = [];
-        if (requirements.data?.source) {
-            tables.push(requirements.data.source);
-        }
-        if (requirements.integrations?.includes('incident')) {
-            tables.push('incident');
-        }
-        if (requirements.integrations?.includes('task')) {
-            tables.push('task');
-        }
-        return [...new Set(tables)];
-    }
-    identifyRequiredEndpoints(requirements) {
-        const endpoints = [];
-        if (requirements.data?.source) {
-            endpoints.push(`/api/now/table/${requirements.data.source}`);
-        }
-        if (requirements.integrations?.includes('external_api')) {
-            endpoints.push('/api/external/data');
-        }
-        return endpoints;
-    }
-    identifyRequiredPageTemplates(requirements) {
-        return ['Standard Service Portal Template'];
-    }
-    identifyRequiredJSLibraries(requirements) {
-        const libraries = ['AngularJS', 'jQuery'];
-        if (requirements.type === 'chart') {
-            libraries.push('Chart.js');
-        }
-        if (requirements.functionality?.export) {
-            libraries.push('SheetJS');
-        }
-        return libraries;
-    }
-    getTableFields(table, requirements) {
-        // Return common fields based on table type
-        const commonFields = ['sys_id', 'sys_created_on', 'sys_updated_on'];
-        if (table === 'incident') {
-            return [...commonFields, 'number', 'priority', 'state', 'short_description', 'assigned_to'];
-        }
-        if (table === 'task') {
-            return [...commonFields, 'number', 'priority', 'state', 'short_description', 'assigned_to'];
-        }
-        return commonFields;
-    }
-    identifyCustomRoles(requirements) {
-        const roles = [];
-        if (requirements.functionality?.administrative) {
-            roles.push('widget_admin');
-        }
-        if (requirements.functionality?.reporting) {
-            roles.push('widget_reporter');
-        }
-        return roles;
-    }
-    generateConditionalRoles(requirements) {
-        return [
-            {
-                condition: 'User is assigned to specific group',
-                roles: ['widget_power_user'],
-                script: 'gs.getUser().isMemberOf("widget_users")'
-            }
-        ];
-    }
-    identifyRequiredRoles(requirements) {
-        const roles = ['service_portal_user'];
-        if (requirements.functionality?.interactive) {
-            roles.push('service_portal_contributor');
-        }
-        return roles;
-    }
-    identifyWidgetDependencies(requirements) {
-        const dependencies = [];
-        if (requirements.type === 'chart') {
-            dependencies.push('chart_widget_base');
-        }
-        if (requirements.functionality?.export) {
-            dependencies.push('export_utility');
-        }
-        return dependencies;
-    }
-    identifyIndexFields(requirements) {
-        const fields = [];
-        if (requirements.data?.source === 'incident') {
-            fields.push('priority', 'state', 'assigned_to');
-        }
-        if (requirements.data?.filters) {
-            fields.push(...Object.keys(requirements.data.filters));
-        }
-        return [...new Set(fields)];
-    }
-    identifyExternalDependencies(requirements) {
-        const deps = [];
-        if (requirements.type === 'chart') {
-            deps.push('Chart.js');
-        }
-        if (requirements.integrations?.includes('external_api')) {
-            deps.push('External API Service');
-        }
-        return deps;
-    }
-    identifyInternalDependencies(requirements) {
-        return ['Service Portal Framework', 'AngularJS', 'ServiceNow APIs'];
-    }
-    identifyOptionalDependencies(requirements) {
-        const deps = [];
-        if (requirements.functionality?.export) {
-            deps.push('Export Service');
-        }
-        if (requirements.functionality?.realtime) {
-            deps.push('WebSocket Service');
-        }
-        return deps;
-    }
-}
-exports.WidgetPlatformAgent = WidgetPlatformAgent;
-//# sourceMappingURL=widget-platform.agent.js.map