snow-flow 3.0.8 → 3.0.10

package/dist/sparc/teams/widget-team.js

@@ -1,280 +0,0 @@
-"use strict";
-/**
- * Widget Development Team
- * Specialized team for Service Portal widget development
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetTeam = void 0;
-const team_modes_js_1 = require("../modes/team-modes.js");
-class WidgetTeam {
-    constructor() {
-        this.members = [];
-        this.teamMode = (0, team_modes_js_1.getTeamMode)('widget');
-        this.initializeTeam();
-    }
-    initializeTeam() {
-        this.members = [
-            {
-                role: 'frontend',
-                name: 'WidgetFrontendAgent',
-                capabilities: [
-                    'HTML template development',
-                    'CSS styling and responsive design',
-                    'JavaScript client-side logic',
-                    'AngularJS directives',
-                    'Performance optimization'
-                ],
-                workload: 0,
-                status: 'available'
-            },
-            {
-                role: 'backend',
-                name: 'WidgetBackendAgent',
-                capabilities: [
-                    'Server-side script development',
-                    'GlideRecord data queries',
-                    'REST API integration',
-                    'Data processing',
-                    'Caching strategies'
-                ],
-                workload: 0,
-                status: 'available'
-            },
-            {
-                role: 'uiux',
-                name: 'UIUXSpecialistAgent',
-                capabilities: [
-                    'User experience design',
-                    'Interface patterns',
-                    'Accessibility compliance',
-                    'Usability testing',
-                    'Mobile-first design'
-                ],
-                workload: 0,
-                status: 'available'
-            },
-            {
-                role: 'platform',
-                name: 'PlatformSpecialistAgent',
-                capabilities: [
-                    'Platform configuration',
-                    'Security and ACL setup',
-                    'Performance monitoring',
-                    'Integration architecture',
-                    'Best practices'
-                ],
-                workload: 0,
-                status: 'available'
-            }
-        ];
-    }
-    createProjectPlan(task, analysis) {
-        console.log('🎨 Creating Widget Development Project Plan...');
-        const complexity = this.assessWidgetComplexity(task, analysis);
-        const phases = this.generateProjectPhases(task, complexity);
-        const deliverables = this.generateDeliverables(task, complexity);
-        this.currentProject = {
-            projectName: `Widget Development: ${this.extractWidgetName(task)}`,
-            description: task,
-            phases,
-            estimatedDuration: this.calculateDuration(complexity, phases),
-            complexity,
-            dependencies: this.identifyDependencies(task),
-            deliverables
-        };
-        console.log(`📋 Project Plan Created:`);
-        console.log(`   Widget Name: ${this.extractWidgetName(task)}`);
-        console.log(`   Complexity: ${complexity}`);
-        console.log(`   Estimated Duration: ${this.currentProject.estimatedDuration}`);
-        console.log(`   Phases: ${phases.length}`);
-        console.log(`   Deliverables: ${deliverables.length}\n`);
-        return this.currentProject;
-    }
-    assessWidgetComplexity(task, analysis) {
-        const complexityIndicators = {
-            simple: ['display', 'show', 'list', 'basic', 'simple'],
-            medium: ['dashboard', 'interactive', 'filter', 'search', 'form'],
-            complex: ['real-time', 'charts', 'integration', 'advanced', 'multiple data sources', 'analytics']
-        };
-        const taskLower = task.toLowerCase();
-        if (complexityIndicators.complex.some(indicator => taskLower.includes(indicator))) {
-            return 'complex';
-        }
-        if (complexityIndicators.medium.some(indicator => taskLower.includes(indicator))) {
-            return 'medium';
-        }
-        return 'simple';
-    }
-    generateProjectPhases(task, complexity) {
-        const basePhases = [
-            {
-                name: 'Analysis & Design',
-                description: 'Analyze requirements and design widget architecture',
-                duration: complexity === 'simple' ? '30min' : complexity === 'medium' ? '1hour' : '2hours',
-                dependencies: [],
-                assignedTo: ['UIUXSpecialistAgent', 'PlatformSpecialistAgent'],
-                deliverables: ['requirements_analysis', 'design_mockups', 'technical_specs'],
-                milestones: ['Requirements approved', 'Design approved']
-            },
-            {
-                name: 'Frontend Development',
-                description: 'Develop HTML template, CSS styling, and client-side JavaScript',
-                duration: complexity === 'simple' ? '1hour' : complexity === 'medium' ? '2hours' : '4hours',
-                dependencies: ['Analysis & Design'],
-                assignedTo: ['WidgetFrontendAgent'],
-                deliverables: ['html_template', 'css_styles', 'client_script'],
-                milestones: ['Template completed', 'Styling completed', 'Client logic completed']
-            },
-            {
-                name: 'Backend Development',
-                description: 'Develop server-side script and data processing logic',
-                duration: complexity === 'simple' ? '45min' : complexity === 'medium' ? '1.5hours' : '3hours',
-                dependencies: ['Analysis & Design'],
-                assignedTo: ['WidgetBackendAgent'],
-                deliverables: ['server_script', 'data_processing'],
-                milestones: ['Server script completed', 'Data integration completed']
-            },
-            {
-                name: 'Integration & Testing',
-                description: 'Integrate components and perform testing',
-                duration: complexity === 'simple' ? '30min' : complexity === 'medium' ? '1hour' : '2hours',
-                dependencies: ['Frontend Development', 'Backend Development'],
-                assignedTo: ['PlatformSpecialistAgent', 'WidgetFrontendAgent'],
-                deliverables: ['integrated_widget', 'test_results'],
-                milestones: ['Integration completed', 'Testing completed']
-            }
-        ];
-        // Add additional phases for complex widgets
-        if (complexity === 'complex') {
-            basePhases.push({
-                name: 'Performance Optimization',
-                description: 'Optimize widget performance and scalability',
-                duration: '1hour',
-                dependencies: ['Integration & Testing'],
-                assignedTo: ['WidgetBackendAgent', 'PlatformSpecialistAgent'],
-                deliverables: ['performance_report', 'optimization_improvements'],
-                milestones: ['Performance targets met']
-            });
-        }
-        return basePhases;
-    }
-    generateDeliverables(task, complexity) {
-        const deliverables = [
-            {
-                type: 'html_template',
-                content: '',
-                owner: 'WidgetFrontendAgent',
-                dependencies: [],
-                status: 'pending'
-            },
-            {
-                type: 'css_styles',
-                content: '',
-                owner: 'WidgetFrontendAgent',
-                dependencies: ['html_template'],
-                status: 'pending'
-            },
-            {
-                type: 'client_script',
-                content: '',
-                owner: 'WidgetFrontendAgent',
-                dependencies: ['html_template'],
-                status: 'pending'
-            },
-            {
-                type: 'server_script',
-                content: '',
-                owner: 'WidgetBackendAgent',
-                dependencies: [],
-                status: 'pending'
-            }
-        ];
-        // Add demo data for medium and complex widgets
-        if (complexity !== 'simple') {
-            deliverables.push({
-                type: 'demo_data',
-                content: '',
-                owner: 'WidgetBackendAgent',
-                dependencies: ['server_script'],
-                status: 'pending'
-            });
-        }
-        // Add documentation for complex widgets
-        if (complexity === 'complex') {
-            deliverables.push({
-                type: 'documentation',
-                content: '',
-                owner: 'UIUXSpecialistAgent',
-                dependencies: ['html_template', 'css_styles', 'client_script', 'server_script'],
-                status: 'pending'
-            });
-        }
-        return deliverables;
-    }
-    extractWidgetName(task) {
-        // Try to extract a meaningful name from the task description
-        const patterns = [
-            /create\s+(.+?)\s+widget/i,
-            /build\s+(.+?)\s+widget/i,
-            /develop\s+(.+?)\s+widget/i,
-            /(.+?)\s+widget/i,
-            /widget\s+for\s+(.+)/i
-        ];
-        for (const pattern of patterns) {
-            const match = task.match(pattern);
-            if (match && match[1]) {
-                return match[1].trim().replace(/\s+/g, '_').toLowerCase();
-            }
-        }
-        return 'custom_widget';
-    }
-    calculateDuration(complexity, phases) {
-        const durationMap = {
-            simple: '2-3 hours',
-            medium: '4-6 hours',
-            complex: '8-12 hours'
-        };
-        return durationMap[complexity];
-    }
-    identifyDependencies(task) {
-        const dependencies = ['ServiceNow Service Portal'];
-        const taskLower = task.toLowerCase();
-        if (taskLower.includes('chart') || taskLower.includes('graph')) {
-            dependencies.push('Chart.js or D3.js');
-        }
-        if (taskLower.includes('real-time') || taskLower.includes('live')) {
-            dependencies.push('WebSocket or Server-Sent Events');
-        }
-        if (taskLower.includes('integration') || taskLower.includes('api')) {
-            dependencies.push('REST API access');
-        }
-        if (taskLower.includes('mobile')) {
-            dependencies.push('Mobile responsive framework');
-        }
-        return dependencies;
-    }
-    getTeamStatus() {
-        const available = this.members.filter(m => m.status === 'available').length;
-        const busy = this.members.filter(m => m.status === 'busy').length;
-        const total = this.members.length;
-        return { available, busy, total };
-    }
-    assignTask(memberRole, deliverable) {
-        const member = this.members.find(m => m.role === memberRole && m.status === 'available');
-        if (member) {
-            member.status = 'busy';
-            member.workload++;
-            console.log(`📌 Assigned ${deliverable} to ${member.name}`);
-            return true;
-        }
-        return false;
-    }
-    getProjectStatus() {
-        return this.currentProject;
-    }
-    getTeamCapabilities() {
-        return this.teamMode?.capabilities || [];
-    }
-}
-exports.WidgetTeam = WidgetTeam;
-//# sourceMappingURL=widget-team.js.map

package/dist/specialists/app-specialists.d.ts

@@ -1,93 +0,0 @@
-import { BaseSpecialist, SpecialistOptions } from './base-specialist.js';
-export declare class DatabaseSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyTables;
-    private analyzeRelationships;
-    private identifyFields;
-    private analyzeIndexingNeeds;
-    private identifyConstraints;
-    private analyzePerformanceRequirements;
-    private estimateDataVolume;
-    private identifyQueryPatterns;
-    private createDatabaseSchema;
-    private createTableDefinitions;
-    private generateFieldDefinitions;
-    private generateTableIndexes;
-    private generateTableConstraints;
-    private generateTablePermissions;
-    private generateBusinessRules;
-}
-export declare class BusinessLogicSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyBusinessRules;
-    private identifyScriptIncludes;
-    private identifyCalculations;
-    private identifyValidations;
-    private identifyWorkflows;
-    private identifyAutomations;
-    private createLogicArchitecture;
-    private createImplementations;
-    private generateBusinessRulesCode;
-    private getWhenCondition;
-    private generateRuleCondition;
-    private generateRuleScript;
-    private generateScriptIncludesCode;
-    private generateScriptIncludeContent;
-    private generateValidationCode;
-    private generateClientValidation;
-    private generateServerValidation;
-    private generateCalculationCode;
-    private generateCalculationImplementation;
-    private generateWorkflowDefinitions;
-    private generateWorkflowDefinition;
-    private getWorkflowTable;
-    private getWorkflowCondition;
-}
-export declare class InterfaceSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private identifyForms;
-    private identifyLists;
-    private identifyUIPolicies;
-    private identifyClientScripts;
-    private identifyNavigationModules;
-    private analyzeUXRequirements;
-    private createInterfaceArchitecture;
-    private createInterfaceImplementations;
-    private generateFormDefinitions;
-    private generateFormLayout;
-    private generateFormSections;
-    private generateListDefinitions;
-    private generateUIPolicyCode;
-    private generateUIPolicyScript;
-    private generateClientScriptCode;
-    private generateClientScriptContent;
-    private generateModuleDefinitions;
-}
-export declare class PerformanceSpecialist extends BaseSpecialist {
-    constructor(options?: SpecialistOptions);
-    execute(task: string, context?: any): Promise<any>;
-    private analyzeQueryOptimization;
-    private identifyQueryPriorities;
-    private analyzeCachingNeeds;
-    private analyzeIndexingStrategy;
-    private identifyIndexPriorities;
-    private analyzeMonitoringNeeds;
-    private analyzeScalabilityRequirements;
-    private analyzeLoadTestingNeeds;
-    private createOptimizationStrategy;
-    private createOptimizationPriorities;
-    private createSuccessCriteria;
-    private createImplementationPlan;
-    private createDatabaseOptimizationPlan;
-    private createCachingImplementationPlan;
-    private createMonitoringSetupPlan;
-    private createTestingStrategy;
-    private getScenarioUsers;
-    private getScenarioDuration;
-    private getScenarioRampUp;
-    private createMaintenancePlan;
-}
-//# sourceMappingURL=app-specialists.d.ts.map