claude-flow 3.5.64 → 3.5.65

package/.claude/helpers/auto-memory-hook.mjs

@@ -255,6 +255,36 @@ async function doImport() {
     dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
     dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
     dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
+
+    // Bridge to AgentDB: store entries with ONNX vector embeddings for semantic search
+    let vectorized = 0;
+    try {
+      const cliDistPath = join(PROJECT_ROOT, 'v3/@claude-flow/cli/dist/src/memory/memory-initializer.js');
+      if (existsSync(cliDistPath)) {
+        const memInit = await import(`file://${cliDistPath}`);
+        await memInit.initializeMemoryDatabase({ force: false, verbose: false });
+
+        const entries = await backend.query({});
+        for (const entry of entries) {
+          if (!entry.content || entry.content.length < 10) continue;
+          try {
+            await memInit.storeEntry({
+              key: entry.key || entry.id,
+              value: entry.content,
+              namespace: entry.namespace || 'auto-memory',
+              generateEmbeddingFlag: true,
+            });
+            vectorized++;
+          } catch { /* skip entries that fail to embed */ }
+        }
+
+        if (vectorized > 0) {
+          success(`Vectorized ${vectorized} entries into AgentDB (ONNX 384-dim)`);
+        }
+      }
+    } catch (vecErr) {
+      dim(`AgentDB vectorization skipped: ${vecErr.message?.slice(0, 60)}`);
+    }
   } catch (err) {
     dim(`Import failed (non-critical): ${err.message}`);
   }
@@ -313,6 +343,21 @@ async function doSync() {
     // Curate MEMORY.md index with graph-aware ordering
     await bridge.curateIndex();
     success('Curated MEMORY.md index');
+
+    // Flush intelligence patterns to disk (SONA + ReasoningBank)
+    try {
+      const intPath = join(PROJECT_ROOT, 'v3/@claude-flow/cli/dist/src/memory/intelligence.js');
+      if (existsSync(intPath)) {
+        const intelligence = await import(`file://${intPath}`);
+        if (intelligence.flushPatterns) {
+          intelligence.flushPatterns();
+          const stats = intelligence.getIntelligenceStats?.();
+          if (stats && stats.patternsLearned > 0) {
+            success(`Flushed ${stats.patternsLearned} learned patterns to disk`);
+          }
+        }
+      }
+    } catch { /* non-critical */ }
   } catch (err) {
     dim(`Sync failed (non-critical): ${err.message}`);
   }
@@ -339,9 +384,158 @@ async function doStatus() {
     } catch { /* ignore */ }
   }
 
+  // AgentDB vector status
+  try {
+    const dbPath = join(PROJECT_ROOT, '.claude-flow', 'memory', 'memory.db');
+    const swarmDbPath = join(PROJECT_ROOT, '.swarm', 'memory.db');
+    const hasDb = existsSync(dbPath) || existsSync(swarmDbPath);
+    console.log(`  AgentDB:        ${hasDb ? '✅ sql.js database exists' : '⏸ Not initialized'}`);
+
+    const intPath = join(PROJECT_ROOT, 'v3/@claude-flow/cli/dist/src/memory/intelligence.js');
+    if (existsSync(intPath)) {
+      const intelligence = await import(`file://${intPath}`);
+      const stats = intelligence.getIntelligenceStats?.();
+      if (stats) {
+        console.log(`  SONA:           ${stats.sonaEnabled ? '✅ Active' : '⏸ Not initialized'}`);
+        console.log(`  Patterns:       ${stats.patternsLearned} learned`);
+        console.log(`  Trajectories:   ${stats.trajectoriesRecorded} recorded`);
+      }
+    }
+  } catch { /* ignore */ }
+
   console.log('');
 }
 
