claude-flow-novice 1.0.0

package/dist/src/coordination/swarm-monitor.js

@@ -0,0 +1,359 @@
+import { EventEmitter } from 'node:events';
+import * as os from 'node:os';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Logger } from '../core/logger.js';
+export class SwarmMonitor extends EventEmitter {
+    logger;
+    config;
+    agentMetrics = new Map();
+    systemMetrics = [];
+    alerts = [];
+    monitoringInterval;
+    startTime;
+    taskStartTimes = new Map();
+    taskCompletionTimes = [];
+    lastThroughputCheck;
+    tasksInLastMinute = 0;
+    constructor(config){
+        super();
+        this.logger = new Logger('SwarmMonitor');
+        this.config = {
+            updateInterval: 1000,
+            metricsRetention: 24,
+            cpuThreshold: 80,
+            memoryThreshold: 85,
+            stallTimeout: 300000,
+            errorRateThreshold: 10,
+            throughputThreshold: 1,
+            enableAlerts: true,
+            enableHistory: true,
+            historyPath: './monitoring/history',
+            ...config
+        };
+        this.startTime = Date.now();
+        this.lastThroughputCheck = Date.now();
+    }
+    async start() {
+        this.logger.info('Starting swarm monitoring...');
+        // Create history directory if needed
+        if (this.config.enableHistory && this.config.historyPath) {
+            await fs.mkdir(this.config.historyPath, {
+                recursive: true
+            });
+        }
+        // Start periodic monitoring
+        this.monitoringInterval = setInterval(()=>{
+            this.collectMetrics();
+        }, this.config.updateInterval);
+        // Start initial collection
+        await this.collectMetrics();
+    }
+    stop() {
+        this.logger.info('Stopping swarm monitoring...');
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = undefined;
+        }
+    }
+    // Agent registration and tracking
+    registerAgent(agentId, name) {
+        this.agentMetrics.set(agentId, {
+            id: agentId,
+            name,
+            status: 'idle',
+            taskCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            averageTaskDuration: 0,
+            lastActivity: Date.now(),
+            errorRate: 0
+        });
+        this.logger.debug(`Registered agent: ${name} (${agentId})`);
+    }
+    unregisterAgent(agentId) {
+        const metrics = this.agentMetrics.get(agentId);
+        if (metrics) {
+            this.logger.debug(`Unregistered agent: ${metrics.name} (${agentId})`);
+            this.agentMetrics.delete(agentId);
+        }
+    }
+    // Task tracking
+    taskStarted(agentId, taskId, taskDescription) {
+        const metrics = this.agentMetrics.get(agentId);
+        if (metrics) {
+            metrics.status = 'running';
+            metrics.currentTask = taskDescription || taskId;
+            metrics.startTime = Date.now();
+            metrics.lastActivity = Date.now();
+            metrics.taskCount++;
+            this.taskStartTimes.set(taskId, Date.now());
+            this.emit('task:started', {
+                agentId,
+                taskId,
+                taskDescription
+            });
+        }
+    }
+    taskCompleted(agentId, taskId, outputSize) {
+        const metrics = this.agentMetrics.get(agentId);
+        const startTime = this.taskStartTimes.get(taskId);
+        if (metrics && startTime) {
+            const duration = Date.now() - startTime;
+            metrics.status = 'completed';
+            metrics.endTime = Date.now();
+            metrics.duration = duration;
+            metrics.lastActivity = Date.now();
+            metrics.successCount++;
+            metrics.outputSize = outputSize;
+            // Update average duration
+            const totalDuration = metrics.averageTaskDuration * (metrics.successCount - 1) + duration;
+            metrics.averageTaskDuration = totalDuration / metrics.successCount;
+            // Update error rate
+            metrics.errorRate = metrics.failureCount / metrics.taskCount * 100;
+            // Track for throughput calculation
+            this.taskCompletionTimes.push(Date.now());
+            this.tasksInLastMinute++;
+            this.taskStartTimes.delete(taskId);
+            this.emit('task:completed', {
+                agentId,
+                taskId,
+                duration,
+                outputSize
+            });
+        }
+    }
+    taskFailed(agentId, taskId, error) {
+        const metrics = this.agentMetrics.get(agentId);
+        const startTime = this.taskStartTimes.get(taskId);
+        if (metrics) {
+            const duration = startTime ? Date.now() - startTime : 0;
+            metrics.status = 'failed';
+            metrics.endTime = Date.now();
+            metrics.duration = duration;
+            metrics.lastActivity = Date.now();
+            metrics.failureCount++;
+            // Update error rate
+            metrics.errorRate = metrics.failureCount / metrics.taskCount * 100;
+            this.taskStartTimes.delete(taskId);
+            this.emit('task:failed', {
+                agentId,
+                taskId,
+                error,
+                duration
+            });
+            // Check error rate threshold
+            if (metrics.errorRate > this.config.errorRateThreshold) {
+                this.createAlert('error_rate', 'critical', `Agent ${metrics.name} has high error rate: ${metrics.errorRate.toFixed(1)}%`);
+            }
+        }
+    }
+    // Metrics collection
+    async collectMetrics() {
+        try {
+            // Collect system metrics
+            const cpuUsage = this.getCPUUsage();
+            const memInfo = this.getMemoryInfo();
+            const loadAvg = os.loadavg();
+            // Calculate throughput
+            const now = Date.now();
+            const minuteAgo = now - 60000;
+            this.taskCompletionTimes = this.taskCompletionTimes.filter((time)=>time > minuteAgo);
+            const throughput = this.taskCompletionTimes.length;
+            // Calculate task statistics
+            let totalTasks = 0;
+            let completedTasks = 0;
+            let failedTasks = 0;
+            let activeAgents = 0;
+            let totalDuration = 0;
+            let durationCount = 0;
+            // Check for stalled agents
+            for (const [agentId, metrics] of this.agentMetrics){
+                if (metrics.status === 'running') {
+                    activeAgents++;
+                    // Check for stalled agent
+                    const stallTime = now - metrics.lastActivity;
+                    if (stallTime > this.config.stallTimeout) {
+                        metrics.status = 'stalled';
+                        this.createAlert('stalled_agent', 'warning', `Agent ${metrics.name} appears to be stalled (${Math.round(stallTime / 1000)}s inactive)`);
+                    }
+                }
+                totalTasks += metrics.taskCount;
+                completedTasks += metrics.successCount;
+                failedTasks += metrics.failureCount;
+                if (metrics.averageTaskDuration > 0) {
+                    totalDuration += metrics.averageTaskDuration * metrics.successCount;
+                    durationCount += metrics.successCount;
+                }
+            }
+            const avgDuration = durationCount > 0 ? totalDuration / durationCount : 0;
+            const pendingTasks = totalTasks - completedTasks - failedTasks;
+            // Create system metrics
+            const systemMetrics = {
+                timestamp: now,
+                cpuUsage,
+                memoryUsage: memInfo.usagePercent,
+                totalMemory: memInfo.total,
+                freeMemory: memInfo.free,
+                loadAverage: loadAvg,
+                activeAgents,
+                totalTasks,
+                completedTasks,
+                failedTasks,
+                pendingTasks,
+                averageTaskDuration: avgDuration,
+                throughput
+            };
+            this.systemMetrics.push(systemMetrics);
+            // Check system thresholds
+            if (this.config.enableAlerts) {
+                this.checkThresholds(systemMetrics);
+            }
+            // Clean old metrics
+            this.cleanOldMetrics();
+            // Save history if enabled
+            if (this.config.enableHistory) {
+                await this.saveHistory(systemMetrics);
+            }
+            // Emit metrics update
+            this.emit('metrics:updated', {
+                system: systemMetrics,
+                agents: Array.from(this.agentMetrics.values())
+            });
+        } catch (error) {
+            this.logger.error('Error collecting metrics:', error);
+        }
+    }
+    getCPUUsage() {
+        const cpus = os.cpus();
+        let totalIdle = 0;
+        let totalTick = 0;
+        cpus.forEach((cpu)=>{
+            for(const type in cpu.times){
+                totalTick += cpu.times[type];
+            }
+            totalIdle += cpu.times.idle;
+        });
+        return 100 - Math.floor(totalIdle / totalTick * 100);
+    }
+    getMemoryInfo() {
+        const total = os.totalmem();
+        const free = os.freemem();
+        const used = total - free;
+        const usagePercent = used / total * 100;
+        return {
+            total,
+            free,
+            used,
+            usagePercent
+        };
+    }
+    checkThresholds(metrics) {
+        // CPU threshold
+        if (metrics.cpuUsage > this.config.cpuThreshold) {
+            this.createAlert('high_cpu', 'warning', `High CPU usage detected: ${metrics.cpuUsage}%`);
+        }
+        // Memory threshold
+        if (metrics.memoryUsage > this.config.memoryThreshold) {
+            this.createAlert('high_memory', 'warning', `High memory usage detected: ${metrics.memoryUsage.toFixed(1)}%`);
+        }
+        // Throughput threshold
+        if (metrics.activeAgents > 0 && metrics.throughput < this.config.throughputThreshold) {
+            this.createAlert('low_throughput', 'warning', `Low throughput detected: ${metrics.throughput} tasks/min`);
+        }
+    }
+    createAlert(type, level, message, details) {
+        const alert = {
+            id: `${type}_${Date.now()}`,
+            timestamp: Date.now(),
+            level,
+            type,
+            message,
+            details
+        };
+        this.alerts.push(alert);
+        this.emit('alert', alert);
+        this.logger[level](message);
+    }
+    cleanOldMetrics() {
+        const retentionTime = this.config.metricsRetention * 60 * 60 * 1000;
+        const cutoff = Date.now() - retentionTime;
+        this.systemMetrics = this.systemMetrics.filter((m)=>m.timestamp > cutoff);
+        this.alerts = this.alerts.filter((a)=>a.timestamp > cutoff);
+    }
+    async saveHistory(metrics) {
+        if (!this.config.historyPath) return;
+        try {
+            const date = new Date();
+            const filename = `metrics_${date.toISOString().split('T')[0]}.jsonl`;
+            const filepath = path.join(this.config.historyPath, filename);
+            const line = JSON.stringify({
+                ...metrics,
+                agents: Array.from(this.agentMetrics.values())
+            }) + '\n';
+            await fs.appendFile(filepath, line);
+        } catch (error) {
+            this.logger.error('Error saving history:', error);
+        }
+    }
+    // Getters for current state
+    getSystemMetrics() {
+        return this.systemMetrics[this.systemMetrics.length - 1];
+    }
+    getAgentMetrics(agentId) {
+        if (agentId) {
+            return this.agentMetrics.get(agentId);
+        }
+        return Array.from(this.agentMetrics.values());
+    }
+    getAlerts(since) {
+        if (since) {
+            return this.alerts.filter((a)=>a.timestamp > since);
+        }
+        return this.alerts;
+    }
+    getHistoricalMetrics(hours = 1) {
+        const since = Date.now() - hours * 60 * 60 * 1000;
+        return this.systemMetrics.filter((m)=>m.timestamp > since);
+    }
+    // Summary statistics
+    getSummary() {
+        const current = this.getSystemMetrics();
+        const uptime = Date.now() - this.startTime;
+        const totalAgents = this.agentMetrics.size;
+        const activeAgents = current?.activeAgents || 0;
+        const totalTasks = current?.totalTasks || 0;
+        const completedTasks = current?.completedTasks || 0;
+        const failedTasks = current?.failedTasks || 0;
+        const successRate = totalTasks > 0 ? completedTasks / totalTasks * 100 : 0;
+        const averageDuration = current?.averageTaskDuration || 0;
+        const currentThroughput = current?.throughput || 0;
+        const alerts = this.alerts.filter((a)=>a.timestamp > Date.now() - 3600000).length; // Last hour
+        return {
+            uptime,
+            totalAgents,
+            activeAgents,
+            totalTasks,
+            completedTasks,
+            failedTasks,
+            successRate,
+            averageDuration,
+            currentThroughput,
+            alerts
+        };
+    }
+    // Export monitoring data
+    async exportMetrics(filepath) {
+        const data = {
+            summary: this.getSummary(),
+            systemMetrics: this.systemMetrics,
+            agentMetrics: Array.from(this.agentMetrics.values()),
+            alerts: this.alerts,
+            exported: new Date().toISOString()
+        };
+        await fs.writeFile(filepath, JSON.stringify(data, null, 2));
+        this.logger.info(`Exported metrics to ${filepath}`);
+    }
+}
+
+//# sourceMappingURL=swarm-monitor.js.map

