claude-flow 3.10.1 → 3.10.4

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/neural/src/modes/research.d.ts

@@ -1,79 +0,0 @@
-/**
- * Research Mode Implementation
- *
- * Optimized for maximum quality with:
- * - +55% quality improvement target
- * - Learning rate 0.002 (sweet spot)
- * - Rank-16 LoRA
- * - Gradient checkpointing
- * - Full learning pipeline
- */
-import type { SONAModeConfig, Trajectory, Pattern, PatternMatch, LoRAWeights, EWCState } from '../types.js';
-import { BaseModeImplementation } from './index.js';
-/**
- * Research mode for maximum quality learning
- */
-export declare class ResearchMode extends BaseModeImplementation {
-    readonly mode = "research";
-    private patternIndex;
-    private clusterCentroids;
-    private gradientHistory;
-    private checkpoints;
-    private adamM;
-    private adamV;
-    private adamStep;
-    private totalPatternMatches;
-    private totalPatternTime;
-    private totalLearnTime;
-    private learnIterations;
-    private qualityHistory;
-    private explorationRewards;
-    initialize(): Promise<void>;
-    cleanup(): Promise<void>;
-    /**
-     * Find patterns using cluster-based search
-     */
-    findPatterns(embedding: Float32Array, k: number, patterns: Pattern[]): Promise<PatternMatch[]>;
-    /**
-     * Learn using full Adam optimizer with gradient checkpointing
-     */
-    learn(trajectories: Trajectory[], config: SONAModeConfig, ewcState: EWCState): Promise<number>;
-    /**
-     * Apply LoRA with rank-16 for maximum expressivity
-     */
-    applyLoRA(input: Float32Array, weights?: LoRAWeights): Promise<Float32Array>;
-    getStats(): Record<string, number>;
-    /**
-     * Rebuild cluster centroids using k-means
-     */
-    private rebuildClusters;
-    /**
-     * Get nearest clusters to embedding
-     */
-    private getNearestClusters;
-    /**
-     * Compute confidence for pattern match
-     */
-    private computeConfidence;
-    /**
-     * Create learning checkpoint
-     */
-    private createCheckpoint;
-    /**
-     * Process a mini-batch with Adam optimizer
-     */
-    private processBatch;
-    /**
-     * Compute gradient from trajectory
-     */
-    private computeTrajectoryGradient;
-    /**
-     * Compute advantages using GAE
-     */
-    private computeAdvantages;
-    /**
-     * Compute EWC loss for continual learning
-     */
-    private computeEWCLoss;
-}
-//# sourceMappingURL=research.d.ts.map

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/neural/src/modes/research.js

