claude-flow 3.6.4 → 3.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.4",
+  "version": "3.6.5",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -804,5 +804,74 @@ export const embeddingsTools = [
             };
         },
     },
+    // --- RaBitQ 1-bit quantized vector index ---
+    {
+        name: 'embeddings_rabitq_build',
+        description: 'Build RaBitQ 1-bit quantized index from stored embeddings (32× compression). Pre-filters candidates via Hamming scan before exact rerank.',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                force: { type: 'boolean', description: 'Force rebuild even if index exists' },
+            },
+        },
+        handler: async (params) => {
+            const { buildRabitqIndex } = await import('../memory/rabitq-index.js');
+            return buildRabitqIndex({ force: params.force });
+        },
+    },
+    {
+        name: 'embeddings_rabitq_search',
+        description: 'Search via RaBitQ quantized index (fast Hamming scan). Returns candidate IDs for reranking.',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query text' },
+                k: { type: 'number', description: 'Number of results (default: 10)' },
+                namespace: { type: 'string', description: 'Filter by namespace' },
+            },
+            required: ['query'],
+        },
+        handler: async (params) => {
+            const { validateText: vt } = await import('./validate-input.js');
+            const v = vt(params.query, 'query');
+            if (!v.valid)
+                return { success: false, error: v.error };
+            const { searchRabitq } = await import('../memory/rabitq-index.js');
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            const queryEmb = await generateEmbedding(params.query);
+            const results = await searchRabitq(queryEmb.embedding, {
+                k: params.k || 10,
+                namespace: params.namespace,
+            });
+            if (!results) {
+                return { success: false, error: 'RaBitQ index not built. Call embeddings_rabitq_build first.' };
+            }
+            return {
+                success: true,
+                results: results.map(r => ({
+                    id: r.id.substring(0, 12),
+                    key: r.key,
+                    namespace: r.namespace,
+                    distance: Math.round(r.distance * 10000) / 10000,
+                })),
+                count: results.length,
+            };
+        },
+    },
+    {
+        name: 'embeddings_rabitq_status',
+        description: 'Get RaBitQ quantized index status — availability, vector count, compression ratio',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            const { getRabitqStatus } = await import('../memory/rabitq-index.js');
+            return { success: true, ...getRabitqStatus() };
+        },
+    },
 ];
 //# sourceMappingURL=embeddings-tools.js.map

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

@@ -2479,20 +2479,25 @@ export const hooksPatternStore = {
         }
         const success = reasoningResult?.success || storeResult.success;
         const controller = reasoningResult?.controller || (storeResult.success ? 'bridge-store' : 'none');
+        const hasEmbedding = !!storeResult.embedding || controller === 'reasoningBank' || controller === 'bridge-fallback';
         return {
             patternId: reasoningResult?.patternId || storeResult.id || patternId,
             pattern,
             type,
             confidence,
             indexed: success,
-            hnswIndexed: success && (!!storeResult.embedding || controller === 'reasoningBank'),
+            hnswIndexed: success && hasEmbedding,
             embedding: storeResult.embedding,
             timestamp,
             controller,
-            implementation: controller === 'reasoningBank' ? 'reasoning-bank-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
+            implementation: (controller === 'reasoningBank' || controller === 'bridge-fallback')
+                ? 'reasoning-bank-controller'
+                : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
             note: controller === 'reasoningBank'
                 ? 'Pattern stored via ReasoningBank controller with HNSW indexing'
-                : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
+                : controller === 'bridge-fallback'
+                    ? 'Pattern stored via bridge with embedding and HNSW indexing'
+                    : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
         };
     },
 };

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -37,6 +37,7 @@ export declare function bridgeStoreEntry(options: {
         dimensions: number;
         model: string;
     };
+    rawEmbedding?: number[];
     guarded?: boolean;
     cached?: boolean;
     attested?: boolean;

package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -381,6 +381,7 @@ export async function bridgeStoreEntry(options) {
             success: true,
             id,
             embedding: embeddingJson ? { dimensions, model } : undefined,
+            rawEmbedding: embeddingJson ? JSON.parse(embeddingJson) : undefined,
             guarded: true,
             cached: true,
             attested: true,
@@ -460,10 +461,11 @@ export async function bridgeSearchEntries(options) {
                 bm25ScoreVal = Math.min(bm25ScoreVal / 10, 1.0);
             }
             // Reciprocal rank fusion: combine semantic and BM25
-            // Weight: 0.7 semantic + 0.3 BM25 (semantic preferred when embeddings available)
-            const score = queryEmbedding
+            // Weight: 0.7 semantic + 0.3 BM25 when both embeddings present
+            // Fall back to BM25-only when either query or row lacks an embedding
+            const score = semanticScore > 0
                 ? (0.7 * semanticScore + 0.3 * bm25ScoreVal)
-                : bm25ScoreVal; // BM25-only when no embeddings
+                : bm25ScoreVal;
             if (score >= threshold) {
                 // Phase 4: ExplainableRecall provenance
                 const provenance = queryEmbedding
@@ -971,15 +973,31 @@ export async function bridgeStorePattern(options) {
             return { success: true, patternId, controller: 'reasoningBank' };
         }
         // Fallback: store via bridge SQL
+        const patternValue = JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata });
         const result = await bridgeStoreEntry({
             key: patternId,
-            value: JSON.stringify({ pattern: options.pattern, type: options.type, confidence: options.confidence, metadata: options.metadata }),
+            value: patternValue,
             namespace: 'pattern',
             generateEmbeddingFlag: true,
             tags: [options.type, 'reasoning-pattern'],
             dbPath: options.dbPath,
         });
-        return result ? { success: true, patternId: result.id, controller: 'bridge-fallback' } : null;
+        if (!result)
+            return null;
+        // Add to HNSW index for fast semantic search (bridgeStoreEntry stores SQL only)
+        if (result.rawEmbedding) {
+            try {
+                const { addToHNSWIndex } = await import('./memory-initializer.js');
+                await addToHNSWIndex(result.id, result.rawEmbedding, {
+                    id: result.id,
+                    key: patternId,
+                    namespace: 'pattern',
+                    content: patternValue,
+                });
+            }
+            catch { /* HNSW is best-effort */ }
+        }
+        return { success: true, patternId: result.id, controller: 'bridge-fallback' };
     }
     catch {
         return null;

package/v3/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -1689,8 +1689,19 @@ export async function storeEntry(options) {
     const bridge = await getBridge();
     if (bridge) {
         const bridgeResult = await bridge.bridgeStoreEntry(options);
-        if (bridgeResult)
+        if (bridgeResult) {
+            // Keep HNSW index in sync with bridge-stored entries
+            if (bridgeResult.rawEmbedding && bridgeResult.success) {
+                const ns = options.namespace || 'default';
+                await addToHNSWIndex(bridgeResult.id, bridgeResult.rawEmbedding, {
+                    id: bridgeResult.id,
+                    key: options.key,
+                    namespace: ns,
+                    content: options.value,
+                }).catch(() => { });
+            }
             return bridgeResult;
+        }
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
@@ -1799,7 +1810,51 @@ export async function searchEntries(options) {
         // Generate query embedding
         const queryEmb = await generateEmbedding(query);
         const queryEmbedding = queryEmb.embedding;
-        // Try HNSW search first (150x faster)
+        // Try RaBitQ pre-filter first (32× compressed Hamming scan)
+        try {
+            const { searchRabitq } = await import('./rabitq-index.js');
+            const rabitqCandidates = await searchRabitq(queryEmbedding, { k: limit * 2, namespace: effectiveNamespace });
+            if (rabitqCandidates && rabitqCandidates.length > 0) {
+                // Rerank candidates with exact cosine similarity from SQLite
+                const initSqlJs = (await import('sql.js')).default;
+                const SQL = await initSqlJs();
+                const fileBuffer = fs.readFileSync(dbPath);
+                const db = new SQL.Database(fileBuffer);
+                const reranked = [];
+                for (const candidate of rabitqCandidates) {
+                    const stmt = db.prepare('SELECT content, embedding FROM memory_entries WHERE id = ? AND status = ?');
+                    stmt.bind([candidate.id, 'active']);
+                    if (stmt.step()) {
+                        const [content, embeddingJson] = stmt.get();
+                        let score = 0;
+                        if (embeddingJson) {
+                            try {
+                                const embedding = JSON.parse(embeddingJson);
+                                score = cosineSim(queryEmbedding, embedding);
+                            }
+                            catch { /* skip */ }
+                        }
+                        if (score >= threshold) {
+                            reranked.push({
+                                id: candidate.id.substring(0, 12),
+                                key: candidate.key || candidate.id.substring(0, 15),
+                                content: (content || '').substring(0, 60) + ((content || '').length > 60 ? '...' : ''),
+                                score,
+                                namespace: candidate.namespace,
+                            });
+                        }
+                    }
+                    stmt.free();
+                }
+                db.close();
+                if (reranked.length > 0) {
+                    reranked.sort((a, b) => b.score - a.score);
+                    return { success: true, results: reranked.slice(0, limit), searchTime: Date.now() - startTime };
+                }
+            }
+        }
+        catch { /* RaBitQ unavailable, fall through */ }
+        // Try HNSW search (150x faster than brute-force)
         const hnswResults = await searchHNSWIndex(queryEmbedding, { k: limit, namespace: effectiveNamespace });
         if (hnswResults && hnswResults.length > 0) {
             // Filter by threshold

package/v3/@claude-flow/cli/dist/src/memory/rabitq-index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * RaBitQ Index — 1-bit quantized vector pre-filter (32× compression)
+ *
+ * Wraps @ruvector/rabitq-wasm to provide Hamming-scan pre-filtering
+ * over quantized embeddings. Candidates are reranked with exact cosine
+ * similarity from the full-precision source (HNSW or SQLite).
+ *
+ * Lifecycle:
+ *  1. build() — bulk-load all embeddings from SQLite into the WASM index
+ *  2. search() — fast Hamming scan → candidate ids → caller reranks
+ *  3. rebuild() — called when entry count drifts >20% from last build
+ */
+/**
+ * Build or rebuild the RaBitQ index from SQLite embeddings.
+ * Returns entry count or 0 if RaBitQ is unavailable.
+ */
+export declare function buildRabitqIndex(options?: {
+    dbPath?: string;
+    dimensions?: number;
+    force?: boolean;
+}): Promise<{
+    success: boolean;
+    vectorCount: number;
+    dimensions: number;
+    compressionRatio: number;
+    buildTimeMs: number;
+    wasmVersion?: string;
+    error?: string;
+}>;
+/**
+ * Search the RaBitQ index for candidate IDs.
+ * Returns null if index not built or unavailable.
+ * Caller is responsible for reranking with exact similarity.
+ */
+export declare function searchRabitq(queryEmbedding: number[], options?: {
+    k?: number;
+    namespace?: string;
+}): Promise<Array<{
+    id: string;
+    key: string;
+    namespace: string;
+    distance: number;
+    position: number;
+}> | null>;
+/**
+ * Check if the RaBitQ index needs rebuilding.
+ */
+export declare function shouldRebuildRabitq(currentEntryCount: number): Promise<boolean>;
+/**
+ * Get RaBitQ index status.
+ */
+export declare function getRabitqStatus(): {
+    available: boolean;
+    initialized: boolean;
+    vectorCount: number;
+    dimensions: number;
+    builtAt: number | null;
+    compressionRatio: number;
+};
+//# sourceMappingURL=rabitq-index.d.ts.map

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

@@ -0,0 +1,226 @@
+/**
+ * RaBitQ Index — 1-bit quantized vector pre-filter (32× compression)
+ *
+ * Wraps @ruvector/rabitq-wasm to provide Hamming-scan pre-filtering
+ * over quantized embeddings. Candidates are reranked with exact cosine
+ * similarity from the full-precision source (HNSW or SQLite).
+ *
+ * Lifecycle:
+ *  1. build() — bulk-load all embeddings from SQLite into the WASM index
+ *  2. search() — fast Hamming scan → candidate ids → caller reranks
+ *  3. rebuild() — called when entry count drifts >20% from last build
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const RABITQ_SEED = 42n;
+const RABITQ_RERANK_FACTOR = 20;
+const REBUILD_DRIFT_THRESHOLD = 0.2; // rebuild when count drifts >20%
+let rabitqState = null;
+let rabitqInitializing = false;
+async function loadRabitqModule() {
+    try {
+        const mod = await import('@ruvector/rabitq-wasm');
+        // Node.js: use initSync with the WASM bytes
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const wasmPath = require.resolve('@ruvector/rabitq-wasm/ruvector_rabitq_wasm_bg.wasm');
+        const wasmBytes = fs.readFileSync(wasmPath);
+        mod.initSync({ module: wasmBytes });
+        return {
+            RabitqIndex: mod.RabitqIndex,
+            initSync: mod.initSync,
+            version: mod.version,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build or rebuild the RaBitQ index from SQLite embeddings.
+ * Returns entry count or 0 if RaBitQ is unavailable.
+ */
+export async function buildRabitqIndex(options) {
+    if (rabitqInitializing) {
+        return { success: false, vectorCount: 0, dimensions: 0, compressionRatio: 0, buildTimeMs: 0, error: 'Build already in progress' };
+    }
+    rabitqInitializing = true;
+    const startTime = Date.now();
+    try {
+        const mod = await loadRabitqModule();
+        if (!mod) {
+            rabitqInitializing = false;
+            return { success: false, vectorCount: 0, dimensions: 0, compressionRatio: 0, buildTimeMs: 0, error: '@ruvector/rabitq-wasm not available' };
+        }
+        const dimensions = options?.dimensions ?? 384;
+        const swarmDir = path.resolve(process.cwd(), '.swarm');
+        const dbPath = options?.dbPath ? path.resolve(options.dbPath) : path.join(swarmDir, 'memory.db');
+        if (!fs.existsSync(dbPath)) {
+            rabitqInitializing = false;
+            return { success: false, vectorCount: 0, dimensions, compressionRatio: 0, buildTimeMs: 0, error: 'Database not found' };
+        }
+        // Load embeddings from SQLite
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fileBuffer = fs.readFileSync(dbPath);
+        const db = new SQL.Database(fileBuffer);
+        const result = db.exec(`
+      SELECT id, key, namespace, embedding
+      FROM memory_entries
+      WHERE status = 'active' AND embedding IS NOT NULL
+      LIMIT 50000
+    `);
+        const entries = [];
+        const vectors = [];
+        if (result[0]?.values) {
+            for (const row of result[0].values) {
+                const [id, key, ns, embeddingJson] = row;
+                if (!embeddingJson)
+                    continue;
+                try {
+                    const embedding = JSON.parse(embeddingJson);
+                    if (embedding.length !== dimensions)
+                        continue;
+                    entries.push({ id: String(id), key: key || String(id), namespace: ns || 'default' });
+                    vectors.push(...embedding);
+                }
+                catch {
+                    // skip invalid
+                }
+            }
+        }
+        db.close();
+        if (entries.length < 2) {
+            rabitqInitializing = false;
+            return { success: false, vectorCount: entries.length, dimensions, compressionRatio: 0, buildTimeMs: Date.now() - startTime, error: 'Need at least 2 vectors to build RaBitQ index' };
+        }
+        // Build the RaBitQ index
+        const flatVectors = new Float32Array(vectors);
+        const index = mod.RabitqIndex.build(flatVectors, dimensions, RABITQ_SEED, RABITQ_RERANK_FACTOR);
+        // Free old index if exists
+        if (rabitqState?.index) {
+            try {
+                rabitqState.index.free();
+            }
+            catch { /* already freed */ }
+        }
+        rabitqState = {
+            index,
+            entries,
+            dimensions,
+            builtAt: Date.now(),
+            vectorCount: entries.length,
+        };
+        // Persist metadata for fast reload hint
+        try {
+            const metaPath = path.join(swarmDir, 'rabitq.meta.json');
+            fs.writeFileSync(metaPath, JSON.stringify({
+                vectorCount: entries.length,
+                dimensions,
+                builtAt: rabitqState.builtAt,
+                wasmVersion: mod.version(),
+            }));
+        }
+        catch { /* best-effort */ }
+        const rawBytes = entries.length * dimensions * 4; // f32 = 4 bytes
+        const quantizedBytes = entries.length * Math.ceil(dimensions / 8); // 1 bit per dim
+        const compressionRatio = rawBytes / Math.max(quantizedBytes, 1);
+        rabitqInitializing = false;
+        return {
+            success: true,
+            vectorCount: entries.length,
+            dimensions,
+            compressionRatio: Math.round(compressionRatio * 10) / 10,
+            buildTimeMs: Date.now() - startTime,
+            wasmVersion: mod.version(),
+        };
+    }
+    catch (error) {
+        rabitqInitializing = false;
+        return {
+            success: false,
+            vectorCount: 0,
+            dimensions: 0,
+            compressionRatio: 0,
+            buildTimeMs: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Search the RaBitQ index for candidate IDs.
+ * Returns null if index not built or unavailable.
+ * Caller is responsible for reranking with exact similarity.
+ */
+export async function searchRabitq(queryEmbedding, options) {
+    if (!rabitqState?.index)
+        return null;
+    try {
+        const query = new Float32Array(queryEmbedding);
+        if (query.length !== rabitqState.dimensions)
+            return null;
+        const k = options?.k ?? 10;
+        // Get more candidates than needed for namespace filtering + rerank
+        const expandedK = Math.min(k * 3, rabitqState.vectorCount);
+        const rawResults = rabitqState.index.search(query, expandedK);
+        const results = [];
+        for (const hit of rawResults) {
+            const pos = hit.id; // row index from build()
+            const entry = rabitqState.entries[pos];
+            if (!entry)
+                continue;
+            // Namespace filter
+            if (options?.namespace && options.namespace !== 'all' && entry.namespace !== options.namespace) {
+                continue;
+            }
+            results.push({
+                id: entry.id,
+                key: entry.key,
+                namespace: entry.namespace,
+                distance: hit.distance,
+                position: pos,
+            });
+            // Free WASM SearchResult to prevent leak
+            try {
+                hit.free();
+            }
+            catch { /* already freed */ }
+            if (results.length >= k)
+                break;
+        }
+        // Free remaining SearchResults
+        for (const hit of rawResults) {
+            try {
+                hit.free();
+            }
+            catch { /* already freed or used */ }
+        }
+        return results;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the RaBitQ index needs rebuilding.
+ */
+export async function shouldRebuildRabitq(currentEntryCount) {
+    if (!rabitqState)
+        return currentEntryCount >= 10; // Build if we have enough vectors
+    const drift = Math.abs(currentEntryCount - rabitqState.vectorCount) / Math.max(rabitqState.vectorCount, 1);
+    return drift > REBUILD_DRIFT_THRESHOLD;
+}
+/**
+ * Get RaBitQ index status.
+ */
+export function getRabitqStatus() {
+    return {
+        available: rabitqState !== null,
+        initialized: rabitqState !== null,
+        vectorCount: rabitqState?.vectorCount ?? 0,
+        dimensions: rabitqState?.dimensions ?? 384,
+        builtAt: rabitqState?.builtAt ?? null,
+        compressionRatio: rabitqState ? Math.round((rabitqState.dimensions * 4) / Math.ceil(rabitqState.dimensions / 8) * 10) / 10 : 0,
+    };
+}
+//# sourceMappingURL=rabitq-index.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.4",
+  "version": "3.6.5",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -97,23 +97,24 @@
     "@claude-flow/mcp": "^3.0.0-alpha.8",
     "@claude-flow/shared": "^3.0.0-alpha.7",
     "@noble/ed25519": "^2.1.0",
+    "@ruvector/rabitq-wasm": "^0.1.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "@claude-flow/aidefence": "^3.0.2",
-    "@claude-flow/security": "^3.0.0-alpha.1",
     "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.12",
     "@claude-flow/guidance": "^3.0.0-alpha.1",
     "@claude-flow/memory": "^3.0.0-alpha.12",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
+    "@claude-flow/security": "^3.0.0-alpha.1",
     "@ruvector/attention": "^0.1.32",
     "@ruvector/attention-darwin-arm64": "0.1.32",
+    "@ruvector/diskann": "^0.1.0",
     "@ruvector/learning-wasm": "^0.1.29",
     "@ruvector/router": "^0.1.30",
     "@ruvector/ruvllm-wasm": "^2.0.2",
     "@ruvector/rvagent-wasm": "^0.1.0",
-    "@ruvector/diskann": "^0.1.0",
     "@ruvector/sona": "^0.1.5",
     "agentdb": "^3.0.0-alpha.11",
     "agentic-flow": "^3.0.0-alpha.1"