package/dist/src/coordination/swarm-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/coordination/swarm-monitor.ts"],"names":["EventEmitter","os","fs","path","Logger","SwarmMonitor","logger","config","agentMetrics","Map","systemMetrics","alerts","monitoringInterval","startTime","taskStartTimes","taskCompletionTimes","lastThroughputCheck","tasksInLastMinute","updateInterval","metricsRetention","cpuThreshold","memoryThreshold","stallTimeout","errorRateThreshold","throughputThreshold","enableAlerts","enableHistory","historyPath","Date","now","start","info","mkdir","recursive","setInterval","collectMetrics","stop","clearInterval","undefined","registerAgent","agentId","name","set","id","status","taskCount","successCount","failureCount","averageTaskDuration","lastActivity","errorRate","debug","unregisterAgent","metrics","get","delete","taskStarted","taskId","taskDescription","currentTask","emit","taskCompleted","outputSize","duration","endTime","totalDuration","push","taskFailed","error","createAlert","toFixed","cpuUsage","getCPUUsage","memInfo","getMemoryInfo","loadAvg","loadavg","minuteAgo","filter","time","throughput","length","totalTasks","completedTasks","failedTasks","activeAgents","durationCount","stallTime","Math","round","avgDuration","pendingTasks","timestamp","memoryUsage","usagePercent","totalMemory","total","freeMemory","free","loadAverage","checkThresholds","cleanOldMetrics","saveHistory","system","agents","Array","from","values","cpus","totalIdle","totalTick","forEach","cpu","type","times","idle","floor","totalmem","freemem","used","level","message","details","alert","retentionTime","cutoff","m","a","date","filename","toISOString","split","filepath","join","line","JSON","stringify","appendFile","getSystemMetrics","getAgentMetrics","getAlerts","since","getHistoricalMetrics","hours","getSummary","current","uptime","totalAgents","size","successRate","averageDuration","currentThroughput","exportMetrics","data","summary","exported","writeFile"],"mappings":"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"}

