claude-flow-novice 1.6.1 → 1.6.3

package/.claude-flow-novice/dist/src/coordination/v2/checkpoints/checkpoint-compressor.js

@@ -0,0 +1,318 @@
+/**
+ * Checkpoint Compressor - Multi-layer compression for state snapshots
+ *
+ * Compression Strategy:
+ * 1. Structural compression (MessagePack binary encoding)
+ * 2. Delta encoding (reference previous checkpoints)
+ * 3. Deduplication (shared data structures)
+ * 4. Gzip final pass
+ *
+ * Target: ≥60% compression ratio
+ *
+ * @module coordination/v2/checkpoints/checkpoint-compressor
+ */ import { gzip, gunzip } from 'zlib';
+import { promisify } from 'util';
+import * as msgpack from 'msgpack-lite';
+import { createHash } from 'crypto';
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
+/**
+ * Checkpoint Compressor - Multi-layer compression engine
+ */ export class CheckpointCompressor {
+    previousCheckpoints = new Map();
+    maxPreviousCheckpoints = 10;
+    minCompressionRatio = 0.6;
+    /**
+   * Compress checkpoint data with multi-layer strategy
+   *
+   * @param data - State snapshot to compress
+   * @param sessionId - Session identifier for delta compression
+   * @param previousCheckpointId - Optional reference for delta compression
+   * @returns Compression result with metrics
+   */ async compress(data, sessionId, previousCheckpointId) {
+        const uncompressedData = JSON.stringify(data);
+        const uncompressedSize = Buffer.byteLength(uncompressedData, 'utf8');
+        // Try delta compression if previous checkpoint available
+        if (previousCheckpointId && this.previousCheckpoints.has(previousCheckpointId)) {
+            const deltaResult = await this.compressWithDelta(data, sessionId, previousCheckpointId, uncompressedSize);
+            if (deltaResult.compressionRatio >= this.minCompressionRatio) {
+                return deltaResult;
+            }
+            // Fall back to full compression if delta didn't achieve target
+            console.warn(`Delta compression ratio ${deltaResult.compressionRatio.toFixed(2)} below target ${this.minCompressionRatio}, using full compression`);
+        }
+        // Full compression: MessagePack + deduplication + gzip
+        return this.compressFull(data, sessionId, uncompressedSize);
+    }
+    /**
+   * Decompress checkpoint data
+   *
+   * @param compressedBuffer - Compressed data buffer
+   * @param compressionStrategy - Strategy used for compression
+   * @param referenceCheckpointId - Reference checkpoint for delta decompression
+   * @returns Decompressed data
+   */ async decompress(compressedBuffer, compressionStrategy, referenceCheckpointId) {
+        const startTime = performance.now();
+        if (compressionStrategy === 'delta' && referenceCheckpointId) {
+            const data = await this.decompressDelta(compressedBuffer, referenceCheckpointId);
+            return {
+                data,
+                latencyMs: performance.now() - startTime
+            };
+        }
+        // Full decompression: gunzip + MessagePack decode
+        const data = await this.decompressFull(compressedBuffer);
+        return {
+            data,
+            latencyMs: performance.now() - startTime
+        };
+    }
+    /**
+   * Full compression: MessagePack + gzip (with small data optimization)
+   */ async compressFull(data, sessionId, uncompressedSize) {
+        // Step 1: Deduplication (extract shared structures)
+        const deduplicated = this.deduplicateData(data);
+        // Step 2: MessagePack encoding (structural compression)
+        const msgpackBuffer = msgpack.encode(deduplicated);
+        // Step 3: Gzip compression (skip for tiny data to avoid overhead)
+        let compressedBuffer;
+        if (msgpackBuffer.length < 256) {
+            // For small data, gzip overhead exceeds savings - use MessagePack only
+            compressedBuffer = msgpackBuffer;
+        } else {
+            // For larger data, apply gzip with maximum compression
+            compressedBuffer = await gzipAsync(msgpackBuffer, {
+                level: 9
+            });
+            // Fallback: if gzip made it bigger, use MessagePack only
+            if (compressedBuffer.length > msgpackBuffer.length) {
+                compressedBuffer = msgpackBuffer;
+            }
+        }
+        const compressedSize = compressedBuffer.length;
+        const compressionRatio = 1 - compressedSize / uncompressedSize;
+        // Store for potential delta compression
+        this.storePreviousCheckpoint(sessionId, data);
+        return {
+            compressedBuffer,
+            uncompressedSize,
+            compressedSize,
+            compressionRatio,
+            strategy: 'full'
+        };
+    }
+    /**
+   * Delta compression: Encode differences from previous checkpoint
+   */ async compressWithDelta(data, sessionId, previousCheckpointId, uncompressedSize) {
+        const previousData = this.previousCheckpoints.get(previousCheckpointId);
+        if (!previousData) {
+            // Fallback to full compression
+            return this.compressFull(data, sessionId, uncompressedSize);
+        }
+        // Calculate delta (differences only)
+        const delta = this.calculateDelta(previousData, data);
+        // Compress delta with MessagePack + gzip
+        const msgpackBuffer = msgpack.encode({
+            _delta: true,
+            _reference: previousCheckpointId,
+            changes: delta
+        });
+        const compressedBuffer = await gzipAsync(msgpackBuffer, {
+            level: 9
+        });
+        const compressedSize = compressedBuffer.length;
+        const compressionRatio = 1 - compressedSize / uncompressedSize;
+        // Store for future delta compression
+        this.storePreviousCheckpoint(sessionId, data);
+        return {
+            compressedBuffer,
+            uncompressedSize,
+            compressedSize,
+            compressionRatio,
+            strategy: 'delta',
+            referenceCheckpointId: previousCheckpointId
+        };
+    }
+    /**
+   * Decompress full checkpoint
+   */ async decompressFull(compressedBuffer) {
+        // Step 1: Gunzip
+        const msgpackBuffer = await gunzipAsync(compressedBuffer);
+        // Step 2: MessagePack decode
+        const data = msgpack.decode(msgpackBuffer);
+        return data;
+    }
+    /**
+   * Decompress delta checkpoint
+   */ async decompressDelta(compressedBuffer, referenceCheckpointId) {
+        const previousData = this.previousCheckpoints.get(referenceCheckpointId);
+        if (!previousData) {
+            throw new Error(`Reference checkpoint ${referenceCheckpointId} not found for delta decompression`);
+        }
+        // Decompress delta
+        const msgpackBuffer = await gunzipAsync(compressedBuffer);
+        const deltaPackage = msgpack.decode(msgpackBuffer);
+        if (!deltaPackage._delta) {
+            throw new Error('Invalid delta checkpoint format');
+        }
+        // Apply delta to previous data
+        const reconstructed = this.applyDelta(previousData, deltaPackage.changes);
+        return reconstructed;
+    }
+    /**
+   * Calculate delta between previous and current data
+   */ calculateDelta(previous, current) {
+        const delta = {};
+        // Find added/modified keys
+        for (const [key, value] of Object.entries(current)){
+            const previousValue = previous[key];
+            if (previousValue === undefined) {
+                // New key
+                delta[key] = {
+                    _op: 'add',
+                    value
+                };
+            } else if (JSON.stringify(previousValue) !== JSON.stringify(value)) {
+                // Modified key
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    // Nested object - recurse
+                    delta[key] = {
+                        _op: 'modify',
+                        delta: this.calculateDelta(previousValue, value)
+                    };
+                } else {
+                    // Primitive or array - replace
+                    delta[key] = {
+                        _op: 'replace',
+                        value
+                    };
+                }
+            }
+        }
+        // Find deleted keys
+        for (const key of Object.keys(previous)){
+            if (!(key in current)) {
+                delta[key] = {
+                    _op: 'delete'
+                };
+            }
+        }
+        return delta;
+    }
+    /**
+   * Apply delta to reconstruct current data from previous
+   */ applyDelta(previous, delta) {
+        const result = {
+            ...previous
+        };
+        for (const [key, change] of Object.entries(delta)){
+            const op = change._op;
+            if (op === 'add' || op === 'replace') {
+                result[key] = change.value;
+            } else if (op === 'delete') {
+                delete result[key];
+            } else if (op === 'modify') {
+                result[key] = this.applyDelta(previous[key], change.delta);
+            }
+        }
+        return result;
+    }
+    /**
+   * Deduplicate data structures (extract shared patterns)
+   */ deduplicateData(data) {
+        const sharedStructures = new Map();
+        const deduplicatedData = this.deduplicateRecursive(data, sharedStructures);
+        // Only wrap if deduplication found shared structures
+        if (sharedStructures.size > 0) {
+            return {
+                _deduplicated: true,
+                _shared: Array.from(sharedStructures.entries()),
+                data: deduplicatedData
+            };
+        }
+        // No shared structures found, return original
+        return deduplicatedData;
+    }
+    /**
+   * Recursive deduplication helper
+   */ deduplicateRecursive(obj, sharedStructures, depth = 0) {
+        if (depth > 10 || obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        // For arrays - detect repeated patterns
+        if (Array.isArray(obj)) {
+            if (obj.length > 3) {
+                // Check if all items are identical
+                const firstItemStr = JSON.stringify(obj[0]);
+                const allIdentical = obj.every((item)=>JSON.stringify(item) === firstItemStr);
+                if (allIdentical && obj.length > 5) {
+                    // Store pattern and return reference
+                    const hash = this.hashObject(obj[0]);
+                    if (!sharedStructures.has(hash)) {
+                        sharedStructures.set(hash, obj[0]);
+                    }
+                    return {
+                        _repeat: obj.length,
+                        _ref: hash
+                    };
+                }
+            }
+            return obj.map((item)=>this.deduplicateRecursive(item, sharedStructures, depth + 1));
+        }
+        // For objects - check for duplicate structures
+        const hash = this.hashObject(obj);
+        const existingStructures = Array.from(sharedStructures.keys());
+        // Find if this exact structure already exists
+        for (const existingHash of existingStructures){
+            const existing = sharedStructures.get(existingHash);
+            if (JSON.stringify(existing) === JSON.stringify(obj)) {
+                return {
+                    _ref: existingHash
+                };
+            }
+        }
+        // New structure - recurse into properties
+        const deduplicated = {};
+        for (const [key, value] of Object.entries(obj)){
+            deduplicated[key] = this.deduplicateRecursive(value, sharedStructures, depth + 1);
+        }
+        return deduplicated;
+    }
+    /**
+   * Hash object for deduplication
+   */ hashObject(obj) {
+        const json = JSON.stringify(obj, Object.keys(obj || {}).sort());
+        return createHash('sha256').update(json).digest('hex').substring(0, 8);
+    }
+    /**
+   * Store previous checkpoint for delta compression
+   */ storePreviousCheckpoint(sessionId, data) {
+        const checkpointId = `${sessionId}-${Date.now()}`;
+        this.previousCheckpoints.set(checkpointId, data);
+        // Maintain LRU cache
+        if (this.previousCheckpoints.size > this.maxPreviousCheckpoints) {
+            const oldestKey = Array.from(this.previousCheckpoints.keys())[0];
+            this.previousCheckpoints.delete(oldestKey);
+        }
+    }
+    /**
+   * Clear compression cache
+   */ clearCache() {
+        this.previousCheckpoints.clear();
+    }
+    /**
+   * Get compression statistics
+   */ getStats() {
+        let totalSize = 0;
+        const values = Array.from(this.previousCheckpoints.values());
+        for (const data of values){
+            totalSize += Buffer.byteLength(JSON.stringify(data), 'utf8');
+        }
+        return {
+            cachedCheckpoints: this.previousCheckpoints.size,
+            cacheMemoryMB: totalSize / (1024 * 1024)
+        };
+    }
+}
+
+//# sourceMappingURL=checkpoint-compressor.js.map

