snow-flow 3.0.8 → 3.0.10

package/dist/agents/teams/adaptive/adaptive-coordinator.agent.d.ts

@@ -1,111 +0,0 @@
-/**
- * Adaptive Coordinator Agent - Analyzes unknown tasks and dynamically assembles specialized teams
- */
-import { BaseSnowAgent } from '../../base/base-snow-agent.js';
-import { Task, TaskPriority } from '../../../types/snow-flow.types.js';
-import { TaskAnalysis } from '../../../intelligence/task-analyzer.js';
-export interface AdaptiveTeam {
-    id: string;
-    specialists: Map<string, BaseSnowAgent>;
-    coordinator: AdaptiveCoordinatorAgent;
-    taskAnalysis: TaskAnalysis;
-    executionPlan: ExecutionPlan;
-    createdAt: Date;
-}
-export interface ExecutionPlan {
-    strategy: 'sequential' | 'parallel' | 'hybrid';
-    steps: ExecutionStep[];
-    parallelTasks: ParallelTask[];
-    dependencies: TaskDependency[];
-    estimatedDuration: number;
-}
-export interface ExecutionStep {
-    id: string;
-    agent: string;
-    task: any;
-    dependencies: string[];
-    estimatedTime: number;
-}
-export interface ParallelTask {
-    id: string;
-    agent: string;
-    task: any;
-    canRunInParallel: boolean;
-}
-export interface TaskDependency {
-    prerequisite: string;
-    dependent: string;
-    type: 'data' | 'completion' | 'approval';
-}
-export interface TaskAnalysisRequest {
-    description: string;
-    context?: any;
-    priority?: TaskPriority;
-    constraints?: string[];
-    expectedOutput?: string;
-}
-export declare class AdaptiveCoordinatorAgent extends BaseSnowAgent {
-    private taskAnalyzer;
-    private teamAssembler;
-    private adaptivePatterns;
-    private activeTeams;
-    private taskHistory;
-    constructor();
-    /**
-     * Main execution method for unknown/custom tasks
-     */
-    execute(task: Task, input?: any): Promise<any>;
-    /**
-     * Analyze unknown task and determine requirements
-     */
-    analyzeUnknownTask(request: TaskAnalysisRequest): Promise<TaskAnalysis>;
-    /**
-     * Dynamically assemble specialized team based on analysis
-     */
-    assembleTeam(analysis: TaskAnalysis): Promise<AdaptiveTeam>;
-    /**
-     * Execute adaptive task with dynamic coordination
-     */
-    executeAdaptiveTask(request: TaskAnalysisRequest): Promise<any>;
-    /**
-     * Coordinate execution based on optimal patterns
-     */
-    private coordinateAdaptiveExecution;
-    /**
-     * Create execution plan based on analysis and team composition
-     */
-    private createExecutionPlan;
-    /**
-     * Determine optimal execution strategy
-     */
-    private determineExecutionStrategy;
-    /**
-     * Enhance analysis with historical patterns
-     */
-    private enhanceWithHistory;
-    /**
-     * Generate recommendations based on execution results
-     */
-    private generateRecommendations;
-    /**
-     * Cleanup team resources
-     */
-    private cleanupTeam;
-    /**
-     * Get current active teams
-     */
-    getActiveTeams(): AdaptiveTeam[];
-    /**
-     * Get task execution history
-     */
-    getTaskHistory(): TaskAnalysis[];
-    /**
-     * Get performance metrics
-     */
-    getPerformanceMetrics(): any;
-    /**
-     * Get unique specialist types that have been used
-     */
-    private getUniqueSpecialistTypes;
-}
-//# sourceMappingURL=adaptive-coordinator.agent.d.ts.map

package/dist/agents/teams/adaptive/adaptive-coordinator.agent.js

