agentic-flow 2.0.2 → 2.0.4

package/dist/utils/circular-rate-limiter.js

@@ -1,391 +0,0 @@
-/**
- * Optimized Rate Limiter with Circular Buffers
- * 2-5% CPU reduction through efficient circular buffer implementation
- * Phase 3 Optimization
- */
-/**
- * Circular Buffer for efficient timestamp storage
- * Avoids array shifts and allocations
- */
-class CircularBuffer {
-    buffer;
-    head = 0;
-    tail = 0;
-    count = 0;
-    size;
-    constructor(size) {
-        this.size = size;
-        this.buffer = new Array(size);
-    }
-    /**
-     * Add timestamp to buffer
-     */
-    add(timestamp) {
-        this.buffer[this.tail] = timestamp;
-        this.tail = (this.tail + 1) % this.size;
-        if (this.count < this.size) {
-            this.count++;
-        }
-        else {
-            // Buffer is full, move head forward
-            this.head = (this.head + 1) % this.size;
-        }
-    }
-    /**
-     * Remove timestamps older than cutoff
-     */
-    removeOlderThan(cutoff) {
-        let removed = 0;
-        while (this.count > 0) {
-            const timestamp = this.buffer[this.head];
-            if (timestamp >= cutoff) {
-                break;
-            }
-            this.head = (this.head + 1) % this.size;
-            this.count--;
-            removed++;
-        }
-        return removed;
-    }
-    /**
-     * Get current count
-     */
-    getCount() {
-        return this.count;
-    }
-    /**
-     * Get oldest timestamp
-     */
-    getOldest() {
-        return this.count > 0 ? this.buffer[this.head] : null;
-    }
-    /**
-     * Clear buffer
-     */
-    clear() {
-        this.head = 0;
-        this.tail = 0;
-        this.count = 0;
-    }
-    /**
-     * Check if buffer is full
-     */
-    isFull() {
-        return this.count === this.size;
-    }
-    /**
-     * Get buffer utilization
-     */
-    getUtilization() {
-        return (this.count / this.size) * 100;
-    }
-}
-/**
- * Circular Rate Limiter
- * Uses circular buffers for efficient rate limiting with minimal CPU overhead
- */
-export class CircularRateLimiter {
-    config;
-    clients = new Map();
-    stats;
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            windowMs: config.windowMs || 60000, // 1 minute default
-            maxRequests: config.maxRequests || 100,
-            bufferSize: config.bufferSize || 200 // 2x maxRequests for safety
-        };
-        this.stats = {
-            totalRequests: 0,
-            allowedRequests: 0,
-            blockedRequests: 0,
-            uniqueClients: 0,
-            avgCheckTime: 0
-        };
-    }
-    /**
-     * Check if request is allowed
-     */
-    checkLimit(clientId) {
-        if (!this.config.enabled) {
-            return {
-                allowed: true,
-                remaining: this.config.maxRequests,
-                resetAt: Date.now() + this.config.windowMs
-            };
-        }
-        const startTime = performance.now();
-        const now = Date.now();
-        const windowStart = now - this.config.windowMs;
-        // Get or create buffer for client
-        let buffer = this.clients.get(clientId);
-        if (!buffer) {
-            buffer = new CircularBuffer(this.config.bufferSize);
-            this.clients.set(clientId, buffer);
-            this.stats.uniqueClients = this.clients.size;
-        }
-        // Remove expired timestamps
-        buffer.removeOlderThan(windowStart);
-        const currentCount = buffer.getCount();
-        const allowed = currentCount < this.config.maxRequests;
-        if (allowed) {
-            buffer.add(now);
-            this.stats.allowedRequests++;
-        }
-        else {
-            this.stats.blockedRequests++;
-        }
-        this.stats.totalRequests++;
-        // Update average check time
-        const checkTime = performance.now() - startTime;
-        this.updateAvgCheckTime(checkTime);
-        const oldest = buffer.getOldest();
-        const resetAt = oldest ? oldest + this.config.windowMs : now + this.config.windowMs;
-        const retryAfter = allowed ? undefined : resetAt - now;
-        return {
-            allowed,
-            remaining: Math.max(0, this.config.maxRequests - currentCount - (allowed ? 1 : 0)),
-            resetAt,
-            retryAfter
-        };
-    }
-    /**
-     * Update average check time
-     */
-    updateAvgCheckTime(newTime) {
-        const total = this.stats.totalRequests;
-        const currentAvg = this.stats.avgCheckTime;
-        this.stats.avgCheckTime = (currentAvg * (total - 1) + newTime) / total;
-    }
-    /**
-     * Reset limit for a client
-     */
-    reset(clientId) {
-        const buffer = this.clients.get(clientId);
-        if (buffer) {
-            buffer.clear();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Remove a client
-     */
-    removeClient(clientId) {
-        const removed = this.clients.delete(clientId);
-        if (removed) {
-            this.stats.uniqueClients = this.clients.size;
-        }
-        return removed;
-    }
-    /**
-     * Clean up expired clients
-     */
-    cleanup() {
-        const now = Date.now();
-        const windowStart = now - this.config.windowMs;
-        let cleaned = 0;
-        for (const [clientId, buffer] of this.clients) {
-            buffer.removeOlderThan(windowStart);
-            // Remove clients with no recent activity
-            if (buffer.getCount() === 0) {
-                this.clients.delete(clientId);
-                cleaned++;
-            }
-        }
-        this.stats.uniqueClients = this.clients.size;
-        return cleaned;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Get block rate
-     */
-    getBlockRate() {
-        return this.stats.totalRequests > 0
-            ? (this.stats.blockedRequests / this.stats.totalRequests) * 100
-            : 0;
-    }
-    /**
-     * Get client info
-     */
-    getClientInfo(clientId) {
-        const buffer = this.clients.get(clientId);
-        if (!buffer) {
-            return null;
-        }
-        return {
-            count: buffer.getCount(),
-            utilization: buffer.getUtilization(),
-            oldest: buffer.getOldest()
-        };
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            totalRequests: 0,
-            allowedRequests: 0,
-            blockedRequests: 0,
-            uniqueClients: this.clients.size,
-            avgCheckTime: 0
-        };
-    }
-    /**
-     * Clear all clients
-     */
-    clear() {
-        this.clients.clear();
-        this.stats.uniqueClients = 0;
-    }
-    /**
-     * Get configuration (for subclasses)
-     */
-    getConfig() {
-        return this.config;
-    }
-}
-/**
- * Sliding Window Rate Limiter
- * More accurate than fixed window, uses circular buffers
- */
-export class SlidingWindowRateLimiter extends CircularRateLimiter {
-    /**
-     * Check with sliding window algorithm
-     */
-    checkLimitSliding(clientId) {
-        const result = this.checkLimit(clientId);
-        // Sliding window provides more accurate rate limiting
-        // by continuously cleaning up old timestamps
-        const clientInfo = this.getClientInfo(clientId);
-        if (clientInfo && clientInfo.oldest) {
-            const now = Date.now();
-            const config = this.getConfig();
-            const windowStart = now - config.windowMs;
-            // More accurate remaining calculation
-            const timeInWindow = now - Math.max(clientInfo.oldest, windowStart);
-            const weightedCount = (clientInfo.count * timeInWindow) / config.windowMs;
-            result.remaining = Math.max(0, Math.floor(config.maxRequests - weightedCount));
-        }
-        return result;
-    }
-}
-/**
- * Token Bucket Rate Limiter
- * Allows burst traffic while maintaining average rate
- */
-export class TokenBucketRateLimiter {
-    config;
-    buckets = new Map();
-    stats;
-    constructor(config) {
-        this.config = {
-            capacity: config.capacity,
-            refillRate: config.refillRate,
-            refillInterval: config.refillInterval || 1000
-        };
-        this.stats = {
-            totalRequests: 0,
-            allowedRequests: 0,
-            blockedRequests: 0,
-            uniqueClients: 0,
-            avgCheckTime: 0
-        };
-    }
-    /**
-     * Check if tokens available
-     */
-    checkLimit(clientId, tokens = 1) {
-        let bucket = this.buckets.get(clientId);
-        if (!bucket) {
-            bucket = new TokenBucket(this.config.capacity, this.config.refillRate, this.config.refillInterval);
-            this.buckets.set(clientId, bucket);
-            this.stats.uniqueClients = this.buckets.size;
-        }
-        const allowed = bucket.consume(tokens);
-        this.stats.totalRequests++;
-        if (allowed) {
-            this.stats.allowedRequests++;
-        }
-        else {
-            this.stats.blockedRequests++;
-        }
-        return {
-            allowed,
-            remaining: Math.floor(bucket.getTokens()),
-            resetAt: Date.now() + this.config.refillInterval
-        };
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-}
-/**
- * Token Bucket implementation
- */
-class TokenBucket {
-    tokens;
-    capacity;
-    refillRate;
-    lastRefill;
-    refillInterval;
-    constructor(capacity, refillRate, refillInterval) {
-        this.capacity = capacity;
-        this.tokens = capacity;
-        this.refillRate = refillRate;
-        this.refillInterval = refillInterval;
-        this.lastRefill = Date.now();
-    }
-    /**
-     * Consume tokens
-     */
-    consume(tokens) {
-        this.refill();
-        if (this.tokens >= tokens) {
-            this.tokens -= tokens;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Refill tokens
-     */
-    refill() {
-        const now = Date.now();
-        const elapsed = now - this.lastRefill;
-        const intervals = Math.floor(elapsed / this.refillInterval);
-        if (intervals > 0) {
-            this.tokens = Math.min(this.capacity, this.tokens + intervals * this.refillRate);
-            this.lastRefill = now;
-        }
-    }
-    /**
-     * Get current tokens
-     */
-    getTokens() {
-        this.refill();
-        return this.tokens;
-    }
-}
-/**
- * Calculate CPU savings from circular buffer optimization
- */
-export function calculateRateLimiterSavings(oldAvgTime, newAvgTime, totalRequests) {
-    const savings = oldAvgTime - newAvgTime;
-    const savingsPercentage = (savings / oldAvgTime) * 100;
-    const totalTimeSaved = savings * totalRequests;
-    const cpuReduction = savingsPercentage;
-    return {
-        savingsPercentage,
-        totalTimeSaved,
-        cpuReduction
-    };
-}

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
-    };
-}