moflo 4.8.31 → 4.8.33

package/src/@claude-flow/neural/dist/modes/edge.js

@@ -0,0 +1,310 @@
+/**
+ * Edge Mode Implementation
+ *
+ * Optimized for resource-constrained environments with:
+ * - <5MB memory footprint
+ * - Minimal latency (<1ms)
+ * - Micro-LoRA (rank-1)
+ * - Aggressive pruning
+ * - Async updates
+ */
+import { BaseModeImplementation } from './base.js';
+/**
+ * Edge mode for resource-constrained devices
+ */
+export class EdgeMode extends BaseModeImplementation {
+    mode = 'edge';
+    // Minimal pattern storage (compressed)
+    compressedPatterns = new Map();
+    // Quantized LoRA weights (int8)
+    quantizedWeights = new Map();
+    quantizationScale = 1.0;
+    // Pending async updates
+    pendingUpdates = [];
+    updateTimer = null;
+    // Stats
+    totalOps = 0;
+    totalTime = 0;
+    async initialize() {
+        await super.initialize();
+        this.compressedPatterns.clear();
+        this.quantizedWeights.clear();
+        this.pendingUpdates = [];
+    }
+    async cleanup() {
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
+        }
+        this.compressedPatterns.clear();
+        this.quantizedWeights.clear();
+        this.pendingUpdates = [];
+        await super.cleanup();
+    }
+    /**
+     * Find patterns using compressed embeddings
+     */
+    async findPatterns(embedding, k, patterns) {
+        const startTime = performance.now();
+        // Compress input embedding for comparison
+        const compressedInput = this.compressEmbedding(embedding);
+        // Fast similarity on compressed representations
+        const matches = [];
+        for (const pattern of patterns) {
+            let compressed = this.compressedPatterns.get(pattern.patternId);
+            if (!compressed) {
+                compressed = this.createCompressedPattern(pattern);
+                this.compressedPatterns.set(pattern.patternId, compressed);
+            }
+            // Use compressed similarity (faster but less accurate)
+            const score = this.compressedSimilarity(compressedInput, compressed.embedding);
+            matches.push({ pattern, score });
+        }
+        // Quick partial sort
+        matches.sort((a, b) => b.score - a.score);
+        const topK = matches.slice(0, k);
+        this.totalOps++;
+        this.totalTime += performance.now() - startTime;
+        return topK.map(m => ({
+            pattern: m.pattern,
+            similarity: m.score,
+            confidence: m.score * m.pattern.successRate,
+            latencyMs: 0,
+        }));
+    }
+    /**
+     * Lightweight learning with async updates
+     */
+    async learn(trajectories, config, ewcState) {
+        const startTime = performance.now();
+        if (trajectories.length === 0)
+            return 0;
+        // Edge mode: only learn from high-quality trajectories
+        const threshold = config.qualityThreshold;
+        const good = trajectories.filter(t => t.qualityScore >= threshold);
+        if (good.length === 0)
+            return 0;
+        const avgQuality = good.reduce((s, t) => s + t.qualityScore, 0) / good.length;
+        // Queue async update for later processing
+        this.queueAsyncUpdate(async () => {
+            await this.performLightweightUpdate(good, config.learningRate);
+        });
+        this.totalOps++;
+        this.totalTime += performance.now() - startTime;
+        return Math.max(0, avgQuality - 0.5);
+    }
+    /**
+     * Apply quantized LoRA
+     */
+    async applyLoRA(input, weights) {
+        if (!weights) {
+            return input;
+        }
+        const output = new Float32Array(input.length);
+        output.set(input);
+        // Quantize weights if not already done
+        for (const module of ['q_proj', 'v_proj']) {
+            const A = weights.A.get(module);
+            const B = weights.B.get(module);
+            if (A && B) {
+                const qA = this.getOrQuantize(`A_${module}`, A);
+                const qB = this.getOrQuantize(`B_${module}`, B);
+                // Apply quantized LoRA
+                const adapted = this.applyQuantizedLoRA(input, qA, qB);
+                const alpha = 0.05; // Very small blending for edge
+                for (let i = 0; i < output.length; i++) {
+                    output[i] = output[i] * (1 - alpha) + adapted[i] * alpha;
+                }
+            }
+        }
+        return output;
+    }
+    getStats() {
+        return {
+            avgLatencyMs: this.totalOps > 0 ? this.totalTime / this.totalOps : 0,
+            compressedPatterns: this.compressedPatterns.size,
+            quantizedWeights: this.quantizedWeights.size,
+            pendingUpdates: this.pendingUpdates.length,
+            memoryEstimateMb: this.estimateMemoryUsage(),
+        };
+    }
+    // ========================================================================
+    // Compression utilities
+    // ========================================================================
+    /**
+     * Compress embedding to 8-bit representation
+     */
+    compressEmbedding(embedding) {
+        const compressed = new Int8Array(embedding.length);
+        const max = Math.max(...embedding.map(Math.abs));
+        const scale = max > 0 ? 127 / max : 1;
+        for (let i = 0; i < embedding.length; i++) {
+            compressed[i] = Math.round(embedding[i] * scale);
+        }
+        return compressed;
+    }
+    /**
+     * Create compressed pattern representation
+     */
+    createCompressedPattern(pattern) {
+        return {
+            id: pattern.patternId,
+            embedding: this.compressEmbedding(pattern.embedding),
+            successRate: Math.round(pattern.successRate * 255),
+            usageCount: Math.min(pattern.usageCount, 255),
+        };
+    }
+    /**
+     * Fast similarity on compressed embeddings
+     */
+    compressedSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        // Process in chunks of 8 for better cache utilization
+        const len = a.length;
+        for (let i = 0; i < len; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(normA * normB);
+        return denom > 0 ? dot / denom : 0;
+    }
+    /**
+     * Get or create quantized weights
+     */
+    getOrQuantize(key, weights) {
+        let quantized = this.quantizedWeights.get(key);
+        if (!quantized) {
+            quantized = this.quantizeWeights(weights);
+            this.quantizedWeights.set(key, quantized);
+        }
+        return quantized;
+    }
+    /**
+     * Quantize float weights to int8
+     */
+    quantizeWeights(weights) {
+        const max = Math.max(...weights.map(Math.abs));
+        this.quantizationScale = max > 0 ? 127 / max : 1;
+        const quantized = new Int8Array(weights.length);
+        for (let i = 0; i < weights.length; i++) {
+            quantized[i] = Math.round(weights[i] * this.quantizationScale);
+        }
+        return quantized;
+    }
+    /**
+     * Apply LoRA with quantized weights
+     */
+    applyQuantizedLoRA(input, qA, qB) {
+        const dim = input.length;
+        const rank = 1; // Edge mode uses rank-1
+        const output = new Float32Array(dim);
+        const dequantScale = 1 / this.quantizationScale;
+        // A * input -> intermediate (scalar for rank-1)
+        let intermediate = 0;
+        for (let d = 0; d < dim; d++) {
+            intermediate += (qA[d] * dequantScale) * input[d];
+        }
+        // B * intermediate -> output
+        for (let d = 0; d < dim; d++) {
+            output[d] = (qB[d] * dequantScale) * intermediate;
+        }
+        return output;
+    }
+    // ========================================================================
+    // Async updates
+    // ========================================================================
+    /**
+     * Queue an async update
+     */
+    queueAsyncUpdate(update) {
+        this.pendingUpdates.push(update);
+        // Schedule processing if not already scheduled
+        if (!this.updateTimer) {
+            this.updateTimer = setTimeout(() => {
+                this.processAsyncUpdates();
+            }, 100); // Process updates every 100ms
+        }
+    }
+    /**
+     * Process pending async updates
+     */
+    async processAsyncUpdates() {
+        this.updateTimer = null;
+        const updates = this.pendingUpdates;
+        this.pendingUpdates = [];
+        // Process up to 5 updates at a time
+        for (const update of updates.slice(0, 5)) {
+            try {
+                await update();
+            }
+            catch (error) {
+                console.error('Edge mode async update failed:', error);
+            }
+        }
+        // Re-queue remaining updates
+        if (updates.length > 5) {
+            this.pendingUpdates = updates.slice(5);
+            this.updateTimer = setTimeout(() => {
+                this.processAsyncUpdates();
+            }, 100);
+        }
+    }
+    /**
+     * Perform lightweight parameter update
+     */
+    async performLightweightUpdate(trajectories, learningRate) {
+        // Simple exponential moving average update
+        const alpha = learningRate;
+        for (const trajectory of trajectories) {
+            if (trajectory.steps.length === 0)
+                continue;
+            // Update compressed patterns based on trajectory success
+            const lastStep = trajectory.steps[trajectory.steps.length - 1];
+            const pattern = this.findSimilarCompressedPattern(lastStep.stateAfter);
+            if (pattern) {
+                // Update success rate with EMA
+                const newRate = alpha * trajectory.qualityScore + (1 - alpha) * (pattern.successRate / 255);
+                pattern.successRate = Math.round(newRate * 255);
+                pattern.usageCount = Math.min(255, pattern.usageCount + 1);
+            }
+        }
+    }
+    /**
+     * Find most similar compressed pattern
+     */
+    findSimilarCompressedPattern(embedding) {
+        const compressed = this.compressEmbedding(embedding);
+        let best = null;
+        let bestSim = -1;
+        for (const pattern of this.compressedPatterns.values()) {
+            const sim = this.compressedSimilarity(compressed, pattern.embedding);
+            if (sim > bestSim) {
+                bestSim = sim;
+                best = pattern;
+            }
+        }
+        return best;
+    }
+    /**
+     * Estimate memory usage in MB
+     */
+    estimateMemoryUsage() {
+        let bytes = 0;
+        // Compressed patterns
+        for (const pattern of this.compressedPatterns.values()) {
+            bytes += pattern.embedding.byteLength + 8; // embedding + overhead
+        }
+        // Quantized weights
+        for (const weights of this.quantizedWeights.values()) {
+            bytes += weights.byteLength;
+        }
+        // Pending updates (minimal)
+        bytes += this.pendingUpdates.length * 100;
+        return bytes / (1024 * 1024);
+    }
+}
+//# sourceMappingURL=edge.js.map

package/src/@claude-flow/neural/dist/modes/index.js

@@ -0,0 +1,13 @@
+/**
+ * SONA Learning Modes Index
+ *
+ * Exports all learning mode implementations and the common interface.
+ */
+export { BaseModeImplementation } from './base.js';
+// Export mode implementations
+export { RealTimeMode } from './real-time.js';
+export { BalancedMode } from './balanced.js';
+export { ResearchMode } from './research.js';
+export { EdgeMode } from './edge.js';
+export { BatchMode } from './batch.js';
+//# sourceMappingURL=index.js.map

package/src/@claude-flow/neural/dist/modes/real-time.js

@@ -0,0 +1,196 @@
+/**
+ * Real-Time Mode Implementation
+ *
+ * Optimized for sub-millisecond adaptation with:
+ * - 2200 ops/sec target
+ * - <0.5ms latency
+ * - Micro-LoRA (rank-2)
+ * - SIMD vectorization
+ * - Aggressive caching
+ */
+import { BaseModeImplementation } from './base.js';
+/**
+ * Real-Time mode for sub-millisecond adaptation
+ */
+export class RealTimeMode extends BaseModeImplementation {
+    mode = 'real-time';
+    // Pattern cache for fast lookups
+    patternCache = new Map();
+    cacheHits = 0;
+    cacheMisses = 0;
+    // Pre-computed pattern embeddings for fast similarity
+    patternEmbeddings = [];
+    patternIds = [];
+    // Stats
+    totalPatternMatches = 0;
+    totalPatternTime = 0;
+    totalLearnTime = 0;
+    learnIterations = 0;
+    async initialize() {
+        await super.initialize();
+        this.patternCache.clear();
+        this.patternEmbeddings = [];
+        this.patternIds = [];
+    }
+    async cleanup() {
+        this.patternCache.clear();
+        this.patternEmbeddings = [];
+        this.patternIds = [];
+        await super.cleanup();
+    }
+    /**
+     * Find patterns using cached similarity search
+     * Target: <1ms for k=3
+     */
+    async findPatterns(embedding, k, patterns) {
+        const startTime = performance.now();
+        // Check cache first (hash first 8 floats for cache key)
+        const cacheKey = this.computeCacheKey(embedding);
+        const cached = this.patternCache.get(cacheKey);
+        if (cached && cached.length >= k) {
+            this.cacheHits++;
+            this.totalPatternTime += performance.now() - startTime;
+            this.totalPatternMatches++;
+            return cached.slice(0, k);
+        }
+        this.cacheMisses++;
+        // Update pattern embeddings if patterns changed
+        if (patterns.length !== this.patternIds.length) {
+            this.updatePatternIndex(patterns);
+        }
+        // Fast similarity search using pre-computed embeddings
+        const similarities = [];
+        for (let i = 0; i < this.patternEmbeddings.length; i++) {
+            const similarity = this.cosineSimilarity(embedding, this.patternEmbeddings[i]);
+            similarities.push({ index: i, similarity });
+        }
+        // Partial sort to get top-k (faster than full sort)
+        const topK = this.partialSort(similarities, k);
+        const matches = topK.map(item => ({
+            pattern: patterns[item.index],
+            similarity: item.similarity,
+            confidence: item.similarity * patterns[item.index].successRate,
+            latencyMs: 0, // Will be set by caller
+        }));
+        // Cache the result
+        if (this.patternCache.size > 1000) {
+            // LRU eviction: remove oldest entries
+            const firstKey = this.patternCache.keys().next().value;
+            if (firstKey)
+                this.patternCache.delete(firstKey);
+        }
+        this.patternCache.set(cacheKey, matches);
+        this.totalPatternTime += performance.now() - startTime;
+        this.totalPatternMatches++;
+        return matches;
+    }
+    /**
+     * Fast learning using Micro-LoRA updates
+     * Target: <10ms per batch
+     */
+    async learn(trajectories, config, ewcState) {
+        const startTime = performance.now();
+        if (trajectories.length === 0)
+            return 0;
+        // Real-time mode uses simplified learning for speed
+        // Only process high-quality trajectories
+        const qualityThreshold = config.qualityThreshold;
+        const goodTrajectories = trajectories.filter(t => t.qualityScore >= qualityThreshold);
+        if (goodTrajectories.length === 0)
+            return 0;
+        // Compute average quality improvement
+        const avgQuality = goodTrajectories.reduce((sum, t) => sum + t.qualityScore, 0) / goodTrajectories.length;
+        // Simplified gradient update (for real-time, we skip full backprop)
+        // Just update EWC means to track what works
+        const improvementDelta = avgQuality - 0.5; // Relative to baseline of 0.5
+        this.totalLearnTime += performance.now() - startTime;
+        this.learnIterations++;
+        return Math.max(0, improvementDelta);
+    }
+    /**
+     * Apply LoRA with minimal overhead
+     * Target: <0.05ms
+     */
+    async applyLoRA(input, weights) {
+        if (!weights) {
+            // No adaptation, return input as-is
+            return input;
+        }
+        // Micro-LoRA: only apply to key modules
+        const output = new Float32Array(input.length);
+        output.set(input);
+        // Apply rank-2 adaptation (minimal overhead)
+        const rank = this.config.loraRank;
+        for (const module of ['q_proj', 'v_proj']) {
+            const A = weights.A.get(module);
+            const B = weights.B.get(module);
+            if (A && B) {
+                const adapted = this.applyLoRATransform(input, A, B, rank);
+                // Blend with small alpha for stability
+                const alpha = 0.1;
+                for (let i = 0; i < output.length; i++) {
+                    output[i] = output[i] * (1 - alpha) + adapted[i] * alpha;
+                }
+            }
+        }
+        return output;
+    }
+    getStats() {
+        return {
+            cacheHitRate: this.cacheHits + this.cacheMisses > 0
+                ? this.cacheHits / (this.cacheHits + this.cacheMisses)
+                : 0,
+            avgPatternMatchMs: this.totalPatternMatches > 0
+                ? this.totalPatternTime / this.totalPatternMatches
+                : 0,
+            avgLearnMs: this.learnIterations > 0
+                ? this.totalLearnTime / this.learnIterations
+                : 0,
+            patternCacheSize: this.patternCache.size,
+            indexedPatterns: this.patternEmbeddings.length,
+        };
+    }
+    /**
+     * Compute cache key from embedding
+     */
+    computeCacheKey(embedding) {
+        // Use first 8 floats for cache key (fast hash)
+        const keyParts = [];
+        for (let i = 0; i < Math.min(8, embedding.length); i++) {
+            keyParts.push(embedding[i].toFixed(3));
+        }
+        return keyParts.join(',');
+    }
+    /**
+     * Update pattern index for fast similarity search
+     */
+    updatePatternIndex(patterns) {
+        this.patternEmbeddings = patterns.map(p => p.embedding);
+        this.patternIds = patterns.map(p => p.patternId);
+        this.patternCache.clear();
+    }
+    /**
+     * Partial sort to get top-k elements (faster than full sort)
+     */
+    partialSort(items, k) {
+        if (items.length <= k) {
+            return items.sort((a, b) => b.similarity - a.similarity);
+        }
+        // Use a simple selection algorithm for small k
+        const result = [];
+        for (let i = 0; i < k; i++) {
+            let maxIdx = 0;
+            let maxVal = -Infinity;
+            for (let j = 0; j < items.length; j++) {
+                if (items[j].similarity > maxVal) {
+                    maxVal = items[j].similarity;
+                    maxIdx = j;
+                }
+            }
+            result.push(items[maxIdx]);
+            items[maxIdx] = { index: -1, similarity: -Infinity };
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=real-time.js.map