snow-flow 3.0.9 → 3.0.10

package/dist/coordination/team-coordinator.js

@@ -1,550 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamCoordinator = void 0;
-const widget_team_js_1 = require("../teams/widget-team.js");
-const flow_team_js_1 = require("../teams/flow-team.js");
-const application_team_js_1 = require("../teams/application-team.js");
-const adaptive_team_js_1 = require("../teams/adaptive-team.js");
-const individual_specialists_js_1 = require("../specialists/individual-specialists.js");
-class TeamCoordinator {
-    constructor(options = {}) {
-        this.taskHistory = new Map();
-        this.performanceMetrics = new Map();
-        this.options = {
-            sharedMemory: true,
-            validation: true,
-            parallel: false,
-            monitor: false,
-            preferTeams: false,
-            qualityLevel: 'standard',
-            ...options
-        };
-    }
-    async coordinate(task) {
-        console.log(`\n🎯 Team Coordinator: Analyzing task coordination strategy`);
-        console.log(`📝 Task: ${task}`);
-        const startTime = Date.now();
-        // Analyze the task to determine optimal approach
-        const analysis = await this.analyzeTask(task);
-        this.logAnalysis(analysis);
-        // Store analysis for learning
-        this.taskHistory.set(task, analysis);
-        // Execute using the recommended approach
-        let result;
-        let executor;
-        switch (analysis.recommendedApproach) {
-            case 'individual':
-                const specialist = this.selectIndividualSpecialist(task, analysis);
-                executor = `Individual ${specialist.name}`;
-                result = await this.executeWithIndividualSpecialist(specialist, task);
-                break;
-            case 'team':
-                const team = this.selectSpecializedTeam(task, analysis);
-                executor = team.constructor.name;
-                result = await team.execute(task);
-                break;
-            case 'adaptive':
-                const adaptiveTeam = new adaptive_team_js_1.AdaptiveTeam(this.options);
-                executor = 'Adaptive Team';
-                result = await adaptiveTeam.execute(task);
-                break;
-            default:
-                throw new Error(`Unknown approach: ${analysis.recommendedApproach}`);
-        }
-        const executionTime = Date.now() - startTime;
-        // Calculate quality metrics
-        const qualityMetrics = await this.calculateExecutionQuality(result, analysis, executionTime);
-        // Generate recommendations for future tasks
-        const recommendations = this.generateRecommendations(analysis, result, qualityMetrics);
-        // Store performance metrics
-        this.updatePerformanceMetrics(analysis.recommendedApproach, executionTime, qualityMetrics);
-        console.log(`\n✅ Coordination completed successfully`);
-        console.log(`   Approach: ${analysis.recommendedApproach}`);
-        console.log(`   Executor: ${executor}`);
-        console.log(`   Execution Time: ${executionTime}ms`);
-        console.log(`   Quality Score: ${qualityMetrics.overallScore}/100`);
-        return {
-            approach: analysis.recommendedApproach,
-            executor,
-            result,
-            executionTime,
-            qualityMetrics,
-            recommendations
-        };
-    }
-    async analyzeTask(task) {
-        const domain = this.identifyDomain(task);
-        const complexity = this.assessComplexity(task);
-        const scope = this.assessScope(task);
-        const timeEstimate = this.estimateTime(task, complexity, scope);
-        // Determine recommended approach
-        const approachAnalysis = this.determineOptimalApproach(task, complexity, scope, domain);
-        return {
-            domain,
-            complexity,
-            scope,
-            timeEstimate,
-            recommendedApproach: approachAnalysis.approach,
-            confidence: approachAnalysis.confidence,
-            reasoning: approachAnalysis.reasoning
-        };
-    }
-    identifyDomain(task) {
-        const lowerTask = task.toLowerCase();
-        // Widget domain indicators
-        if (lowerTask.includes('widget') ||
-            (lowerTask.includes('ui') && !lowerTask.includes('flow')) ||
-            lowerTask.includes('service portal') ||
-            lowerTask.includes('dashboard widget')) {
-            return 'widget';
-        }
-        // Flow domain indicators
-        if (lowerTask.includes('flow') ||
-            lowerTask.includes('workflow') ||
-            lowerTask.includes('process') ||
-            lowerTask.includes('automation') ||
-            lowerTask.includes('approval')) {
-            return 'flow';
-        }
-        // Application domain indicators
-        if (lowerTask.includes('application') ||
-            lowerTask.includes('app') ||
-            lowerTask.includes('table') ||
-            lowerTask.includes('database') ||
-            lowerTask.includes('business rule') ||
-            lowerTask.includes('script include')) {
-            return 'application';
-        }
-        // Individual specialist domains
-        if (lowerTask.includes('frontend') || lowerTask.includes('html') || lowerTask.includes('css')) {
-            return 'frontend';
-        }
-        if (lowerTask.includes('backend') || lowerTask.includes('server script') || lowerTask.includes('api')) {
-            return 'backend';
-        }
-        if (lowerTask.includes('security') || lowerTask.includes('access control') || lowerTask.includes('compliance')) {
-            return 'security';
-        }
-        if (lowerTask.includes('data') || lowerTask.includes('query') || lowerTask.includes('analysis')) {
-            return 'data';
-        }
-        if (lowerTask.includes('integration') || lowerTask.includes('sync') || lowerTask.includes('external')) {
-            return 'integration';
-        }
-        return 'general';
-    }
-    assessComplexity(task) {
-        const lowerTask = task.toLowerCase();
-        let complexityScore = 0;
-        // Simple indicators
-        if (lowerTask.includes('simple') || lowerTask.includes('basic') || lowerTask.includes('quick')) {
-            complexityScore -= 2;
-        }
-        // Complex indicators
-        if (lowerTask.includes('complex') || lowerTask.includes('advanced') || lowerTask.includes('enterprise')) {
-            complexityScore += 3;
-        }
-        // Multiple component indicators
-        const components = ['ui', 'backend', 'database', 'integration', 'security', 'workflow'];
-        const componentCount = components.filter(comp => lowerTask.includes(comp)).length;
-        complexityScore += componentCount;
-        // Integration complexity
-        if (lowerTask.includes('integration') || lowerTask.includes('api') || lowerTask.includes('external')) {
-            complexityScore += 2;
-        }
-        // Multiple systems/technologies
-        const technologies = ['rest', 'soap', 'ldap', 'oauth', 'saml', 'json', 'xml'];
-        const techCount = technologies.filter(tech => lowerTask.includes(tech)).length;
-        complexityScore += techCount;
-        // Task length as complexity indicator
-        if (task.length > 200)
-            complexityScore += 2;
-        else if (task.length > 100)
-            complexityScore += 1;
-        if (complexityScore >= 5)
-            return 'complex';
-        if (complexityScore >= 2)
-            return 'moderate';
-        return 'simple';
-    }
-    assessScope(task) {
-        const lowerTask = task.toLowerCase();
-        let scopeScore = 0;
-        // Focused indicators
-        if (lowerTask.includes('specific') || lowerTask.includes('single') || lowerTask.includes('one')) {
-            scopeScore -= 1;
-        }
-        // Broad indicators
-        if (lowerTask.includes('complete') || lowerTask.includes('full') || lowerTask.includes('entire')) {
-            scopeScore += 2;
-        }
-        if (lowerTask.includes('multiple') || lowerTask.includes('several') || lowerTask.includes('various')) {
-            scopeScore += 2;
-        }
-        // Count action words (indicates broader scope)
-        const actions = ['create', 'update', 'delete', 'manage', 'configure', 'implement', 'design'];
-        const actionCount = actions.filter(action => lowerTask.includes(action)).length;
-        scopeScore += actionCount - 1; // First action is expected, additional ones increase scope
-        if (scopeScore >= 3)
-            return 'broad';
-        if (scopeScore >= 1)
-            return 'medium';
-        return 'focused';
-    }
-    estimateTime(task, complexity, scope) {
-        const baseTime = {
-            'simple': { 'focused': 15, 'medium': 30, 'broad': 60 },
-            'moderate': { 'focused': 45, 'medium': 90, 'broad': 180 },
-            'complex': { 'focused': 90, 'medium': 180, 'broad': 360 }
-        };
-        let minutes = baseTime[complexity][scope];
-        // Adjust for domain-specific factors
-        const lowerTask = task.toLowerCase();
-        if (lowerTask.includes('integration') || lowerTask.includes('migration')) {
-            minutes *= 1.5;
-        }
-        if (lowerTask.includes('security') || lowerTask.includes('compliance')) {
-            minutes *= 1.3;
-        }
-        if (lowerTask.includes('performance') || lowerTask.includes('optimization')) {
-            minutes *= 1.2;
-        }
-        minutes = Math.round(minutes);
-        if (minutes < 60) {
-            return `${minutes} minutes`;
-        }
-        else {
-            const hours = Math.floor(minutes / 60);
-            const remainingMinutes = minutes % 60;
-            return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-        }
-    }
-    determineOptimalApproach(task, complexity, scope, domain) {
-        const reasoning = [];
-        let confidence = 80; // Base confidence
-        // Individual specialist approach
-        if (this.shouldUseIndividualSpecialist(task, complexity, scope, domain)) {
-            reasoning.push(`Task is focused on ${domain} specialty`);
-            reasoning.push(`Complexity (${complexity}) and scope (${scope}) suitable for individual work`);
-            if (complexity === 'simple' && scope === 'focused')
-                confidence += 15;
-            return {
-                approach: 'individual',
-                confidence: Math.min(confidence, 95),
-                reasoning
-            };
-        }
-        // Specialized team approach
-        if (this.shouldUseSpecializedTeam(domain, complexity, scope)) {
-            reasoning.push(`Task clearly fits ${domain} development pattern`);
-            reasoning.push(`Complexity (${complexity}) benefits from specialized team collaboration`);
-            if (['widget', 'flow', 'application'].includes(domain))
-                confidence += 10;
-            if (complexity === 'moderate' || complexity === 'complex')
-                confidence += 5;
-            return {
-                approach: 'team',
-                confidence: Math.min(confidence, 90),
-                reasoning
-            };
-        }
-        // Adaptive team approach (fallback for unclear/complex cases)
-        reasoning.push(`Task doesn't clearly fit standard patterns`);
-        reasoning.push(`Using adaptive team for optimal specialist selection`);
-        if (domain === 'general')
-            reasoning.push('Domain is unclear, adaptive analysis will determine needs');
-        if (complexity === 'complex')
-            reasoning.push('High complexity benefits from adaptive specialist assembly');
-        return {
-            approach: 'adaptive',
-            confidence: Math.max(confidence - 10, 60),
-            reasoning
-        };
-    }
-    shouldUseIndividualSpecialist(task, complexity, scope, domain) {
-        // Use individual specialist for simple, focused tasks in specific domains
-        if (complexity === 'simple' && scope === 'focused' &&
-            ['frontend', 'backend', 'security', 'data', 'integration'].includes(domain)) {
-            return true;
-        }
-        // Use individual for quick tasks regardless of domain
-        if (complexity === 'simple' && scope === 'focused' &&
-            this.options.qualityLevel === 'quick') {
-            return true;
-        }
-        // Force individual if configured to avoid teams
-        if (!this.options.preferTeams && complexity === 'simple') {
-            return true;
-        }
-        return false;
-    }
-    shouldUseSpecializedTeam(domain, complexity, scope) {
-        // Use specialized teams for their core domains
-        if (['widget', 'flow', 'application'].includes(domain)) {
-            // For moderate/complex tasks or medium/broad scope
-            if (complexity !== 'simple' || scope !== 'focused') {
-                return true;
-            }
-            // For simple tasks if teams are preferred
-            if (this.options.preferTeams) {
-                return true;
-            }
-        }
-        return false;
-    }
-    selectIndividualSpecialist(task, analysis) {
-        const lowerTask = task.toLowerCase();
-        // Map domain to specialist
-        switch (analysis.domain) {
-            case 'frontend':
-                return {
-                    name: 'Frontend Specialist',
-                    instance: new individual_specialists_js_1.IndividualSpecialists.Frontend(this.options)
-                };
-            case 'backend':
-                return {
-                    name: 'Backend Specialist',
-                    instance: new individual_specialists_js_1.IndividualSpecialists.Backend(this.options)
-                };
-            case 'security':
-                return {
-                    name: 'Security Specialist',
-                    instance: new individual_specialists_js_1.IndividualSpecialists.Security(this.options)
-                };
-            case 'data':
-                return {
-                    name: 'Data Specialist',
-                    instance: new individual_specialists_js_1.IndividualSpecialists.Data(this.options)
-                };
-            case 'integration':
-                return {
-                    name: 'Integration Specialist',
-                    instance: new individual_specialists_js_1.IndividualSpecialists.Integration(this.options)
-                };
-            default:
-                // For general tasks, pick the most relevant specialist
-                if (lowerTask.includes('script') || lowerTask.includes('server')) {
-                    return {
-                        name: 'Backend Specialist',
-                        instance: new individual_specialists_js_1.IndividualSpecialists.Backend(this.options)
-                    };
-                }
-                else if (lowerTask.includes('ui') || lowerTask.includes('interface')) {
-                    return {
-                        name: 'Frontend Specialist',
-                        instance: new individual_specialists_js_1.IndividualSpecialists.Frontend(this.options)
-                    };
-                }
-                else {
-                    return {
-                        name: 'Data Specialist',
-                        instance: new individual_specialists_js_1.IndividualSpecialists.Data(this.options)
-                    };
-                }
-        }
-    }
-    selectSpecializedTeam(task, analysis) {
-        switch (analysis.domain) {
-            case 'widget':
-                return new widget_team_js_1.WidgetTeam(this.options);
-            case 'flow':
-                return new flow_team_js_1.FlowTeam(this.options);
-            case 'application':
-                return new application_team_js_1.ApplicationTeam(this.options);
-            default:
-                // This shouldn't happen if shouldUseSpecializedTeam logic is correct
-                throw new Error(`No specialized team available for domain: ${analysis.domain}`);
-        }
-    }
-    async executeWithIndividualSpecialist(specialist, task) {
-        console.log(`\n👤 Executing with ${specialist.name}...`);
-        const result = await specialist.instance.execute(task);
-        return {
-            executorType: 'individual',
-            specialist: specialist.name,
-            result
-        };
-    }
-    logAnalysis(analysis) {
-        console.log(`\n📊 Task Analysis Results:`);
-        console.log(`   Domain: ${analysis.domain}`);
-        console.log(`   Complexity: ${analysis.complexity}`);
-        console.log(`   Scope: ${analysis.scope}`);
-        console.log(`   Time Estimate: ${analysis.timeEstimate}`);
-        console.log(`   Recommended Approach: ${analysis.recommendedApproach}`);
-        console.log(`   Confidence: ${analysis.confidence}%`);
-        console.log(`   Reasoning:`);
-        analysis.reasoning.forEach(reason => {
-            console.log(`     • ${reason}`);
-        });
-    }
-    async calculateExecutionQuality(result, analysis, executionTime) {
-        const qualityFactors = {
-            completeness: this.assessCompleteness(result),
-            accuracy: this.assessAccuracy(result, analysis),
-            efficiency: this.assessEfficiency(executionTime, analysis),
-            maintainability: this.assessMaintainability(result),
-            scalability: this.assessScalability(result)
-        };
-        const overallScore = Object.values(qualityFactors).reduce((sum, score) => sum + score, 0) / Object.keys(qualityFactors).length;
-        return {
-            overallScore: Math.round(overallScore),
-            factors: qualityFactors,
-            executionTime,
-            approach: analysis.recommendedApproach
-        };
-    }
-    assessCompleteness(result) {
-        if (!result || !result.result)
-            return 0;
-        // Check if result has expected structure
-        const hasDeliverables = result.result.deliverables || result.result.components || result.result.dataAnalysis;
-        const hasSpecialist = result.result.specialist;
-        if (hasDeliverables && hasSpecialist)
-            return 90;
-        if (hasDeliverables || hasSpecialist)
-            return 70;
-        return 50;
-    }
-    assessAccuracy(result, analysis) {
-        // Simplified accuracy assessment based on result structure
-        if (!result || !result.result)
-            return 0;
-        let accuracy = 80; // Base accuracy
-        // Check if result matches expected domain
-        if (result.result.specialist && analysis.domain !== 'general') {
-            const specialistDomain = result.result.specialist.toLowerCase();
-            if (specialistDomain.includes(analysis.domain) || analysis.domain.includes(specialistDomain.split(' ')[0])) {
-                accuracy += 15;
-            }
-        }
-        // Check for error indicators
-        if (result.result.error || result.result.errors) {
-            accuracy -= 20;
-        }
-        return Math.max(Math.min(accuracy, 100), 0);
-    }
-    assessEfficiency(executionTime, analysis) {
-        // Convert time estimate to milliseconds for comparison
-        const estimatedMs = this.parseTimeToMs(analysis.timeEstimate);
-        const efficiency = Math.max(0, 100 - ((executionTime - estimatedMs) / estimatedMs) * 50);
-        return Math.min(efficiency, 100);
-    }
-    parseTimeToMs(timeString) {
-        const hours = timeString.includes('h') ? parseInt(timeString.split('h')[0]) * 3600000 : 0;
-        const minutes = timeString.includes('minutes') ? parseInt(timeString.split(' ')[0]) * 60000 :
-            timeString.includes('m') ? parseInt(timeString.match(/(\d+)m/)?.[1] || '0') * 60000 : 0;
-        return Math.max(hours + minutes, 60000); // Minimum 1 minute
-    }
-    assessMaintainability(result) {
-        // Simplified maintainability assessment
-        if (!result || !result.result)
-            return 50;
-        let score = 70; // Base score
-        // Check for documentation/structure
-        if (result.result.requirements || result.result.analysis)
-            score += 15;
-        if (result.result.recommendations)
-            score += 10;
-        if (result.result.quickImplementation)
-            score -= 5; // Quick implementations are less maintainable
-        return Math.min(score, 100);
-    }
-    assessScalability(result) {
-        // Simplified scalability assessment
-        if (!result || !result.result)
-            return 50;
-        let score = 75; // Base score
-        // Team results generally more scalable
-        if (result.executorType !== 'individual')
-            score += 15;
-        if (result.result.qualityMetrics)
-            score += 10;
-        return Math.min(score, 100);
-    }
-    generateRecommendations(analysis, result, qualityMetrics) {
-        const recommendations = [];
-        // Performance recommendations
-        if (qualityMetrics.factors.efficiency < 80) {
-            recommendations.push('Consider optimizing execution approach for better performance');
-        }
-        // Quality recommendations
-        if (qualityMetrics.overallScore < 85) {
-            recommendations.push('Review task analysis accuracy for better specialist selection');
-        }
-        // Approach recommendations
-        if (analysis.confidence < 80) {
-            recommendations.push('Task pattern unclear - consider providing more specific requirements');
-        }
-        // Domain-specific recommendations
-        if (analysis.domain === 'general') {
-            recommendations.push('Consider specifying domain context for better specialist matching');
-        }
-        return recommendations;
-    }
-    updatePerformanceMetrics(approach, executionTime, qualityMetrics) {
-        const current = this.performanceMetrics.get(approach) || {
-            totalExecutions: 0,
-            totalTime: 0,
-            totalQuality: 0,
-            averageTime: 0,
-            averageQuality: 0
-        };
-        current.totalExecutions++;
-        current.totalTime += executionTime;
-        current.totalQuality += qualityMetrics.overallScore;
-        current.averageTime = current.totalTime / current.totalExecutions;
-        current.averageQuality = current.totalQuality / current.totalExecutions;
-        this.performanceMetrics.set(approach, current);
-    }
-    // Public methods for accessing coordinator state and metrics
-    getTaskHistory() {
-        return this.taskHistory;
-    }
-    getPerformanceMetrics() {
-        return this.performanceMetrics;
-    }
-    getCoordinatorInsights() {
-        const approaches = Array.from(this.performanceMetrics.keys());
-        const totalTasks = Array.from(this.taskHistory.values()).length;
-        return {
-            totalTasksCoordinated: totalTasks,
-            approachesUsed: approaches,
-            performanceByApproach: Object.fromEntries(this.performanceMetrics),
-            mostUsedApproach: this.getMostUsedApproach(),
-            averageConfidence: this.getAverageConfidence(),
-            recommendations: this.getCoordinatorRecommendations()
-        };
-    }
-    getMostUsedApproach() {
-        let maxCount = 0;
-        let mostUsed = 'none';
-        this.performanceMetrics.forEach((metrics, approach) => {
-            if (metrics.totalExecutions > maxCount) {
-                maxCount = metrics.totalExecutions;
-                mostUsed = approach;
-            }
-        });
-        return mostUsed;
-    }
-    getAverageConfidence() {
-        const analyses = Array.from(this.taskHistory.values());
-        if (analyses.length === 0)
-            return 0;
-        const totalConfidence = analyses.reduce((sum, analysis) => sum + analysis.confidence, 0);
-        return Math.round(totalConfidence / analyses.length);
-    }
-    getCoordinatorRecommendations() {
-        const recommendations = [];
-        const insights = this.getCoordinatorInsights();
-        if (insights.averageConfidence < 75) {
-            recommendations.push('Tasks often have unclear requirements - encourage more specific task descriptions');
-        }
-        if (insights.totalTasksCoordinated > 10) {
-            recommendations.push('Consider implementing task pattern caching for frequently similar tasks');
-        }
-        return recommendations;
-    }
-}
-exports.TeamCoordinator = TeamCoordinator;
-//# sourceMappingURL=team-coordinator.js.map