+// ============================================================================
+// Import ALL Claude Code memories from all projects into AgentDB
+// ============================================================================
+
+async function doImportAll() {
+  log('Importing ALL Claude Code memories into AgentDB...');
+
+  const { homedir } = await import('os');
+  const { readdirSync } = await import('fs');
+  const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+
+  if (!existsSync(claudeProjectsDir)) {
+    dim('No Claude Code projects found at ' + claudeProjectsDir);
+    return;
+  }
+
+  // Find all memory files across all projects
+  const memoryFiles = [];
+  try {
+    const projects = readdirSync(claudeProjectsDir, { withFileTypes: true });
+    for (const project of projects) {
+      if (!project.isDirectory()) continue;
+      const memDir = join(claudeProjectsDir, project.name, 'memory');
+      if (!existsSync(memDir)) continue;
+      const files = readdirSync(memDir).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        memoryFiles.push({
+          path: join(memDir, file),
+          project: project.name,
+          file,
+        });
+      }
+    }
+  } catch (err) {
+    dim('Error scanning projects: ' + err.message);
+    return;
+  }
+
+  if (memoryFiles.length === 0) {
+    dim('No memory files found');
+    return;
+  }
+
+  log(`Found ${memoryFiles.length} memory files across ${new Set(memoryFiles.map(f => f.project)).size} projects`);
+
+  // Load memory-initializer for vectorized storage
+  let memInit = null;
+  try {
+    const cliDistPath = join(PROJECT_ROOT, 'v3/@claude-flow/cli/dist/src/memory/memory-initializer.js');
+    if (existsSync(cliDistPath)) {
+      memInit = await import(`file://${cliDistPath}`);
+      await memInit.initializeMemoryDatabase({ force: false, verbose: false });
+    }
+  } catch (err) {
+    dim('Memory initializer not available: ' + err.message?.slice(0, 60));
+  }
+
+  if (!memInit) {
+    dim('Cannot vectorize without memory-initializer. Run: cd v3/@claude-flow/cli && npm run build');
+    return;
+  }
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (const memFile of memoryFiles) {
+    try {
+      const content = readFileSync(memFile.path, 'utf-8');
+
+      // Parse YAML frontmatter + body
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+      let name = memFile.file.replace('.md', '');
+      let description = '';
+      let type = 'auto-memory';
+      let body = content;
+
+      if (frontmatterMatch) {
+        const yaml = frontmatterMatch[1];
+        body = frontmatterMatch[2].trim();
+        const nameMatch = yaml.match(/^name:\s*(.+)$/m);
+        const descMatch = yaml.match(/^description:\s*(.+)$/m);
+        const typeMatch = yaml.match(/^type:\s*(.+)$/m);
+        if (nameMatch) name = nameMatch[1].trim();
+        if (descMatch) description = descMatch[1].trim();
+        if (typeMatch) type = typeMatch[1].trim();
+      }
+
+      // Split body into sections (## headers) for granular entries
+      const sections = body.split(/^(?=## )/m).filter(s => s.trim().length > 20);
+
+      if (sections.length === 0) {
+        // Store whole file as one entry
+        if (body.length > 10) {
+          await memInit.storeEntry({
+            key: `claude-memory:${memFile.project}:${name}`,
+            value: body.slice(0, 4096),
+            namespace: 'claude-memories',
+            generateEmbeddingFlag: true,
+          });
+          imported++;
+        }
+      } else {
+        // Store each section separately for better search granularity
+        for (const section of sections) {
+          const titleMatch = section.match(/^##\s+(.+)/);
+          const sectionTitle = titleMatch ? titleMatch[1].trim() : name;
+          const sectionBody = section.replace(/^##\s+.+\n/, '').trim();
+          if (sectionBody.length < 10) continue;
+
+          await memInit.storeEntry({
+            key: `claude-memory:${memFile.project}:${name}:${sectionTitle.slice(0, 50)}`,
+            value: sectionBody.slice(0, 4096),
+            namespace: 'claude-memories',
+            generateEmbeddingFlag: true,
+          });
+          imported++;
+        }
+      }
+
+      dim(`  ✓ ${memFile.project}/${memFile.file} (${sections.length || 1} entries)`);
+    } catch (err) {
+      dim(`  ✗ ${memFile.project}/${memFile.file}: ${err.message?.slice(0, 60)}`);
+      skipped++;
+    }
+  }
+
+  success(`Imported ${imported} entries from ${memoryFiles.length} files (${skipped} skipped)`);
+  success('All Claude Code memories now searchable via AgentDB vector search');
+}
+
 // ============================================================================
 // Main
 // ============================================================================
@@ -355,6 +549,7 @@ process.on('unhandledRejection', () => {});
 try {
   switch (command) {
     case 'import': await doImport(); break;
+    case 'import-all': await doImportAll(); break;
     case 'sync': await doSync(); break;
     case 'status': await doStatus(); break;
     default: