agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/utils/server-push.js

@@ -1,251 +0,0 @@
-/**
- * HTTP/2 Server Push Implementation
- * Predictively pushes related resources to reduce latency
- * Phase 2 Optimization
- */
-/**
- * Server Push Manager
- * Manages HTTP/2 server push for predictive resource delivery
- */
-export class ServerPushManager {
-    config;
-    pushRules;
-    pushStats;
-    activePushes = 0;
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            maxConcurrentPushes: config.maxConcurrentPushes || 5,
-            pushDelay: config.pushDelay || 0,
-            intelligentPrediction: config.intelligentPrediction !== false
-        };
-        this.pushRules = new Map();
-        this.pushStats = new Map();
-    }
-    /**
-     * Register a push rule
-     */
-    registerRule(id, rule) {
-        this.pushRules.set(id, rule);
-    }
-    /**
-     * Unregister a push rule
-     */
-    unregisterRule(id) {
-        this.pushRules.delete(id);
-    }
-    /**
-     * Perform server push for a stream
-     */
-    async push(stream, path, headers) {
-        if (!this.config.enabled)
-            return;
-        if (this.activePushes >= this.config.maxConcurrentPushes)
-            return;
-        // Find matching rules
-        const matchingRules = this.findMatchingRules(path, headers);
-        for (const rule of matchingRules) {
-            for (const resource of rule.resources) {
-                await this.pushResource(stream, resource);
-            }
-        }
-    }
-    /**
-     * Push a single resource
-     */
-    async pushResource(stream, resource) {
-        if (this.activePushes >= this.config.maxConcurrentPushes)
-            return;
-        return new Promise((resolve, reject) => {
-            this.activePushes++;
-            const pushHeaders = {
-                ':path': resource.path,
-                ...resource.headers
-            };
-            try {
-                stream.pushStream(pushHeaders, (err, pushStream) => {
-                    if (err) {
-                        this.activePushes--;
-                        reject(err);
-                        return;
-                    }
-                    // Set priority if specified
-                    if (resource.priority !== undefined) {
-                        pushStream.priority({
-                            weight: resource.priority,
-                            exclusive: false
-                        });
-                    }
-                    pushStream.on('finish', () => {
-                        this.activePushes--;
-                        this.recordPush(resource.path);
-                    });
-                    pushStream.on('error', () => {
-                        this.activePushes--;
-                    });
-                    // Write the resource (in real implementation, fetch from cache/disk)
-                    pushStream.respond({
-                        ':status': 200,
-                        'content-type': this.getContentType(resource.path)
-                    });
-                    pushStream.end();
-                    resolve();
-                });
-            }
-            catch (error) {
-                this.activePushes--;
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Find rules matching the current request
-     */
-    findMatchingRules(path, headers) {
-        const matches = [];
-        for (const [, rule] of this.pushRules) {
-            // Check trigger match
-            const triggerMatch = typeof rule.trigger === 'string'
-                ? path.includes(rule.trigger)
-                : rule.trigger.test(path);
-            if (!triggerMatch)
-                continue;
-            // Check condition if present
-            if (rule.condition && !rule.condition(headers))
-                continue;
-            matches.push(rule);
-        }
-        return matches;
-    }
-    /**
-     * Record push statistics
-     */
-    recordPush(path) {
-        const count = this.pushStats.get(path) || 0;
-        this.pushStats.set(path, count + 1);
-    }
-    /**
-     * Get content type for a path
-     */
-    getContentType(path) {
-        const ext = path.split('.').pop()?.toLowerCase();
-        const types = {
-            'js': 'application/javascript',
-            'css': 'text/css',
-            'json': 'application/json',
-            'png': 'image/png',
-            'jpg': 'image/jpeg',
-            'jpeg': 'image/jpeg',
-            'gif': 'image/gif',
-            'svg': 'image/svg+xml',
-            'html': 'text/html',
-            'txt': 'text/plain'
-        };
-        return types[ext || ''] || 'application/octet-stream';
-    }
-    /**
-     * Get push statistics
-     */
-    getStats() {
-        return {
-            activePushes: this.activePushes,
-            totalPushes: Array.from(this.pushStats.values()).reduce((a, b) => a + b, 0),
-            pushCounts: new Map(this.pushStats)
-        };
-    }
-    /**
-     * Clear statistics
-     */
-    clearStats() {
-        this.pushStats.clear();
-    }
-}
-/**
- * Predefined push rules for common patterns
- */
-export const CommonPushRules = {
-    /**
-     * Push API schema when main API endpoint is accessed
-     */
-    apiSchema: {
-        trigger: /^\/api\/v1\//,
-        resources: [
-            { path: '/api/v1/schema.json', priority: 10 }
-        ]
-    },
-    /**
-     * Push authentication assets
-     */
-    authAssets: {
-        trigger: '/auth',
-        resources: [
-            { path: '/auth/login.js', priority: 15 },
-            { path: '/auth/styles.css', priority: 10 }
-        ]
-    }
-};
-/**
- * Intelligent push predictor
- * Learns from access patterns to predict what to push
- */
-export class IntelligentPushPredictor {
-    accessPatterns = new Map();
-    confidence = new Map();
-    /**
-     * Record an access pattern
-     */
-    recordAccess(primary, secondary) {
-        // Record that secondary was accessed after primary
-        if (!this.accessPatterns.has(primary)) {
-            this.accessPatterns.set(primary, new Set());
-        }
-        this.accessPatterns.get(primary).add(secondary);
-        // Update confidence scores
-        if (!this.confidence.has(primary)) {
-            this.confidence.set(primary, new Map());
-        }
-        const scores = this.confidence.get(primary);
-        scores.set(secondary, (scores.get(secondary) || 0) + 1);
-    }
-    /**
-     * Predict resources to push based on confidence
-     */
-    predict(path, minConfidence = 0.7) {
-        const patterns = this.accessPatterns.get(path);
-        if (!patterns)
-            return [];
-        const scores = this.confidence.get(path);
-        if (!scores)
-            return [];
-        const total = Array.from(scores.values()).reduce((a, b) => a + b, 0);
-        const predictions = [];
-        for (const [resource, count] of scores) {
-            const confidence = count / total;
-            if (confidence >= minConfidence) {
-                predictions.push({
-                    path: resource,
-                    priority: Math.round(confidence * 20) // 0-20 priority based on confidence
-                });
-            }
-        }
-        return predictions.sort((a, b) => (b.priority || 0) - (a.priority || 0));
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        let totalConfidence = 0;
-        let count = 0;
-        for (const scores of this.confidence.values()) {
-            const total = Array.from(scores.values()).reduce((a, b) => a + b, 0);
-            for (const score of scores.values()) {
-                totalConfidence += score / total;
-                count++;
-            }
-        }
-        return {
-            totalPatterns: this.accessPatterns.size,
-            averageConfidence: count > 0 ? totalConfidence / count : 0
-        };
-    }
-}

package/dist/utils/streaming-optimizer.d.ts

@@ -1,37 +0,0 @@
-/**
- * Streaming Optimization with Backpressure Handling
- * Provides 15-25% improvement for streaming requests
- */
-import { Readable, Writable } from 'stream';
-export interface StreamOptions {
-    highWaterMark?: number;
-    enableBackpressure?: boolean;
-    bufferSize?: number;
-    timeout?: number;
-}
-export declare class StreamOptimizer {
-    private options;
-    constructor(options?: StreamOptions);
-    /**
-     * Optimized streaming with backpressure handling
-     */
-    streamResponse(sourceStream: Readable, targetStream: Writable): Promise<void>;
-    /**
-     * Optimized chunked streaming for SSE (Server-Sent Events)
-     */
-    streamChunked(sourceStream: Readable, targetStream: Writable, transformer?: (chunk: Buffer) => Buffer): Promise<void>;
-    private flushChunks;
-    /**
-     * Memory-efficient pipe with monitoring
-     */
-    pipeWithMonitoring(sourceStream: Readable, targetStream: Writable, onProgress?: (stats: StreamStats) => void): Promise<StreamStats>;
-}
-export interface StreamStats {
-    bytesProcessed: number;
-    chunks: number;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    throughput: number;
-}
-//# sourceMappingURL=streaming-optimizer.d.ts.map

package/dist/utils/suppress-warnings.d.ts

@@ -1,19 +0,0 @@
-/**
- * Warning Suppression Utilities
- *
- * Suppresses noisy warnings like ExperimentalWarning for WASM imports
- * while preserving important warnings.
- */
-/**
- * Suppress experimental warnings for WASM module imports
- */
-export declare function suppressExperimentalWarnings(): void;
-/**
- * Run a function with warnings suppressed
- */
-export declare function withSuppressedWarnings<T>(fn: () => Promise<T>): Promise<T>;
-/**
- * Import a module with experimental warnings suppressed
- */
-export declare function quietImport<T>(modulePath: string): Promise<T>;
-//# sourceMappingURL=suppress-warnings.d.ts.map

package/dist/utils/suppress-warnings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suppress-warnings.d.ts","sourceRoot":"","sources":["../../src/utils/suppress-warnings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAmCnD;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGhF;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAGnE"}

package/dist/utils/suppress-warnings.js

@@ -1,59 +0,0 @@
-/**
- * Warning Suppression Utilities
- *
- * Suppresses noisy warnings like ExperimentalWarning for WASM imports
- * while preserving important warnings.
- */
-let warningsSetup = false;
-/**
- * Suppress experimental warnings for WASM module imports
- */
-export function suppressExperimentalWarnings() {
-    if (warningsSetup)
-        return;
-    warningsSetup = true;
-    const originalEmit = process.emit.bind(process);
-    // @ts-ignore - Override emit to filter warnings
-    process.emit = function (event, ...args) {
-        if (event === 'warning') {
-            const warning = args[0];
-            if (warning && typeof warning === 'object') {
-                const name = warning.name;
-                const message = warning.message || '';
-                // Suppress ExperimentalWarning for import assertions/attributes
-                if (name === 'ExperimentalWarning') {
-                    if (message.includes('Import') ||
-                        message.includes('import.meta') ||
-                        message.includes('--experimental')) {
-                        return false;
-                    }
-                }
-                // Suppress noisy deprecation warnings from dependencies
-                if (name === 'DeprecationWarning') {
-                    if (message.includes('punycode') ||
-                        message.includes('Buffer()')) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return originalEmit(event, ...args);
-    };
-}
-/**
- * Run a function with warnings suppressed
- */
-export async function withSuppressedWarnings(fn) {
-    suppressExperimentalWarnings();
-    return fn();
-}
-/**
- * Import a module with experimental warnings suppressed
- */
-export async function quietImport(modulePath) {
-    suppressExperimentalWarnings();
-    return import(modulePath);
-}
-// Auto-setup on module load
-suppressExperimentalWarnings();
-//# sourceMappingURL=suppress-warnings.js.map

package/dist/utils/suppress-warnings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"suppress-warnings.js","sourceRoot":"","sources":["../../src/utils/suppress-warnings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,IAAI,aAAa,GAAG,KAAK,CAAC;AAE1B;;GAEG;AACH,MAAM,UAAU,4BAA4B;IAC1C,IAAI,aAAa;QAAE,OAAO;IAC1B,aAAa,GAAG,IAAI,CAAC;IAErB,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAEhD,gDAAgD;IAChD,OAAO,CAAC,IAAI,GAAG,UAAU,KAAa,EAAE,GAAG,IAAW;QACpD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC3C,MAAM,IAAI,GAAI,OAAe,CAAC,IAAI,CAAC;gBACnC,MAAM,OAAO,GAAI,OAAe,CAAC,OAAO,IAAI,EAAE,CAAC;gBAE/C,gEAAgE;gBAChE,IAAI,IAAI,KAAK,qBAAqB,EAAE,CAAC;oBACnC,IAAI,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;wBAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;wBAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;wBACvC,OAAO,KAAK,CAAC;oBACf,CAAC;gBACH,CAAC;gBAED,wDAAwD;gBACxD,IAAI,IAAI,KAAK,oBAAoB,EAAE,CAAC;oBAClC,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC;wBAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;wBACjC,OAAO,KAAK,CAAC;oBACf,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,YAAY,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAI,EAAoB;IAClE,4BAA4B,EAAE,CAAC;IAC/B,OAAO,EAAE,EAAE,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAI,UAAkB;IACrD,4BAA4B,EAAE,CAAC;IAC/B,OAAO,MAAM,CAAC,UAAU,CAAe,CAAC;AAC1C,CAAC;AAED,4BAA4B;AAC5B,4BAA4B,EAAE,CAAC","sourcesContent":["/**\n * Warning Suppression Utilities\n *\n * Suppresses noisy warnings like ExperimentalWarning for WASM imports\n * while preserving important warnings.\n */\n\nlet warningsSetup = false;\n\n/**\n * Suppress experimental warnings for WASM module imports\n */\nexport function suppressExperimentalWarnings(): void {\n  if (warningsSetup) return;\n  warningsSetup = true;\n\n  const originalEmit = process.emit.bind(process);\n\n  // @ts-ignore - Override emit to filter warnings\n  process.emit = function (event: string, ...args: any[]): boolean {\n    if (event === 'warning') {\n      const warning = args[0];\n      if (warning && typeof warning === 'object') {\n        const name = (warning as any).name;\n        const message = (warning as any).message || '';\n\n        // Suppress ExperimentalWarning for import assertions/attributes\n        if (name === 'ExperimentalWarning') {\n          if (message.includes('Import') ||\n              message.includes('import.meta') ||\n              message.includes('--experimental')) {\n            return false;\n          }\n        }\n\n        // Suppress noisy deprecation warnings from dependencies\n        if (name === 'DeprecationWarning') {\n          if (message.includes('punycode') ||\n              message.includes('Buffer()')) {\n            return false;\n          }\n        }\n      }\n    }\n\n    return originalEmit(event, ...args);\n  };\n}\n\n/**\n * Run a function with warnings suppressed\n */\nexport async function withSuppressedWarnings<T>(fn: () => Promise<T>): Promise<T> {\n  suppressExperimentalWarnings();\n  return fn();\n}\n\n/**\n * Import a module with experimental warnings suppressed\n */\nexport async function quietImport<T>(modulePath: string): Promise<T> {\n  suppressExperimentalWarnings();\n  return import(modulePath) as Promise<T>;\n}\n\n// Auto-setup on module load\nsuppressExperimentalWarnings();\n"]}

package/dist/utils/zero-copy-buffer.js

@@ -1,286 +0,0 @@
-/**
- * Zero-Copy Buffer Implementation
- * Direct memory access without intermediate copies for 10-15% memory/CPU reduction
- * Phase 2 Optimization
- */
-import { Buffer } from 'buffer';
-/**
- * Zero-Copy Buffer Pool
- * Manages reusable buffers to avoid allocations and copies
- */
-export class ZeroCopyBufferPool {
-    config;
-    availableBuffers = [];
-    inUseBuffers = new Set();
-    stats = {
-        allocated: 0,
-        reused: 0,
-        copiesAvoided: 0,
-        memorySaved: 0
-    };
-    constructor(config) {
-        this.config = {
-            enabled: config.enabled,
-            poolSize: config.poolSize || 100,
-            bufferSize: config.bufferSize || 64 * 1024, // 64KB default
-            reuseBuffers: config.reuseBuffers !== false
-        };
-        // Pre-allocate buffer pool
-        if (this.config.enabled) {
-            this.initializePool();
-        }
-    }
-    /**
-     * Initialize the buffer pool
-     */
-    initializePool() {
-        for (let i = 0; i < this.config.poolSize; i++) {
-            const buffer = Buffer.allocUnsafe(this.config.bufferSize);
-            this.availableBuffers.push(buffer);
-            this.stats.allocated++;
-        }
-    }
-    /**
-     * Acquire a buffer from the pool
-     */
-    acquire(size) {
-        if (!this.config.enabled || !this.config.reuseBuffers) {
-            const buffer = Buffer.allocUnsafe(size || this.config.bufferSize);
-            this.stats.allocated++;
-            return buffer;
-        }
-        // Try to reuse an existing buffer
-        let buffer = this.availableBuffers.pop();
-        if (buffer) {
-            this.stats.reused++;
-        }
-        else {
-            // Pool exhausted, allocate new buffer
-            buffer = Buffer.allocUnsafe(size || this.config.bufferSize);
-            this.stats.allocated++;
-        }
-        this.inUseBuffers.add(buffer);
-        return buffer;
-    }
-    /**
-     * Release a buffer back to the pool
-     */
-    release(buffer) {
-        if (!this.config.enabled || !this.config.reuseBuffers) {
-            return;
-        }
-        if (this.inUseBuffers.has(buffer)) {
-            this.inUseBuffers.delete(buffer);
-            // Only keep buffers up to pool size
-            if (this.availableBuffers.length < this.config.poolSize) {
-                this.availableBuffers.push(buffer);
-            }
-        }
-    }
-    /**
-     * Get buffer statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            allocated: this.availableBuffers.length + this.inUseBuffers.size,
-            reused: 0,
-            copiesAvoided: 0,
-            memorySaved: 0
-        };
-    }
-    /**
-     * Clear the pool
-     */
-    clear() {
-        this.availableBuffers = [];
-        this.inUseBuffers.clear();
-        this.resetStats();
-    }
-}
-/**
- * Zero-Copy Stream Handler
- * Handles streaming data without unnecessary copies
- */
-export class ZeroCopyStreamHandler {
-    bufferPool;
-    stats;
-    constructor(bufferPool) {
-        this.bufferPool = bufferPool;
-        this.stats = {
-            allocated: 0,
-            reused: 0,
-            copiesAvoided: 0,
-            memorySaved: 0
-        };
-    }
-    /**
-     * Process stream chunk without copying
-     * Uses Buffer.slice() which creates a view, not a copy
-     */
-    processChunk(chunk, offset = 0, length) {
-        const actualLength = length || (chunk.length - offset);
-        // Create a view of the chunk (zero-copy)
-        const view = chunk.subarray(offset, offset + actualLength);
-        // Track statistics
-        this.stats.copiesAvoided++;
-        this.stats.memorySaved += actualLength;
-        return view;
-    }
-    /**
-     * Concatenate buffers efficiently
-     * Uses Buffer.concat which is optimized internally
-     */
-    concat(buffers) {
-        if (buffers.length === 0) {
-            return Buffer.allocUnsafe(0);
-        }
-        if (buffers.length === 1) {
-            // No need to concat
-            this.stats.copiesAvoided++;
-            return buffers[0];
-        }
-        // Calculate total length
-        const totalLength = buffers.reduce((sum, buf) => sum + buf.length, 0);
-        // Use Buffer.concat which is optimized
-        return Buffer.concat(buffers, totalLength);
-    }
-    /**
-     * Transfer data between buffers without intermediate copies
-     */
-    transfer(source, target, sourceStart = 0, targetStart = 0, length) {
-        const actualLength = length || (source.length - sourceStart);
-        // Use copy which is optimized in native code
-        const copied = source.copy(target, targetStart, sourceStart, sourceStart + actualLength);
-        if (copied > 0) {
-            this.stats.copiesAvoided++;
-            this.stats.memorySaved += copied;
-        }
-        return copied;
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Reset statistics
-     */
-    resetStats() {
-        this.stats = {
-            allocated: 0,
-            reused: 0,
-            copiesAvoided: 0,
-            memorySaved: 0
-        };
-    }
-}
-/**
- * Zero-Copy Response Builder
- * Build HTTP responses without unnecessary buffer copies
- */
-export class ZeroCopyResponseBuilder {
-    chunks = [];
-    totalLength = 0;
-    /**
-     * Add a chunk to the response (stores reference, not copy)
-     */
-    addChunk(chunk) {
-        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
-        this.chunks.push(buffer);
-        this.totalLength += buffer.length;
-    }
-    /**
-     * Build the final response buffer
-     * Only concatenates when needed
-     */
-    build() {
-        if (this.chunks.length === 0) {
-            return Buffer.allocUnsafe(0);
-        }
-        if (this.chunks.length === 1) {
-            return this.chunks[0];
-        }
-        // Efficient concatenation
-        return Buffer.concat(this.chunks, this.totalLength);
-    }
-    /**
-     * Get response length without building
-     */
-    getLength() {
-        return this.totalLength;
-    }
-    /**
-     * Clear chunks
-     */
-    clear() {
-        this.chunks = [];
-        this.totalLength = 0;
-    }
-}
-/**
- * Shared buffer for zero-copy operations
- */
-export class SharedBuffer {
-    buffer;
-    refCount = 0;
-    isDetached = false;
-    constructor(size) {
-        this.buffer = Buffer.allocUnsafe(size);
-    }
-    /**
-     * Acquire a reference to this buffer
-     */
-    acquire() {
-        if (this.isDetached) {
-            throw new Error('Cannot acquire detached buffer');
-        }
-        this.refCount++;
-        return this.buffer;
-    }
-    /**
-     * Release a reference
-     */
-    release() {
-        if (this.refCount > 0) {
-            this.refCount--;
-        }
-    }
-    /**
-     * Check if buffer can be reused
-     */
-    canReuse() {
-        return this.refCount === 0 && !this.isDetached;
-    }
-    /**
-     * Detach buffer (mark as unusable)
-     */
-    detach() {
-        this.isDetached = true;
-    }
-    /**
-     * Get current reference count
-     */
-    getReferenceCount() {
-        return this.refCount;
-    }
-}
-/**
- * Calculate memory savings from zero-copy optimizations
- */
-export function calculateMemorySavings(stats) {
-    const totalAllocated = stats.allocated * 64 * 1024; // Assuming 64KB average
-    const savings = stats.memorySaved;
-    const savingsPercentage = totalAllocated > 0 ? (savings / totalAllocated) * 100 : 0;
-    return {
-        savingsPercentage,
-        savingsBytes: savings,
-        savingsMB: savings / (1024 * 1024)
-    };
-}