snow-flow 3.0.8 → 3.0.10

package/dist/assembly/team-assembler.d.ts

@@ -1,140 +0,0 @@
-/**
- * Team Assembler - Dynamic assembly of specialist agents based on requirements
- */
-import { BaseSnowAgent } from '../agents/base/base-snow-agent.js';
-import { SkillSet } from '../intelligence/task-analyzer.js';
-export interface SpecialistPool {
-    available: Map<string, typeof BaseSnowAgent>;
-    active: Map<string, BaseSnowAgent>;
-    capacity: Map<string, CapacityInfo>;
-    performance: Map<string, PerformanceMetrics>;
-}
-export interface CapacityInfo {
-    maxConcurrent: number;
-    currentLoad: number;
-    reservedSlots: number;
-    nextAvailable?: Date;
-}
-export interface PerformanceMetrics {
-    averageExecutionTime: number;
-    successRate: number;
-    totalTasksCompleted: number;
-    lastActivity: Date;
-    complexityRating: number;
-}
-export interface TeamConfiguration {
-    maxTeamSize: number;
-    preferredStructure: 'flat' | 'hierarchical' | 'matrix';
-    loadBalancing: boolean;
-    skillOverlap: boolean;
-    performanceThreshold: number;
-}
-export interface AssemblyResult {
-    success: boolean;
-    team: Map<string, BaseSnowAgent>;
-    configuration: TeamConfiguration;
-    assemblyTime: number;
-    warnings: string[];
-    recommendations: string[];
-    fallbacks: FallbackOption[];
-}
-export interface FallbackOption {
-    description: string;
-    impact: 'low' | 'medium' | 'high';
-    alternative: string;
-    reason: string;
-}
-export interface SkillMapping {
-    skillType: string;
-    specialistTypes: string[];
-    fallbackTypes: string[];
-    complexityMapping: Record<string, string[]>;
-}
-export declare class TeamAssembler {
-    private logger;
-    private specialistPool;
-    private skillMappings;
-    private defaultConfig;
-    constructor();
-    /**
-     * Assemble team based on required skills
-     */
-    assembleTeam(requiredSkills: SkillSet[], config?: Partial<TeamConfiguration>): Promise<Map<string, BaseSnowAgent>>;
-    /**
-     * Select optimal specialist for a skill requirement
-     */
-    private selectSpecialist;
-    /**
-     * Find fallback specialist when primary selection fails
-     */
-    private findFallbackSpecialist;
-    /**
-     * Get candidate specialist types based on skill complexity
-     */
-    private getCandidateTypes;
-    /**
-     * Evaluate candidate specialists
-     */
-    private evaluateCandidates;
-    /**
-     * Evaluate individual candidate
-     */
-    private evaluateCandidate;
-    /**
-     * Select best candidate from evaluations
-     */
-    private selectBestCandidate;
-    /**
-     * Instantiate specialist instance
-     */
-    private instantiateSpecialist;
-    /**
-     * Check if specialist type is available
-     */
-    private isSpecialistAvailable;
-    /**
-     * Apply load balancing to team
-     */
-    private applyLoadBalancing;
-    /**
-     * Update capacity tracking
-     */
-    private updateCapacity;
-    /**
-     * Calculate skill match score
-     */
-    private calculateSkillMatch;
-    /**
-     * Calculate team synergy score
-     */
-    private calculateTeamSynergy;
-    /**
-     * Calculate diversity bonus
-     */
-    private calculateDiversityBonus;
-    /**
-     * Assess candidate risk level
-     */
-    private assessCandidateRisk;
-    /**
-     * Initialize specialist pool
-     */
-    private initializeSpecialistPool;
-    /**
-     * Initialize skill mappings
-     */
-    private initializeSkillMappings;
-    /**
-     * Get team assembly statistics
-     */
-    getAssemblyStatistics(): any;
-    /**
-     * Calculate overall capacity utilization
-     */
-    private calculateCapacityUtilization;
-    /**
-     * Get aggregated performance metrics
-     */
-    private getAggregatedPerformance;
-}
-//# sourceMappingURL=team-assembler.d.ts.map

