snow-flow 3.0.9 → 3.0.13

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

@@ -1,1033 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetUIUXAgent = void 0;
-/**
- * Widget UI/UX Agent - UI/UX Design Specialist
- * Focuses on user experience design, accessibility, and design system compliance
- */
-const base_team_1 = require("../base-team");
-class WidgetUIUXAgent extends base_team_1.BaseSnowAgent {
-    constructor(config) {
-        const capabilities = [
-            {
-                name: 'ux_design',
-                description: 'Design optimal user experiences and workflows',
-                proficiency: 0.95,
-                tools: ['user_research', 'wireframing', 'prototyping', 'user_journey_mapping']
-            },
-            {
-                name: 'accessibility_design',
-                description: 'Ensure compliance with accessibility standards',
-                proficiency: 0.9,
-                tools: ['wcag_guidelines', 'screen_reader_testing', 'keyboard_navigation']
-            },
-            {
-                name: 'design_systems',
-                description: 'Apply and maintain design system consistency',
-                proficiency: 0.88,
-                tools: ['servicenow_design_system', 'component_libraries', 'style_guides']
-            },
-            {
-                name: 'visual_design',
-                description: 'Create visually appealing and functional interfaces',
-                proficiency: 0.85,
-                tools: ['color_theory', 'typography', 'layout_design', 'iconography']
-            },
-            {
-                name: 'usability_testing',
-                description: 'Test and validate user interface designs',
-                proficiency: 0.8,
-                tools: ['usability_testing', 'heuristic_evaluation', 'accessibility_testing']
-            }
-        ];
-        const specialization = {
-            primary: ['ux_design', 'accessibility', 'design_systems'],
-            secondary: ['visual_design', 'usability_testing', 'interaction_design'],
-            tools: ['ServiceNow Design System', 'WCAG Guidelines', 'Figma', 'Accessibility Tools'],
-            experience: 0.88
-        };
-        super('widget-uiux-001', 'Widget UI/UX Specialist', 'uiux_designer', capabilities, specialization, config);
-    }
-    /**
-     * Analyze design requirements and create UX strategy
-     */
-    async analyzeRequirements(requirements) {
-        try {
-            this.setStatus('busy');
-            console.log('UI/UX Agent: Analyzing design requirements...');
-            const analysis = {
-                userExperienceStrategy: this.analyzeUserExperience(requirements),
-                accessibilityStrategy: this.analyzeAccessibilityNeeds(requirements),
-                designSystemAlignment: this.analyzeDesignSystemNeeds(requirements),
-                interactionDesign: this.analyzeInteractionNeeds(requirements),
-                usabilityConsiderations: this.analyzeUsabilityFactors(requirements)
-            };
-            console.log('UI/UX Agent: Design analysis complete');
-            return analysis;
-        }
-        catch (error) {
-            console.error('UI/UX Agent: Error analyzing requirements:', error);
-            throw error;
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Execute UI/UX design tasks
-     */
-    async execute(requirements) {
-        try {
-            this.setStatus('busy');
-            console.log('UI/UX Agent: Starting UI/UX design process...');
-            // Create design system specification
-            const designSpec = await this.createDesignSystem(requirements);
-            // Create user experience guidelines
-            const uxGuidelines = await this.createUXGuidelines(requirements);
-            // Create accessibility specifications
-            const accessibilitySpec = await this.createAccessibilitySpec(requirements);
-            // Create interaction patterns
-            const interactionPatterns = await this.createInteractionPatterns(requirements);
-            // Create visual design guidelines
-            const visualGuidelines = await this.createVisualGuidelines(requirements);
-            // Validate design against usability heuristics
-            const usabilityValidation = await this.validateUsability({
-                designSpec,
-                uxGuidelines,
-                accessibilitySpec,
-                requirements
-            });
-            console.log('UI/UX Agent: Design process completed');
-            return {
-                success: true,
-                artifact: {
-                    designSpec,
-                    uxGuidelines,
-                    accessibilitySpec,
-                    interactionPatterns,
-                    visualGuidelines,
-                    usabilityValidation
-                },
-                metadata: {
-                    duration: 0,
-                    performance: {
-                        design_consistency: this.assessDesignConsistency(designSpec),
-                        accessibility_compliance: this.assessAccessibilityCompliance(accessibilitySpec),
-                        user_experience_score: this.assessUserExperience(uxGuidelines)
-                    },
-                    quality: {
-                        usability_score: usabilityValidation.overallScore,
-                        accessibility_score: usabilityValidation.accessibilityScore,
-                        design_system_adherence: usabilityValidation.designSystemScore
-                    }
-                }
-            };
-        }
-        catch (error) {
-            console.error('UI/UX Agent: Error in design process:', error);
-            return this.handleError(error);
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Create comprehensive design system specification
-     */
-    async createDesignSystem(requirements) {
-        console.log('UI/UX Agent: Creating design system specification...');
-        const designSpec = {
-            colorScheme: this.createColorScheme(requirements),
-            typography: this.createTypographySystem(requirements),
-            layout: this.createLayoutSystem(requirements),
-            interactions: this.createInteractionSystem(requirements),
-            accessibility: this.createAccessibilityGuidelines(requirements)
-        };
-        return designSpec;
-    }
-    /**
-     * Create user experience guidelines
-     */
-    async createUXGuidelines(requirements) {
-        console.log('UI/UX Agent: Creating UX guidelines...');
-        return {
-            userFlows: this.createUserFlows(requirements),
-            informationArchitecture: this.createInformationArchitecture(requirements),
-            contentStrategy: this.createContentStrategy(requirements),
-            errorHandling: this.createErrorHandlingUX(requirements),
-            feedbackSystems: this.createFeedbackSystems(requirements),
-            performanceUX: this.createPerformanceUXGuidelines(requirements)
-        };
-    }
-    /**
-     * Create accessibility specification
-     */
-    async createAccessibilitySpec(requirements) {
-        console.log('UI/UX Agent: Creating accessibility specification...');
-        const wcagLevel = requirements.accessibility.wcag || 'AA';
-        return {
-            wcagCompliance: {
-                level: wcagLevel,
-                guidelines: this.getWCAGGuidelines(wcagLevel),
-                testingCriteria: this.getAccessibilityTestingCriteria(wcagLevel)
-            },
-            keyboardNavigation: {
-                tabOrder: this.defineTabOrder(requirements),
-                shortcuts: this.defineKeyboardShortcuts(requirements),
-                focusManagement: this.defineFocusManagement(requirements)
-            },
-            screenReaderSupport: {
-                ariaLabels: this.defineAriaLabels(requirements),
-                landmarks: this.defineLandmarks(requirements),
-                announcements: this.defineScreenReaderAnnouncements(requirements)
-            },
-            visualAccessibility: {
-                colorContrast: this.defineColorContrast(requirements),
-                textScaling: this.defineTextScaling(requirements),
-                motionPreferences: this.defineMotionPreferences(requirements)
-            },
-            cognitiveAccessibility: {
-                errorPrevention: this.defineErrorPrevention(requirements),
-                helpSystems: this.defineHelpSystems(requirements),
-                timeouts: this.defineTimeoutHandling(requirements)
-            }
-        };
-    }
-    /**
-     * Create interaction patterns
-     */
-    async createInteractionPatterns(requirements) {
-        console.log('UI/UX Agent: Creating interaction patterns...');
-        return {
-            gestureInteractions: this.defineGestureInteractions(requirements),
-            mouseInteractions: this.defineMouseInteractions(requirements),
-            touchInteractions: this.defineTouchInteractions(requirements),
-            voiceInteractions: this.defineVoiceInteractions(requirements),
-            stateTransitions: this.defineStateTransitions(requirements),
-            animations: this.defineAnimations(requirements),
-            microInteractions: this.defineMicroInteractions(requirements)
-        };
-    }
-    /**
-     * Create visual design guidelines
-     */
-    async createVisualGuidelines(requirements) {
-        console.log('UI/UX Agent: Creating visual guidelines...');
-        return {
-            brandAlignment: this.createBrandAlignment(requirements),
-            iconography: this.createIconographySystem(requirements),
-            imagery: this.createImageryGuidelines(requirements),
-            spacing: this.createSpacingSystem(requirements),
-            elevation: this.createElevationSystem(requirements),
-            responsiveDesign: this.createResponsiveGuidelines(requirements)
-        };
-    }
-    // Design system creation methods
-    createColorScheme(requirements) {
-        const pattern = requirements.uiPattern;
-        const baseColors = {
-            primary: {
-                50: '#e3f2fd',
-                100: '#bbdefb',
-                500: '#2196f3',
-                700: '#1976d2',
-                900: '#0d47a1'
-            },
-            secondary: {
-                50: '#f3e5f5',
-                100: '#e1bee7',
-                500: '#9c27b0',
-                700: '#7b1fa2',
-                900: '#4a148c'
-            },
-            neutral: {
-                50: '#fafafa',
-                100: '#f5f5f5',
-                200: '#eeeeee',
-                300: '#e0e0e0',
-                500: '#9e9e9e',
-                700: '#616161',
-                900: '#212121'
-            },
-            semantic: {
-                success: '#4caf50',
-                warning: '#ff9800',
-                error: '#f44336',
-                info: '#2196f3'
-            }
-        };
-        // Adjust colors based on UI pattern
-        switch (pattern) {
-            case 'card_grid':
-                baseColors.primary[500] = '#1565c0';
-                break;
-            case 'data_table':
-                baseColors.neutral[50] = '#f8f9fa';
-                break;
-            case 'visualization':
-                baseColors.primary[500] = '#6366f1';
-                break;
-        }
-        return baseColors;
-    }
-    createTypographySystem(requirements) {
-        return {
-            fontFamily: {
-                primary: "'Source Sans Pro', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
-                secondary: "'Roboto Mono', 'Courier New', monospace"
-            },
-            fontSizes: {
-                xs: '0.75rem',
-                sm: '0.875rem',
-                base: '1rem',
-                lg: '1.125rem',
-                xl: '1.25rem',
-                '2xl': '1.5rem',
-                '3xl': '1.875rem',
-                '4xl': '2.25rem'
-            },
-            fontWeights: {
-                normal: 400,
-                medium: 500,
-                semibold: 600,
-                bold: 700
-            },
-            lineHeights: {
-                tight: 1.25,
-                normal: 1.5,
-                relaxed: 1.75
-            },
-            letterSpacing: {
-                tight: '-0.025em',
-                normal: '0',
-                wide: '0.025em'
-            }
-        };
-    }
-    createLayoutSystem(requirements) {
-        const pattern = requirements.uiPattern;
-        const layouts = {
-            card_grid: {
-                container: 'grid',
-                columns: 'repeat(auto-fill, minmax(280px, 1fr))',
-                gap: '1.5rem',
-                padding: '1rem'
-            },
-            form_layout: {
-                container: 'flex',
-                direction: 'column',
-                gap: '1rem',
-                maxWidth: '600px'
-            },
-            data_table: {
-                container: 'block',
-                overflow: 'auto',
-                width: '100%'
-            },
-            visualization: {
-                container: 'flex',
-                direction: 'column',
-                alignItems: 'center',
-                justifyContent: 'center'
-            },
-            flexible_layout: {
-                container: 'flex',
-                direction: 'column',
-                gap: '1rem'
-            }
-        };
-        return layouts[pattern] || layouts.flexible_layout;
-    }
-    createInteractionSystem(requirements) {
-        return {
-            hoverStates: {
-                backgroundColor: 'rgba(0, 0, 0, 0.04)',
-                transform: 'translateY(-1px)',
-                boxShadow: '0 4px 8px rgba(0, 0, 0, 0.12)',
-                transition: 'all 0.2s ease'
-            },
-            focusStates: {
-                outline: '2px solid #2196f3',
-                outlineOffset: '2px',
-                borderRadius: '4px'
-            },
-            activeStates: {
-                transform: 'translateY(1px)',
-                boxShadow: '0 2px 4px rgba(0, 0, 0, 0.12)'
-            },
-            transitions: {
-                default: 'all 0.2s ease',
-                fast: 'all 0.1s ease',
-                slow: 'all 0.3s ease'
-            }
-        };
-    }
-    createAccessibilityGuidelines(requirements) {
-        return {
-            colorContrast: {
-                normal: '4.5:1',
-                large: '3:1',
-                nonText: '3:1'
-            },
-            focusIndicators: {
-                width: '2px',
-                style: 'solid',
-                color: '#2196f3',
-                offset: '2px'
-            },
-            textSizing: {
-                minimum: '16px',
-                lineHeight: '1.5',
-                maxWidth: '80ch'
-            },
-            touchTargets: {
-                minimum: '44px',
-                recommended: '48px',
-                spacing: '8px'
-            }
-        };
-    }
-    // UX Guidelines creation methods
-    createUserFlows(requirements) {
-        return {
-            primaryFlows: requirements.userExperience.workflow.map(flow => ({
-                name: flow,
-                steps: this.generateFlowSteps(flow),
-                decisionPoints: this.generateDecisionPoints(flow),
-                errorPaths: this.generateErrorPaths(flow)
-            })),
-            secondaryFlows: this.generateSecondaryFlows(requirements),
-            edgeCases: this.generateEdgeCaseFlows(requirements)
-        };
-    }
-    createInformationArchitecture(requirements) {
-        return {
-            hierarchy: this.createContentHierarchy(requirements),
-            navigation: this.createNavigationStructure(requirements),
-            categorization: this.createCategorization(requirements),
-            searchability: this.createSearchStrategy(requirements)
-        };
-    }
-    createContentStrategy(requirements) {
-        return {
-            messaging: {
-                primary: 'Clear, concise, and action-oriented',
-                secondary: 'Helpful and contextual',
-                error: 'Specific and solution-focused'
-            },
-            tone: {
-                voice: 'Professional yet approachable',
-                personality: 'Helpful and reliable',
-                formality: 'Semi-formal'
-            },
-            microcopy: this.generateMicrocopy(requirements),
-            helpContent: this.generateHelpContent(requirements)
-        };
-    }
-    createErrorHandlingUX(requirements) {
-        return {
-            prevention: {
-                validation: 'Real-time with clear indicators',
-                constraints: 'Progressive disclosure of requirements',
-                confirmation: 'For destructive actions'
-            },
-            recovery: {
-                errorMessages: 'Specific, actionable, and polite',
-                helpOptions: 'Context-sensitive assistance',
-                fallbacks: 'Graceful degradation options'
-            },
-            feedback: {
-                loading: 'Clear progress indicators',
-                success: 'Confirmation with next steps',
-                failure: 'Clear explanation and recovery options'
-            }
-        };
-    }
-    createFeedbackSystems(requirements) {
-        return requirements.userExperience.feedback.map(feedback => ({
-            type: feedback,
-            implementation: this.getFeedbackImplementation(feedback),
-            timing: this.getFeedbackTiming(feedback),
-            accessibility: this.getFeedbackAccessibility(feedback)
-        }));
-    }
-    createPerformanceUXGuidelines(requirements) {
-        return {
-            loadingStates: {
-                skeleton: 'For content-heavy sections',
-                spinner: 'For quick actions',
-                progressBar: 'For known duration tasks'
-            },
-            optimisticUI: {
-                immediateResponse: 'For common actions',
-                rollbackStrategy: 'For failed optimistic updates',
-                conflictResolution: 'For concurrent modifications'
-            },
-            caching: {
-                strategy: 'Cache frequently accessed data',
-                invalidation: 'Clear cache on data changes',
-                fallbacks: 'Graceful degradation when cache fails'
-            }
-        };
-    }
-    // Accessibility specification methods
-    getWCAGGuidelines(level) {
-        const guidelines = {
-            'A': [
-                'Provide text alternatives for images',
-                'Provide captions for videos',
-                'Ensure keyboard accessibility',
-                'Avoid seizure-inducing content'
-            ],
-            'AA': [
-                'Ensure sufficient color contrast (4.5:1)',
-                'Support text resize up to 200%',
-                'Ensure keyboard accessibility',
-                'Provide clear headings and labels',
-                'Make error identification clear',
-                'Ensure focus indicators are visible'
-            ],
-            'AAA': [
-                'Ensure higher color contrast (7:1)',
-                'Support text resize up to 200% without assistive technology',
-                'Provide context and orientation information',
-                'Ensure timing is adjustable'
-            ]
-        };
-        return guidelines[level] || guidelines['AA'];
-    }
-    getAccessibilityTestingCriteria(level) {
-        return {
-            automated: [
-                'Color contrast ratios',
-                'Missing alt text',
-                'Heading structure',
-                'Form label associations',
-                'Focus order'
-            ],
-            manual: [
-                'Keyboard navigation',
-                'Screen reader compatibility',
-                'Logical reading order',
-                'Error handling',
-                'Time-based content'
-            ],
-            userTesting: [
-                'Screen reader user testing',
-                'Keyboard-only user testing',
-                'Cognitive accessibility testing'
-            ]
-        };
-    }
-    defineTabOrder(requirements) {
-        return {
-            strategy: 'Logical and intuitive flow',
-            skipLinks: 'Provide skip to main content',
-            focusTraps: 'For modal dialogs and overlays',
-            customTabIndex: 'Only when necessary, prefer natural order'
-        };
-    }
-    defineKeyboardShortcuts(requirements) {
-        return {
-            global: {
-                'Alt + M': 'Skip to main content',
-                'Alt + N': 'Skip to navigation',
-                'Escape': 'Close modals/dropdowns'
-            },
-            widget: {
-                'Enter': 'Activate primary action',
-                'Space': 'Select/toggle items',
-                'Arrow Keys': 'Navigate lists/grids'
-            }
-        };
-    }
-    defineFocusManagement(requirements) {
-        return {
-            initialFocus: 'First interactive element or logical starting point',
-            focusTrapping: 'Keep focus within modals and overlays',
-            focusRestoration: 'Return focus to trigger element after modal close',
-            visibleIndicators: 'Clear, high-contrast focus indicators'
-        };
-    }
-    defineAriaLabels(requirements) {
-        return {
-            buttons: 'Descriptive action labels',
-            links: 'Clear destination or purpose',
-            forms: 'Associated labels and descriptions',
-            landmarks: 'Page structure identification',
-            dynamicContent: 'Live region announcements'
-        };
-    }
-    defineLandmarks(requirements) {
-        return {
-            banner: 'Site header',
-            navigation: 'Primary navigation',
-            main: 'Main content area',
-            complementary: 'Sidebar content',
-            contentinfo: 'Site footer',
-            search: 'Search functionality'
-        };
-    }
-    defineScreenReaderAnnouncements(requirements) {
-        return {
-            statusUpdates: 'aria-live="polite" for non-critical updates',
-            errorMessages: 'aria-live="assertive" for errors',
-            loadingStates: 'Announce loading start and completion',
-            dynamicContent: 'Announce content changes'
-        };
-    }
-    defineColorContrast(requirements) {
-        return {
-            normalText: '4.5:1 minimum',
-            largeText: '3:1 minimum',
-            nonTextElements: '3:1 minimum',
-            focusIndicators: '3:1 against adjacent colors'
-        };
-    }
-    defineTextScaling(requirements) {
-        return {
-            support: 'Up to 200% zoom',
-            responsive: 'Layout remains functional',
-            readability: 'Text remains readable',
-            interaction: 'Interactive elements remain usable'
-        };
-    }
-    defineMotionPreferences(requirements) {
-        return {
-            respectPreference: 'Honor prefers-reduced-motion',
-            alternatives: 'Provide static alternatives to animations',
-            controls: 'Allow users to disable motion',
-            essential: 'Keep only essential motion'
-        };
-    }
-    defineErrorPrevention(requirements) {
-        return {
-            validation: 'Real-time validation with clear feedback',
-            confirmation: 'Confirm destructive or irreversible actions',
-            review: 'Allow review before submission',
-            recovery: 'Provide clear correction paths'
-        };
-    }
-    defineHelpSystems(requirements) {
-        return {
-            contextual: 'Help available where needed',
-            progressive: 'Information revealed as needed',
-            multiple: 'Various help formats (text, video, examples)',
-            accessible: 'Help content follows accessibility guidelines'
-        };
-    }
-    defineTimeoutHandling(requirements) {
-        return {
-            warning: 'Warn users before timeout',
-            extension: 'Allow timeout extension',
-            saving: 'Auto-save user progress',
-            recovery: 'Recover work after timeout'
-        };
-    }
-    // Validation methods
-    async validateUsability(design) {
-        console.log('UI/UX Agent: Validating usability...');
-        const heuristics = this.evaluateUsabilityHeuristics(design);
-        const accessibility = this.evaluateAccessibility(design);
-        const designSystem = this.evaluateDesignSystemAdherence(design);
-        const overallScore = (heuristics.score + accessibility.score + designSystem.score) / 3;
-        return {
-            score: overallScore,
-            issues: [...heuristics.issues, ...accessibility.issues, ...designSystem.issues],
-            recommendations: this.generateRecommendations(design, overallScore)
-        };
-    }
-    evaluateUsabilityHeuristics(design) {
-        const heuristics = [
-            { name: 'Visibility of system status', weight: 0.15 },
-            { name: 'Match between system and real world', weight: 0.1 },
-            { name: 'User control and freedom', weight: 0.15 },
-            { name: 'Consistency and standards', weight: 0.15 },
-            { name: 'Error prevention', weight: 0.1 },
-            { name: 'Recognition rather than recall', weight: 0.1 },
-            { name: 'Flexibility and efficiency of use', weight: 0.1 },
-            { name: 'Aesthetic and minimalist design', weight: 0.05 },
-            { name: 'Help users recognize and recover from errors', weight: 0.05 },
-            { name: 'Help and documentation', weight: 0.05 }
-        ];
-        let totalScore = 0;
-        const issues = [];
-        heuristics.forEach(heuristic => {
-            const score = this.evaluateHeuristic(design, heuristic.name);
-            totalScore += score * heuristic.weight;
-            if (score < 0.7) {
-                issues.push({
-                    type: 'usability',
-                    heuristic: heuristic.name,
-                    severity: score < 0.5 ? 'high' : 'medium',
-                    description: `Low score for ${heuristic.name}`
-                });
-            }
-        });
-        return { score: totalScore, issues };
-    }
-    evaluateAccessibility(design) {
-        const criteria = [
-            'Color contrast',
-            'Keyboard navigation',
-            'Screen reader support',
-            'Focus management',
-            'Error handling',
-            'Time-based content'
-        ];
-        let totalScore = 0;
-        const issues = [];
-        criteria.forEach(criterion => {
-            const score = this.evaluateAccessibilityCriterion(design, criterion);
-            totalScore += score / criteria.length;
-            if (score < 0.8) {
-                issues.push({
-                    type: 'accessibility',
-                    criterion,
-                    severity: score < 0.6 ? 'high' : 'medium',
-                    description: `Accessibility issue with ${criterion}`
-                });
-            }
-        });
-        return { score: totalScore, issues };
-    }
-    evaluateDesignSystemAdherence(design) {
-        const aspects = [
-            'Color usage',
-            'Typography consistency',
-            'Spacing consistency',
-            'Component usage',
-            'Interaction patterns'
-        ];
-        let totalScore = 0;
-        const issues = [];
-        aspects.forEach(aspect => {
-            const score = this.evaluateDesignSystemAspect(design, aspect);
-            totalScore += score / aspects.length;
-            if (score < 0.75) {
-                issues.push({
-                    type: 'design_system',
-                    aspect,
-                    severity: score < 0.5 ? 'high' : 'medium',
-                    description: `Design system inconsistency in ${aspect}`
-                });
-            }
-        });
-        return { score: totalScore, issues };
-    }
-    generateRecommendations(design, score) {
-        const recommendations = [];
-        if (score < 0.7) {
-            recommendations.push('Consider a comprehensive usability review');
-            recommendations.push('Conduct user testing with representative users');
-        }
-        if (score < 0.5) {
-            recommendations.push('Major usability improvements needed');
-            recommendations.push('Consider design iteration with user feedback');
-        }
-        // Add specific recommendations based on design analysis
-        recommendations.push('Ensure all interactive elements have clear affordances');
-        recommendations.push('Validate color contrast meets WCAG AA standards');
-        recommendations.push('Test keyboard navigation thoroughly');
-        return recommendations;
-    }
-    // Helper evaluation methods
-    evaluateHeuristic(design, heuristicName) {
-        // Simplified evaluation - in real implementation, this would be more sophisticated
-        const baseScore = 0.7;
-        // Add evaluation logic based on design properties
-        if (design.uxGuidelines && design.uxGuidelines.errorHandling) {
-            return Math.min(baseScore + 0.2, 1.0);
-        }
-        return baseScore;
-    }
-    evaluateAccessibilityCriterion(design, criterion) {
-        // Simplified evaluation
-        const baseScore = 0.8;
-        if (design.accessibilitySpec && design.accessibilitySpec.wcagCompliance) {
-            return Math.min(baseScore + 0.1, 1.0);
-        }
-        return baseScore;
-    }
-    evaluateDesignSystemAspect(design, aspect) {
-        // Simplified evaluation
-        const baseScore = 0.75;
-        if (design.designSpec && design.designSpec.colorScheme) {
-            return Math.min(baseScore + 0.15, 1.0);
-        }
-        return baseScore;
-    }
-    // Assessment methods
-    assessDesignConsistency(designSpec) {
-        // Check if design spec has consistent color and typography usage
-        const hasColorScheme = !!designSpec.colorScheme;
-        const hasTypography = !!designSpec.typography;
-        const hasLayout = !!designSpec.layout;
-        let score = 0.3;
-        if (hasColorScheme)
-            score += 0.25;
-        if (hasTypography)
-            score += 0.25;
-        if (hasLayout)
-            score += 0.2;
-        return Math.min(score, 1.0);
-    }
-    assessAccessibilityCompliance(accessibilitySpec) {
-        // Check accessibility specification completeness
-        const hasWCAG = !!accessibilitySpec.wcagCompliance;
-        const hasKeyboard = !!accessibilitySpec.keyboardNavigation;
-        const hasScreenReader = !!accessibilitySpec.screenReaderSupport;
-        let score = 0.4;
-        if (hasWCAG)
-            score += 0.25;
-        if (hasKeyboard)
-            score += 0.2;
-        if (hasScreenReader)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    assessUserExperience(uxGuidelines) {
-        // Check UX guidelines completeness
-        const hasUserFlows = !!uxGuidelines.userFlows;
-        const hasErrorHandling = !!uxGuidelines.errorHandling;
-        const hasFeedback = !!uxGuidelines.feedbackSystems;
-        let score = 0.4;
-        if (hasUserFlows)
-            score += 0.25;
-        if (hasErrorHandling)
-            score += 0.2;
-        if (hasFeedback)
-            score += 0.15;
-        return Math.min(score, 1.0);
-    }
-    // Helper methods for generating content
-    generateFlowSteps(flow) {
-        const flows = {
-            'load_data': ['Initialize', 'Validate permissions', 'Fetch data', 'Process data', 'Display results'],
-            'user_interaction': ['Detect interaction', 'Validate input', 'Process action', 'Update UI', 'Provide feedback'],
-            'error_handling': ['Detect error', 'Log error', 'Display user message', 'Provide recovery options']
-        };
-        return flows[flow] || ['Start', 'Process', 'Complete'];
-    }
-    generateDecisionPoints(flow) {
-        return ['User permissions check', 'Data availability check', 'Error condition check'];
-    }
-    generateErrorPaths(flow) {
-        return ['Permission denied path', 'Data unavailable path', 'System error path'];
-    }
-    generateSecondaryFlows(requirements) {
-        return [
-            { name: 'Settings configuration', priority: 'low' },
-            { name: 'Help access', priority: 'medium' },
-            { name: 'Refresh data', priority: 'medium' }
-        ];
-    }
-    generateEdgeCaseFlows(requirements) {
-        return [
-            { name: 'Network offline', recovery: 'Show cached data with notice' },
-            { name: 'No data available', recovery: 'Show empty state with guidance' },
-            { name: 'Timeout error', recovery: 'Offer retry option' }
-        ];
-    }
-    // Analysis methods
-    analyzeUserExperience(requirements) {
-        return {
-            complexity: requirements.userExperience.workflow.length > 3 ? 'high' : 'medium',
-            workflows: requirements.userExperience.workflow,
-            feedbackNeeds: requirements.userExperience.feedback
-        };
-    }
-    analyzeAccessibilityNeeds(requirements) {
-        return {
-            wcagLevel: requirements.accessibility.wcag,
-            screenReaderSupport: requirements.accessibility.screenReader,
-            keyboardNavigation: requirements.accessibility.keyboard,
-            priority: 'high'
-        };
-    }
-    analyzeDesignSystemNeeds(requirements) {
-        return {
-            pattern: requirements.uiPattern,
-            consistency: 'high',
-            customization: 'medium'
-        };
-    }
-    analyzeInteractionNeeds(requirements) {
-        return {
-            complexity: 'medium',
-            types: ['click', 'hover', 'keyboard', 'touch'],
-            responsiveness: 'required'
-        };
-    }
-    analyzeUsabilityFactors(requirements) {
-        return {
-            testing: 'recommended',
-            heuristics: 'apply_all',
-            iteration: 'expected'
-        };
-    }
-    // Content generation helpers
-    createContentHierarchy(requirements) {
-        return {
-            primary: 'Widget title and main content',
-            secondary: 'Actions and controls',
-            tertiary: 'Metadata and support information'
-        };
-    }
-    createNavigationStructure(requirements) {
-        return {
-            type: 'inline',
-            patterns: ['breadcrumbs', 'tabs', 'pagination'],
-            accessibility: 'full keyboard support'
-        };
-    }
-    createCategorization(requirements) {
-        return {
-            method: 'logical grouping',
-            labels: 'clear and descriptive',
-            hierarchy: 'shallow preferred'
-        };
-    }
-    createSearchStrategy(requirements) {
-        return {
-            type: 'inline filtering',
-            scope: 'current data set',
-            feedback: 'real-time results'
-        };
-    }
-    generateMicrocopy(requirements) {
-        return {
-            buttons: 'Action-oriented verbs',
-            labels: 'Clear and concise',
-            errors: 'Specific and helpful',
-            success: 'Encouraging and next-step focused'
-        };
-    }
-    generateHelpContent(requirements) {
-        return {
-            contextual: 'Tooltips and inline help',
-            comprehensive: 'Help documentation',
-            interactive: 'Guided tours and tutorials'
-        };
-    }
-    getFeedbackImplementation(feedback) {
-        const implementations = {
-            'loading_indicators': 'Spinners, progress bars, skeleton screens',
-            'error_messages': 'Inline alerts with clear messaging',
-            'success_notifications': 'Toast notifications with success icons'
-        };
-        return implementations[feedback] || 'Standard UI feedback pattern';
-    }
-    getFeedbackTiming(feedback) {
-        const timings = {
-            'loading_indicators': 'Immediate on action initiation',
-            'error_messages': 'Real-time validation',
-            'success_notifications': 'Immediate on successful completion'
-        };
-        return timings[feedback] || 'Context-appropriate timing';
-    }
-    getFeedbackAccessibility(feedback) {
-        return 'Screen reader announcements, high contrast, keyboard accessible';
-    }
-    // Additional helper methods for completeness
-    defineGestureInteractions(requirements) {
-        return {
-            swipe: 'Navigate between items',
-            pinch: 'Zoom content',
-            tap: 'Primary interaction',
-            longPress: 'Context menu'
-        };
-    }
-    defineMouseInteractions(requirements) {
-        return {
-            click: 'Primary action',
-            doubleClick: 'Quick action',
-            rightClick: 'Context menu',
-            hover: 'Preview information'
-        };
-    }
-    defineTouchInteractions(requirements) {
-        return {
-            tap: 'Primary interaction',
-            swipe: 'Navigation',
-            pinch: 'Zoom',
-            twoFinger: 'Secondary actions'
-        };
-    }
-    defineVoiceInteractions(requirements) {
-        return {
-            commands: ['refresh', 'filter', 'select'],
-            feedback: 'Audio confirmation',
-            fallback: 'Visual alternative always available'
-        };
-    }
-    defineStateTransitions(requirements) {
-        return {
-            loading: 'Fade in with spinner',
-            error: 'Slide in error message',
-            success: 'Smooth content update',
-            empty: 'Fade to empty state'
-        };
-    }
-    defineAnimations(requirements) {
-        return {
-            duration: '0.2s for UI, 0.3s for content',
-            easing: 'ease-out for entrances, ease-in for exits',
-            reducedMotion: 'Respect user preferences'
-        };
-    }
-    defineMicroInteractions(requirements) {
-        return {
-            buttonPress: 'Subtle scale down',
-            hoverFeedback: 'Color change and elevation',
-            focusFeedback: 'Clear outline indicator',
-            errorShake: 'Gentle horizontal shake'
-        };
-    }
-    createBrandAlignment(requirements) {
-        return {
-            serviceNowBrand: 'Follow ServiceNow design system',
-            consistency: 'Maintain brand consistency',
-            flexibility: 'Allow for customization within guidelines'
-        };
-    }
-    createIconographySystem(requirements) {
-        return {
-            style: 'Outline icons from ServiceNow icon library',
-            size: '16px, 20px, 24px',
-            usage: 'Consistent meaning across contexts',
-            accessibility: 'Always paired with text labels'
-        };
-    }
-    createImageryGuidelines(requirements) {
-        return {
-            style: 'Professional and purposeful',
-            quality: 'High resolution for all screen densities',
-            accessibility: 'Meaningful alt text for all images',
-            optimization: 'Optimized for web performance'
-        };
-    }
-    createSpacingSystem(requirements) {
-        return {
-            scale: '4px, 8px, 12px, 16px, 24px, 32px, 48px, 64px',
-            usage: 'Consistent spacing between elements',
-            responsive: 'Adjust spacing for different screen sizes'
-        };
-    }
-    createElevationSystem(requirements) {
-        return {
-            levels: '0, 1, 2, 3, 4',
-            shadows: 'Consistent shadow definitions',
-            usage: 'Indicate hierarchy and interactivity'
-        };
-    }
-    createResponsiveGuidelines(requirements) {
-        return {
-            breakpoints: '320px, 768px, 1024px, 1200px',
-            approach: 'Mobile-first design',
-            testing: 'Test on multiple devices and screen sizes'
-        };
-    }
-}
-exports.WidgetUIUXAgent = WidgetUIUXAgent;
-//# sourceMappingURL=widget-uiux.agent.js.map