moflo 4.8.32 → 4.8.34

package/src/@claude-flow/neural/dist/application/services/neural-application-service.js

@@ -0,0 +1,161 @@
+/**
+ * Neural Application Service - Application Layer
+ *
+ * Orchestrates neural learning operations.
+ *
+ * @module v3/neural/application/services
+ */
+import { Pattern } from '../../domain/entities/pattern.js';
+import { LearningDomainService } from '../../domain/services/learning-service.js';
+/**
+ * Neural Application Service
+ */
+export class NeuralApplicationService {
+    learningService;
+    constructor() {
+        this.learningService = new LearningDomainService();
+    }
+    // ============================================================================
+    // Learning Operations
+    // ============================================================================
+    /**
+     * Learn from a single trajectory
+     */
+    learn(trajectory) {
+        return this.learningService.updatePatterns(trajectory);
+    }
+    /**
+     * Train on batch of trajectories
+     */
+    train(trajectories) {
+        const start = Date.now();
+        let totalPatternsExtracted = 0;
+        let totalPatternsUpdated = 0;
+        let totalConfidenceChange = 0;
+        for (const trajectory of trajectories) {
+            const result = this.learningService.updatePatterns(trajectory);
+            totalPatternsExtracted += result.patternsExtracted;
+            totalPatternsUpdated += result.patternsUpdated;
+            totalConfidenceChange += result.confidenceChange;
+        }
+        return {
+            trajectoriesProcessed: trajectories.length,
+            patternsExtracted: totalPatternsExtracted,
+            patternsUpdated: totalPatternsUpdated,
+            averageConfidenceChange: trajectories.length > 0 ? totalConfidenceChange / trajectories.length : 0,
+            duration: Date.now() - start,
+        };
+    }
+    // ============================================================================
+    // Routing
+    // ============================================================================
+    /**
+     * Get route recommendation for task
+     */
+    route(taskDescription) {
+        return this.learningService.getRouteRecommendation(taskDescription);
+    }
+    /**
+     * Explain routing decision
+     */
+    explain(taskDescription) {
+        const recommendation = this.route(taskDescription);
+        const matchingPatterns = this.learningService
+            .getPatternsByType('task-routing')
+            .filter((p) => p.matches(taskDescription));
+        const reasoning = [];
+        if (matchingPatterns.length > 0) {
+            reasoning.push(`Found ${matchingPatterns.length} matching patterns`);
+            for (const p of matchingPatterns.slice(0, 3)) {
+                reasoning.push(`- Pattern "${p.name}": ${p.successRate.toFixed(2)} success rate, ${p.confidence.toFixed(2)} confidence`);
+            }
+        }
+        else {
+            reasoning.push('No matching patterns found, using keyword-based routing');
+        }
+        reasoning.push(`Recommended: ${recommendation.agentRole} (${(recommendation.confidence * 100).toFixed(0)}% confidence)`);
+        return {
+            recommendation,
+            matchingPatterns,
+            reasoning,
+        };
+    }
+    // ============================================================================
+    // Pattern Management
+    // ============================================================================
+    /**
+     * Get all patterns
+     */
+    getPatterns() {
+        return this.learningService.getPatterns();
+    }
+    /**
+     * Get patterns by type
+     */
+    getPatternsByType(type) {
+        return this.learningService.getPatternsByType(type);
+    }
+    /**
+     * Add custom pattern
+     */
+    addPattern(props) {
+        const pattern = Pattern.create({
+            type: props.type,
+            name: props.name,
+            description: props.description,
+            condition: props.condition,
+            action: props.action,
+            confidence: props.confidence ?? 0.5,
+        });
+        this.learningService.addPattern(pattern);
+        return pattern;
+    }
+    /**
+     * Remove pattern
+     */
+    removePattern(id) {
+        return this.learningService.removePattern(id);
+    }
+    /**
+     * Consolidate patterns
+     */
+    consolidate(minConfidence) {
+        return this.learningService.consolidate(minConfidence);
+    }
+    // ============================================================================
+    // Metrics
+    // ============================================================================
+    /**
+     * Get neural metrics
+     */
+    getMetrics() {
+        const patterns = this.learningService.getPatterns();
+        const patternsByType = {
+            'task-routing': 0,
+            'error-recovery': 0,
+            optimization: 0,
+            learning: 0,
+        };
+        let totalConfidence = 0;
+        let reliablePatterns = 0;
+        let totalSuccesses = 0;
+        let totalFailures = 0;
+        for (const pattern of patterns) {
+            patternsByType[pattern.type]++;
+            totalConfidence += pattern.confidence;
+            if (pattern.isReliable())
+                reliablePatterns++;
+            totalSuccesses += pattern.successCount;
+            totalFailures += pattern.failureCount;
+        }
+        return {
+            totalPatterns: patterns.length,
+            patternsByType,
+            averageConfidence: patterns.length > 0 ? totalConfidence / patterns.length : 0,
+            reliablePatterns,
+            totalSuccesses,
+            totalFailures,
+        };
+    }
+}
+//# sourceMappingURL=neural-application-service.js.map

package/src/@claude-flow/neural/dist/domain/entities/pattern.js

@@ -0,0 +1,134 @@
+/**
+ * Pattern Entity - Domain Layer
+ *
+ * Represents a learned pattern for intelligent routing and optimization.
+ *
+ * @module v3/neural/domain/entities
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Pattern Entity
+ */
+export class Pattern {
+    _id;
+    _type;
+    _name;
+    _description;
+    _condition;
+    _action;
+    _confidence;
+    _successCount;
+    _failureCount;
+    _metadata;
+    _createdAt;
+    _updatedAt;
+    _lastMatchedAt;
+    constructor(props) {
+        const now = new Date();
+        this._id = props.id ?? randomUUID();
+        this._type = props.type;
+        this._name = props.name;
+        this._description = props.description;
+        this._condition = props.condition;
+        this._action = props.action;
+        this._confidence = props.confidence;
+        this._successCount = props.successCount ?? 0;
+        this._failureCount = props.failureCount ?? 0;
+        this._metadata = props.metadata ?? {};
+        this._createdAt = props.createdAt ?? now;
+        this._updatedAt = props.updatedAt ?? now;
+        this._lastMatchedAt = props.lastMatchedAt;
+    }
+    static create(props) {
+        return new Pattern(props);
+    }
+    static fromPersistence(props) {
+        return new Pattern(props);
+    }
+    get id() { return this._id; }
+    get type() { return this._type; }
+    get name() { return this._name; }
+    get description() { return this._description; }
+    get condition() { return this._condition; }
+    get action() { return this._action; }
+    get confidence() { return this._confidence; }
+    get successCount() { return this._successCount; }
+    get failureCount() { return this._failureCount; }
+    get metadata() { return { ...this._metadata }; }
+    get createdAt() { return new Date(this._createdAt); }
+    get updatedAt() { return new Date(this._updatedAt); }
+    get lastMatchedAt() { return this._lastMatchedAt ? new Date(this._lastMatchedAt) : undefined; }
+    /**
+     * Calculate success rate
+     */
+    get successRate() {
+        const total = this._successCount + this._failureCount;
+        return total > 0 ? this._successCount / total : 0;
+    }
+    /**
+     * Record successful match
+     */
+    recordSuccess() {
+        this._successCount++;
+        this._confidence = this.calculateConfidence();
+        this._lastMatchedAt = new Date();
+        this._updatedAt = new Date();
+    }
+    /**
+     * Record failed match
+     */
+    recordFailure() {
+        this._failureCount++;
+        this._confidence = this.calculateConfidence();
+        this._lastMatchedAt = new Date();
+        this._updatedAt = new Date();
+    }
+    /**
+     * Calculate confidence based on success rate
+     */
+    calculateConfidence() {
+        const total = this._successCount + this._failureCount;
+        if (total < 5)
+            return this._confidence; // Not enough data
+        const newConfidence = this.successRate;
+        // Weighted average with existing confidence
+        return this._confidence * 0.3 + newConfidence * 0.7;
+    }
+    /**
+     * Check if pattern matches input
+     */
+    matches(input) {
+        try {
+            const regex = new RegExp(this._condition, 'i');
+            return regex.test(input);
+        }
+        catch {
+            return input.toLowerCase().includes(this._condition.toLowerCase());
+        }
+    }
+    /**
+     * Check if pattern is reliable (high confidence, sufficient data)
+     */
+    isReliable() {
+        const total = this._successCount + this._failureCount;
+        return total >= 10 && this._confidence >= 0.7;
+    }
+    toPersistence() {
+        return {
+            id: this._id,
+            type: this._type,
+            name: this._name,
+            description: this._description,
+            condition: this._condition,
+            action: this._action,
+            confidence: this._confidence,
+            successCount: this._successCount,
+            failureCount: this._failureCount,
+            metadata: this._metadata,
+            createdAt: this._createdAt.toISOString(),
+            updatedAt: this._updatedAt.toISOString(),
+            lastMatchedAt: this._lastMatchedAt?.toISOString(),
+        };
+    }
+}
+//# sourceMappingURL=pattern.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Neural Domain Layer - Public Exports
+ *
+ * @module v3/neural/domain
+ */
+export { Pattern, } from './entities/pattern.js';
+export { LearningDomainService, } from './services/learning-service.js';
+//# sourceMappingURL=index.js.map