package/dist/assembly/team-assembler.js

@@ -1,502 +0,0 @@
-"use strict";
-/**
- * Team Assembler - Dynamic assembly of specialist agents based on requirements
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamAssembler = void 0;
-const data_specialist_agent_js_1 = require("../agents/specialists/data-specialist.agent.js");
-const integration_specialist_agent_js_1 = require("../agents/specialists/integration-specialist.agent.js");
-const automation_specialist_agent_js_1 = require("../agents/specialists/automation-specialist.agent.js");
-const reporting_specialist_agent_js_1 = require("../agents/specialists/reporting-specialist.agent.js");
-const security_specialist_agent_js_1 = require("../agents/specialists/security-specialist.agent.js");
-const logger_js_1 = require("../utils/logger.js");
-class TeamAssembler {
-    constructor() {
-        this.skillMappings = new Map();
-        this.logger = new logger_js_1.Logger('TeamAssembler');
-        this.specialistPool = this.initializeSpecialistPool();
-        this.initializeSkillMappings();
-        this.defaultConfig = {
-            maxTeamSize: 8,
-            preferredStructure: 'flat',
-            loadBalancing: true,
-            skillOverlap: false,
-            performanceThreshold: 0.8
-        };
-    }
-    /**
-     * Assemble team based on required skills
-     */
-    async assembleTeam(requiredSkills, config) {
-        const startTime = Date.now();
-        const teamConfig = { ...this.defaultConfig, ...config };
-        const team = new Map();
-        const warnings = [];
-        const fallbacks = [];
-        this.logger.info('Assembling team', {
-            requiredSkills: requiredSkills.map(s => s.type),
-            maxTeamSize: teamConfig.maxTeamSize
-        });
-        try {
-            // Group skills by importance
-            const primarySkills = requiredSkills.filter(s => s.importance === 'primary');
-            const secondarySkills = requiredSkills.filter(s => s.importance === 'secondary');
-            const optionalSkills = requiredSkills.filter(s => s.importance === 'optional');
-            // Assemble primary specialists first
-            for (const skill of primarySkills) {
-                const specialist = await this.selectSpecialist(skill, team, teamConfig);
-                if (specialist) {
-                    team.set(skill.type, specialist);
-                    this.updateCapacity(skill.type, 'allocate');
-                }
-                else {
-                    warnings.push(`Could not allocate primary specialist for ${skill.type}`);
-                    const fallback = this.findFallbackSpecialist(skill, team, teamConfig);
-                    if (fallback.specialist) {
-                        team.set(skill.type, fallback.specialist);
-                        fallbacks.push({
-                            description: `Using ${fallback.type} as fallback for ${skill.type}`,
-                            impact: 'medium',
-                            alternative: fallback.type,
-                            reason: fallback.reason
-                        });
-                    }
-                }
-            }
-            // Add secondary specialists if capacity allows
-            if (team.size < teamConfig.maxTeamSize) {
-                for (const skill of secondarySkills) {
-                    if (team.size >= teamConfig.maxTeamSize)
-                        break;
-                    const specialist = await this.selectSpecialist(skill, team, teamConfig);
-                    if (specialist) {
-                        team.set(skill.type, specialist);
-                        this.updateCapacity(skill.type, 'allocate');
-                    }
-                }
-            }
-            // Add optional specialists if there's still capacity and no skill overlap concerns
-            if (team.size < teamConfig.maxTeamSize && !teamConfig.skillOverlap) {
-                for (const skill of optionalSkills) {
-                    if (team.size >= teamConfig.maxTeamSize)
-                        break;
-                    const specialist = await this.selectSpecialist(skill, team, teamConfig);
-                    if (specialist) {
-                        team.set(skill.type, specialist);
-                        this.updateCapacity(skill.type, 'allocate');
-                    }
-                }
-            }
-            // Apply load balancing if enabled
-            if (teamConfig.loadBalancing) {
-                await this.applyLoadBalancing(team, teamConfig);
-            }
-            const assemblyTime = Date.now() - startTime;
-            this.logger.info('Team assembly completed', {
-                teamSize: team.size,
-                assemblyTime,
-                warningCount: warnings.length,
-                fallbackCount: fallbacks.length
-            });
-            return team;
-        }
-        catch (error) {
-            this.logger.error('Team assembly failed', error);
-            throw error;
-        }
-    }
-    /**
-     * Select optimal specialist for a skill requirement
-     */
-    async selectSpecialist(skill, currentTeam, config) {
-        const skillMapping = this.skillMappings.get(skill.type);
-        if (!skillMapping) {
-            this.logger.warn('No skill mapping found', { skillType: skill.type });
-            return null;
-        }
-        // Get candidate specialist types based on complexity
-        const candidateTypes = this.getCandidateTypes(skill, skillMapping);
-        // Evaluate candidates
-        const candidates = await this.evaluateCandidates(candidateTypes, skill, currentTeam, config);
-        if (candidates.length === 0) {
-            return null;
-        }
-        // Select best candidate based on multiple criteria
-        const bestCandidate = this.selectBestCandidate(candidates, skill, config);
-        if (bestCandidate) {
-            return this.instantiateSpecialist(bestCandidate.type);
-        }
-        return null;
-    }
-    /**
-     * Find fallback specialist when primary selection fails
-     */
-    findFallbackSpecialist(skill, currentTeam, config) {
-        const skillMapping = this.skillMappings.get(skill.type);
-        if (!skillMapping) {
-            return { specialist: null, type: '', reason: 'No skill mapping available' };
-        }
-        // Try fallback types
-        for (const fallbackType of skillMapping.fallbackTypes) {
-            if (this.isSpecialistAvailable(fallbackType)) {
-                const specialist = this.instantiateSpecialist(fallbackType);
-                if (specialist) {
-                    return {
-                        specialist,
-                        type: fallbackType,
-                        reason: `Primary specialist ${skill.type} not available`
-                    };
-                }
-            }
-        }
-        // Try existing team members with overlapping skills
-        for (const [teamMemberType, teamMember] of currentTeam) {
-            if (teamMember.canHandle(skill.type, skill.complexity) > 0.3) {
-                return {
-                    specialist: teamMember,
-                    type: teamMemberType,
-                    reason: `Existing team member can handle ${skill.type} with lower efficiency`
-                };
-            }
-        }
-        return { specialist: null, type: '', reason: 'No fallback options available' };
-    }
-    /**
-     * Get candidate specialist types based on skill complexity
-     */
-    getCandidateTypes(skill, mapping) {
-        const complexityMapping = mapping.complexityMapping[skill.complexity] || [];
-        if (complexityMapping.length > 0) {
-            return complexityMapping;
-        }
-        // Default to primary specialist types
-        return mapping.specialistTypes;
-    }
-    /**
-     * Evaluate candidate specialists
-     */
-    async evaluateCandidates(candidateTypes, skill, currentTeam, config) {
-        const candidates = [];
-        for (const candidateType of candidateTypes) {
-            if (!this.isSpecialistAvailable(candidateType)) {
-                continue;
-            }
-            const evaluation = await this.evaluateCandidate(candidateType, skill, currentTeam, config);
-            if (evaluation.score >= config.performanceThreshold) {
-                candidates.push(evaluation);
-            }
-        }
-        return candidates.sort((a, b) => b.score - a.score);
-    }
-    /**
-     * Evaluate individual candidate
-     */
-    async evaluateCandidate(candidateType, skill, currentTeam, config) {
-        const performance = this.specialistPool.performance.get(candidateType);
-        const capacity = this.specialistPool.capacity.get(candidateType);
-        let score = 0;
-        const factors = {};
-        // Skill match score (40%)
-        const skillMatchScore = this.calculateSkillMatch(candidateType, skill);
-        factors.skillMatch = skillMatchScore;
-        score += skillMatchScore * 0.4;
-        // Performance score (25%)
-        if (performance) {
-            const performanceScore = (performance.successRate +
-                (performance.complexityRating / 5) +
-                Math.min(performance.totalTasksCompleted / 100, 1)) / 3;
-            factors.performance = performanceScore;
-            score += performanceScore * 0.25;
-        }
-        // Availability score (20%)
-        if (capacity) {
-            const availabilityScore = Math.max(0, (capacity.maxConcurrent - capacity.currentLoad) / capacity.maxConcurrent);
-            factors.availability = availabilityScore;
-            score += availabilityScore * 0.2;
-        }
-        // Team synergy score (10%)
-        const synergyScore = this.calculateTeamSynergy(candidateType, currentTeam);
-        factors.synergy = synergyScore;
-        score += synergyScore * 0.1;
-        // Diversity bonus (5%)
-        const diversityScore = this.calculateDiversityBonus(candidateType, currentTeam);
-        factors.diversity = diversityScore;
-        score += diversityScore * 0.05;
-        return {
-            type: candidateType,
-            score,
-            factors,
-            estimatedTime: skill.estimatedTime,
-            riskLevel: this.assessCandidateRisk(candidateType, skill)
-        };
-    }
-    /**
-     * Select best candidate from evaluations
-     */
-    selectBestCandidate(candidates, skill, config) {
-        if (candidates.length === 0) {
-            return null;
-        }
-        // For critical skills, prefer higher performance even if slightly less available
-        if (skill.importance === 'primary' && skill.complexity === 'high') {
-            return candidates.find(c => c.factors.performance > 0.8) || candidates[0];
-        }
-        // For secondary skills, prefer availability
-        if (skill.importance === 'secondary') {
-            return candidates.find(c => c.factors.availability > 0.7) || candidates[0];
-        }
-        // Default: highest overall score
-        return candidates[0];
-    }
-    /**
-     * Instantiate specialist instance
-     */
-    instantiateSpecialist(specialistType) {
-        const SpecialistClass = this.specialistPool.available.get(specialistType);
-        if (SpecialistClass) {
-            const instance = new SpecialistClass();
-            this.specialistPool.active.set(`${specialistType}_${Date.now()}`, instance);
-            return instance;
-        }
-        return null;
-    }
-    /**
-     * Check if specialist type is available
-     */
-    isSpecialistAvailable(specialistType) {
-        const capacity = this.specialistPool.capacity.get(specialistType);
-        return capacity ? capacity.currentLoad < capacity.maxConcurrent : false;
-    }
-    /**
-     * Apply load balancing to team
-     */
-    async applyLoadBalancing(team, config) {
-        // Calculate current load distribution
-        const loadDistribution = new Map();
-        team.forEach((specialist, skillType) => {
-            const capacity = this.specialistPool.capacity.get(skillType);
-            if (capacity) {
-                const loadPercentage = capacity.currentLoad / capacity.maxConcurrent;
-                loadDistribution.set(skillType, loadPercentage);
-            }
-        });
-        // If load is heavily skewed, consider redistributing
-        const maxLoad = Math.max(...loadDistribution.values());
-        const minLoad = Math.min(...loadDistribution.values());
-        if (maxLoad - minLoad > 0.5) { // 50% difference
-            this.logger.warn('Load imbalance detected', {
-                maxLoad,
-                minLoad,
-                difference: maxLoad - minLoad
-            });
-            // Could implement load redistribution logic here
-            // For now, just log the warning
-        }
-    }
-    /**
-     * Update capacity tracking
-     */
-    updateCapacity(specialistType, action) {
-        const capacity = this.specialistPool.capacity.get(specialistType);
-        if (capacity) {
-            if (action === 'allocate') {
-                capacity.currentLoad++;
-            }
-            else {
-                capacity.currentLoad = Math.max(0, capacity.currentLoad - 1);
-            }
-            this.specialistPool.capacity.set(specialistType, capacity);
-        }
-    }
-    /**
-     * Calculate skill match score
-     */
-    calculateSkillMatch(candidateType, skill) {
-        // This would typically use the specialist's canHandle method
-        const skillMapping = this.skillMappings.get(skill.type);
-        if (!skillMapping)
-            return 0;
-        if (skillMapping.specialistTypes.includes(candidateType)) {
-            return 1.0; // Perfect match
-        }
-        if (skillMapping.fallbackTypes.includes(candidateType)) {
-            return 0.7; // Good fallback match
-        }
-        return 0.3; // Minimal capability
-    }
-    /**
-     * Calculate team synergy score
-     */
-    calculateTeamSynergy(candidateType, currentTeam) {
-        // Teams with complementary skills have higher synergy
-        const complementaryTypes = {
-            'data-specialist': ['reporting-specialist', 'integration-specialist'],
-            'integration-specialist': ['data-specialist', 'security-specialist'],
-            'automation-specialist': ['integration-specialist', 'data-specialist'],
-            'reporting-specialist': ['data-specialist'],
-            'security-specialist': ['integration-specialist', 'data-specialist']
-        };
-        const complementary = complementaryTypes[candidateType] || [];
-        let synergyScore = 0.5; // Base score
-        currentTeam.forEach((_, teamMemberType) => {
-            if (complementary.includes(teamMemberType)) {
-                synergyScore += 0.2;
-            }
-        });
-        return Math.min(synergyScore, 1.0);
-    }
-    /**
-     * Calculate diversity bonus
-     */
-    calculateDiversityBonus(candidateType, currentTeam) {
-        // Bonus for adding different specialist types
-        const existingTypes = Array.from(currentTeam.keys());
-        return existingTypes.includes(candidateType) ? 0 : 1.0;
-    }
-    /**
-     * Assess candidate risk level
-     */
-    assessCandidateRisk(candidateType, skill) {
-        const performance = this.specialistPool.performance.get(candidateType);
-        if (!performance)
-            return 'high';
-        if (performance.successRate > 0.9 && performance.totalTasksCompleted > 50) {
-            return 'low';
-        }
-        if (performance.successRate > 0.7 && performance.totalTasksCompleted > 10) {
-            return 'medium';
-        }
-        return 'high';
-    }
-    /**
-     * Initialize specialist pool
-     */
-    initializeSpecialistPool() {
-        const available = new Map();
-        const capacity = new Map();
-        const performance = new Map();
-        // Register available specialists
-        available.set('data-specialist', data_specialist_agent_js_1.DataSpecialistAgent);
-        available.set('integration-specialist', integration_specialist_agent_js_1.IntegrationSpecialistAgent);
-        available.set('automation-specialist', automation_specialist_agent_js_1.AutomationSpecialistAgent);
-        available.set('reporting-specialist', reporting_specialist_agent_js_1.ReportingSpecialistAgent);
-        available.set('security-specialist', security_specialist_agent_js_1.SecuritySpecialistAgent);
-        // Initialize capacity information
-        available.forEach((_, type) => {
-            capacity.set(type, {
-                maxConcurrent: 3,
-                currentLoad: 0,
-                reservedSlots: 0
-            });
-            performance.set(type, {
-                averageExecutionTime: 300000, // 5 minutes
-                successRate: 0.85,
-                totalTasksCompleted: 0,
-                lastActivity: new Date(),
-                complexityRating: 3
-            });
-        });
-        return {
-            available,
-            active: new Map(),
-            capacity,
-            performance
-        };
-    }
-    /**
-     * Initialize skill mappings
-     */
-    initializeSkillMappings() {
-        this.skillMappings.set('data_modeling', {
-            skillType: 'data_modeling',
-            specialistTypes: ['data-specialist'],
-            fallbackTypes: ['integration-specialist'],
-            complexityMapping: {
-                'low': ['data-specialist'],
-                'medium': ['data-specialist'],
-                'high': ['data-specialist', 'integration-specialist']
-            }
-        });
-        this.skillMappings.set('api_integration', {
-            skillType: 'api_integration',
-            specialistTypes: ['integration-specialist'],
-            fallbackTypes: ['data-specialist'],
-            complexityMapping: {
-                'low': ['integration-specialist'],
-                'medium': ['integration-specialist'],
-                'high': ['integration-specialist', 'security-specialist']
-            }
-        });
-        this.skillMappings.set('workflow_design', {
-            skillType: 'workflow_design',
-            specialistTypes: ['automation-specialist'],
-            fallbackTypes: ['integration-specialist'],
-            complexityMapping: {
-                'low': ['automation-specialist'],
-                'medium': ['automation-specialist'],
-                'high': ['automation-specialist', 'integration-specialist']
-            }
-        });
-        this.skillMappings.set('report_creation', {
-            skillType: 'report_creation',
-            specialistTypes: ['reporting-specialist'],
-            fallbackTypes: ['data-specialist'],
-            complexityMapping: {
-                'low': ['reporting-specialist'],
-                'medium': ['reporting-specialist'],
-                'high': ['reporting-specialist', 'data-specialist']
-            }
-        });
-        this.skillMappings.set('security_configuration', {
-            skillType: 'security_configuration',
-            specialistTypes: ['security-specialist'],
-            fallbackTypes: ['integration-specialist'],
-            complexityMapping: {
-                'low': ['security-specialist'],
-                'medium': ['security-specialist'],
-                'high': ['security-specialist', 'integration-specialist']
-            }
-        });
-    }
-    /**
-     * Get team assembly statistics
-     */
-    getAssemblyStatistics() {
-        return {
-            availableSpecialists: this.specialistPool.available.size,
-            activeSpecialists: this.specialistPool.active.size,
-            capacityUtilization: this.calculateCapacityUtilization(),
-            skillMappings: this.skillMappings.size,
-            performanceMetrics: this.getAggregatedPerformance()
-        };
-    }
-    /**
-     * Calculate overall capacity utilization
-     */
-    calculateCapacityUtilization() {
-        let totalCapacity = 0;
-        let totalUsed = 0;
-        this.specialistPool.capacity.forEach(capacity => {
-            totalCapacity += capacity.maxConcurrent;
-            totalUsed += capacity.currentLoad;
-        });
-        return totalCapacity > 0 ? totalUsed / totalCapacity : 0;
-    }
-    /**
-     * Get aggregated performance metrics
-     */
-    getAggregatedPerformance() {
-        const performances = Array.from(this.specialistPool.performance.values());
-        if (performances.length === 0) {
-            return { averageSuccessRate: 0, totalTasksCompleted: 0 };
-        }
-        const avgSuccessRate = performances.reduce((sum, p) => sum + p.successRate, 0) / performances.length;
-        const totalTasks = performances.reduce((sum, p) => sum + p.totalTasksCompleted, 0);
-        return {
-            averageSuccessRate: avgSuccessRate,
-            totalTasksCompleted: totalTasks
-        };
-    }
-}
-exports.TeamAssembler = TeamAssembler;
-//# sourceMappingURL=team-assembler.js.map

package/dist/benchmark-performance.d.ts

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-declare class PerformanceBenchmark {
-    private client;
-    private logger;
-    private results;
-    constructor();
-    /**
-     * Measure memory usage of a data structure
-     */
-    private measureMemory;
-    /**
-     * Format bytes to human readable string
-     */
-    private formatBytes;
-    /**
-     * Benchmark count-only queries (minimal memory footprint)
-     */
-    benchmarkCountOnly(): Promise<void>;
-    /**
-     * Benchmark specific field queries (optimized memory)
-     */
-    benchmarkSpecificFields(): Promise<void>;
-    /**
-     * Benchmark ML batch processing
-     */
-    benchmarkMLBatchProcessing(): Promise<void>;
-    /**
-     * Compare full content vs optimized queries
-     */
-    benchmarkComparison(): Promise<void>;
-    /**
-     * Generate summary report
-     */
-    generateReport(): void;
-    /**
-     * Run all benchmarks
-     */
-    runAll(): Promise<void>;
-}
-export { PerformanceBenchmark };
-//# sourceMappingURL=benchmark-performance.d.ts.map