package/.claude-flow-novice/dist/src/coordination/v2/checkpoints/checkpoint-compressor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/checkpoints/checkpoint-compressor.ts"],"names":["gzip","gunzip","promisify","msgpack","createHash","gzipAsync","gunzipAsync","CheckpointCompressor","previousCheckpoints","Map","maxPreviousCheckpoints","minCompressionRatio","compress","data","sessionId","previousCheckpointId","uncompressedData","JSON","stringify","uncompressedSize","Buffer","byteLength","has","deltaResult","compressWithDelta","compressionRatio","console","warn","toFixed","compressFull","decompress","compressedBuffer","compressionStrategy","referenceCheckpointId","startTime","performance","now","decompressDelta","latencyMs","decompressFull","deduplicated","deduplicateData","msgpackBuffer","encode","length","level","compressedSize","storePreviousCheckpoint","strategy","previousData","get","delta","calculateDelta","_delta","_reference","changes","decode","Error","deltaPackage","reconstructed","applyDelta","previous","current","key","value","Object","entries","previousValue","undefined","_op","Array","isArray","keys","result","change","op","sharedStructures","deduplicatedData","deduplicateRecursive","size","_deduplicated","_shared","from","obj","depth","firstItemStr","allIdentical","every","item","hash","hashObject","set","_repeat","_ref","map","existingStructures","existingHash","existing","json","sort","update","digest","substring","checkpointId","Date","oldestKey","delete","clearCache","clear","getStats","totalSize","values","cachedCheckpoints","cacheMemoryMB"],"mappings":"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"}