moflo 4.8.32 → 4.8.33

package/src/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -1950,14 +1950,11 @@ export async function searchEntries(options) {
                         // Invalid embedding, use keyword score
                     }
                 }
-                // Fallback to keyword matching
+                // Skip entries without valid semantic embeddings — keyword fallback
+                // produces misleading 0.500 scores that degrade search quality.
+                // Entries must have real vector embeddings to participate in semantic search.
                 if (score < threshold) {
-                    const lowerContent = (content || '').toLowerCase();
-                    const lowerQuery = query.toLowerCase();
-                    const words = lowerQuery.split(/\s+/);
-                    const matchCount = words.filter(w => lowerContent.includes(w)).length;
-                    const keywordScore = matchCount / words.length * 0.5;
-                    score = Math.max(score, keywordScore);
+                    continue;
                 }
                 if (score >= threshold) {
                     results.push({

package/src/@claude-flow/neural/README.md

@@ -0,0 +1,260 @@
+# @claude-flow/neural
+
+[![npm version](https://img.shields.io/npm/v/@claude-flow/neural.svg)](https://www.npmjs.com/package/@claude-flow/neural)
+[![npm downloads](https://img.shields.io/npm/dm/@claude-flow/neural.svg)](https://www.npmjs.com/package/@claude-flow/neural)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![AI Learning](https://img.shields.io/badge/AI-Self--Learning-purple.svg)](https://github.com/eric-cielo/moflo)
+
+> Self-Optimizing Neural Architecture (SONA) module for Claude Flow V3 - adaptive learning, trajectory tracking, and pattern-based optimization.
+
+## Features
+
+- **SONA Learning** - Self-Optimizing Neural Architecture with <0.05ms adaptation time
+- **5 Learning Modes** - Real-time, Balanced, Research, Edge, and Batch modes
+- **9 RL Algorithms** - PPO, A2C, DQN, Q-Learning, SARSA, Decision Transformer, and more
+- **LoRA Integration** - Low-Rank Adaptation for efficient fine-tuning
+- **EWC++ Memory** - Elastic Weight Consolidation for continual learning without forgetting
+- **Trajectory Tracking** - Record and learn from agent execution paths
+- **Pattern Recognition** - Automatic pattern extraction and reuse
+
+## Installation
+
+```bash
+npm install @claude-flow/neural
+```
+
+## Quick Start
+
+```typescript
+import { SONAManager, createSONAManager } from '@claude-flow/neural';
+
+// Create SONA manager
+const sona = createSONAManager('balanced');
+await sona.initialize();
+
+// Begin trajectory tracking
+const trajectoryId = sona.beginTrajectory('code-review-task', 'development');
+
+// Record steps
+sona.recordStep(trajectoryId, 'analyze-code', 0.8, stateEmbedding, {
+  filesAnalyzed: 5,
+  issuesFound: 2
+});
+
+sona.recordStep(trajectoryId, 'generate-feedback', 0.9, newStateEmbedding);
+
+// Complete trajectory
+const trajectory = sona.completeTrajectory(trajectoryId);
+
+// Find similar patterns for guidance
+const patterns = await sona.findSimilarPatterns(contextEmbedding, 3);
+```
+
+## Learning Modes
+
+| Mode | Adaptation | Quality | Memory | Use Case |
+|------|------------|---------|--------|----------|
+| **real-time** | <0.5ms | 70%+ | 25MB | Production, low-latency |
+| **balanced** | <18ms | 75%+ | 50MB | General purpose |
+| **research** | <100ms | 95%+ | 100MB | Deep exploration |
+| **edge** | <1ms | 80%+ | 5MB | Resource-constrained |
+| **batch** | <50ms | 85%+ | 75MB | High-throughput |
+
+```typescript
+// Switch modes dynamically
+await sona.setMode('research');
+
+// Get current configuration
+const { mode, config, optimizations } = sona.getConfig();
+```
+
+## API Reference
+
+### SONA Manager
+
+```typescript
+import { SONAManager } from '@claude-flow/neural';
+
+const sona = new SONAManager('balanced');
+await sona.initialize();
+
+// Trajectory Management
+const trajectoryId = sona.beginTrajectory(context, domain);
+sona.recordStep(trajectoryId, action, reward, stateEmbedding, metadata);
+const trajectory = sona.completeTrajectory(trajectoryId, finalQuality);
+
+// Pattern Matching
+const patterns = await sona.findSimilarPatterns(embedding, k);
+const pattern = sona.storePattern({ name, strategy, embedding, domain });
+sona.updatePatternUsage(patternId, quality);
+
+// Learning
+await sona.triggerLearning('manual');
+const output = await sona.applyAdaptations(input, domain);
+
+// Statistics
+const stats = sona.getStats();
+```
+
+### RL Algorithms
+
+```typescript
+import { PPO, A2C, DQN, QLearning, SARSA, DecisionTransformer } from '@claude-flow/neural';
+
+// Proximal Policy Optimization
+const ppo = new PPO({
+  learningRate: 0.0003,
+  epsilon: 0.2,
+  valueCoef: 0.5
+});
+
+// Advantage Actor-Critic
+const a2c = new A2C({
+  learningRate: 0.001,
+  gamma: 0.99,
+  entropyCoef: 0.01
+});
+
+// Deep Q-Network
+const dqn = new DQN({
+  learningRate: 0.001,
+  gamma: 0.99,
+  epsilon: 0.1,
+  targetUpdateFreq: 100
+});
+
+// Decision Transformer
+const dt = new DecisionTransformer({
+  contextLength: 20,
+  embeddingDim: 256,
+  numHeads: 4
+});
+```
+
+### LoRA Configuration
+
+```typescript
+// Get LoRA config for current mode
+const loraConfig = sona.getLoRAConfig();
+// {
+//   rank: 4,
+//   alpha: 8,
+//   dropout: 0.05,
+//   targetModules: ['q_proj', 'v_proj', 'k_proj', 'o_proj'],
+//   microLoRA: false
+// }
+
+// Initialize LoRA weights for a domain
+const weights = sona.initializeLoRAWeights('code-generation');
+```
+
+### EWC++ (Elastic Weight Consolidation)
+
+```typescript
+// Get EWC config
+const ewcConfig = sona.getEWCConfig();
+// {
+//   lambda: 2000,
+//   decay: 0.9,
+//   fisherSamples: 100,
+//   minFisher: 1e-8,
+//   online: true
+// }
+
+// Consolidate after learning a new task
+sona.consolidateEWC();
+```
+
+### Event System
+
+```typescript
+// Subscribe to neural events
+sona.addEventListener((event) => {
+  switch (event.type) {
+    case 'trajectory_started':
+      console.log(`Started: ${event.trajectoryId}`);
+      break;
+    case 'trajectory_completed':
+      console.log(`Completed with quality: ${event.qualityScore}`);
+      break;
+    case 'pattern_matched':
+      console.log(`Pattern ${event.patternId} matched`);
+      break;
+    case 'learning_triggered':
+      console.log(`Learning: ${event.reason}`);
+      break;
+    case 'mode_changed':
+      console.log(`Mode: ${event.fromMode} -> ${event.toMode}`);
+      break;
+  }
+});
+```
+
+## Mode Configurations
+
+```typescript
+// Real-time mode (ultra-fast)
+{
+  loraRank: 2,
+  learningRate: 0.001,
+  batchSize: 32,
+  trajectoryCapacity: 1000,
+  qualityThreshold: 0.7,
+  maxLatencyMs: 0.5
+}
+
+// Research mode (high quality)
+{
+  loraRank: 16,
+  learningRate: 0.002,
+  batchSize: 64,
+  trajectoryCapacity: 10000,
+  qualityThreshold: 0.2,
+  maxLatencyMs: 100
+}
+```
+
+## Performance Targets
+
+| Metric | Target | Typical |
+|--------|--------|---------|
+| Adaptation latency | <0.05ms | 0.02ms |
+| Pattern retrieval | <1ms | 0.5ms |
+| Learning step | <10ms | 5ms |
+| Quality improvement | +55% | +40-60% |
+| Memory overhead | <50MB | 25-75MB |
+
+## TypeScript Types
+
+```typescript
+import type {
+  SONAMode,
+  SONAModeConfig,
+  Trajectory,
+  TrajectoryStep,
+  Pattern,
+  PatternMatch,
+  NeuralStats,
+  NeuralEvent,
+  LoRAConfig,
+  LoRAWeights,
+  EWCConfig,
+  RLAlgorithm
+} from '@claude-flow/neural';
+```
+
+## Dependencies
+
+- [@claude-flow/memory](../memory) - Memory integration
+- `@ruvector/sona` - SONA learning engine
+
+## Related Packages
+
+- [@claude-flow/memory](../memory) - Vector memory for patterns
+- [@claude-flow/integration](../integration) - agentic-flow integration
+- [@claude-flow/performance](../performance) - Benchmarking
+
+## License
+
+MIT

package/src/@claude-flow/neural/dist/algorithms/a2c.js

@@ -0,0 +1,361 @@
+/**
+ * Advantage Actor-Critic (A2C)
+ *
+ * Implements synchronous A2C algorithm with:
+ * - Shared actor-critic network
+ * - N-step returns
+ * - Entropy regularization
+ * - Advantage normalization
+ *
+ * Performance Target: <10ms per update step
+ */
+/**
+ * Default A2C configuration
+ */
+export const DEFAULT_A2C_CONFIG = {
+    algorithm: 'a2c',
+    learningRate: 0.0007,
+    gamma: 0.99,
+    entropyCoef: 0.01,
+    valueLossCoef: 0.5,
+    maxGradNorm: 0.5,
+    epochs: 1,
+    miniBatchSize: 32,
+    nSteps: 5,
+    useGAE: true,
+    gaeLambda: 0.95,
+};
+/**
+ * A2C Algorithm Implementation
+ */
+export class A2CAlgorithm {
+    config;
+    // Shared network weights
+    sharedWeights;
+    policyHead;
+    valueHead;
+    // Optimizer state
+    sharedMomentum;
+    policyMomentum;
+    valueMomentum;
+    // Experience buffer for n-step
+    buffer = [];
+    // Dimensions
+    inputDim = 768;
+    hiddenDim = 64;
+    numActions = 4;
+    // Statistics
+    updateCount = 0;
+    avgPolicyLoss = 0;
+    avgValueLoss = 0;
+    avgEntropy = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_A2C_CONFIG, ...config };
+        // Initialize network
+        const scale = Math.sqrt(2 / this.inputDim);
+        this.sharedWeights = new Float32Array(this.inputDim * this.hiddenDim);
+        this.policyHead = new Float32Array(this.hiddenDim * this.numActions);
+        this.valueHead = new Float32Array(this.hiddenDim);
+        for (let i = 0; i < this.sharedWeights.length; i++) {
+            this.sharedWeights[i] = (Math.random() - 0.5) * scale;
+        }
+        for (let i = 0; i < this.policyHead.length; i++) {
+            this.policyHead[i] = (Math.random() - 0.5) * 0.1;
+        }
+        for (let i = 0; i < this.valueHead.length; i++) {
+            this.valueHead[i] = (Math.random() - 0.5) * 0.1;
+        }
+        // Initialize momentum
+        this.sharedMomentum = new Float32Array(this.sharedWeights.length);
+        this.policyMomentum = new Float32Array(this.policyHead.length);
+        this.valueMomentum = new Float32Array(this.valueHead.length);
+    }
+    /**
+     * Add experience from trajectory
+     */
+    addExperience(trajectory) {
+        for (const step of trajectory.steps) {
+            const { probs, value, entropy } = this.evaluate(step.stateAfter);
+            const action = this.hashAction(step.action);
+            this.buffer.push({
+                state: step.stateAfter,
+                action,
+                reward: step.reward,
+                value,
+                logProb: Math.log(probs[action] + 1e-8),
+                entropy,
+            });
+        }
+    }
+    /**
+     * Perform A2C update
+     * Target: <10ms
+     */
+    update() {
+        const startTime = performance.now();
+        if (this.buffer.length < this.config.nSteps) {
+            return { policyLoss: 0, valueLoss: 0, entropy: 0 };
+        }
+        // Compute returns and advantages
+        const returns = this.computeReturns();
+        const advantages = this.computeAdvantages(returns);
+        // Initialize gradients
+        const sharedGrad = new Float32Array(this.sharedWeights.length);
+        const policyGrad = new Float32Array(this.policyHead.length);
+        const valueGrad = new Float32Array(this.valueHead.length);
+        let totalPolicyLoss = 0;
+        let totalValueLoss = 0;
+        let totalEntropy = 0;
+        // Process all experiences
+        for (let i = 0; i < this.buffer.length; i++) {
+            const exp = this.buffer[i];
+            const advantage = advantages[i];
+            const return_ = returns[i];
+            // Get current policy and value
+            const { probs, value, hidden } = this.forwardWithHidden(exp.state);
+            const logProb = Math.log(probs[exp.action] + 1e-8);
+            // Policy loss
+            const policyLoss = -logProb * advantage;
+            totalPolicyLoss += policyLoss;
+            // Value loss
+            const valueLoss = (value - return_) ** 2;
+            totalValueLoss += valueLoss;
+            // Entropy
+            let entropy = 0;
+            for (const p of probs) {
+                if (p > 0)
+                    entropy -= p * Math.log(p);
+            }
+            totalEntropy += entropy;
+            // Accumulate gradients
+            this.accumulateGradients(sharedGrad, policyGrad, valueGrad, exp.state, hidden, exp.action, advantage, value - return_);
+        }
+        // Add entropy bonus to policy gradient
+        for (let i = 0; i < policyGrad.length; i++) {
+            policyGrad[i] -= this.config.entropyCoef * totalEntropy / this.buffer.length;
+        }
+        // Apply gradients
+        this.applyGradients(sharedGrad, policyGrad, valueGrad, this.buffer.length);
+        // Clear buffer
+        this.buffer = [];
+        this.updateCount++;
+        this.avgPolicyLoss = totalPolicyLoss / this.buffer.length || 0;
+        this.avgValueLoss = totalValueLoss / this.buffer.length || 0;
+        this.avgEntropy = totalEntropy / this.buffer.length || 0;
+        const elapsed = performance.now() - startTime;
+        if (elapsed > 10) {
+            console.warn(`A2C update exceeded target: ${elapsed.toFixed(2)}ms > 10ms`);
+        }
+        return {
+            policyLoss: this.avgPolicyLoss,
+            valueLoss: this.avgValueLoss,
+            entropy: this.avgEntropy,
+        };
+    }
+    /**
+     * Get action from policy
+     */
+    getAction(state) {
+        const { probs, value } = this.evaluate(state);
+        const action = this.sampleAction(probs);
+        return { action, value };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            updateCount: this.updateCount,
+            bufferSize: this.buffer.length,
+            avgPolicyLoss: this.avgPolicyLoss,
+            avgValueLoss: this.avgValueLoss,
+            avgEntropy: this.avgEntropy,
+        };
+    }
+    // ==========================================================================
+    // Private Methods
+    // ==========================================================================
+    evaluate(state) {
+        const { probs, value } = this.forward(state);
+        let entropy = 0;
+        for (const p of probs) {
+            if (p > 0)
+                entropy -= p * Math.log(p);
+        }
+        return { probs, value, entropy };
+    }
+    forward(state) {
+        // Shared hidden layer
+        const hidden = new Float32Array(this.hiddenDim);
+        for (let h = 0; h < this.hiddenDim; h++) {
+            let sum = 0;
+            for (let i = 0; i < Math.min(state.length, this.inputDim); i++) {
+                sum += state[i] * this.sharedWeights[i * this.hiddenDim + h];
+            }
+            hidden[h] = Math.max(0, sum); // ReLU
+        }
+        // Policy head
+        const logits = new Float32Array(this.numActions);
+        for (let a = 0; a < this.numActions; a++) {
+            let sum = 0;
+            for (let h = 0; h < this.hiddenDim; h++) {
+                sum += hidden[h] * this.policyHead[h * this.numActions + a];
+            }
+            logits[a] = sum;
+        }
+        const probs = this.softmax(logits);
+        // Value head
+        let value = 0;
+        for (let h = 0; h < this.hiddenDim; h++) {
+            value += hidden[h] * this.valueHead[h];
+        }
+        return { probs, value };
+    }
+    forwardWithHidden(state) {
+        const hidden = new Float32Array(this.hiddenDim);
+        for (let h = 0; h < this.hiddenDim; h++) {
+            let sum = 0;
+            for (let i = 0; i < Math.min(state.length, this.inputDim); i++) {
+                sum += state[i] * this.sharedWeights[i * this.hiddenDim + h];
+            }
+            hidden[h] = Math.max(0, sum);
+        }
+        const logits = new Float32Array(this.numActions);
+        for (let a = 0; a < this.numActions; a++) {
+            let sum = 0;
+            for (let h = 0; h < this.hiddenDim; h++) {
+                sum += hidden[h] * this.policyHead[h * this.numActions + a];
+            }
+            logits[a] = sum;
+        }
+        const probs = this.softmax(logits);
+        let value = 0;
+        for (let h = 0; h < this.hiddenDim; h++) {
+            value += hidden[h] * this.valueHead[h];
+        }
+        return { probs, value, hidden };
+    }
+    computeReturns() {
+        const returns = new Array(this.buffer.length).fill(0);
+        let cumReturn = 0;
+        // Bootstrap from last value if not terminal
+        if (this.buffer.length > 0) {
+            cumReturn = this.buffer[this.buffer.length - 1].value;
+        }
+        for (let t = this.buffer.length - 1; t >= 0; t--) {
+            cumReturn = this.buffer[t].reward + this.config.gamma * cumReturn;
+            returns[t] = cumReturn;
+        }
+        return returns;
+    }
+    computeAdvantages(returns) {
+        if (this.config.useGAE) {
+            return this.computeGAE();
+        }
+        // Simple advantage: return - value
+        const advantages = new Array(this.buffer.length).fill(0);
+        for (let i = 0; i < this.buffer.length; i++) {
+            advantages[i] = returns[i] - this.buffer[i].value;
+        }
+        // Normalize
+        const mean = advantages.reduce((a, b) => a + b, 0) / advantages.length;
+        const std = Math.sqrt(advantages.reduce((a, b) => a + (b - mean) ** 2, 0) / advantages.length) + 1e-8;
+        return advantages.map(a => (a - mean) / std);
+    }
+    computeGAE() {
+        const advantages = new Array(this.buffer.length).fill(0);
+        let lastGae = 0;
+        for (let t = this.buffer.length - 1; t >= 0; t--) {
+            const nextValue = t < this.buffer.length - 1
+                ? this.buffer[t + 1].value
+                : 0;
+            const delta = this.buffer[t].reward + this.config.gamma * nextValue - this.buffer[t].value;
+            lastGae = delta + this.config.gamma * this.config.gaeLambda * lastGae;
+            advantages[t] = lastGae;
+        }
+        // Normalize
+        const mean = advantages.reduce((a, b) => a + b, 0) / advantages.length;
+        const std = Math.sqrt(advantages.reduce((a, b) => a + (b - mean) ** 2, 0) / advantages.length) + 1e-8;
+        return advantages.map(a => (a - mean) / std);
+    }
+    accumulateGradients(sharedGrad, policyGrad, valueGrad, state, hidden, action, advantage, valueError) {
+        // Policy gradient
+        for (let h = 0; h < this.hiddenDim; h++) {
+            policyGrad[h * this.numActions + action] += hidden[h] * advantage;
+        }
+        // Value gradient
+        for (let h = 0; h < this.hiddenDim; h++) {
+            valueGrad[h] += hidden[h] * valueError * this.config.valueLossCoef;
+        }
+        // Shared layer gradient (backprop through both heads)
+        for (let h = 0; h < this.hiddenDim; h++) {
+            if (hidden[h] > 0) { // ReLU gradient
+                const policySignal = advantage * this.policyHead[h * this.numActions + action];
+                const valueSignal = valueError * this.valueHead[h] * this.config.valueLossCoef;
+                const totalSignal = policySignal + valueSignal;
+                for (let i = 0; i < Math.min(state.length, this.inputDim); i++) {
+                    sharedGrad[i * this.hiddenDim + h] += state[i] * totalSignal;
+                }
+            }
+        }
+    }
+    applyGradients(sharedGrad, policyGrad, valueGrad, batchSize) {
+        const lr = this.config.learningRate / batchSize;
+        const beta = 0.9;
+        // Apply to shared weights
+        for (let i = 0; i < this.sharedWeights.length; i++) {
+            const grad = Math.max(Math.min(sharedGrad[i], this.config.maxGradNorm), -this.config.maxGradNorm);
+            this.sharedMomentum[i] = beta * this.sharedMomentum[i] + (1 - beta) * grad;
+            this.sharedWeights[i] -= lr * this.sharedMomentum[i];
+        }
+        // Apply to policy head
+        for (let i = 0; i < this.policyHead.length; i++) {
+            const grad = Math.max(Math.min(policyGrad[i], this.config.maxGradNorm), -this.config.maxGradNorm);
+            this.policyMomentum[i] = beta * this.policyMomentum[i] + (1 - beta) * grad;
+            this.policyHead[i] -= lr * this.policyMomentum[i];
+        }
+        // Apply to value head
+        for (let i = 0; i < this.valueHead.length; i++) {
+            const grad = Math.max(Math.min(valueGrad[i], this.config.maxGradNorm), -this.config.maxGradNorm);
+            this.valueMomentum[i] = beta * this.valueMomentum[i] + (1 - beta) * grad;
+            this.valueHead[i] -= lr * this.valueMomentum[i];
+        }
+    }
+    softmax(logits) {
+        const max = Math.max(...logits);
+        const exps = new Float32Array(logits.length);
+        let sum = 0;
+        for (let i = 0; i < logits.length; i++) {
+            exps[i] = Math.exp(logits[i] - max);
+            sum += exps[i];
+        }
+        for (let i = 0; i < exps.length; i++) {
+            exps[i] /= sum;
+        }
+        return exps;
+    }
+    sampleAction(probs) {
+        const r = Math.random();
+        let cumSum = 0;
+        for (let i = 0; i < probs.length; i++) {
+            cumSum += probs[i];
+            if (r < cumSum)
+                return i;
+        }
+        return probs.length - 1;
+    }
+    hashAction(action) {
+        let hash = 0;
+        for (let i = 0; i < action.length; i++) {
+            hash = (hash * 31 + action.charCodeAt(i)) % this.numActions;
+        }
+        return hash;
+    }
+}
+/**
+ * Factory function
+ */
+export function createA2C(config) {
+    return new A2CAlgorithm(config);
+}
+//# sourceMappingURL=a2c.js.map