agentic-flow 3.0.0-alpha.2 → 3.0.0

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

package/docs/.claude-flow/metrics/agent-metrics.json

@@ -1 +0,0 @@
-{}

package/docs/.claude-flow/metrics/performance.json

@@ -1,87 +0,0 @@
-{
-  "startTime": 1762467996367,
-  "sessionId": "session-1762467996367",
-  "lastActivity": 1762467996367,
-  "sessionDuration": 0,
-  "totalTasks": 1,
-  "successfulTasks": 1,
-  "failedTasks": 0,
-  "totalAgents": 0,
-  "activeAgents": 0,
-  "neuralEvents": 0,
-  "memoryMode": {
-    "reasoningbankOperations": 0,
-    "basicOperations": 0,
-    "autoModeSelections": 0,
-    "modeOverrides": 0,
-    "currentMode": "auto"
-  },
-  "operations": {
-    "store": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "retrieve": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "query": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "list": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "delete": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "search": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "init": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    }
-  },
-  "performance": {
-    "avgOperationDuration": 0,
-    "minOperationDuration": null,
-    "maxOperationDuration": null,
-    "slowOperations": 0,
-    "fastOperations": 0,
-    "totalOperationTime": 0
-  },
-  "storage": {
-    "totalEntries": 0,
-    "reasoningbankEntries": 0,
-    "basicEntries": 0,
-    "databaseSize": 0,
-    "lastBackup": null,
-    "growthRate": 0
-  },
-  "errors": {
-    "total": 0,
-    "byType": {},
-    "byOperation": {},
-    "recent": []
-  },
-  "reasoningbank": {
-    "semanticSearches": 0,
-    "sqlFallbacks": 0,
-    "embeddingGenerated": 0,
-    "consolidations": 0,
-    "avgQueryTime": 0,
-    "cacheHits": 0,
-    "cacheMisses": 0
-  }
-}

package/docs/.claude-flow/metrics/task-metrics.json

@@ -1,10 +0,0 @@
-[
-  {
-    "id": "cmd-hooks-1762467996503",
-    "type": "hooks",
-    "success": true,
-    "duration": 39.07860499999998,
-    "timestamp": 1762467996542,
-    "metadata": {}
-  }
-]