moflo 4.8.32 → 4.8.34

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

@@ -4,9 +4,6 @@
  *
  * Created with ❤️ by motailz.com
  */
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
 import { commandParser } from './parser.js';
 import { output } from './output.js';
 import { commands, commandsByCategory, getCommand, getCommandAsync, getCommandNames, hasCommand } from './commands/index.js';
@@ -14,21 +11,8 @@ import { suggestCommand } from './suggest.js';
 import { runStartupUpdateCheck } from './update/index.js';
 import { loadMofloConfig } from './config/moflo-config.js';
 import { getDaemonLockHolder } from './services/daemon-lock.js';
-// Read version from package.json at runtime
-function getPackageVersion() {
-    try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        // Navigate from dist/src to package root
-        const pkgPath = join(__dirname, '..', '..', 'package.json');
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        return pkg.version || '3.0.0';
-    }
-    catch {
-        return '3.0.0';
-    }
-}
-export const VERSION = getPackageVersion();
+import { VERSION } from './version.js';
+export { VERSION };
 const LONG_RUNNING_COMMANDS = ['mcp', 'daemon'];
 /**
  * V3 CLI Application

package/src/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -1676,6 +1676,22 @@ export const hooksSessionStart = {
         catch {
             // Bridge not available
         }
+        // Auto-pretrain when intelligence is cold (no patterns restored)
+        let pretrainResult = { ran: false };
+        const restoredCount = sessionMemory?.restoredPatterns ?? 0;
+        if (restoredCount === 0) {
+            try {
+                const result = await hooksPretrain.handler({
+                    path: process.cwd(),
+                    depth: 'shallow',
+                });
+                const stats = result?.stats;
+                pretrainResult = { ran: true, patternsStored: stats?.patternsStored ?? 0 };
+            }
+            catch {
+                pretrainResult = { ran: true, patternsStored: 0 };
+            }
+        }
         return {
             sessionId,
             started: new Date().toISOString(),
@@ -1688,6 +1704,7 @@ export const hooksSessionStart = {
             },
             daemon: daemonStatus,
             sessionMemory: sessionMemory || { controller: 'none', restoredPatterns: 0 },
+            pretrain: pretrainResult,
             previousSession: restoreLatest ? {
                 id: `session-${Date.now() - 86400000}`,
                 tasksRestored: sessionMemory?.restoredPatterns || 3,

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/cli/dist/src/version.js

@@ -0,0 +1,6 @@
+/**
+ * Auto-generated by build. Do not edit manually.
+ * Source of truth: root package.json → scripts/sync-version.mjs
+ */
+export const VERSION = '4.8.34';
+//# sourceMappingURL=version.js.map

package/src/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.8.32",
+  "version": "4.8.34",
   "type": "module",
   "description": "MoFlo CLI — AI agent orchestration with specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

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