claude-flow-novice 1.6.4 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/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/archives/v2-sdk-typescript/v2/checkpoints/checkpoint-compressor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/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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"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/completion-detector.js

@@ -0,0 +1,234 @@
+/**
+ * Agent Coordination V2 - Completion Detection Interface
+ *
+ * Base interface for detecting swarm completion with event-driven architecture.
+ * Integrates with State Machine and Message Bus for real-time completion tracking.
+ *
+ * Performance targets:
+ * - Detection latency: <1000ms for 20-agent swarm
+ * - Event-driven (no polling)
+ * - Zero false positives
+ *
+ * @module coordination/v2/completion/completion-detector
+ */ import { EventEmitter } from 'node:events';
+import { AgentState } from '../../shared/core/agent-state.js';
+import { LamportClock } from './lamport-clock.js';
+/**
+ * Base CompletionDetector interface
+ *
+ * Provides core completion detection functionality with:
+ * - Event-driven architecture (completion:detected, completion:failed)
+ * - State Machine integration for agent state tracking
+ * - Message Bus integration for real-time updates
+ * - Checkpoint creation on completion
+ * - Validation and metrics tracking
+ *
+ * @example
+ * ```typescript
+ * const detector = new HierarchicalCompletionDetector(
+ *   stateMachine,
+ *   messageBroker,
+ *   checkpointManager,
+ *   { autoCheckpoint: true }
+ * );
+ *
+ * detector.on('completion:detected', (result) => {
+ *   console.log(`Swarm ${result.swarmId} completed!`);
+ * });
+ *
+ * const result = await detector.detectCompletion('swarm-1');
+ * if (result.completed) {
+ *   console.log(`Checkpoint: ${result.checkpointId}`);
+ * }
+ * ```
+ */ export class CompletionDetector extends EventEmitter {
+    stateMachine;
+    messageBroker;
+    checkpointManager;
+    config;
+    metrics;
+    detectionLatencies;
+    lamportClock;
+    constructor(stateMachine, messageBroker, checkpointManager, config){
+        super();
+        this.stateMachine = stateMachine;
+        this.messageBroker = messageBroker;
+        this.checkpointManager = checkpointManager;
+        this.config = {
+            autoCheckpoint: config?.autoCheckpoint ?? true,
+            enableValidation: config?.enableValidation ?? true,
+            maxDetectionLatencyMs: config?.maxDetectionLatencyMs ?? 1000,
+            enableLogging: config?.enableLogging ?? true
+        };
+        this.metrics = {
+            totalDetections: 0,
+            successfulDetections: 0,
+            failedDetections: 0,
+            averageLatencyMs: 0,
+            p99LatencyMs: 0,
+            totalCheckpointsCreated: 0
+        };
+        this.detectionLatencies = [];
+        this.lamportClock = new LamportClock();
+        // Subscribe to state machine events for real-time tracking
+        this.stateMachine.on('state:transition', this.handleStateTransition.bind(this));
+        if (this.config.enableLogging) {
+            this.log('CompletionDetector initialized', {
+                strategy: this.getStrategy(),
+                autoCheckpoint: this.config.autoCheckpoint,
+                enableValidation: this.config.enableValidation
+            });
+        }
+    }
+    /**
+   * Create checkpoint on completion
+   *
+   * @param swarmId - Swarm identifier
+   * @param agentStates - Final agent states
+   * @returns Checkpoint ID
+   */ async createCompletionCheckpoint(swarmId, agentStates) {
+        if (!this.config.autoCheckpoint) {
+            throw new Error('Auto-checkpoint disabled');
+        }
+        const lamportTimestamp = this.lamportClock.tick();
+        const physicalTime = Date.now();
+        const sessionId = `swarm-${swarmId}`;
+        // Create state snapshot with both Lamport and physical timestamps
+        const stateSnapshot = {
+            swarmId,
+            lamportTimestamp,
+            physicalTime,
+            completionTime: physicalTime,
+            agentStates: Object.fromEntries(agentStates),
+            totalAgents: agentStates.size,
+            completedAgents: Array.from(agentStates.values()).filter((state)=>state === AgentState.COMPLETED).length
+        };
+        // Create checkpoint with first completed agent or swarm ID
+        const firstAgent = Array.from(agentStates.keys())[0] || `agent-${swarmId}`;
+        const messageUUID = `completion-${swarmId}-${lamportTimestamp}`;
+        const checkpointId = await this.checkpointManager.createCheckpoint(sessionId, firstAgent, messageUUID, AgentState.COMPLETED, stateSnapshot, {
+            reason: `Swarm completion: ${swarmId}`,
+            autoCheckpoint: true,
+            context: {
+                lamportTimestamp,
+                physicalTime: new Date(physicalTime).toISOString(),
+                strategy: this.getStrategy()
+            }
+        });
+        this.metrics.totalCheckpointsCreated++;
+        if (this.config.enableLogging) {
+            this.log('Completion checkpoint created', {
+                swarmId,
+                checkpointId,
+                agentCount: agentStates.size
+            });
+        }
+        return checkpointId;
+    }
+    /**
+   * Update metrics after detection
+   */ updateMetrics(latencyMs, success) {
+        this.metrics.totalDetections++;
+        if (success) {
+            this.metrics.successfulDetections++;
+        } else {
+            this.metrics.failedDetections++;
+        }
+        this.detectionLatencies.push(latencyMs);
+        // Keep only last 1000 samples
+        if (this.detectionLatencies.length > 1000) {
+            this.detectionLatencies.shift();
+        }
+        // Update average latency
+        this.metrics.averageLatencyMs = (this.metrics.averageLatencyMs * (this.metrics.totalDetections - 1) + latencyMs) / this.metrics.totalDetections;
+        // Update p99 latency
+        if (this.detectionLatencies.length > 0) {
+            const sorted = [
+                ...this.detectionLatencies
+            ].sort((a, b)=>a - b);
+            const p99Index = Math.floor(sorted.length * 0.99);
+            this.metrics.p99LatencyMs = sorted[p99Index] || sorted[sorted.length - 1];
+        }
+        // Warn if exceeding latency threshold
+        if (latencyMs > this.config.maxDetectionLatencyMs) {
+            this.log('Detection latency exceeded threshold', {
+                latencyMs: latencyMs.toFixed(2),
+                threshold: this.config.maxDetectionLatencyMs,
+                p99: this.metrics.p99LatencyMs.toFixed(2)
+            });
+        }
+    }
+    /**
+   * Get completion metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Reset metrics (for testing)
+   */ resetMetrics() {
+        this.metrics.totalDetections = 0;
+        this.metrics.successfulDetections = 0;
+        this.metrics.failedDetections = 0;
+        this.metrics.averageLatencyMs = 0;
+        this.metrics.p99LatencyMs = 0;
+        this.metrics.totalCheckpointsCreated = 0;
+        this.detectionLatencies.length = 0;
+    }
+    /**
+   * Emit completion detected event
+   */ emitCompletionDetected(result) {
+        this.emit('completion:detected', result);
+        if (this.config.enableLogging) {
+            this.log('Completion detected', {
+                swarmId: result.swarmId,
+                completedCount: result.completedCount,
+                totalCount: result.totalCount,
+                latencyMs: result.latencyMs.toFixed(2),
+                checkpointId: result.checkpointId
+            });
+        }
+    }
+    /**
+   * Emit completion failed event
+   */ emitCompletionFailed(swarmId, error) {
+        this.emit('completion:failed', {
+            swarmId,
+            error
+        });
+        if (this.config.enableLogging) {
+            this.log('Completion detection failed', {
+                swarmId,
+                error: error.message
+            });
+        }
+    }
+    /**
+   * Internal logging helper
+   */ log(message, data) {
+        if (!this.config.enableLogging) {
+            return;
+        }
+        const logData = {
+            timestamp: new Date().toISOString(),
+            strategy: this.getStrategy(),
+            ...data
+        };
+        console.log(`[CompletionDetector:${this.getStrategy()}] ${message}`, logData);
+    }
+    /**
+   * Cleanup detector resources
+   */ async cleanup() {
+        this.stateMachine.removeListener('state:transition', this.handleStateTransition.bind(this));
+        this.removeAllListeners();
+        if (this.config.enableLogging) {
+            this.log('CompletionDetector cleanup complete', {
+                totalDetections: this.metrics.totalDetections,
+                averageLatencyMs: this.metrics.averageLatencyMs.toFixed(2)
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=completion-detector.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/completion-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/completion/completion-detector.ts"],"names":["EventEmitter","AgentState","LamportClock","CompletionDetector","stateMachine","messageBroker","checkpointManager","config","metrics","detectionLatencies","lamportClock","autoCheckpoint","enableValidation","maxDetectionLatencyMs","enableLogging","totalDetections","successfulDetections","failedDetections","averageLatencyMs","p99LatencyMs","totalCheckpointsCreated","on","handleStateTransition","bind","log","strategy","getStrategy","createCompletionCheckpoint","swarmId","agentStates","Error","lamportTimestamp","tick","physicalTime","Date","now","sessionId","stateSnapshot","completionTime","Object","fromEntries","totalAgents","size","completedAgents","Array","from","values","filter","state","COMPLETED","length","firstAgent","keys","messageUUID","checkpointId","createCheckpoint","reason","context","toISOString","agentCount","updateMetrics","latencyMs","success","push","shift","sorted","sort","a","b","p99Index","Math","floor","toFixed","threshold","p99","getMetrics","resetMetrics","emitCompletionDetected","result","emit","completedCount","totalCount","emitCompletionFailed","error","message","data","logData","timestamp","console","cleanup","removeListener","removeAllListeners"],"mappings":"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"}