package/src/@claude-flow/neural/dist/domain/services/learning-service.js

@@ -0,0 +1,195 @@
+/**
+ * Learning Domain Service - Domain Layer
+ *
+ * Contains learning logic for pattern recognition and optimization.
+ *
+ * @module v3/neural/domain/services
+ */
+import { Pattern } from '../entities/pattern.js';
+/**
+ * Learning Domain Service
+ */
+export class LearningDomainService {
+    patterns = new Map();
+    /**
+     * Extract patterns from trajectory
+     */
+    extractPatterns(trajectory) {
+        const extracted = [];
+        // Extract task-routing pattern
+        if (trajectory.outcome === 'success') {
+            const taskPattern = Pattern.create({
+                type: 'task-routing',
+                name: `route_${trajectory.id}`,
+                description: `Learned from successful trajectory`,
+                condition: this.extractCondition(trajectory.input),
+                action: trajectory.actions[0] ?? 'default',
+                confidence: 0.6 + trajectory.reward * 0.2,
+                metadata: { source: trajectory.id },
+            });
+            extracted.push(taskPattern);
+        }
+        // Extract error recovery pattern if failure
+        if (trajectory.outcome === 'failure' && trajectory.actions.length > 1) {
+            const lastAction = trajectory.actions[trajectory.actions.length - 1];
+            const recoveryPattern = Pattern.create({
+                type: 'error-recovery',
+                name: `recovery_${trajectory.id}`,
+                description: `Recovery action from failure`,
+                condition: `error:${trajectory.actions[0]}`,
+                action: lastAction,
+                confidence: 0.5,
+                metadata: { source: trajectory.id },
+            });
+            extracted.push(recoveryPattern);
+        }
+        return extracted;
+    }
+    /**
+     * Update patterns based on trajectory outcome
+     */
+    updatePatterns(trajectory) {
+        let patternsUpdated = 0;
+        let totalConfidenceChange = 0;
+        for (const pattern of this.patterns.values()) {
+            if (pattern.matches(trajectory.input)) {
+                const oldConfidence = pattern.confidence;
+                if (trajectory.outcome === 'success') {
+                    pattern.recordSuccess();
+                }
+                else {
+                    pattern.recordFailure();
+                }
+                totalConfidenceChange += pattern.confidence - oldConfidence;
+                patternsUpdated++;
+            }
+        }
+        // Extract and add new patterns
+        const newPatterns = this.extractPatterns(trajectory);
+        for (const pattern of newPatterns) {
+            this.patterns.set(pattern.id, pattern);
+        }
+        return {
+            patternsExtracted: newPatterns.length,
+            patternsUpdated,
+            confidenceChange: totalConfidenceChange,
+        };
+    }
+    /**
+     * Get route recommendation for task
+     */
+    getRouteRecommendation(taskDescription) {
+        const matchingPatterns = [];
+        for (const pattern of this.patterns.values()) {
+            if (pattern.type !== 'task-routing')
+                continue;
+            if (pattern.matches(taskDescription)) {
+                const score = pattern.confidence * (pattern.isReliable() ? 1.2 : 1.0);
+                matchingPatterns.push({ pattern, score });
+            }
+        }
+        // Sort by score
+        matchingPatterns.sort((a, b) => b.score - a.score);
+        if (matchingPatterns.length === 0) {
+            return this.getDefaultRecommendation(taskDescription);
+        }
+        const best = matchingPatterns[0];
+        const alternates = matchingPatterns.slice(1, 4).map((m) => ({
+            role: m.pattern.action,
+            confidence: m.score,
+        }));
+        return {
+            agentRole: best.pattern.action,
+            confidence: best.score,
+            reasoning: `Based on pattern "${best.pattern.name}" with ${best.pattern.successCount} successes`,
+            alternates,
+        };
+    }
+    /**
+     * Get default recommendation based on keywords
+     */
+    getDefaultRecommendation(task) {
+        const taskLower = task.toLowerCase();
+        const keywordMap = {
+            code: 'coder',
+            implement: 'coder',
+            write: 'coder',
+            test: 'tester',
+            review: 'reviewer',
+            plan: 'planner',
+            research: 'researcher',
+            security: 'security-architect',
+            performance: 'performance-engineer',
+            memory: 'memory-specialist',
+        };
+        for (const [keyword, role] of Object.entries(keywordMap)) {
+            if (taskLower.includes(keyword)) {
+                return {
+                    agentRole: role,
+                    confidence: 0.5,
+                    reasoning: `Keyword match: "${keyword}"`,
+                    alternates: [],
+                };
+            }
+        }
+        return {
+            agentRole: 'coder',
+            confidence: 0.3,
+            reasoning: 'Default fallback',
+            alternates: [],
+        };
+    }
+    /**
+     * Extract condition from input
+     */
+    extractCondition(input) {
+        // Extract key terms from input
+        const words = input.toLowerCase().split(/\s+/);
+        const keyWords = words.filter((w) => w.length > 4).slice(0, 5);
+        return keyWords.join('|');
+    }
+    /**
+     * Consolidate patterns (merge duplicates, prune low-confidence)
+     */
+    consolidate(minConfidence = 0.3) {
+        let merged = 0;
+        let pruned = 0;
+        const toRemove = [];
+        for (const [id, pattern] of this.patterns) {
+            // Prune low confidence patterns with enough data
+            if (pattern.confidence < minConfidence && pattern.successCount + pattern.failureCount > 20) {
+                toRemove.push(id);
+                pruned++;
+            }
+        }
+        for (const id of toRemove) {
+            this.patterns.delete(id);
+        }
+        return { merged, pruned };
+    }
+    /**
+     * Get all patterns
+     */
+    getPatterns() {
+        return Array.from(this.patterns.values());
+    }
+    /**
+     * Get patterns by type
+     */
+    getPatternsByType(type) {
+        return Array.from(this.patterns.values()).filter((p) => p.type === type);
+    }
+    /**
+     * Add pattern
+     */
+    addPattern(pattern) {
+        this.patterns.set(pattern.id, pattern);
+    }
+    /**
+     * Remove pattern
+     */
+    removePattern(id) {
+        return this.patterns.delete(id);
+    }
+}
+//# sourceMappingURL=learning-service.js.map

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

@@ -0,0 +1,201 @@
+/**
+ * V3 Neural/Learning System
+ *
+ * Complete neural learning module with SONA learning modes,
+ * ReasoningBank integration, pattern learning, and RL algorithms.
+ *
+ * Performance Targets:
+ * - SONA adaptation: <0.05ms
+ * - Pattern matching: <1ms
+ * - Learning step: <10ms
+ *
+ * @module @claude-flow/neural
+ */
+// =============================================================================
+// SONA Manager
+// =============================================================================
+export { SONAManager, createSONAManager, getModeConfig, getModeOptimizations, } from './sona-manager.js';
+export { BaseModeImplementation, RealTimeMode, BalancedMode, ResearchMode, EdgeMode, BatchMode, } from './modes/index.js';
+// =============================================================================
+// SONA Integration (@ruvector/sona)
+// =============================================================================
+export { SONALearningEngine, createSONALearningEngine, } from './sona-integration.js';
+// =============================================================================
+// ReasoningBank
+// =============================================================================
+export { ReasoningBank, createReasoningBank, createInitializedReasoningBank, } from './reasoning-bank.js';
+// =============================================================================
+// Pattern Learner
+// =============================================================================
+export { PatternLearner, createPatternLearner, } from './pattern-learner.js';
+// =============================================================================
+// RL Algorithms
+// =============================================================================
+export { 
+// PPO
+PPOAlgorithm, createPPO, DEFAULT_PPO_CONFIG, 
+// DQN
+DQNAlgorithm, createDQN, DEFAULT_DQN_CONFIG, 
+// A2C
+A2CAlgorithm, createA2C, DEFAULT_A2C_CONFIG, 
+// Decision Transformer
+DecisionTransformer, createDecisionTransformer, DEFAULT_DT_CONFIG, 
+// Q-Learning
+QLearning, createQLearning, DEFAULT_QLEARNING_CONFIG, 
+// SARSA
+SARSAAlgorithm, createSARSA, DEFAULT_SARSA_CONFIG, 
+// Curiosity
+CuriosityModule, createCuriosity, DEFAULT_CURIOSITY_CONFIG, 
+// Factory functions
+createAlgorithm, getDefaultConfig, } from './algorithms/index.js';
+// =============================================================================
+// Convenience Factory
+// =============================================================================
+import { SONAManager, createSONAManager } from './sona-manager.js';
+import { ReasoningBank, createReasoningBank } from './reasoning-bank.js';
+import { PatternLearner, createPatternLearner } from './pattern-learner.js';
+import { SONALearningEngine, createSONALearningEngine } from './sona-integration.js';
+/**
+ * Neural Learning System - Complete integrated learning module
+ */
+export class NeuralLearningSystem {
+    sona;
+    reasoningBank;
+    patternLearner;
+    initialized = false;
+    constructor(mode = 'balanced') {
+        this.sona = createSONAManager(mode);
+        this.reasoningBank = createReasoningBank();
+        this.patternLearner = createPatternLearner();
+    }
+    /**
+     * Initialize the learning system
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.sona.initialize();
+        this.initialized = true;
+    }
+    /**
+     * Get SONA manager
+     */
+    getSONAManager() {
+        return this.sona;
+    }
+    /**
+     * Get ReasoningBank
+     */
+    getReasoningBank() {
+        return this.reasoningBank;
+    }
+    /**
+     * Get Pattern Learner
+     */
+    getPatternLearner() {
+        return this.patternLearner;
+    }
+    /**
+     * Change learning mode
+     */
+    async setMode(mode) {
+        await this.sona.setMode(mode);
+    }
+    /**
+     * Begin tracking a task
+     */
+    beginTask(context, domain = 'general') {
+        return this.sona.beginTrajectory(context, domain);
+    }
+    /**
+     * Record a step in the current task
+     */
+    recordStep(trajectoryId, action, reward, stateEmbedding) {
+        this.sona.recordStep(trajectoryId, action, reward, stateEmbedding);
+    }
+    /**
+     * Complete a task and trigger learning
+     */
+    async completeTask(trajectoryId, quality) {
+        const trajectory = this.sona.completeTrajectory(trajectoryId, quality);
+        if (trajectory) {
+            // Store in reasoning bank
+            this.reasoningBank.storeTrajectory(trajectory);
+            // Judge and potentially distill
+            await this.reasoningBank.judge(trajectory);
+            const memory = await this.reasoningBank.distill(trajectory);
+            // Extract pattern if successful
+            if (memory) {
+                this.patternLearner.extractPattern(trajectory, memory);
+            }
+        }
+    }
+    /**
+     * Find similar patterns for a task
+     */
+    async findPatterns(queryEmbedding, k = 3) {
+        return this.patternLearner.findMatches(queryEmbedding, k);
+    }
+    /**
+     * Retrieve relevant memories
+     */
+    async retrieveMemories(queryEmbedding, k = 3) {
+        return this.reasoningBank.retrieve(queryEmbedding, k);
+    }
+    /**
+     * Trigger learning cycle
+     */
+    async triggerLearning() {
+        await this.sona.triggerLearning('manual');
+        await this.reasoningBank.consolidate();
+    }
+    /**
+     * Get comprehensive statistics
+     */
+    getStats() {
+        return {
+            sona: this.sona.getStats(),
+            reasoningBank: this.reasoningBank.getStats(),
+            patternLearner: this.patternLearner.getStats(),
+        };
+    }
+    /**
+     * Add event listener
+     */
+    addEventListener(listener) {
+        this.sona.addEventListener(listener);
+        this.reasoningBank.addEventListener(listener);
+        this.patternLearner.addEventListener(listener);
+    }
+    /**
+     * Cleanup resources
+     */
+    async cleanup() {
+        await this.sona.cleanup();
+        this.initialized = false;
+    }
+}
+/**
+ * Create a complete neural learning system
+ */
+export function createNeuralLearningSystem(mode = 'balanced') {
+    return new NeuralLearningSystem(mode);
+}
+// =============================================================================
+// Default Export
+// =============================================================================
+export default {
+    // Factories
+    createSONAManager,
+    createReasoningBank,
+    createPatternLearner,
+    createNeuralLearningSystem,
+    createSONALearningEngine,
+    // Classes
+    SONAManager,
+    ReasoningBank,
+    PatternLearner,
+    NeuralLearningSystem,
+    SONALearningEngine,
+};
+//# sourceMappingURL=index.js.map