agentic-flow 2.0.1-alpha.9 → 2.0.2-alpha

package/dist/utils/dynamic-compression.js

@@ -1,298 +0,0 @@
-/**
- * Dynamic Compression based on CPU
- * Adaptive compression levels based on CPU availability
- * Phase 3 Optimization
- */
-import * as zlib from 'zlib';
-import { performance } from 'perf_hooks';
-/**
- * Compression levels with CPU costs
- */
-export const COMPRESSION_LEVELS = {
-    gzip: [
-        { level: 1, name: 'fastest', cpuCost: 1, compressionRatio: 3 },
-        { level: 3, name: 'fast', cpuCost: 3, compressionRatio: 5 },
-        { level: 6, name: 'default', cpuCost: 6, compressionRatio: 7 },
-        { level: 9, name: 'best', cpuCost: 10, compressionRatio: 9 }
-    ],
-    brotli: [
-        { level: 1, name: 'fastest', cpuCost: 2, compressionRatio: 4 },
-        { level: 4, name: 'fast', cpuCost: 4, compressionRatio: 6 },
-        { level: 6, name: 'default', cpuCost: 7, compressionRatio: 8 },
-        { level: 11, name: 'best', cpuCost: 10, compressionRatio: 10 }
-    ]
-};
-/**
- * Dynamic Compression Manager
- * Adjusts compression levels based on CPU load
- */
-export class DynamicCompressionManager {
-    config;
-    stats;
-    currentLevelIndex = 1; // Start with 'fast'
-    cpuSamples = [];
-    monitorInterval;
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            minSize: config.minSize || 1024,
-            algorithm: config.algorithm || 'gzip',
-            adaptive: config.adaptive !== false,
-            cpuThresholdHigh: config.cpuThresholdHigh || 70,
-            cpuThresholdLow: config.cpuThresholdLow || 30,
-            checkInterval: config.checkInterval || 5000
-        };
-        this.stats = {
-            totalBytes: 0,
-            compressedBytes: 0,
-            compressionRatio: 1,
-            avgCompressionTime: 0,
-            currentLevel: this.getCurrentLevel().level,
-            levelChanges: 0,
-            cpuAdjustments: 0
-        };
-        if (this.config.adaptive) {
-            this.startCPUMonitoring();
-        }
-    }
-    /**
-     * Compress data with adaptive level
-     */
-    async compress(data) {
-        if (!this.config.enabled || data.length < this.config.minSize) {
-            return data;
-        }
-        const startTime = performance.now();
-        const level = this.getCurrentLevel();
-        let compressed;
-        try {
-            if (this.config.algorithm === 'brotli') {
-                compressed = await this.compressBrotli(data, level.level);
-            }
-            else if (this.config.algorithm === 'deflate') {
-                compressed = await this.compressDeflate(data, level.level);
-            }
-            else {
-                compressed = await this.compressGzip(data, level.level);
-            }
-            // Update statistics
-            const compressionTime = performance.now() - startTime;
-            this.updateStats(data.length, compressed.length, compressionTime);
-            return compressed;
-        }
-        catch (error) {
-            // Fallback to uncompressed
-            return data;
-        }
-    }
-    /**
-     * Compress with gzip
-     */
-    compressGzip(data, level) {
-        return new Promise((resolve, reject) => {
-            zlib.gzip(data, { level }, (err, result) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(result);
-            });
-        });
-    }
-    /**
-     * Compress with brotli
-     */
-    compressBrotli(data, level) {
-        return new Promise((resolve, reject) => {
-            zlib.brotliCompress(data, {
-                params: {
-                    [zlib.constants.BROTLI_PARAM_QUALITY]: level
-                }
-            }, (err, result) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(result);
-            });
-        });
-    }
-    /**
-     * Compress with deflate
-     */
-    compressDeflate(data, level) {
-        return new Promise((resolve, reject) => {
-            zlib.deflate(data, { level }, (err, result) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(result);
-            });
-        });
-    }
-    /**
-     * Get current compression level
-     */
-    getCurrentLevel() {
-        const levels = COMPRESSION_LEVELS[this.config.algorithm];
-        return levels[this.currentLevelIndex] || levels[1];
-    }
-    /**
-     * Adjust compression level based on CPU
-     */
-    adjustLevel(cpuUsage) {
-        const levels = COMPRESSION_LEVELS[this.config.algorithm];
-        const oldIndex = this.currentLevelIndex;
-        if (cpuUsage > this.config.cpuThresholdHigh && this.currentLevelIndex > 0) {
-            // CPU high, reduce compression level
-            this.currentLevelIndex--;
-            this.stats.cpuAdjustments++;
-        }
-        else if (cpuUsage < this.config.cpuThresholdLow && this.currentLevelIndex < levels.length - 1) {
-            // CPU low, increase compression level
-            this.currentLevelIndex++;
-            this.stats.cpuAdjustments++;
-        }
-        if (oldIndex !== this.currentLevelIndex) {
-            this.stats.levelChanges++;
-            this.stats.currentLevel = this.getCurrentLevel().level;
-        }
-    }
-    /**
-     * Start CPU monitoring
-     */
-    startCPUMonitoring() {
-        this.monitorInterval = setInterval(() => {
-            const cpuUsage = this.getCPUUsage();
-            this.cpuSamples.push(cpuUsage);
-            // Keep last 10 samples
-            if (this.cpuSamples.length > 10) {
-                this.cpuSamples.shift();
-            }
-            // Calculate average CPU
-            const avgCPU = this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length;
-            // Adjust compression level
-            this.adjustLevel(avgCPU);
-        }, this.config.checkInterval);
-    }
-    /**
-     * Get CPU usage percentage
-     */
-    getCPUUsage() {
-        const cpus = require('os').cpus();
-        let totalIdle = 0;
-        let totalTick = 0;
-        for (const cpu of cpus) {
-            for (const type in cpu.times) {
-                totalTick += cpu.times[type];
-            }
-            totalIdle += cpu.times.idle;
-        }
-        const idle = totalIdle / cpus.length;
-        const total = totalTick / cpus.length;
-        const usage = 100 - ~~(100 * idle / total);
-        return Math.max(0, Math.min(100, usage));
-    }
-    /**
-     * Update statistics
-     */
-    updateStats(originalSize, compressedSize, time) {
-        this.stats.totalBytes += originalSize;
-        this.stats.compressedBytes += compressedSize;
-        this.stats.compressionRatio = this.stats.totalBytes / this.stats.compressedBytes;
-        // Update average compression time
-        const totalCompressions = this.stats.totalBytes / (originalSize || 1);
-        this.stats.avgCompressionTime =
-            (this.stats.avgCompressionTime * (totalCompressions - 1) + time) / totalCompressions;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        const level = this.getCurrentLevel();
-        const avgCPU = this.cpuSamples.length > 0
-            ? this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length
-            : 0;
-        return {
-            ...this.stats,
-            currentLevelName: level.name,
-            cpuUsage: avgCPU
-        };
-    }
-    /**
-     * Get compression savings
-     */
-    getSavings() {
-        const byteSavings = this.stats.totalBytes - this.stats.compressedBytes;
-        const percentSavings = (byteSavings / this.stats.totalBytes) * 100;
-        const mbSaved = byteSavings / (1024 * 1024);
-        return {
-            byteSavings,
-            percentSavings,
-            mbSaved
-        };
-    }
-    /**
-     * Manually set compression level
-     */
-    setLevel(levelName) {
-        const levels = COMPRESSION_LEVELS[this.config.algorithm];
-        const index = levels.findIndex(l => l.name === levelName);
-        if (index !== -1) {
-            this.currentLevelIndex = index;
-            this.stats.currentLevel = levels[index].level;
-            this.stats.levelChanges++;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            totalBytes: 0,
-            compressedBytes: 0,
-            compressionRatio: 1,
-            avgCompressionTime: 0,
-            currentLevel: this.getCurrentLevel().level,
-            levelChanges: 0,
-            cpuAdjustments: 0
-        };
-    }
-    /**
-     * Stop CPU monitoring
-     */
-    destroy() {
-        if (this.monitorInterval) {
-            clearInterval(this.monitorInterval);
-        }
-    }
-}
-/**
- * Content-type aware compression
- */
-export function shouldCompress(contentType, size, minSize = 1024) {
-    if (size < minSize) {
-        return false;
-    }
-    const compressibleTypes = [
-        'text/',
-        'application/json',
-        'application/javascript',
-        'application/xml',
-        'application/x-www-form-urlencoded'
-    ];
-    return compressibleTypes.some(type => contentType.startsWith(type));
-}
-/**
- * Calculate compression efficiency
- */
-export function calculateCompressionEfficiency(stats) {
-    const timePerMB = stats.avgCompressionTime / ((stats.totalBytes / (1024 * 1024)) || 1);
-    const ratioScore = Math.min(100, (stats.compressionRatio - 1) * 10);
-    const efficiency = (ratioScore * 0.7) + ((100 - Math.min(100, timePerMB)) * 0.3);
-    return {
-        efficiency,
-        timePerMB,
-        ratioScore
-    };
-}

