snow-flow 3.0.8 → 3.0.10

package/dist/teams/base-team.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTeam = void 0;
-class BaseTeam {
-    constructor(options) {
-        this.members = [];
-        this.sharedContext = new Map();
-        this.qualityGates = [];
-        this.options = {
-            sharedMemory: true,
-            validation: true,
-            parallel: false,
-            monitor: false,
-            ...options
-        };
-        this.initializeTeam();
-        this.initializeQualityGates();
-    }
-    async executeWithCoordination(task) {
-        console.log(`🎯 Team Coordination: ${this.constructor.name}`);
-        console.log(`📋 Task: ${task}`);
-        if (this.options.dryRun) {
-            return this.previewExecution(task);
-        }
-        // Initialize shared memory
-        if (this.options.sharedMemory) {
-            await this.initializeSharedMemory(task);
-        }
-        // Start monitoring if enabled
-        if (this.options.monitor) {
-            this.startMonitoring();
-        }
-        try {
-            // Analyze requirements
-            const requirements = await this.analyzeRequirements(task);
-            this.updateSharedContext('requirements', requirements);
-            // Create task breakdown
-            const taskBreakdown = await this.createTaskBreakdown(requirements);
-            this.updateSharedContext('taskBreakdown', taskBreakdown);
-            // Execute based on coordination pattern
-            const results = this.options.parallel
-                ? await this.executeParallel(taskBreakdown)
-                : await this.executeSequential(taskBreakdown);
-            // Quality gates
-            if (this.options.validation) {
-                await this.runQualityGates(results);
-            }
-            // Integrate results
-            const finalResult = await this.integrateResults(results);
-            console.log(`✅ Team execution completed successfully`);
-            return finalResult;
-        }
-        catch (error) {
-            console.error(`❌ Team execution failed:`, error);
-            await this.handleExecutionError(error);
-            throw error;
-        }
-        finally {
-            if (this.options.monitor) {
-                this.stopMonitoring();
-            }
-        }
-    }
-    async executeParallel(tasks) {
-        console.log(`🚀 Executing ${tasks.length} tasks in parallel`);
-        // Group tasks by dependencies
-        const taskGroups = this.groupTasksByDependencies(tasks);
-        const results = [];
-        // Execute each group sequentially, but tasks within groups in parallel
-        for (const group of taskGroups) {
-            const groupResults = await Promise.all(group.map(task => this.executeTask(task)));
-            results.push(...groupResults);
-        }
-        return results;
-    }
-    async executeSequential(tasks) {
-        console.log(`📋 Executing ${tasks.length} tasks sequentially`);
-        const results = [];
-        for (const task of tasks) {
-            const result = await this.executeTask(task);
-            results.push(result);
-        }
-        return results;
-    }
-    async executeTask(task) {
-        console.log(`\n🔧 ${task.assignedTo.role} executing: ${task.description}`);
-        const context = {
-            task,
-            sharedContext: this.options.sharedMemory ? this.sharedContext : new Map(),
-            team: this.constructor.name
-        };
-        try {
-            const result = await task.assignedTo.execute(task, context);
-            if (this.options.sharedMemory) {
-                this.updateSharedContext(`result_${task.id}`, result);
-            }
-            return { task, result, status: 'success' };
-        }
-        catch (error) {
-            console.error(`❌ Task failed: ${task.description}`, error);
-            return { task, error, status: 'failed' };
-        }
-    }
-    async runQualityGates(results) {
-        console.log(`\n🔍 Running quality gates...`);
-        for (const gate of this.qualityGates) {
-            console.log(`  Checking: ${gate.name}`);
-            const passed = await gate.check(results);
-            if (!passed) {
-                console.log(`  ❌ Failed: ${gate.name}`);
-                if (gate.onFailure) {
-                    await gate.onFailure(results);
-                }
-                throw new Error(`Quality gate failed: ${gate.name}`);
-            }
-            console.log(`  ✅ Passed: ${gate.name}`);
-        }
-    }
-    initializeQualityGates() {
-        this.qualityGates = [
-            {
-                name: 'All tasks completed',
-                check: async (results) => results.every(r => r.status === 'success')
-            },
-            {
-                name: 'No critical errors',
-                check: async (results) => !results.some(r => r.error?.critical)
-            }
-        ];
-    }
-    async initializeSharedMemory(task) {
-        this.sharedContext.clear();
-        this.sharedContext.set('task', task);
-        this.sharedContext.set('startTime', new Date());
-        this.sharedContext.set('teamName', this.constructor.name);
-    }
-    updateSharedContext(key, value) {
-        if (this.options.sharedMemory) {
-            this.sharedContext.set(key, value);
-            this.sharedContext.set('lastUpdated', new Date());
-        }
-    }
-    groupTasksByDependencies(tasks) {
-        const groups = [];
-        const completed = new Set();
-        const remaining = [...tasks];
-        while (remaining.length > 0) {
-            const group = remaining.filter(task => task.dependencies.every(dep => completed.has(dep)));
-            if (group.length === 0) {
-                throw new Error('Circular dependency detected in task breakdown');
-            }
-            groups.push(group);
-            group.forEach(task => {
-                completed.add(task.id);
-                remaining.splice(remaining.indexOf(task), 1);
-            });
-        }
-        return groups;
-    }
-    assessComplexity(task) {
-        const complexityIndicators = {
-            complex: ['multiple', 'integration', 'complex', 'advanced', 'enterprise'],
-            moderate: ['custom', 'specific', 'detailed', 'enhanced'],
-            simple: ['basic', 'simple', 'standard', 'default']
-        };
-        const lowerTask = task.toLowerCase();
-        for (const [level, indicators] of Object.entries(complexityIndicators)) {
-            if (indicators.some(indicator => lowerTask.includes(indicator))) {
-                return level;
-            }
-        }
-        return 'moderate';
-    }
-    identifyComponents(task) {
-        const components = [];
-        const lowerTask = task.toLowerCase();
-        const componentKeywords = {
-            'ui': ['ui', 'interface', 'frontend', 'display', 'view'],
-            'data': ['data', 'database', 'table', 'query', 'fetch'],
-            'logic': ['logic', 'process', 'calculate', 'validate', 'transform'],
-            'integration': ['api', 'integration', 'external', 'service', 'connect'],
-            'security': ['security', 'permission', 'access', 'auth', 'role']
-        };
-        for (const [component, keywords] of Object.entries(componentKeywords)) {
-            if (keywords.some(keyword => lowerTask.includes(keyword))) {
-                components.push(component);
-            }
-        }
-        return components.length > 0 ? components : ['general'];
-    }
-    findDependencies(task) {
-        // This would be enhanced with actual dependency analysis
-        return [];
-    }
-    async handleExecutionError(error) {
-        console.error('🚨 Team execution error:', error);
-        // Store error context for debugging
-        if (this.options.sharedMemory) {
-            this.updateSharedContext('error', {
-                message: error.message,
-                stack: error.stack,
-                timestamp: new Date(),
-                context: Object.fromEntries(this.sharedContext)
-            });
-        }
-    }
-    startMonitoring() {
-        if (this.options.monitor) {
-            console.log('📊 Monitoring enabled - tracking team progress');
-        }
-    }
-    stopMonitoring() {
-        if (this.options.monitor) {
-            console.log('📊 Monitoring stopped');
-        }
-    }
-    async previewExecution(task) {
-        console.log('\n🔍 Team Assembly Preview:');
-        console.log('━'.repeat(50));
-        console.log(`Team: ${this.constructor.name}`);
-        console.log(`Task: ${task}`);
-        console.log(`\nTeam Members:`);
-        this.members.forEach(member => {
-            console.log(`  ${member.role} - ${member.name}`);
-            console.log(`    Expertise: ${member.expertise.join(', ')}`);
-        });
-        console.log(`\nExecution Options:`);
-        console.log(`  Shared Memory: ${this.options.sharedMemory ? 'Enabled' : 'Disabled'}`);
-        console.log(`  Validation: ${this.options.validation ? 'Enabled' : 'Disabled'}`);
-        console.log(`  Parallel: ${this.options.parallel ? 'Enabled' : 'Disabled'}`);
-        console.log(`  Monitoring: ${this.options.monitor ? 'Enabled' : 'Disabled'}`);
-        console.log('━'.repeat(50));
-        return {
-            preview: true,
-            task,
-            team: this.constructor.name,
-            members: this.members.map(m => ({ role: m.role, name: m.name })),
-            options: this.options
-        };
-    }
-}
-exports.BaseTeam = BaseTeam;
-//# sourceMappingURL=base-team.js.map

package/dist/teams/flow-team.d.ts

@@ -1,28 +0,0 @@
-import { BaseTeam, TeamOptions, TaskBreakdown } from './base-team.js';
-export declare class FlowTeam extends BaseTeam {
-    constructor(options?: TeamOptions);
-    initializeTeam(): void;
-    execute(task: string): Promise<any>;
-    protected analyzeRequirements(task: string): Promise<any>;
-    protected createTaskBreakdown(requirements: any): Promise<TaskBreakdown[]>;
-    protected integrateResults(results: any[]): Promise<any>;
-    private identifyFlowType;
-    private identifyRequiredFeatures;
-    private identifyIntegrationNeeds;
-    private determineCoordinationPattern;
-    private estimateProjectTime;
-    private identifyRisks;
-    private estimateDataTime;
-    private estimateTriggerTime;
-    private estimateIntegrationTime;
-    private getMemberByRole;
-    private createFlowDeliverable;
-    private calculateQualityMetrics;
-    private generateQualityRecommendations;
-    private prepareDeploymentPackage;
-    private generateFlowName;
-    private generateTriggerCondition;
-    private generateFlowJson;
-    private initializeFlowQualityGates;
-}
-//# sourceMappingURL=flow-team.d.ts.map