package/dist/src/coordination/work-stealing.js

@@ -0,0 +1,164 @@
+/**
+ * Work stealing algorithm for load balancing between agents
+ */ /**
+ * Work stealing coordinator for load balancing
+ */ export class WorkStealingCoordinator {
+    config;
+    eventBus;
+    logger;
+    workloads = new Map();
+    stealInterval;
+    taskDurations = new Map();
+    constructor(config, eventBus, logger){
+        this.config = config;
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    async initialize() {
+        if (!this.config.enabled) {
+            this.logger.info('Work stealing is disabled');
+            return;
+        }
+        this.logger.info('Initializing work stealing coordinator');
+        // Start periodic steal checks
+        this.stealInterval = setInterval(()=>this.checkAndSteal(), this.config.stealInterval);
+    }
+    async shutdown() {
+        if (this.stealInterval) {
+            clearInterval(this.stealInterval);
+        }
+        this.workloads.clear();
+        this.taskDurations.clear();
+    }
+    updateAgentWorkload(agentId, workload) {
+        const existing = this.workloads.get(agentId) || {
+            agentId,
+            taskCount: 0,
+            avgTaskDuration: 0,
+            cpuUsage: 0,
+            memoryUsage: 0,
+            priority: 0,
+            capabilities: []
+        };
+        this.workloads.set(agentId, {
+            ...existing,
+            ...workload
+        });
+    }
+    recordTaskDuration(agentId, duration) {
+        if (!this.taskDurations.has(agentId)) {
+            this.taskDurations.set(agentId, []);
+        }
+        const durations = this.taskDurations.get(agentId);
+        durations.push(duration);
+        // Keep only last 100 durations
+        if (durations.length > 100) {
+            durations.shift();
+        }
+        // Update average duration
+        const avg = durations.reduce((sum, d)=>sum + d, 0) / durations.length;
+        this.updateAgentWorkload(agentId, {
+            avgTaskDuration: avg
+        });
+    }
+    async checkAndSteal() {
+        const workloads = Array.from(this.workloads.values());
+        if (workloads.length < 2) {
+            return; // Need at least 2 agents
+        }
+        // Sort by task count (ascending)
+        workloads.sort((a, b)=>a.taskCount - b.taskCount);
+        const minLoaded = workloads[0];
+        const maxLoaded = workloads[workloads.length - 1];
+        // Check if stealing is warranted
+        const difference = maxLoaded.taskCount - minLoaded.taskCount;
+        if (difference < this.config.stealThreshold) {
+            return; // Not enough imbalance
+        }
+        // Calculate how many tasks to steal
+        const tasksToSteal = Math.min(Math.floor(difference / 2), this.config.maxStealBatch);
+        this.logger.info('Initiating work stealing', {
+            from: maxLoaded.agentId,
+            to: minLoaded.agentId,
+            tasksToSteal,
+            difference
+        });
+        // Emit steal request event
+        this.eventBus.emit('workstealing:request', {
+            sourceAgent: maxLoaded.agentId,
+            targetAgent: minLoaded.agentId,
+            taskCount: tasksToSteal
+        });
+    }
+    /**
+   * Find the best agent for a task based on capabilities and load
+   */ findBestAgent(task, agents) {
+        const candidates = [];
+        for (const agent of agents){
+            const workload = this.workloads.get(agent.id);
+            if (!workload) {
+                continue;
+            }
+            // Calculate score based on multiple factors
+            let score = 100;
+            // Factor 1: Task count (lower is better)
+            score -= workload.taskCount * 10;
+            // Factor 2: CPU usage (lower is better)
+            score -= workload.cpuUsage * 0.5;
+            // Factor 3: Memory usage (lower is better)
+            score -= workload.memoryUsage * 0.3;
+            // Factor 4: Agent priority (higher is better)
+            score += agent.priority * 5;
+            // Factor 5: Capability match
+            const taskType = task.type;
+            if (agent.capabilities.includes(taskType)) {
+                score += 20; // Bonus for capability match
+            }
+            // Factor 6: Average task duration (predictive load)
+            const predictedLoad = workload.avgTaskDuration * workload.taskCount;
+            score -= predictedLoad / 1000; // Convert to seconds
+            candidates.push({
+                agentId: agent.id,
+                score
+            });
+        }
+        if (candidates.length === 0) {
+            return null;
+        }
+        // Sort by score (descending) and return best
+        candidates.sort((a, b)=>b.score - a.score);
+        this.logger.debug('Agent selection scores', {
+            taskId: task.id,
+            candidates: candidates.slice(0, 5)
+        });
+        return candidates[0].agentId;
+    }
+    getWorkloadStats() {
+        const stats = {
+            totalAgents: this.workloads.size,
+            workloads: {}
+        };
+        let totalTasks = 0;
+        let minTasks = Infinity;
+        let maxTasks = 0;
+        for (const [agentId, workload] of this.workloads){
+            totalTasks += workload.taskCount;
+            minTasks = Math.min(minTasks, workload.taskCount);
+            maxTasks = Math.max(maxTasks, workload.taskCount);
+            stats.workloads[agentId] = {
+                taskCount: workload.taskCount,
+                avgTaskDuration: workload.avgTaskDuration,
+                cpuUsage: workload.cpuUsage,
+                memoryUsage: workload.memoryUsage
+            };
+        }
+        stats.totalTasks = totalTasks;
+        stats.avgTasksPerAgent = totalTasks / this.workloads.size;
+        stats.minTasks = minTasks === Infinity ? 0 : minTasks;
+        stats.maxTasks = maxTasks;
+        stats.imbalance = maxTasks - (minTasks === Infinity ? 0 : minTasks);
+        return stats;
+    }
+}
+
+//# sourceMappingURL=work-stealing.js.map

package/dist/src/coordination/work-stealing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/coordination/work-stealing.ts"],"names":["WorkStealingCoordinator","workloads","Map","stealInterval","taskDurations","config","eventBus","logger","initialize","enabled","info","setInterval","checkAndSteal","shutdown","clearInterval","clear","updateAgentWorkload","agentId","workload","existing","get","taskCount","avgTaskDuration","cpuUsage","memoryUsage","priority","capabilities","set","recordTaskDuration","duration","has","durations","push","length","shift","avg","reduce","sum","d","Array","from","values","sort","a","b","minLoaded","maxLoaded","difference","stealThreshold","tasksToSteal","Math","min","floor","maxStealBatch","to","emit","sourceAgent","targetAgent","findBestAgent","task","agents","candidates","agent","id","score","taskType","type","includes","predictedLoad","debug","taskId","slice","getWorkloadStats","stats","totalAgents","size","totalTasks","minTasks","Infinity","maxTasks","max","avgTasksPerAgent","imbalance"],"mappings":"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"}

package/dist/src/core/agent-manager.js

@@ -0,0 +1,80 @@
+/**
+ * Simple Agent Manager for novice users
+ */ import { SimpleAgent } from '../agents/simple-agent.js';
+export class AgentManager {
+    agents = new Map();
+    /**
+   * Create a new agent
+   */ createAgent(type, task) {
+        const id = this.generateId();
+        const agent = {
+            id,
+            type,
+            task,
+            status: 'pending',
+            created: new Date()
+        };
+        this.agents.set(id, agent);
+        console.log(`✅ Created ${type} agent: ${id}`);
+        return id;
+    }
+    /**
+   * List all agents
+   */ listAgents() {
+        return Array.from(this.agents.values());
+    }
+    /**
+   * Get agent by ID
+   */ getAgent(id) {
+        return this.agents.get(id);
+    }
+    /**
+   * Remove agent
+   */ removeAgent(id) {
+        const success = this.agents.delete(id);
+        if (success) {
+            console.log(`🗑️ Removed agent: ${id}`);
+        }
+        return success;
+    }
+    /**
+   * Run a specific agent
+   */ async runAgent(id) {
+        const config = this.agents.get(id);
+        if (!config) {
+            throw new Error(`Agent ${id} not found`);
+        }
+        console.log(`🚀 Running ${config.type} agent: ${config.task}`);
+        config.status = 'running';
+        try {
+            const agent = new SimpleAgent(config);
+            const result = await agent.execute();
+            config.result = result;
+            config.status = 'completed';
+            console.log(`✅ Agent ${id} completed successfully`);
+        } catch (error) {
+            config.status = 'failed';
+            console.error(`❌ Agent ${id} failed:`, error);
+            throw error;
+        }
+    }
+    /**
+   * Run all pending agents
+   */ async runAll() {
+        const pendingAgents = Array.from(this.agents.values()).filter((agent)=>agent.status === 'pending');
+        if (pendingAgents.length === 0) {
+            console.log('No pending agents to run');
+            return;
+        }
+        console.log(`🚀 Running ${pendingAgents.length} agents...`);
+        for (const agentConfig of pendingAgents){
+            await this.runAgent(agentConfig.id);
+        }
+        console.log('🎉 All agents completed!');
+    }
+    generateId() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+}
+
+//# sourceMappingURL=agent-manager.js.map

package/dist/src/core/agent-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/agent-manager.ts"],"names":["SimpleAgent","AgentManager","agents","Map","createAgent","type","task","id","generateId","agent","status","created","Date","set","console","log","listAgents","Array","from","values","getAgent","get","removeAgent","success","delete","runAgent","config","Error","result","execute","error","runAll","pendingAgents","filter","length","agentConfig","Math","random","toString","substr"],"mappings":"AAAA;;CAEC,GAGD,SAASA,WAAW,QAAQ,4BAA4B;AAExD,OAAO,MAAMC;IACHC,SAAmC,IAAIC,MAAM;IAErD;;GAEC,GACDC,YAAYC,IAAe,EAAEC,IAAY,EAAU;QACjD,MAAMC,KAAK,IAAI,CAACC,UAAU;QAC1B,MAAMC,QAAqB;YACzBF;YACAF;YACAC;YACAI,QAAQ;YACRC,SAAS,IAAIC;QACf;QAEA,IAAI,CAACV,MAAM,CAACW,GAAG,CAACN,IAAIE;QACpBK,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAEV,KAAK,QAAQ,EAAEE,IAAI;QAC5C,OAAOA;IACT;IAEA;;GAEC,GACDS,aAA4B;QAC1B,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAAChB,MAAM,CAACiB,MAAM;IACtC;IAEA;;GAEC,GACDC,SAASb,EAAU,EAA2B;QAC5C,OAAO,IAAI,CAACL,MAAM,CAACmB,GAAG,CAACd;IACzB;IAEA;;GAEC,GACDe,YAAYf,EAAU,EAAW;QAC/B,MAAMgB,UAAU,IAAI,CAACrB,MAAM,CAACsB,MAAM,CAACjB;QACnC,IAAIgB,SAAS;YACXT,QAAQC,GAAG,CAAC,CAAC,mBAAmB,EAAER,IAAI;QACxC;QACA,OAAOgB;IACT;IAEA;;GAEC,GACD,MAAME,SAASlB,EAAU,EAAiB;QACxC,MAAMmB,SAAS,IAAI,CAACxB,MAAM,CAACmB,GAAG,CAACd;QAC/B,IAAI,CAACmB,QAAQ;YACX,MAAM,IAAIC,MAAM,CAAC,MAAM,EAAEpB,GAAG,UAAU,CAAC;QACzC;QAEAO,QAAQC,GAAG,CAAC,CAAC,WAAW,EAAEW,OAAOrB,IAAI,CAAC,QAAQ,EAAEqB,OAAOpB,IAAI,EAAE;QAC7DoB,OAAOhB,MAAM,GAAG;QAEhB,IAAI;YACF,MAAMD,QAAQ,IAAIT,YAAY0B;YAC9B,MAAME,SAAS,MAAMnB,MAAMoB,OAAO;YAElCH,OAAOE,MAAM,GAAGA;YAChBF,OAAOhB,MAAM,GAAG;YAChBI,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAER,GAAG,uBAAuB,CAAC;QACpD,EAAE,OAAOuB,OAAO;YACdJ,OAAOhB,MAAM,GAAG;YAChBI,QAAQgB,KAAK,CAAC,CAAC,QAAQ,EAAEvB,GAAG,QAAQ,CAAC,EAAEuB;YACvC,MAAMA;QACR;IACF;IAEA;;GAEC,GACD,MAAMC,SAAwB;QAC5B,MAAMC,gBAAgBf,MAAMC,IAAI,CAAC,IAAI,CAAChB,MAAM,CAACiB,MAAM,IAAIc,MAAM,CAC3D,CAACxB,QAAUA,MAAMC,MAAM,KAAK;QAG9B,IAAIsB,cAAcE,MAAM,KAAK,GAAG;YAC9BpB,QAAQC,GAAG,CAAC;YACZ;QACF;QAEAD,QAAQC,GAAG,CAAC,CAAC,WAAW,EAAEiB,cAAcE,MAAM,CAAC,UAAU,CAAC;QAE1D,KAAK,MAAMC,eAAeH,cAAe;YACvC,MAAM,IAAI,CAACP,QAAQ,CAACU,YAAY5B,EAAE;QACpC;QAEAO,QAAQC,GAAG,CAAC;IACd;IAEQP,aAAqB;QAC3B,OAAO4B,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,MAAM,CAAC,GAAG;IAC9C;AACF"}