package/dist/utils/http2-multiplexing.js

@@ -1,319 +0,0 @@
-/**
- * HTTP/2 Multiplexing Optimization
- * Stream prioritization and flow control for concurrent request optimization
- * Phase 2 Optimization
- */
-/**
- * HTTP/2 Multiplexing Manager
- * Manages stream prioritization and concurrent request handling
- */
-export class HTTP2MultiplexingManager {
-    config;
-    activeStreams = new Map();
-    priorityQueues = new Map();
-    stats;
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            maxConcurrentStreams: config.maxConcurrentStreams || 100,
-            defaultPriority: config.defaultPriority || 16,
-            enableFlowControl: config.enableFlowControl !== false,
-            initialWindowSize: config.initialWindowSize || 65535
-        };
-        this.stats = {
-            totalStreams: 0,
-            activeStreams: 0,
-            completedStreams: 0,
-            averageDuration: 0,
-            priorityChanges: 0
-        };
-        this.initializePriorityQueues();
-    }
-    /**
-     * Initialize priority queues (1-256)
-     */
-    initializePriorityQueues() {
-        for (let i = 1; i <= 256; i++) {
-            this.priorityQueues.set(i, new Set());
-        }
-    }
-    /**
-     * Register a new stream
-     */
-    registerStream(stream, priority) {
-        if (!this.config.enabled)
-            return;
-        const streamId = stream.id || 0;
-        const streamPriority = priority?.weight || this.config.defaultPriority;
-        const info = {
-            stream,
-            priority: streamPriority,
-            bytesReceived: 0,
-            bytesSent: 0,
-            startTime: Date.now(),
-            state: 'open'
-        };
-        this.activeStreams.set(streamId, info);
-        this.priorityQueues.get(streamPriority)?.add(streamId);
-        this.stats.totalStreams++;
-        this.stats.activeStreams++;
-        // Set stream priority
-        if (priority) {
-            this.setPriority(stream, priority);
-        }
-        // Setup event handlers
-        this.setupStreamHandlers(stream, streamId);
-    }
-    /**
-     * Set stream priority
-     */
-    setPriority(stream, priority) {
-        try {
-            stream.priority(priority);
-            const streamId = stream.id || 0;
-            const info = this.activeStreams.get(streamId);
-            if (info) {
-                // Move to new priority queue
-                const oldPriority = info.priority;
-                const newPriority = priority.weight;
-                this.priorityQueues.get(oldPriority)?.delete(streamId);
-                info.priority = newPriority;
-                this.priorityQueues.get(newPriority)?.add(streamId);
-                this.stats.priorityChanges++;
-            }
-        }
-        catch (error) {
-            // Stream may be closed
-        }
-    }
-    /**
-     * Adjust stream priority based on load
-     */
-    adjustPriority(streamId, adjustment) {
-        const info = this.activeStreams.get(streamId);
-        if (!info)
-            return;
-        const newPriority = Math.max(1, Math.min(256, info.priority + adjustment));
-        this.setPriority(info.stream, {
-            weight: newPriority,
-            exclusive: false
-        });
-    }
-    /**
-     * Get next stream to process based on priority
-     */
-    getNextStream() {
-        // Process highest priority streams first (256 is highest)
-        for (let priority = 256; priority >= 1; priority--) {
-            const queue = this.priorityQueues.get(priority);
-            if (queue && queue.size > 0) {
-                const streamId = queue.values().next().value;
-                if (streamId !== undefined) {
-                    const info = this.activeStreams.get(streamId);
-                    if (info && info.state === 'open') {
-                        return info.stream;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Setup stream event handlers
-     */
-    setupStreamHandlers(stream, streamId) {
-        stream.on('data', (chunk) => {
-            const info = this.activeStreams.get(streamId);
-            if (info) {
-                info.bytesReceived += chunk.length;
-            }
-        });
-        stream.on('end', () => {
-            this.updateStreamState(streamId, 'half-closed');
-        });
-        stream.on('close', () => {
-            this.handleStreamClose(streamId);
-        });
-        stream.on('error', () => {
-            this.handleStreamClose(streamId);
-        });
-    }
-    /**
-     * Update stream state
-     */
-    updateStreamState(streamId, state) {
-        const info = this.activeStreams.get(streamId);
-        if (info) {
-            info.state = state;
-        }
-    }
-    /**
-     * Handle stream closure
-     */
-    handleStreamClose(streamId) {
-        const info = this.activeStreams.get(streamId);
-        if (!info)
-            return;
-        // Remove from priority queue
-        this.priorityQueues.get(info.priority)?.delete(streamId);
-        // Update statistics
-        const duration = Date.now() - info.startTime;
-        this.updateStats(duration);
-        // Remove from active streams
-        this.activeStreams.delete(streamId);
-        this.stats.activeStreams--;
-        this.stats.completedStreams++;
-    }
-    /**
-     * Update statistics
-     */
-    updateStats(duration) {
-        const currentAvg = this.stats.averageDuration;
-        const total = this.stats.completedStreams;
-        this.stats.averageDuration = (currentAvg * (total - 1) + duration) / total;
-    }
-    /**
-     * Get stream statistics
-     */
-    getStreamStats(streamId) {
-        const info = this.activeStreams.get(streamId);
-        if (!info)
-            return null;
-        return {
-            streamId,
-            priority: info.priority,
-            bytesReceived: info.bytesReceived,
-            bytesSent: info.bytesSent,
-            duration: Date.now() - info.startTime,
-            state: info.state
-        };
-    }
-    /**
-     * Get all statistics
-     */
-    getStats() {
-        const priorityDistribution = new Map();
-        for (const [priority, queue] of this.priorityQueues) {
-            if (queue.size > 0) {
-                priorityDistribution.set(priority, queue.size);
-            }
-        }
-        return {
-            ...this.stats,
-            priorityDistribution
-        };
-    }
-    /**
-     * Check if can accept more streams
-     */
-    canAcceptStream() {
-        return this.stats.activeStreams < this.config.maxConcurrentStreams;
-    }
-    /**
-     * Get load percentage
-     */
-    getLoad() {
-        return (this.stats.activeStreams / this.config.maxConcurrentStreams) * 100;
-    }
-}
-/**
- * Flow Control Manager
- * Manages HTTP/2 flow control for optimal throughput
- */
-export class FlowControlManager {
-    windowSizes = new Map();
-    config;
-    constructor(config) {
-        this.config = {
-            initialWindowSize: config?.initialWindowSize || 65535,
-            maxWindowSize: config?.maxWindowSize || 16777215, // 16MB
-            minWindowSize: config?.minWindowSize || 16384 // 16KB
-        };
-    }
-    /**
-     * Initialize window size for a stream
-     */
-    initializeWindow(streamId) {
-        this.windowSizes.set(streamId, this.config.initialWindowSize);
-    }
-    /**
-     * Update window size
-     */
-    updateWindow(streamId, delta) {
-        const current = this.windowSizes.get(streamId) || this.config.initialWindowSize;
-        const newSize = Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, current + delta));
-        this.windowSizes.set(streamId, newSize);
-        return newSize;
-    }
-    /**
-     * Get current window size
-     */
-    getWindowSize(streamId) {
-        return this.windowSizes.get(streamId) || this.config.initialWindowSize;
-    }
-    /**
-     * Calculate optimal window size based on throughput
-     */
-    calculateOptimalWindow(throughputBps, rttMs) {
-        // Bandwidth-Delay Product
-        const bdp = (throughputBps / 8) * (rttMs / 1000);
-        return Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, Math.ceil(bdp * 2)));
-    }
-    /**
-     * Clean up closed stream
-     */
-    cleanup(streamId) {
-        this.windowSizes.delete(streamId);
-    }
-}
-/**
- * Priority scheduler for optimal stream processing
- */
-export class PriorityScheduler {
-    queues = new Map();
-    /**
-     * Add stream to priority queue
-     */
-    enqueue(streamId, priority) {
-        if (!this.queues.has(priority)) {
-            this.queues.set(priority, []);
-        }
-        this.queues.get(priority).push(streamId);
-    }
-    /**
-     * Get next stream to process
-     */
-    dequeue() {
-        // Process highest priority first
-        for (let priority = 256; priority >= 1; priority--) {
-            const queue = this.queues.get(priority);
-            if (queue && queue.length > 0) {
-                return queue.shift();
-            }
-        }
-        return null;
-    }
-    /**
-     * Remove stream from all queues
-     */
-    remove(streamId) {
-        for (const queue of this.queues.values()) {
-            const index = queue.indexOf(streamId);
-            if (index !== -1) {
-                queue.splice(index, 1);
-            }
-        }
-    }
-    /**
-     * Get queue sizes
-     */
-    getStats() {
-        const stats = new Map();
-        for (const [priority, queue] of this.queues) {
-            if (queue.length > 0) {
-                stats.set(priority, queue.length);
-            }
-        }
-        return stats;
-    }
-}