@@ -1,389 +0,0 @@
-/**
- * Research Mode Implementation
- *
- * Optimized for maximum quality with:
- * - +55% quality improvement target
- * - Learning rate 0.002 (sweet spot)
- * - Rank-16 LoRA
- * - Gradient checkpointing
- * - Full learning pipeline
- */
-import { BaseModeImplementation } from './index.js';
-/**
- * Research mode for maximum quality learning
- */
-export class ResearchMode extends BaseModeImplementation {
-    mode = 'research';
-    // Extended pattern storage
-    patternIndex = new Map();
-    clusterCentroids = [];
-    // Learning state with checkpointing
-    gradientHistory = [];
-    checkpoints = [];
-    // Adam optimizer state
-    adamM = new Map();
-    adamV = new Map();
-    adamStep = 0;
-    // Stats
-    totalPatternMatches = 0;
-    totalPatternTime = 0;
-    totalLearnTime = 0;
-    learnIterations = 0;
-    qualityHistory = [];
-    explorationRewards = [];
-    async initialize() {
-        await super.initialize();
-        this.patternIndex.clear();
-        this.clusterCentroids = [];
-        this.gradientHistory = [];
-        this.checkpoints = [];
-        this.adamM.clear();
-        this.adamV.clear();
-        this.adamStep = 0;
-    }
-    async cleanup() {
-        this.patternIndex.clear();
-        this.clusterCentroids = [];
-        this.gradientHistory = [];
-        this.checkpoints = [];
-        this.adamM.clear();
-        this.adamV.clear();
-        await super.cleanup();
-    }
-    /**
-     * Find patterns using cluster-based search
-     */
-    async findPatterns(embedding, k, patterns) {
-        const startTime = performance.now();
-        // Update clusters if needed
-        if (this.clusterCentroids.length !== this.config.patternClusters) {
-            await this.rebuildClusters(patterns);
-        }
-        // Find nearest cluster
-        let bestCluster = 0;
-        let bestSim = -1;
-        for (let c = 0; c < this.clusterCentroids.length; c++) {
-            const sim = this.cosineSimilarity(embedding, this.clusterCentroids[c]);
-            if (sim > bestSim) {
-                bestSim = sim;
-                bestCluster = c;
-            }
-        }
-        // Search within cluster + nearby clusters
-        const clustersToSearch = this.getNearestClusters(embedding, 3);
-        const candidates = [];
-        for (const pattern of patterns) {
-            const patternCluster = this.patternIndex.get(pattern.patternId);
-            if (patternCluster !== undefined && clustersToSearch.includes(patternCluster)) {
-                const similarity = this.cosineSimilarity(embedding, pattern.embedding);
-                candidates.push({
-                    pattern,
-                    similarity,
-                    confidence: this.computeConfidence(pattern, similarity),
-                    latencyMs: 0,
-                });
-            }
-        }
-        // If not enough candidates, search all patterns
-        if (candidates.length < k) {
-            for (const pattern of patterns) {
-                if (!candidates.find(c => c.pattern.patternId === pattern.patternId)) {
-                    const similarity = this.cosineSimilarity(embedding, pattern.embedding);
-                    candidates.push({
-                        pattern,
-                        similarity,
-                        confidence: this.computeConfidence(pattern, similarity),
-                        latencyMs: 0,
-                    });
-                }
-            }
-        }
-        // Sort and return top-k
-        candidates.sort((a, b) => b.similarity - a.similarity);
-        this.totalPatternTime += performance.now() - startTime;
-        this.totalPatternMatches++;
-        return candidates.slice(0, k);
-    }
-    /**
-     * Learn using full Adam optimizer with gradient checkpointing
-     */
-    async learn(trajectories, config, ewcState) {
-        const startTime = performance.now();
-        if (trajectories.length === 0)
-            return 0;
-        // Research mode uses low threshold to learn from all data
-        const learningRate = config.learningRate; // 0.002 sweet spot
-        const batchSize = config.batchSize;
-        // Sort trajectories by quality
-        const sortedTrajectories = [...trajectories].sort((a, b) => b.qualityScore - a.qualityScore);
-        // Create checkpoint before learning
-        if (this.learnIterations % 10 === 0) {
-            this.createCheckpoint();
-        }
-        let totalLoss = 0;
-        let batchCount = 0;
-        // Process in mini-batches
-        for (let i = 0; i < sortedTrajectories.length; i += batchSize) {
-            const batch = sortedTrajectories.slice(i, i + batchSize);
-            const batchLoss = await this.processBatch(batch, learningRate, ewcState, config.ewcLambda);
-            totalLoss += batchLoss;
-            batchCount++;
-        }
-        // Track quality
-        const avgQuality = sortedTrajectories.reduce((s, t) => s + t.qualityScore, 0) / sortedTrajectories.length;
-        this.qualityHistory.push(avgQuality);
-        if (this.qualityHistory.length > 1000) {
-            this.qualityHistory = this.qualityHistory.slice(-1000);
-        }
-        // Compute improvement
-        const recentAvg = this.qualityHistory.slice(-10).reduce((a, b) => a + b, 0) / Math.min(10, this.qualityHistory.length);
-        const oldAvg = this.qualityHistory.slice(0, Math.max(1, this.qualityHistory.length - 10)).reduce((a, b) => a + b, 0) / Math.max(1, this.qualityHistory.length - 10);
-        const improvementDelta = recentAvg - oldAvg;
-        this.totalLearnTime += performance.now() - startTime;
-        this.learnIterations++;
-        return Math.max(0, improvementDelta * 2); // Scale for research mode
-    }
-    /**
-     * Apply LoRA with rank-16 for maximum expressivity
-     */
-    async applyLoRA(input, weights) {
-        if (!weights) {
-            return input;
-        }
-        const output = new Float32Array(input.length);
-        output.set(input);
-        const rank = this.config.loraRank; // 16 for research mode
-        // Apply to all modules with higher blending
-        for (const module of ['q_proj', 'v_proj', 'k_proj', 'o_proj']) {
-            const A = weights.A.get(module);
-            const B = weights.B.get(module);
-            if (A && B) {
-                const adapted = this.applyLoRATransform(input, A, B, rank);
-                const alpha = 0.3; // Higher blending for research
-                for (let i = 0; i < output.length; i++) {
-                    output[i] = output[i] * (1 - alpha) + adapted[i] * alpha;
-                }
-            }
-        }
-        return output;
-    }
-    getStats() {
-        const avgQuality = this.qualityHistory.length > 0
-            ? this.qualityHistory.reduce((a, b) => a + b, 0) / this.qualityHistory.length
-            : 0;
-        const recentQuality = this.qualityHistory.slice(-10).reduce((a, b) => a + b, 0) / Math.min(10, this.qualityHistory.length) || 0;
-        return {
-            avgPatternMatchMs: this.totalPatternMatches > 0
-                ? this.totalPatternTime / this.totalPatternMatches
-                : 0,
-            avgLearnMs: this.learnIterations > 0
-                ? this.totalLearnTime / this.learnIterations
-                : 0,
-            avgQuality,
-            recentQuality,
-            qualityImprovement: recentQuality - avgQuality,
-            clusterCount: this.clusterCentroids.length,
-            checkpointCount: this.checkpoints.length,
-            adamStep: this.adamStep,
-            learnIterations: this.learnIterations,
-        };
-    }
-    /**
-     * Rebuild cluster centroids using k-means
-     */
-    async rebuildClusters(patterns) {
-        if (patterns.length === 0)
-            return;
-        const k = Math.min(this.config.patternClusters, patterns.length);
-        const dim = patterns[0].embedding.length;
-        // Initialize centroids randomly
-        this.clusterCentroids = [];
-        const indices = new Set();
-        while (indices.size < k) {
-            indices.add(Math.floor(Math.random() * patterns.length));
-        }
-        for (const idx of indices) {
-            this.clusterCentroids.push(new Float32Array(patterns[idx].embedding));
-        }
-        // Run k-means iterations
-        for (let iter = 0; iter < 10; iter++) {
-            // Assign patterns to clusters
-            const clusterAssignments = Array.from({ length: k }, () => []);
-            for (let p = 0; p < patterns.length; p++) {
-                let bestCluster = 0;
-                let bestSim = -1;
-                for (let c = 0; c < k; c++) {
-                    const sim = this.cosineSimilarity(patterns[p].embedding, this.clusterCentroids[c]);
-                    if (sim > bestSim) {
-                        bestSim = sim;
-                        bestCluster = c;
-                    }
-                }
-                clusterAssignments[bestCluster].push(p);
-                this.patternIndex.set(patterns[p].patternId, bestCluster);
-            }
-            // Update centroids
-            for (let c = 0; c < k; c++) {
-                if (clusterAssignments[c].length > 0) {
-                    const newCentroid = new Float32Array(dim);
-                    for (const p of clusterAssignments[c]) {
-                        for (let d = 0; d < dim; d++) {
-                            newCentroid[d] += patterns[p].embedding[d];
-                        }
-                    }
-                    for (let d = 0; d < dim; d++) {
-                        newCentroid[d] /= clusterAssignments[c].length;
-                    }
-                    this.clusterCentroids[c] = newCentroid;
-                }
-            }
-        }
-    }
-    /**
-     * Get nearest clusters to embedding
-     */
-    getNearestClusters(embedding, n) {
-        const similarities = [];
-        for (let c = 0; c < this.clusterCentroids.length; c++) {
-            similarities.push({ cluster: c, sim: this.cosineSimilarity(embedding, this.clusterCentroids[c]) });
-        }
-        similarities.sort((a, b) => b.sim - a.sim);
-        return similarities.slice(0, n).map(s => s.cluster);
-    }
-    /**
-     * Compute confidence for pattern match
-     */
-    computeConfidence(pattern, similarity) {
-        // Combine similarity with pattern history
-        const historyWeight = Math.min(pattern.usageCount / 10, 1);
-        return similarity * (1 - historyWeight * 0.3) + pattern.successRate * historyWeight * 0.3;
-    }
-    /**
-     * Create learning checkpoint
-     */
-    createCheckpoint() {
-        const state = new Map();
-        for (const [key, value] of this.adamM) {
-            state.set(`m_${key}`, new Float32Array(value));
-        }
-        for (const [key, value] of this.adamV) {
-            state.set(`v_${key}`, new Float32Array(value));
-        }
-        this.checkpoints.push({ iteration: this.learnIterations, state });
-        // Keep only last 10 checkpoints
-        if (this.checkpoints.length > 10) {
-            this.checkpoints = this.checkpoints.slice(-10);
-        }
-    }
-    /**
-     * Process a mini-batch with Adam optimizer
-     */
-    async processBatch(batch, learningRate, ewcState, ewcLambda) {
-        const beta1 = 0.9;
-        const beta2 = 0.999;
-        const epsilon = 1e-8;
-        this.adamStep++;
-        let totalLoss = 0;
-        for (const trajectory of batch) {
-            if (trajectory.steps.length === 0)
-                continue;
-            // Compute gradient from trajectory
-            const gradient = this.computeTrajectoryGradient(trajectory);
-            for (const [key, grad] of gradient) {
-                // Get or initialize Adam state
-                let m = this.adamM.get(key);
-                let v = this.adamV.get(key);
-                if (!m) {
-                    m = new Float32Array(grad.length);
-                    this.adamM.set(key, m);
-                }
-                if (!v) {
-                    v = new Float32Array(grad.length);
-                    this.adamV.set(key, v);
-                }
-                // Update biased first moment estimate
-                for (let i = 0; i < grad.length; i++) {
-                    m[i] = beta1 * m[i] + (1 - beta1) * grad[i];
-                }
-                // Update biased second moment estimate
-                for (let i = 0; i < grad.length; i++) {
-                    v[i] = beta2 * v[i] + (1 - beta2) * grad[i] * grad[i];
-                }
-                // Bias correction
-                const mHat = new Float32Array(grad.length);
-                const vHat = new Float32Array(grad.length);
-                for (let i = 0; i < grad.length; i++) {
-                    mHat[i] = m[i] / (1 - Math.pow(beta1, this.adamStep));
-                    vHat[i] = v[i] / (1 - Math.pow(beta2, this.adamStep));
-                }
-                // Compute loss contribution
-                for (let i = 0; i < grad.length; i++) {
-                    totalLoss += grad[i] * grad[i];
-                }
-            }
-        }
-        // Add EWC penalty
-        const ewcPenalty = this.computeEWCLoss(ewcState, ewcLambda);
-        totalLoss += ewcPenalty;
-        return totalLoss / batch.length;
-    }
-    /**
-     * Compute gradient from trajectory
-     */
-    computeTrajectoryGradient(trajectory) {
-        const gradient = new Map();
-        if (trajectory.steps.length < 2)
-            return gradient;
-        // Use advantage estimation
-        const rewards = trajectory.steps.map(s => s.reward);
-        const advantages = this.computeAdvantages(rewards);
-        for (let i = 0; i < trajectory.steps.length; i++) {
-            const step = trajectory.steps[i];
-            const advantage = advantages[i];
-            // Policy gradient: grad = advantage * grad_log_pi
-            const stateGrad = new Float32Array(step.stateAfter.length);
-            for (let j = 0; j < stateGrad.length; j++) {
-                stateGrad[j] = step.stateAfter[j] * advantage;
-            }
-            gradient.set(`step_${i}`, stateGrad);
-        }
-        return gradient;
-    }
-    /**
-     * Compute advantages using GAE
-     */
-    computeAdvantages(rewards) {
-        const gamma = 0.99;
-        const lambda = 0.95;
-        const advantages = new Array(rewards.length).fill(0);
-        let lastGae = 0;
-        for (let t = rewards.length - 1; t >= 0; t--) {
-            const nextValue = t < rewards.length - 1 ? rewards[t + 1] : 0;
-            const delta = rewards[t] + gamma * nextValue - rewards[t];
-            lastGae = delta + gamma * lambda * lastGae;
-            advantages[t] = lastGae;
-        }
-        // Normalize advantages
-        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);
-    }
-    /**
-     * Compute EWC loss for continual learning
-     */
-    computeEWCLoss(ewcState, lambda) {
-        let loss = 0;
-        for (const [key, fisher] of ewcState.fisher) {
-            const means = ewcState.means.get(key);
-            const current = this.adamM.get(key);
-            if (means && current) {
-                for (let i = 0; i < Math.min(fisher.length, means.length, current.length); i++) {
-                    const diff = current[i] - means[i];
-                    loss += fisher[i] * diff * diff;
-                }
-            }
-        }
-        return lambda * loss * 0.5;
-    }
-}
-//# sourceMappingURL=research.js.map