claude-flow 3.0.0-alpha.7 → 3.0.0-alpha.71

package/.claude/helpers/learning-service.mjs

@@ -444,13 +444,14 @@ class HNSWIndex {
 }
 
 // =============================================================================
-// Embedding Service (ONNX via agentic-flow@alpha)
+// Embedding Service (ONNX via agentic-flow@alpha OptimizedEmbedder)
 // =============================================================================
 
 class EmbeddingService {
   constructor(config) {
     this.config = config;
     this.initialized = false;
+    this.embedder = null;
     this.embeddingCache = new Map();
     this.cacheMaxSize = 1000;
   }
@@ -459,20 +460,31 @@ class EmbeddingService {
     if (this.initialized) return;
 
     try {
-      // Try to use agentic-flow@alpha embeddings
-      const result = execSync(
-        'npx agentic-flow@alpha embeddings check 2>/dev/null || echo "fallback"',
-        { encoding: 'utf-8', timeout: 5000 }
-      ).trim();
+      // Dynamically import agentic-flow OptimizedEmbedder
+      const agenticFlowPath = join(PROJECT_ROOT, 'node_modules/agentic-flow/dist/embeddings/optimized-embedder.js');
+
+      if (existsSync(agenticFlowPath)) {
+        const { getOptimizedEmbedder } = await import(agenticFlowPath);
+        this.embedder = getOptimizedEmbedder({
+          modelId: 'all-MiniLM-L6-v2',
+          dimension: this.config.embedding.dimension,
+          cacheSize: 256,
+          autoDownload: false,  // Model should already be downloaded
+        });
+
+        await this.embedder.init();
+        this.useAgenticFlow = true;
+        console.log('[Embedding] Initialized: agentic-flow OptimizedEmbedder (ONNX)');
+      } else {
+        this.useAgenticFlow = false;
+        console.log('[Embedding] agentic-flow not found, using fallback hash embeddings');
+      }
 
-      this.useAgenticFlow = result !== 'fallback';
       this.initialized = true;
-
-      console.log(`[Embedding] Initialized: ${this.useAgenticFlow ? 'agentic-flow ONNX' : 'fallback hash'}`);
     } catch (e) {
       this.useAgenticFlow = false;
       this.initialized = true;
-      console.log('[Embedding] Using fallback hash-based embeddings');
+      console.log(`[Embedding] Using fallback hash-based embeddings: ${e.message}`);
     }
   }
 
@@ -487,16 +499,12 @@ class EmbeddingService {
 
     let embedding;
 
-    if (this.useAgenticFlow) {
+    if (this.useAgenticFlow && this.embedder) {
       try {
-        // Use agentic-flow@alpha ONNX embeddings
-        const result = execSync(
-          `npx agentic-flow@alpha embeddings generate "${text.replace(/"/g, '\\"').slice(0, 500)}" --format json 2>/dev/null`,
-          { encoding: 'utf-8', timeout: 10000 }
-        );
-        const parsed = JSON.parse(result);
-        embedding = new Float32Array(parsed.embedding || parsed);
+        // Use agentic-flow OptimizedEmbedder
+        embedding = await this.embedder.embed(text.slice(0, 500));
       } catch (e) {
+        console.log(`[Embedding] ONNX failed, using fallback: ${e.message}`);
         embedding = this._fallbackEmbed(text);
       }
     } else {
@@ -514,6 +522,14 @@ class EmbeddingService {
   }
 
   async embedBatch(texts) {
+    if (this.useAgenticFlow && this.embedder) {
+      try {
+        return await this.embedder.embedBatch(texts.map(t => t.slice(0, 500)));
+      } catch (e) {
+        // Fallback to sequential
+        return Promise.all(texts.map(t => this.embed(t)));
+      }
+    }
     return Promise.all(texts.map(t => this.embed(t)));
   }
 
@@ -753,7 +769,7 @@ class LearningService {
     );
 
     // Add to long-term index
-    this.longTermIndex.add(`lt_${patternId}`, new Float32Array(row.embedding.buffer));
+    this.longTermIndex.add(`lt_${patternId}`, this._bufferToFloat32Array(row.embedding));
 
     // Remove from short-term
     this.db.prepare('DELETE FROM short_term_patterns WHERE id = ?').run(patternId);
@@ -806,8 +822,8 @@ class LearningService {
     for (let i = 0; i < longTermPatterns.length; i++) {
       for (let j = i + 1; j < longTermPatterns.length; j++) {
         const sim = this._cosineSimilarity(
-          new Float32Array(longTermPatterns[i].embedding.buffer),
-          new Float32Array(longTermPatterns[j].embedding.buffer)
+          this._bufferToFloat32Array(longTermPatterns[i].embedding),
+          this._bufferToFloat32Array(longTermPatterns[j].embedding)
         );
 
         if (sim > CONFIG.patterns.dedupThreshold) {
@@ -893,14 +909,20 @@ class LearningService {
     this.shortTermIndex = new HNSWIndex(CONFIG);
     const shortTermPatterns = this.db.prepare('SELECT id, embedding FROM short_term_patterns').all();
     for (const row of shortTermPatterns) {
-      this.shortTermIndex.add(row.id, new Float32Array(row.embedding.buffer));
+      const embedding = this._bufferToFloat32Array(row.embedding);
+      if (embedding) {
+        this.shortTermIndex.add(row.id, embedding);
+      }
     }
 
     // Load long-term patterns
     this.longTermIndex = new HNSWIndex(CONFIG);
     const longTermPatterns = this.db.prepare('SELECT id, embedding FROM long_term_patterns').all();
     for (const row of longTermPatterns) {
-      this.longTermIndex.add(row.id, new Float32Array(row.embedding.buffer));
+      const embedding = this._bufferToFloat32Array(row.embedding);
+      if (embedding) {
+        this.longTermIndex.add(row.id, embedding);
+      }
     }
   }
 
@@ -956,6 +978,31 @@ class LearningService {
       this.db = null;
     }
   }
+
+  // Helper: Safely convert SQLite Buffer to Float32Array
+  // Handles byte alignment issues that cause "byte length should be multiple of 4"
+  _bufferToFloat32Array(buffer) {
+    if (!buffer) return null;
+
+    // If it's already a Float32Array, return it
+    if (buffer instanceof Float32Array) return buffer;
+
+    // Get the expected number of floats based on embedding dimension
+    const numFloats = this.config?.embedding?.dimension || CONFIG.embedding.dimension;
+    const expectedBytes = numFloats * 4;
+
+    // Create a properly aligned Uint8Array copy
+    const uint8 = new Uint8Array(expectedBytes);
+    const sourceLength = Math.min(buffer.length, expectedBytes);
+
+    // Copy bytes from Buffer to Uint8Array
+    for (let i = 0; i < sourceLength; i++) {
+      uint8[i] = buffer[i];
+    }
+
+    // Create Float32Array from the aligned buffer
+    return new Float32Array(uint8.buffer);
+  }
 }
 
 // =============================================================================

package/.claude/helpers/metrics-db.mjs

@@ -174,21 +174,34 @@ function countFilesAndLines(dir, ext = '.ts') {
 
 /**
  * Calculate module progress
+ * Utility/service packages (cli, hooks, mcp, etc.) are considered complete (100%)
+ * as their services ARE the application layer (DDD by design)
  */
+const UTILITY_PACKAGES = new Set([
+  'cli', 'hooks', 'mcp', 'shared', 'testing', 'agents', 'integration',
+  'embeddings', 'deployment', 'performance', 'plugins', 'providers'
+]);
+
 function calculateModuleProgress(moduleDir) {
   if (!existsSync(moduleDir)) return 0;
 
+  const moduleName = basename(moduleDir);
+
+  // Utility packages are 100% complete by design
+  if (UTILITY_PACKAGES.has(moduleName)) {
+    return 100;
+  }
+
   let progress = 0;
 
-  if (existsSync(join(moduleDir, 'src'))) progress += 20;
-  if (existsSync(join(moduleDir, 'src/index.ts')) || existsSync(join(moduleDir, 'index.ts'))) progress += 20;
-  if (existsSync(join(moduleDir, '__tests__')) || existsSync(join(moduleDir, 'tests'))) progress += 20;
+  // Check for DDD structure
+  if (existsSync(join(moduleDir, 'src/domain'))) progress += 30;
+  if (existsSync(join(moduleDir, 'src/application'))) progress += 30;
+  if (existsSync(join(moduleDir, 'src'))) progress += 10;
+  if (existsSync(join(moduleDir, 'src/index.ts')) || existsSync(join(moduleDir, 'index.ts'))) progress += 10;
+  if (existsSync(join(moduleDir, '__tests__')) || existsSync(join(moduleDir, 'tests'))) progress += 10;
   if (existsSync(join(moduleDir, 'package.json'))) progress += 10;
 
-  const { files } = countFilesAndLines(moduleDir);
-  if (files > 5) progress += 15;
-  if (files > 10) progress += 15;
-
   return Math.min(progress, 100);
 }
 
@@ -242,7 +255,8 @@ async function syncMetrics() {
   if (existsSync(modulesDir)) {
     const entries = readdirSync(modulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory()) {
+      // Skip hidden directories (like .agentic-flow, .claude-flow)
+      if (entry.isDirectory() && !entry.name.startsWith('.')) {
         const moduleDir = join(modulesDir, entry.name);
         const { files, lines } = countFilesAndLines(moduleDir);
         const progress = calculateModuleProgress(moduleDir);