ruvector 0.1.67 → 0.1.69

package/.ruvector/intelligence.json

@@ -127,7 +127,8 @@
     "total_memories": 0,
     "total_trajectories": 0,
     "total_errors": 0,
-    "session_count": 0,
-    "last_session": 0
-  }
+    "session_count": 2,
+    "last_session": 1767194641
+  },
+  "trajectories": []
 }

package/bin/cli.js

@@ -2609,22 +2609,56 @@ class Intelligence {
   }
 
   sessionEnd() {
-    // Ensure stats exists with defaults
+    // Ensure data structure exists with defaults
+    if (!this.data) {
+      this.data = { patterns: {}, memories: [], trajectories: [], errors: [], agents: {}, edges: [], stats: {} };
+    }
     if (!this.data.stats) {
       this.data.stats = { total_patterns: 0, total_memories: 0, total_trajectories: 0, total_errors: 0, session_count: 0, last_session: 0 };
     }
+    if (!this.data.trajectories) {
+      this.data.trajectories = [];
+    }
+
     const lastSession = this.data.stats.last_session || 0;
     const duration = this.now() - (this.sessionStartTime || lastSession);
-    const actions = (this.data.trajectories || []).filter(t => t.timestamp >= lastSession).length;
+    const actions = this.data.trajectories.filter(t => t && t.timestamp >= lastSession).length;
 
     // Force learning cycle (only if engine already initialized)
-    const eng = this.getEngineIfReady();
-    if (eng) {
-      eng.forceLearn();
+    try {
+      const eng = this.getEngineIfReady();
+      if (eng) {
+        eng.forceLearn();
+      }
+    } catch (e) {
+      // Ignore engine errors on session end
+    }
+
+    // Auto-compress patterns if enabled (v2.1)
+    try {
+      if (process.env.RUVECTOR_AUTO_COMPRESS === 'true' || process.env.RUVECTOR_TENSOR_COMPRESS === 'true') {
+        const TensorCompressClass = require('../dist/core/tensor-compress').default;
+        if (TensorCompressClass && this.data.compressedPatterns) {
+          const compress = new TensorCompressClass({ autoCompress: false });
+          compress.import(this.data.compressedPatterns);
+          const stats = compress.recompressAll();
+          this.data.compressedPatterns = compress.export();
+          // Only log if significant savings
+          if (stats.savingsPercent > 10 && stats.totalTensors > 5) {
+            // Silently compress, no console output to avoid hook noise
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore compression errors on session end
     }
 
     // Save all data
-    this.save();
+    try {
+      this.save();
+    } catch (e) {
+      // Ignore save errors on session end
+    }
 
     return { duration, actions };
   }
@@ -2734,11 +2768,23 @@ hooksCmd.command('init')
   // Environment variables for intelligence (unless --minimal or --no-env)
   if (!opts.minimal && opts.env !== false) {
     settings.env = settings.env || {};
+    // Core intelligence settings
     settings.env.RUVECTOR_INTELLIGENCE_ENABLED = settings.env.RUVECTOR_INTELLIGENCE_ENABLED || 'true';
     settings.env.RUVECTOR_LEARNING_RATE = settings.env.RUVECTOR_LEARNING_RATE || '0.1';
     settings.env.RUVECTOR_MEMORY_BACKEND = settings.env.RUVECTOR_MEMORY_BACKEND || 'rvlite';
     settings.env.INTELLIGENCE_MODE = settings.env.INTELLIGENCE_MODE || 'treatment';
-    console.log(chalk.blue('  ✓ Environment variables configured'));
+    // v2.0 capabilities
+    settings.env.RUVECTOR_AST_ENABLED = settings.env.RUVECTOR_AST_ENABLED || 'true';
+    settings.env.RUVECTOR_DIFF_EMBEDDINGS = settings.env.RUVECTOR_DIFF_EMBEDDINGS || 'true';
+    settings.env.RUVECTOR_COVERAGE_ROUTING = settings.env.RUVECTOR_COVERAGE_ROUTING || 'true';
+    settings.env.RUVECTOR_GRAPH_ALGORITHMS = settings.env.RUVECTOR_GRAPH_ALGORITHMS || 'true';
+    settings.env.RUVECTOR_SECURITY_SCAN = settings.env.RUVECTOR_SECURITY_SCAN || 'true';
+    // v2.1 learning & compression
+    settings.env.RUVECTOR_MULTI_ALGORITHM = settings.env.RUVECTOR_MULTI_ALGORITHM || 'true';
+    settings.env.RUVECTOR_DEFAULT_ALGORITHM = settings.env.RUVECTOR_DEFAULT_ALGORITHM || 'double-q';
+    settings.env.RUVECTOR_TENSOR_COMPRESS = settings.env.RUVECTOR_TENSOR_COMPRESS || 'true';
+    settings.env.RUVECTOR_AUTO_COMPRESS = settings.env.RUVECTOR_AUTO_COMPRESS || 'true';
+    console.log(chalk.blue('  ✓ Environment variables configured (v2.1 with multi-algorithm learning)'));
   }
 
   // Permissions based on detected project type (unless --minimal or --no-permissions)
@@ -5092,10 +5138,98 @@ hooksCmd.command('pretrain')
       console.log(chalk.yellow(`  ⚠ Graph analysis skipped: ${e.message}`));
     }
 
+    // Phase 10: Initialize multi-algorithm learning engine
+    console.log(chalk.yellow('\n🎯 Phase 10: Initializing multi-algorithm learning engine...\n'));
+
+    try {
+      if (loadLearningModules() && LearningEngineClass) {
+        const engine = new LearningEngineClass();
+
+        // Configure optimal algorithms for each task type based on repo analysis
+        engine.configure('agent-routing', { algorithm: 'double-q', learningRate: 0.1, epsilon: 0.1 });
+        engine.configure('error-avoidance', { algorithm: 'sarsa', learningRate: 0.05, epsilon: 0.05 });
+        engine.configure('confidence-scoring', { algorithm: 'actor-critic', learningRate: 0.01 });
+        engine.configure('trajectory-learning', { algorithm: 'decision-transformer', sequenceLength: 20 });
+        engine.configure('context-ranking', { algorithm: 'ppo', clipRange: 0.2 });
+        engine.configure('memory-recall', { algorithm: 'td-lambda', lambda: 0.8 });
+
+        // Bootstrap with initial experiences from file patterns
+        let bootstrapCount = 0;
+        for (const [state, actions] of Object.entries(intel.data.patterns || {})) {
+          for (const [action, value] of Object.entries(actions)) {
+            if (value > 0.3) { // Only strong patterns
+              engine.update('agent-routing', {
+                state,
+                action,
+                reward: value,
+                nextState: state,
+                done: true
+              });
+              bootstrapCount++;
+            }
+          }
+        }
+
+        intel.data.learning = engine.export();
+        stats.learningBootstrap = bootstrapCount;
+        console.log(chalk.green(`  ✓ Configured 6 task-specific algorithms`));
+        console.log(chalk.green(`  ✓ Bootstrapped with ${bootstrapCount} initial experiences`));
+        console.log(chalk.dim('  Algorithms: double-q, sarsa, actor-critic, decision-transformer, ppo, td-lambda'));
+      } else {
+        console.log(chalk.dim('  ⏭️  LearningEngine not available'));
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Learning engine init skipped: ${e.message}`));
+    }
+
+    // Phase 11: Initialize TensorCompress for pattern storage
+    console.log(chalk.yellow('\n📦 Phase 11: Initializing TensorCompress for efficient storage...\n'));
+
+    try {
+      if (loadLearningModules() && TensorCompressClass) {
+        const compress = new TensorCompressClass({
+          autoCompress: false,
+          hotThreshold: 0.8,
+          warmThreshold: 0.4,
+          coolThreshold: 0.1,
+          coldThreshold: 0.01
+        });
+
+        // Store any existing embeddings with compression
+        let compressed = 0;
+        if (intel.data.memories) {
+          for (let i = 0; i < intel.data.memories.length; i++) {
+            const mem = intel.data.memories[i];
+            if (mem.embedding && Array.isArray(mem.embedding)) {
+              compress.store(`memory_${i}`, mem.embedding, 'pq8');
+              compressed++;
+            }
+          }
+        }
+
+        if (compressed > 0) {
+          const compStats = compress.recompressAll();
+          intel.data.compressedPatterns = compress.export();
+          stats.compressed = compressed;
+          stats.compressionSavings = compStats.savingsPercent;
+          console.log(chalk.green(`  ✓ Compressed ${compressed} embeddings`));
+          console.log(chalk.green(`  ✓ Memory savings: ${compStats.savingsPercent.toFixed(1)}%`));
+        } else {
+          intel.data.compressedPatterns = compress.export();
+          console.log(chalk.green(`  ✓ TensorCompress initialized (ready for future embeddings)`));
+        }
+        console.log(chalk.dim('  Levels: none (hot), half (warm), pq8 (cool), pq4 (cold), binary (archive)'));
+      } else {
+        console.log(chalk.dim('  ⏭️  TensorCompress not available'));
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ TensorCompress init skipped: ${e.message}`));
+    }
+
     // Save all learning data
     intel.data.pretrained = {
       date: new Date().toISOString(),
-      version: '2.0',
+      version: '2.1',
       stats: stats
     };
     intel.save();
@@ -5112,6 +5246,8 @@ hooksCmd.command('pretrain')
     if (stats.coverage) console.log(`  🧪 Coverage: ${stats.coverage.lines.toFixed(1)}% lines`);
     if (stats.neural?.attention) console.log(`  🧠 10 attention mechanisms available`);
     if (stats.graph) console.log(`  🔗 ${stats.graph.communities} code communities detected`);
+    if (stats.learningBootstrap) console.log(`  🎯 ${stats.learningBootstrap} learning experiences bootstrapped`);
+    if (stats.compressionSavings) console.log(`  📦 ${stats.compressionSavings.toFixed(1)}% compression savings`);
     console.log(chalk.dim('\nThe intelligence layer will now provide better recommendations.'));
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",