@@ -1,383 +0,0 @@
-"use strict";
-/**
- * Adaptive Coordinator Agent - Analyzes unknown tasks and dynamically assembles specialized teams
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdaptiveCoordinatorAgent = void 0;
-const base_snow_agent_js_1 = require("../../base/base-snow-agent.js");
-const task_analyzer_js_1 = require("../../../intelligence/task-analyzer.js");
-const team_assembler_js_1 = require("../../../assembly/team-assembler.js");
-const adaptive_patterns_js_1 = require("../../../patterns/adaptive-patterns.js");
-class AdaptiveCoordinatorAgent extends base_snow_agent_js_1.BaseSnowAgent {
-    constructor() {
-        const capabilities = {
-            primarySkills: [
-                'task_analysis',
-                'team_coordination',
-                'requirement_analysis',
-                'strategy_planning',
-                'resource_allocation'
-            ],
-            secondarySkills: [
-                'pattern_recognition',
-                'workflow_optimization',
-                'risk_assessment',
-                'performance_monitoring'
-            ],
-            complexity: 'high',
-            autonomy: 'fully-autonomous'
-        };
-        super('coordinator', 'AdaptiveCoordinator', capabilities);
-        this.activeTeams = new Map();
-        this.taskHistory = [];
-        this.taskAnalyzer = new task_analyzer_js_1.TaskAnalyzer();
-        this.teamAssembler = new team_assembler_js_1.TeamAssembler();
-        this.adaptivePatterns = new adaptive_patterns_js_1.AdaptivePatterns();
-        this.logger.info('Adaptive Coordinator Agent initialized');
-    }
-    /**
-     * Main execution method for unknown/custom tasks
-     */
-    async execute(task, input) {
-        await this.startTask(task);
-        try {
-            const request = {
-                description: task.description,
-                context: input?.context,
-                priority: task.priority,
-                constraints: input?.constraints,
-                expectedOutput: input?.expectedOutput
-            };
-            const result = await this.executeAdaptiveTask(request);
-            await this.completeTask(result);
-            return result;
-        }
-        catch (error) {
-            await this.handleError(error);
-            throw error;
-        }
-    }
-    /**
-     * Analyze unknown task and determine requirements
-     */
-    async analyzeUnknownTask(request) {
-        this.logger.info('Analyzing unknown task', { description: request.description });
-        try {
-            // Use AI-powered task analysis
-            const analysis = await this.taskAnalyzer.analyzeTaskType({
-                description: request.description,
-                context: request.context,
-                priority: request.priority,
-                constraints: request.constraints || [],
-                expectedOutput: request.expectedOutput
-            });
-            // Enhance analysis with historical patterns
-            const enhancedAnalysis = await this.enhanceWithHistory(analysis);
-            // Store for future learning
-            this.taskHistory.push(enhancedAnalysis);
-            this.logger.info('Task analysis completed', {
-                taskType: enhancedAnalysis.taskType,
-                complexity: enhancedAnalysis.complexity,
-                requiredSkills: enhancedAnalysis.requiredSkills.length
-            });
-            return enhancedAnalysis;
-        }
-        catch (error) {
-            this.logger.error('Task analysis failed', error);
-            throw new Error(`Failed to analyze task: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Dynamically assemble specialized team based on analysis
-     */
-    async assembleTeam(analysis) {
-        this.logger.info('Assembling adaptive team', {
-            taskType: analysis.taskType,
-            requiredSkills: analysis.requiredSkills
-        });
-        try {
-            // Identify required skill sets
-            const skillRequirements = await this.taskAnalyzer.identifyRequiredSkills(analysis);
-            // Suggest optimal team composition
-            const teamComposition = await this.taskAnalyzer.suggestTeamComposition(skillRequirements);
-            // Assemble the team using available specialists
-            const specialists = await this.teamAssembler.assembleTeam(skillRequirements);
-            // Create execution plan
-            const executionPlan = await this.createExecutionPlan(analysis, teamComposition);
-            const team = {
-                id: `team_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                specialists,
-                coordinator: this,
-                taskAnalysis: analysis,
-                executionPlan,
-                createdAt: new Date()
-            };
-            this.activeTeams.set(team.id, team);
-            this.logger.info('Team assembled successfully', {
-                teamId: team.id,
-                specialistCount: specialists.size,
-                strategy: executionPlan.strategy
-            });
-            return team;
-        }
-        catch (error) {
-            this.logger.error('Team assembly failed', error);
-            throw new Error(`Failed to assemble team: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Execute adaptive task with dynamic coordination
-     */
-    async executeAdaptiveTask(request) {
-        this.logger.info('Executing adaptive task', { description: request.description });
-        try {
-            // Step 1: Analyze the task
-            const analysis = await this.analyzeUnknownTask(request);
-            // Step 2: Assemble specialized team
-            const team = await this.assembleTeam(analysis);
-            // Step 3: Execute with adaptive coordination
-            const result = await this.coordinateAdaptiveExecution(team, analysis);
-            // Step 4: Cleanup team resources
-            await this.cleanupTeam(team.id);
-            this.logger.info('Adaptive task execution completed', {
-                taskType: analysis.taskType,
-                teamId: team.id,
-                success: !!result.success
-            });
-            return {
-                success: true,
-                taskAnalysis: analysis,
-                teamComposition: Array.from(team.specialists.keys()),
-                executionStrategy: team.executionPlan.strategy,
-                result: result,
-                metrics: {
-                    analysisTime: result.analysisTime,
-                    assemblyTime: result.assemblyTime,
-                    executionTime: result.executionTime,
-                    totalTime: result.totalTime
-                },
-                recommendations: this.generateRecommendations(analysis, team, result)
-            };
-        }
-        catch (error) {
-            this.logger.error('Adaptive task execution failed', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                analysis: null,
-                recommendations: ['Review task requirements and try again', 'Consider breaking down complex tasks']
-            };
-        }
-    }
-    /**
-     * Coordinate execution based on optimal patterns
-     */
-    async coordinateAdaptiveExecution(team, analysis) {
-        const startTime = Date.now();
-        try {
-            let result;
-            switch (team.executionPlan.strategy) {
-                case 'sequential':
-                    result = await this.adaptivePatterns.executeSequentialPattern(team, team.executionPlan);
-                    break;
-                case 'parallel':
-                    result = await this.adaptivePatterns.executeParallelPattern(team, team.executionPlan);
-                    break;
-                case 'hybrid':
-                    result = await this.adaptivePatterns.executeHybridPattern(team, team.executionPlan);
-                    break;
-                default:
-                    throw new Error(`Unknown execution strategy: ${team.executionPlan.strategy}`);
-            }
-            const executionTime = Date.now() - startTime;
-            return {
-                ...result,
-                executionTime,
-                strategy: team.executionPlan.strategy,
-                teamSize: team.specialists.size
-            };
-        }
-        catch (error) {
-            this.logger.error('Execution coordination failed', error);
-            throw error;
-        }
-    }
-    /**
-     * Create execution plan based on analysis and team composition
-     */
-    async createExecutionPlan(analysis, teamComposition) {
-        const strategy = this.determineExecutionStrategy(analysis);
-        const steps = [];
-        const parallelTasks = [];
-        const dependencies = [];
-        // Create execution steps based on task complexity and dependencies
-        if (analysis.hasServiceNowComponents) {
-            steps.push({
-                id: 'servicenow_setup',
-                agent: 'servicenow-specialist',
-                task: { type: 'setup', description: 'Setup ServiceNow environment' },
-                dependencies: [],
-                estimatedTime: 300000 // 5 minutes
-            });
-        }
-        if (analysis.requiresDataProcessing) {
-            steps.push({
-                id: 'data_processing',
-                agent: 'data-specialist',
-                task: { type: 'data_analysis', description: analysis.description },
-                dependencies: analysis.hasServiceNowComponents ? ['servicenow_setup'] : [],
-                estimatedTime: 600000 // 10 minutes
-            });
-        }
-        if (analysis.requiresIntegration) {
-            const integrationStep = {
-                id: 'integration_setup',
-                agent: 'integration-specialist',
-                task: { type: 'integration', description: analysis.description },
-                dependencies: ['data_processing'],
-                estimatedTime: 900000 // 15 minutes
-            };
-            if (strategy === 'parallel' && !analysis.hasStrictDependencies) {
-                parallelTasks.push({
-                    id: integrationStep.id,
-                    agent: integrationStep.agent,
-                    task: integrationStep.task,
-                    canRunInParallel: true
-                });
-            }
-            else {
-                steps.push(integrationStep);
-            }
-        }
-        // Add more steps based on analysis requirements...
-        const estimatedDuration = steps.reduce((sum, step) => sum + step.estimatedTime, 0) +
-            parallelTasks.reduce((sum, task) => sum + 300000, 0); // Base time for parallel tasks
-        return {
-            strategy,
-            steps,
-            parallelTasks,
-            dependencies,
-            estimatedDuration
-        };
-    }
-    /**
-     * Determine optimal execution strategy
-     */
-    determineExecutionStrategy(analysis) {
-        if (analysis.hasStrictDependencies || analysis.complexity === 'high') {
-            return 'sequential';
-        }
-        if (analysis.canParallelize && analysis.requiredSkills.length > 2) {
-            return 'parallel';
-        }
-        if (analysis.complexity === 'medium' && analysis.requiredSkills.length > 1) {
-            return 'hybrid';
-        }
-        return 'sequential';
-    }
-    /**
-     * Enhance analysis with historical patterns
-     */
-    async enhanceWithHistory(analysis) {
-        // Find similar historical tasks
-        const similarTasks = this.taskHistory.filter(task => task.taskType === analysis.taskType ||
-            task.requiredSkills.some(skill => analysis.requiredSkills.includes(skill)));
-        if (similarTasks.length > 0) {
-            // Apply lessons learned
-            const avgComplexity = similarTasks.reduce((sum, task) => {
-                const complexityMap = { 'low': 1, 'medium': 2, 'high': 3 };
-                return sum + complexityMap[task.complexity];
-            }, 0) / similarTasks.length;
-            if (avgComplexity > 2 && analysis.complexity === 'medium') {
-                analysis.complexity = 'high';
-                analysis.recommendations.push('Complexity upgraded based on historical patterns');
-            }
-            // Add successful patterns from history
-            const successfulPatterns = similarTasks
-                .filter(task => task.successRate > 0.8)
-                .map(task => task.recommendedPattern)
-                .filter(Boolean);
-            if (successfulPatterns.length > 0) {
-                analysis.recommendedPattern = successfulPatterns[0];
-            }
-        }
-        return analysis;
-    }
-    /**
-     * Generate recommendations based on execution results
-     */
-    generateRecommendations(analysis, team, result) {
-        const recommendations = [];
-        if (result.executionTime > team.executionPlan.estimatedDuration * 1.5) {
-            recommendations.push('Consider optimizing workflow - execution took longer than expected');
-        }
-        if (team.specialists.size > 5) {
-            recommendations.push('Large team size may introduce coordination overhead');
-        }
-        if (analysis.complexity === 'high' && team.executionPlan.strategy === 'parallel') {
-            recommendations.push('Sequential execution might be more reliable for high complexity tasks');
-        }
-        if (result.success && result.executionTime < team.executionPlan.estimatedDuration * 0.8) {
-            recommendations.push('Excellent performance - consider this pattern for similar tasks');
-        }
-        return recommendations;
-    }
-    /**
-     * Cleanup team resources
-     */
-    async cleanupTeam(teamId) {
-        const team = this.activeTeams.get(teamId);
-        if (team) {
-            // Terminate all specialists
-            for (const specialist of team.specialists.values()) {
-                specialist.terminate();
-            }
-            this.activeTeams.delete(teamId);
-            this.logger.info('Team cleanup completed', { teamId });
-        }
-    }
-    /**
-     * Get current active teams
-     */
-    getActiveTeams() {
-        return Array.from(this.activeTeams.values());
-    }
-    /**
-     * Get task execution history
-     */
-    getTaskHistory() {
-        return [...this.taskHistory];
-    }
-    /**
-     * Get performance metrics
-     */
-    getPerformanceMetrics() {
-        const totalTasks = this.taskHistory.length;
-        const successfulTasks = this.taskHistory.filter(task => task.successRate > 0.8).length;
-        const avgComplexity = this.taskHistory.reduce((sum, task) => {
-            const complexityMap = { 'low': 1, 'medium': 2, 'high': 3 };
-            return sum + complexityMap[task.complexity];
-        }, 0) / totalTasks || 0;
-        return {
-            totalTasksAnalyzed: totalTasks,
-            successRate: totalTasks > 0 ? successfulTasks / totalTasks : 0,
-            averageComplexity: avgComplexity,
-            activeTeams: this.activeTeams.size,
-            specialistTypes: this.getUniqueSpecialistTypes()
-        };
-    }
-    /**
-     * Get unique specialist types that have been used
-     */
-    getUniqueSpecialistTypes() {
-        const types = new Set();
-        for (const team of this.activeTeams.values()) {
-            for (const specialistType of team.specialists.keys()) {
-                types.add(specialistType);
-            }
-        }
-        return Array.from(types);
-    }
-}
-exports.AdaptiveCoordinatorAgent = AdaptiveCoordinatorAgent;
-//# sourceMappingURL=adaptive-coordinator.agent.js.map

package/dist/agents/teams/base-team.d.ts

@@ -1,72 +0,0 @@
-/**
- * Base classes for specialized agent teams
- */
-import { TeamSpecification, TeamResult, TeamCoordinationStrategy, AgentCapability, SpecializationProfile } from './team-types';
-import { ServiceNowAgentConfig } from '../../types/servicenow.types';
-/**
- * Abstract base class for all specialized agents
- */
-export declare abstract class BaseSnowAgent {
-    protected id: string;
-    protected name: string;
-    protected role: string;
-    protected capabilities: AgentCapability[];
-    protected specialization: SpecializationProfile;
-    protected config: ServiceNowAgentConfig;
-    protected status: 'available' | 'busy' | 'offline';
-    constructor(id: string, name: string, role: string, capabilities: AgentCapability[], specialization: SpecializationProfile, config: ServiceNowAgentConfig);
-    abstract analyzeRequirements(requirements: any): Promise<any>;
-    abstract execute(specification: any): Promise<TeamResult>;
-    getId(): string;
-    getName(): string;
-    getRole(): string;
-    getCapabilities(): AgentCapability[];
-    getStatus(): string;
-    setStatus(status: 'available' | 'busy' | 'offline'): void;
-    canHandle(requirement: string): boolean;
-    getProficiency(capability: string): number;
-    protected handleError(error: any): TeamResult;
-    protected validateRequirements(requirements: any): boolean;
-}
-/**
- * Abstract base class for specialized teams
- */
-export declare abstract class BaseTeam {
-    protected id: string;
-    protected name: string;
-    protected architect: BaseSnowAgent;
-    protected specialists: BaseSnowAgent[];
-    protected coordinationStrategy: TeamCoordinationStrategy;
-    protected config: ServiceNowAgentConfig;
-    constructor(id: string, name: string, architect: BaseSnowAgent, specialists: BaseSnowAgent[], coordinationStrategy: TeamCoordinationStrategy, config: ServiceNowAgentConfig);
-    abstract analyzeRequirements(requirements: any): Promise<TeamSpecification>;
-    abstract executeTask(specification: TeamSpecification): Promise<TeamResult>;
-    getId(): string;
-    getName(): string;
-    getArchitect(): BaseSnowAgent;
-    getSpecialists(): BaseSnowAgent[];
-    getAllMembers(): BaseSnowAgent[];
-    findBestAgent(requirement: string): BaseSnowAgent;
-    coordinatedExecution(specification: TeamSpecification): Promise<TeamResult>;
-    protected executeSequential(specification: TeamSpecification): Promise<TeamResult>;
-    protected executeParallel(specification: TeamSpecification): Promise<TeamResult>;
-    protected executeHybrid(specification: TeamSpecification): Promise<TeamResult>;
-    protected combineResults(results: TeamResult[]): TeamResult;
-    protected executeDependencyGraph(plan: any): Promise<TeamResult>;
-    private setAllAgentsStatus;
-    getTeamStatus(): {
-        architect: string;
-        specialists: {
-            name: string;
-            status: string;
-        }[];
-    };
-    isTeamReady(): boolean;
-}
-/**
- * Team factory for creating specialized teams
- */
-export declare class TeamFactory {
-    static createTeam(type: 'widget' | 'flow' | 'application' | 'generic', config: ServiceNowAgentConfig): BaseTeam;
-}
-//# sourceMappingURL=base-team.d.ts.map