snow-flow 3.0.8 → 3.0.10

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

@@ -1,436 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetArchitectAgent = void 0;
-/**
- * Widget Architect Agent - Coordinates widget development team
- * Analyzes requirements and orchestrates specialized team members
- */
-const base_team_1 = require("../base-team");
-class WidgetArchitectAgent extends base_team_1.BaseSnowAgent {
-    constructor(config) {
-        const capabilities = [
-            {
-                name: 'requirement_analysis',
-                description: 'Analyze and break down widget requirements',
-                proficiency: 0.95,
-                tools: ['analysis', 'planning', 'coordination']
-            },
-            {
-                name: 'team_coordination',
-                description: 'Coordinate specialized team members',
-                proficiency: 0.9,
-                tools: ['coordination', 'communication', 'project_management']
-            },
-            {
-                name: 'widget_architecture',
-                description: 'Design widget architecture and structure',
-                proficiency: 0.85,
-                tools: ['architecture', 'design_patterns', 'servicenow_patterns']
-            },
-            {
-                name: 'integration_planning',
-                description: 'Plan widget integrations and dependencies',
-                proficiency: 0.8,
-                tools: ['integration', 'api_design', 'dependency_management']
-            }
-        ];
-        const specialization = {
-            primary: ['widget_architecture', 'team_coordination', 'requirement_analysis'],
-            secondary: ['ui_design', 'performance_planning', 'testing_strategy'],
-            tools: ['ServiceNow Flow Composer', 'ServiceNow Deployment', 'Team Coordination'],
-            experience: 0.9
-        };
-        super('widget-architect-001', 'Widget Architect', 'architect', capabilities, specialization, config);
-    }
-    /**
-     * Set team members that this architect will coordinate
-     */
-    setTeamMembers(frontendAgent, backendAgent, uiuxAgent, platformAgent) {
-        this.frontendAgent = frontendAgent;
-        this.backendAgent = backendAgent;
-        this.uiuxAgent = uiuxAgent;
-        this.platformAgent = platformAgent;
-    }
-    /**
-     * Analyze widget requirements and create technical specification
-     */
-    async analyzeRequirements(requirements) {
-        try {
-            this.setStatus('busy');
-            // Analyze complexity based on requirements
-            const complexity = this.assessComplexity(requirements);
-            // Estimate time based on complexity and features
-            const estimatedTime = this.estimateTime(requirements, complexity);
-            // Identify dependencies
-            const dependencies = this.identifyDependencies(requirements);
-            const specification = {
-                id: `widget-spec-${Date.now()}`,
-                requirements,
-                complexity,
-                estimatedTime,
-                dependencies
-            };
-            console.log(`Widget Architect: Analyzed requirements - Complexity: ${complexity}, Time: ${estimatedTime}m`);
-            return specification;
-        }
-        catch (error) {
-            console.error('Widget Architect: Error analyzing requirements:', error);
-            throw error;
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Coordinate the entire widget development team
-     */
-    async execute(specification) {
-        try {
-            this.setStatus('busy');
-            console.log('Widget Architect: Starting team coordination...');
-            if (!this.frontendAgent || !this.backendAgent || !this.uiuxAgent || !this.platformAgent) {
-                throw new Error('Team members not properly initialized');
-            }
-            // Break down specification into specialized tasks
-            const tasks = await this.createTaskBreakdown(specification);
-            // Execute tasks based on dependencies and complexity
-            const result = await this.coordinateTeam(tasks);
-            // Integrate all components into final widget
-            const widget = await this.integrateComponents(result);
-            // Deploy the widget
-            const deployment = await this.deployWidget(widget);
-            console.log('Widget Architect: Team coordination completed successfully');
-            return {
-                success: true,
-                artifact: deployment,
-                metadata: {
-                    duration: 0, // Will be set by base class
-                    performance: {
-                        coordination_efficiency: 0.85,
-                        team_synchronization: 0.9
-                    },
-                    quality: {
-                        architecture_score: 0.9,
-                        integration_score: 0.85
-                    }
-                }
-            };
-        }
-        catch (error) {
-            console.error('Widget Architect: Error coordinating team:', error);
-            return this.handleError(error);
-        }
-        finally {
-            this.setStatus('available');
-        }
-    }
-    /**
-     * Break down widget specification into specialized tasks
-     */
-    async createTaskBreakdown(specification) {
-        const { requirements } = specification;
-        // Create frontend requirements
-        const frontend = {
-            template: {
-                layout: this.determineLayout(requirements.type),
-                components: this.identifyComponents(requirements),
-                responsive: requirements.ui.responsive
-            },
-            styling: {
-                theme: requirements.ui.theme,
-                accessibility: requirements.ui.accessibility
-            },
-            clientScript: {
-                framework: 'angular', // ServiceNow default
-                events: this.identifyClientEvents(requirements),
-                apiCalls: this.identifyApiCalls(requirements)
-            }
-        };
-        // Create backend requirements
-        const backend = {
-            serverScript: {
-                dataProcessing: this.identifyDataProcessing(requirements),
-                apiIntegrations: requirements.integrations || [],
-                businessLogic: this.identifyBusinessLogic(requirements)
-            },
-            performance: {
-                caching: this.requiresCaching(requirements),
-                optimization: this.identifyOptimizations(requirements)
-            },
-            security: {
-                validation: this.identifyValidations(requirements),
-                authorization: this.identifyAuthorization(requirements)
-            }
-        };
-        // Create design requirements
-        const design = {
-            uiPattern: this.determineUIPattern(requirements.type),
-            accessibility: {
-                wcag: 'AA',
-                screenReader: requirements.ui.accessibility,
-                keyboard: requirements.ui.accessibility
-            },
-            userExperience: {
-                workflow: this.identifyWorkflows(requirements),
-                feedback: this.identifyFeedbackNeeds(requirements)
-            }
-        };
-        // Create platform requirements
-        const platform = {
-            integration: {
-                apis: requirements.integrations || [],
-                tables: [requirements.data.source],
-                dependencies: this.identifyPlatformDependencies(requirements)
-            },
-            deployment: {
-                scope: 'global',
-                permissions: this.identifyPermissions(requirements)
-            }
-        };
-        return { frontend, backend, design, platform };
-    }
-    /**
-     * Coordinate team execution with proper dependency management
-     */
-    async coordinateTeam(tasks) {
-        console.log('Widget Architect: Coordinating specialized agents...');
-        // Phase 1: Design and Planning (parallel)
-        const [designResult, platformSetup] = await Promise.all([
-            this.uiuxAgent.execute(tasks.design),
-            this.platformAgent.execute(tasks.platform)
-        ]);
-        if (!designResult.success || !platformSetup.success) {
-            throw new Error('Design or platform setup failed');
-        }
-        // Phase 2: Implementation (parallel, dependent on design)
-        const [frontendResult, backendResult] = await Promise.all([
-            this.frontendAgent.execute({
-                ...tasks.frontend,
-                design: designResult.artifact
-            }),
-            this.backendAgent.execute({
-                ...tasks.backend,
-                platform: platformSetup.artifact
-            })
-        ]);
-        if (!frontendResult.success || !backendResult.success) {
-            throw new Error('Frontend or backend implementation failed');
-        }
-        return {
-            design: designResult.artifact,
-            frontend: frontendResult.artifact,
-            backend: backendResult.artifact,
-            platform: platformSetup.artifact
-        };
-    }
-    /**
-     * Integrate all components into final widget
-     */
-    async integrateComponents(components) {
-        console.log('Widget Architect: Integrating components...');
-        const widget = {
-            name: `${components.design.name || 'custom_widget'}_${Date.now()}`,
-            id: `${components.design.id || 'custom_widget'}_${Date.now()}`,
-            template: components.frontend.template,
-            css: components.frontend.css,
-            client_script: components.frontend.clientScript,
-            server_script: components.backend.serverScript,
-            option_schema: JSON.stringify(components.frontend.optionSchema || {}),
-            public: true,
-            data: components.backend.data || {}
-        };
-        return widget;
-    }
-    /**
-     * Deploy the integrated widget
-     */
-    async deployWidget(widget) {
-        console.log('Widget Architect: Deploying widget...');
-        // This would integrate with the ServiceNow deployment MCP
-        // For now, return the widget specification
-        return {
-            widget,
-            deploymentStatus: 'prepared',
-            commands: [
-                {
-                    tool: 'mcp__servicenow-deployment__snow_deploy_widget',
-                    parameters: widget
-                }
-            ]
-        };
-    }
-    // Helper methods for requirement analysis
-    assessComplexity(requirements) {
-        let complexity = 0;
-        // Data complexity
-        if (requirements.data.fields.length > 10)
-            complexity += 2;
-        else if (requirements.data.fields.length > 5)
-            complexity += 1;
-        // Functionality complexity
-        if (requirements.functionality.realtime)
-            complexity += 2;
-        if (requirements.functionality.interactive)
-            complexity += 1;
-        if (requirements.functionality.export)
-            complexity += 1;
-        // Integration complexity
-        complexity += (requirements.integrations?.length || 0);
-        // UI complexity
-        if (requirements.ui.responsive)
-            complexity += 1;
-        if (requirements.ui.accessibility)
-            complexity += 1;
-        if (complexity >= 6)
-            return 'complex';
-        if (complexity >= 3)
-            return 'medium';
-        return 'simple';
-    }
-    estimateTime(requirements, complexity) {
-        const baseTime = {
-            simple: 60,
-            medium: 120,
-            complex: 240
-        };
-        let time = baseTime[complexity];
-        // Add time for specific features
-        if (requirements.functionality.realtime)
-            time += 60;
-        if (requirements.functionality.interactive)
-            time += 30;
-        if (requirements.ui.accessibility)
-            time += 45;
-        return time;
-    }
-    identifyDependencies(requirements) {
-        const deps = [];
-        if (requirements.functionality.realtime) {
-            deps.push('websocket_service');
-        }
-        if (requirements.type === 'chart') {
-            deps.push('chart_library');
-        }
-        if (requirements.integrations?.length) {
-            deps.push('integration_service');
-        }
-        return deps;
-    }
-    // Component identification methods
-    determineLayout(type) {
-        const layouts = {
-            dashboard: 'grid',
-            form: 'vertical',
-            list: 'table',
-            chart: 'centered',
-            custom: 'flexible'
-        };
-        return layouts[type] || 'flexible';
-    }
-    identifyComponents(requirements) {
-        const components = ['container'];
-        if (requirements.type === 'chart') {
-            components.push('chart', 'legend', 'filters');
-        }
-        if (requirements.functionality.interactive) {
-            components.push('controls', 'buttons');
-        }
-        if (requirements.functionality.export) {
-            components.push('export_button');
-        }
-        return components;
-    }
-    identifyClientEvents(requirements) {
-        const events = ['onLoad'];
-        if (requirements.functionality.interactive) {
-            events.push('onClick', 'onChange');
-        }
-        if (requirements.functionality.realtime) {
-            events.push('onUpdate');
-        }
-        return events;
-    }
-    identifyApiCalls(requirements) {
-        const calls = [`/api/now/table/${requirements.data.source}`];
-        if (requirements.integrations?.length) {
-            calls.push(...requirements.integrations.map(i => `/api/integration/${i}`));
-        }
-        return calls;
-    }
-    identifyDataProcessing(requirements) {
-        const processing = ['data_fetch'];
-        if (requirements.type === 'chart') {
-            processing.push('data_aggregation', 'chart_data_formatting');
-        }
-        if (requirements.data.filters) {
-            processing.push('data_filtering');
-        }
-        return processing;
-    }
-    identifyBusinessLogic(requirements) {
-        const logic = [];
-        if (requirements.functionality.interactive) {
-            logic.push('user_interaction_logic');
-        }
-        if (requirements.functionality.realtime) {
-            logic.push('realtime_update_logic');
-        }
-        return logic;
-    }
-    requiresCaching(requirements) {
-        return requirements.data.fields.length > 20 ||
-            requirements.functionality.realtime ||
-            (requirements.integrations?.length || 0) > 0;
-    }
-    identifyOptimizations(requirements) {
-        const optimizations = [];
-        if (requirements.data.fields.length > 10) {
-            optimizations.push('lazy_loading', 'pagination');
-        }
-        if (requirements.functionality.realtime) {
-            optimizations.push('efficient_polling', 'websocket_optimization');
-        }
-        return optimizations;
-    }
-    identifyValidations(requirements) {
-        return ['input_validation', 'data_validation', 'permission_check'];
-    }
-    identifyAuthorization(requirements) {
-        return ['role_check', 'table_access_check'];
-    }
-    determineUIPattern(type) {
-        const patterns = {
-            dashboard: 'card_grid',
-            form: 'form_layout',
-            list: 'data_table',
-            chart: 'visualization',
-            custom: 'flexible_layout'
-        };
-        return patterns[type] || 'flexible_layout';
-    }
-    identifyWorkflows(requirements) {
-        const workflows = ['load_data', 'display_data'];
-        if (requirements.functionality.interactive) {
-            workflows.push('user_interaction', 'update_display');
-        }
-        return workflows;
-    }
-    identifyFeedbackNeeds(requirements) {
-        return ['loading_indicators', 'error_messages', 'success_notifications'];
-    }
-    identifyPlatformDependencies(requirements) {
-        const deps = [];
-        if (requirements.type === 'chart') {
-            deps.push('chart_js');
-        }
-        if (requirements.functionality.export) {
-            deps.push('export_service');
-        }
-        return deps;
-    }
-    identifyPermissions(requirements) {
-        return [`${requirements.data.source}.read`];
-    }
-}
-exports.WidgetArchitectAgent = WidgetArchitectAgent;
-//# sourceMappingURL=widget-architect.agent.js.map

package/dist/agents/teams/widget/widget-backend.agent.d.ts

@@ -1,74 +0,0 @@
-/**
- * Widget Backend Agent - Backend Development Specialist
- * Handles server-side scripts, data processing, API integrations, and performance optimization
- */
-import { BaseSnowAgent } from '../base-team';
-import { BackendRequirements, TeamResult } from '../team-types';
-import { ServiceNowAgentConfig } from '../../../types/servicenow.types';
-export declare class WidgetBackendAgent extends BaseSnowAgent {
-    constructor(config: ServiceNowAgentConfig);
-    /**
-     * Analyze backend requirements and prepare implementation plan
-     */
-    analyzeRequirements(requirements: BackendRequirements & {
-        platform?: any;
-    }): Promise<any>;
-    /**
-     * Execute backend development tasks
-     */
-    execute(requirements: BackendRequirements & {
-        platform?: any;
-    }): Promise<TeamResult>;
-    /**
-     * Create comprehensive server-side script
-     */
-    createServerScript(requirements: BackendRequirements): Promise<string>;
-    /**
-     * Create data processing functions
-     */
-    createDataProcessors(requirements: BackendRequirements): Promise<any>;
-    /**
-     * Create API integration handlers
-     */
-    createApiHandlers(requirements: BackendRequirements): Promise<any>;
-    /**
-     * Create performance optimizations
-     */
-    createPerformanceOptimizations(requirements: BackendRequirements): Promise<any>;
-    /**
-     * Create security validations
-     */
-    createSecurityValidations(requirements: BackendRequirements): Promise<any>;
-    private createDataLoadingFunctions;
-    private createApiIntegrationFunctions;
-    private createCachingFunctions;
-    private createSecurityFunctions;
-    private createErrorHandlingFunctions;
-    private createDataFilterProcessor;
-    private createDataAggregationProcessor;
-    private createDataTransformationProcessor;
-    private createDataValidationProcessor;
-    private createRestApiHandler;
-    private createExternalApiHandler;
-    private createServiceNowApiHandler;
-    private createQueryOptimizations;
-    private createCachingStrategy;
-    private createLazyLoadingStrategy;
-    private createInputValidation;
-    private createAccessControl;
-    private createDataSanitization;
-    private analyzeDataProcessing;
-    private analyzeApiIntegrations;
-    private analyzePerformanceNeeds;
-    private analyzeSecurityNeeds;
-    private analyzeErrorHandling;
-    private validateImplementation;
-    private validateErrorHandling;
-    private validateSecurity;
-    private validateMaintainability;
-    private assessScriptEfficiency;
-    private assessQueryOptimization;
-    private assessApiPerformance;
-    private capitalizeFirst;
-}
-//# sourceMappingURL=widget-backend.agent.d.ts.map