kynjal-cli 3.1.4 → 4.0.1

package/dist/src/memory/memory-initializer.js

@@ -3,16 +3,35 @@
  * Properly initializes the memory database with sql.js (WASM SQLite)
  * Includes pattern tables, vector embeddings, migration state tracking
  *
+ * ADR-053: Routes through ControllerRegistry → AgentDB v3 when available,
+ * falls back to raw sql.js for backwards compatibility.
+ *
  * @module v3/cli/memory-initializer
  */
 import * as fs from 'fs';
 import * as path from 'path';
+// ADR-053: Lazy import of AgentDB v3 bridge
+let _bridge;
+async function getBridge() {
+    if (_bridge === null)
+        return null;
+    if (_bridge)
+        return _bridge;
+    try {
+        _bridge = await import('./memory-bridge.js');
+        return _bridge;
+    }
+    catch {
+        _bridge = null;
+        return null;
+    }
+}
 /**
  * Enhanced schema with pattern confidence, temporal decay, versioning
  * Vector embeddings enabled for semantic search
  */
 export const MEMORY_SCHEMA_V3 = `
--- KynjalFlow V3 Memory Database
+-- RuFlo V3 Memory Database
 -- Version: 3.0.0
 -- Features: Pattern learning, vector embeddings, temporal decay, migration tracking
 
@@ -452,6 +471,13 @@ function saveHNSWMetadata() {
  * Add entry to HNSW index (with automatic persistence)
  */
 export async function addToHNSWIndex(id, embedding, entry) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeAddToHNSW(id, embedding, entry);
+        if (bridgeResult === true)
+            return true;
+    }
     const index = await getHNSWIndex({ dimensions: embedding.length });
     if (!index)
         return false;
@@ -475,6 +501,13 @@ export async function addToHNSWIndex(id, embedding, entry) {
  * Returns results sorted by similarity (highest first)
  */
 export async function searchHNSWIndex(queryEmbedding, options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeSearchHNSW(queryEmbedding, options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
     const index = await getHNSWIndex({ dimensions: queryEmbedding.length });
     if (!index)
         return null;
@@ -517,6 +550,16 @@ export async function searchHNSWIndex(queryEmbedding, options) {
  * Get HNSW index status
  */
 export function getHNSWStatus() {
+    // ADR-053: If bridge was previously loaded, report availability
+    if (_bridge && _bridge !== null) {
+        // Bridge is loaded — HNSW-equivalent is available via AgentDB v3
+        return {
+            available: true,
+            initialized: true,
+            entryCount: hnswIndex?.entries.size ?? 0,
+            dimensions: hnswIndex?.dimensions ?? 384
+        };
+    }
     return {
         available: hnswIndex !== null,
         initialized: hnswIndex?.initialized ?? false,
@@ -530,6 +573,15 @@ export function getHNSWStatus() {
 export function clearHNSWIndex() {
     hnswIndex = null;
 }
+/**
+ * Invalidate the in-memory HNSW cache so the next search rebuilds from DB.
+ * Call this after deleting entries that had embeddings to prevent ghost
+ * vectors from appearing in search results.
+ */
+export function rebuildSearchIndex() {
+    hnswIndex = null;
+    hnswInitializing = false;
+}
 // ============================================================================
 // INT8 VECTOR QUANTIZATION (4x memory reduction)
 // ============================================================================
@@ -871,6 +923,51 @@ export async function checkAndMigrateLegacy(options) {
     }
     return { needsMigration: false };
 }
+/**
+ * ADR-053: Activate ControllerRegistry so AgentDB v3 controllers
+ * (ReasoningBank, SkillLibrary, ExplainableRecall, etc.) are instantiated.
+ *
+ * Uses the memory-bridge's getControllerRegistry() which lazily creates
+ * a singleton ControllerRegistry and initializes it with the given dbPath.
+ * After this call, all enabled controllers are ready for immediate use.
+ *
+ * Failures are isolated: if @claude-flow/memory or agentdb is not installed,
+ * this returns an empty result without throwing.
+ */
+async function activateControllerRegistry(dbPath, verbose) {
+    const startTime = performance.now();
+    const activated = [];
+    const failed = [];
+    try {
+        const bridge = await getBridge();
+        if (!bridge) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        const registry = await bridge.getControllerRegistry(dbPath);
+        if (!registry) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        // Collect controller status from the registry
+        if (typeof registry.listControllers === 'function') {
+            const controllers = registry.listControllers();
+            for (const ctrl of controllers) {
+                if (ctrl.enabled) {
+                    activated.push(ctrl.name);
+                }
+                else {
+                    failed.push(ctrl.name);
+                }
+            }
+        }
+        if (verbose && activated.length > 0) {
+            console.log(`ControllerRegistry: ${activated.length} controllers activated`);
+        }
+    }
+    catch {
+        // ControllerRegistry activation is best-effort
+    }
+    return { activated, failed, initTimeMs: performance.now() - startTime };
+}
 /**
  * Initialize the memory database properly using sql.js
  */
@@ -944,6 +1041,9 @@ export async function initializeMemoryDatabase(options) {
             // Also create schema file for reference
             const schemaPath = path.join(dbDir, 'schema.sql');
             fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
+            // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
+            // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
             return {
                 success: true,
                 backend,
@@ -981,7 +1081,8 @@ export async function initializeMemoryDatabase(options) {
                     temporalDecay: true,
                     hnswIndexing: true,
                     migrationTracking: true
-                }
+                },
+                controllers: controllerResult,
             };
         }
         else {
@@ -1001,6 +1102,8 @@ export async function initializeMemoryDatabase(options) {
             sqliteHeader[26] = 0x20; // min embedded payload
             sqliteHeader[27] = 0x20; // leaf payload
             fs.writeFileSync(dbPath, sqliteHeader);
+            // ADR-053: Activate ControllerRegistry even on fallback path
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
             return {
                 success: true,
                 backend,
@@ -1024,7 +1127,8 @@ export async function initializeMemoryDatabase(options) {
                     temporalDecay: true,
                     hnswIndexing: true,
                     migrationTracking: true
-                }
+                },
+                controllers: controllerResult,
             };
         }
     }
@@ -1154,6 +1258,21 @@ export async function loadEmbeddingModel(options) {
             loadTime: 0
         };
     }
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeLoadEmbeddingModel();
+        if (bridgeResult && bridgeResult.success) {
+            // Mark local state as loaded too so subsequent calls use cache
+            embeddingModelState = {
+                loaded: true,
+                model: null, // Bridge handles embedding
+                tokenizer: null,
+                dimensions: bridgeResult.dimensions
+            };
+            return bridgeResult;
+        }
+    }
     try {
         // Try to import @xenova/transformers for ONNX embeddings
         const transformers = await import('@xenova/transformers').catch(() => null);
@@ -1177,7 +1296,62 @@ export async function loadEmbeddingModel(options) {
                 loadTime: Date.now() - startTime
             };
         }
-        // Fallback: Check for agentic-flow ONNX
+        // Fallback: Check for agentic-flow ReasoningBank embeddings (v3)
+        const reasoningBank = await import('agentic-flow/reasoningbank').catch(() => null);
+        if (reasoningBank?.computeEmbedding) {
+            if (verbose) {
+                console.log('Loading agentic-flow ReasoningBank embedding model...');
+            }
+            embeddingModelState = {
+                loaded: true,
+                model: { embed: reasoningBank.computeEmbedding },
+                tokenizer: null,
+                dimensions: 768
+            };
+            return {
+                success: true,
+                dimensions: 768,
+                modelName: 'agentic-flow/reasoningbank',
+                loadTime: Date.now() - startTime
+            };
+        }
+        // Fallback: Check for ruvector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
+        // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
+        // Note: isReady() returns false until first embed() call (lazy init), so we
+        // skip the isReady() gate and verify with a probe embed instead.
+        const ruvector = await import('ruvector').catch(() => null);
+        if (ruvector?.initOnnxEmbedder) {
+            try {
+                await ruvector.initOnnxEmbedder();
+                // Fallback: OptimizedOnnxEmbedder (raw ONNX, lazy-inits on first embed)
+                const onnxEmb = ruvector.getOptimizedOnnxEmbedder?.();
+                if (onnxEmb?.embed) {
+                    // Probe embed to trigger lazy ONNX init and verify it works
+                    const probe = await onnxEmb.embed('test');
+                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
+                        if (verbose) {
+                            console.log(`Loading ruvector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
+                        }
+                        embeddingModelState = {
+                            loaded: true,
+                            model: (text) => onnxEmb.embed(text),
+                            tokenizer: null,
+                            dimensions: probe.length || 384
+                        };
+                        return {
+                            success: true,
+                            dimensions: probe.length || 384,
+                            modelName: 'ruvector/onnx',
+                            loadTime: Date.now() - startTime
+                        };
+                    }
+                }
+            }
+            catch {
+                // ruvector ONNX init failed, continue to next fallback
+            }
+        }
+        // Legacy fallback: Check for agentic-flow core embeddings
         const agenticFlow = await import('agentic-flow').catch(() => null);
         if (agenticFlow && agenticFlow.embeddings) {
             if (verbose) {
@@ -1224,6 +1398,13 @@ export async function loadEmbeddingModel(options) {
  * Uses ONNX model if available, falls back to deterministic hash
  */
 export async function generateEmbedding(text) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGenerateEmbedding(text);
+        if (bridgeResult)
+            return bridgeResult;
+    }
     // Ensure model is loaded
     if (!embeddingModelState?.loaded) {
         await loadEmbeddingModel();
@@ -1233,12 +1414,17 @@ export async function generateEmbedding(text) {
     if (state.model && typeof state.model === 'function') {
         try {
             const output = await state.model(text, { pooling: 'mean', normalize: true });
-            const embedding = Array.from(output.data);
-            return {
-                embedding,
-                dimensions: embedding.length,
-                model: 'onnx'
-            };
+            // Handle both @xenova/transformers (output.data) and ruvector (plain array) formats
+            const embedding = output?.data
+                ? Array.from(output.data)
+                : Array.isArray(output) ? output : null;
+            if (embedding) {
+                return {
+                    embedding,
+                    dimensions: embedding.length,
+                    model: 'onnx'
+                };
+            }
         }
         catch {
             // Fall through to fallback
@@ -1499,6 +1685,14 @@ export async function verifyMemoryInit(dbPath, options) {
  * This bypasses MCP and writes directly to the database
  */
 export async function storeEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeStoreEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
     const swarmDir = path.join(process.cwd(), '.swarm');
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
@@ -1583,6 +1777,14 @@ export async function storeEntry(options) {
  * Uses HNSW index for 150x faster search when available
  */
 export async function searchEntries(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeSearchEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
     const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;
     const swarmDir = path.join(process.cwd(), '.swarm');
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
@@ -1613,13 +1815,18 @@ export async function searchEntries(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get entries with embeddings
-        const entries = db.exec(`
-      SELECT id, key, namespace, content, embedding
-      FROM memory_entries
-      WHERE status = 'active'
-        ${namespace !== 'all' ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
-      LIMIT 1000
-    `);
+        const searchStmt = db.prepare(namespace !== 'all'
+            ? `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' AND namespace = ? LIMIT 1000`
+            : `SELECT id, key, namespace, content, embedding FROM memory_entries WHERE status = 'active' LIMIT 1000`);
+        if (namespace !== 'all') {
+            searchStmt.bind([namespace]);
+        }
+        const searchRows = [];
+        while (searchStmt.step()) {
+            searchRows.push(searchStmt.get());
+        }
+        searchStmt.free();
+        const entries = searchRows.length > 0 ? [{ values: searchRows }] : [];
         const results = [];
         if (entries[0]?.values) {
             for (const row of entries[0].values) {
@@ -1697,6 +1904,14 @@ function cosineSim(a, b) {
  * List all entries from the memory database
  */
 export async function listEntries(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeListEntries(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
     const swarmDir = path.join(process.cwd(), '.swarm');
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
@@ -1711,21 +1926,37 @@ export async function listEntries(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get total count
-        const countQuery = namespace
-            ? `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = '${namespace.replace(/'/g, "''")}'`
-            : `SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`;
-        const countResult = db.exec(countQuery);
+        const countStmt = namespace
+            ? db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND namespace = ?`)
+            : db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`);
+        if (namespace) {
+            countStmt.bind([namespace]);
+        }
+        const countRows = [];
+        while (countStmt.step()) {
+            countRows.push(countStmt.get());
+        }
+        countStmt.free();
+        const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
         const total = countResult[0]?.values?.[0]?.[0] || 0;
         // Get entries
-        const listQuery = `
-      SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at
-      FROM memory_entries
-      WHERE status = 'active'
-        ${namespace ? `AND namespace = '${namespace.replace(/'/g, "''")}'` : ''}
-      ORDER BY updated_at DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-        const result = db.exec(listQuery);
+        const safeLimit = parseInt(String(limit), 10) || 100;
+        const safeOffset = parseInt(String(offset), 10) || 0;
+        const listStmt = namespace
+            ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
+            : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
+        if (namespace) {
+            listStmt.bind([namespace, safeLimit, safeOffset]);
+        }
+        else {
+            listStmt.bind([safeLimit, safeOffset]);
+        }
+        const listRows = [];
+        while (listStmt.step()) {
+            listRows.push(listStmt.get());
+        }
+        listStmt.free();
+        const result = listRows.length > 0 ? [{ values: listRows }] : [];
         const entries = [];
         if (result[0]?.values) {
             for (const row of result[0].values) {
@@ -1758,6 +1989,14 @@ export async function listEntries(options) {
  * Get a specific entry from the memory database
  */
 export async function getEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeGetEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
     const swarmDir = path.join(process.cwd(), '.swarm');
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
@@ -1772,14 +2011,21 @@ export async function getEntry(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Find entry by key
-        const result = db.exec(`
+        const getStmt = db.prepare(`
       SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
       FROM memory_entries
       WHERE status = 'active'
-        AND key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+        AND key = ?
+        AND namespace = ?
       LIMIT 1
     `);
+        getStmt.bind([key, namespace]);
+        const getRows = [];
+        while (getStmt.step()) {
+            getRows.push(getStmt.get());
+        }
+        getStmt.free();
+        const result = getRows.length > 0 ? [{ values: getRows }] : [];
         if (!result[0]?.values?.[0]) {
             db.close();
             return { success: true, found: false };
@@ -1789,8 +2035,8 @@ export async function getEntry(options) {
         db.run(`
       UPDATE memory_entries
       SET access_count = access_count + 1, last_accessed_at = strftime('%s', 'now') * 1000
-      WHERE id = '${String(id).replace(/'/g, "''")}'
-    `);
+      WHERE id = ?
+    `, [String(id)]);
         // Save updated database
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
@@ -1833,6 +2079,14 @@ export async function getEntry(options) {
  * Issue #980: Properly supports namespaced entries
  */
 export async function deleteEntry(options) {
+    // ADR-053: Try AgentDB v3 bridge first
+    const bridge = await getBridge();
+    if (bridge) {
+        const bridgeResult = await bridge.bridgeDeleteEntry(options);
+        if (bridgeResult)
+            return bridgeResult;
+    }
+    // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
     const swarmDir = path.join(process.cwd(), '.swarm');
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
@@ -1854,13 +2108,20 @@ export async function deleteEntry(options) {
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Check if entry exists first
-        const checkResult = db.exec(`
+        const checkStmt = db.prepare(`
       SELECT id FROM memory_entries
       WHERE status = 'active'
-        AND key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+        AND key = ?
+        AND namespace = ?
       LIMIT 1
     `);
+        checkStmt.bind([key, namespace]);
+        const checkRows = [];
+        while (checkStmt.step()) {
+            checkRows.push(checkStmt.get());
+        }
+        checkStmt.free();
+        const checkResult = checkRows.length > 0 ? [{ values: checkRows }] : [];
         if (!checkResult[0]?.values?.[0]) {
             // Get remaining count before closing
             const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
@@ -1875,14 +2136,19 @@ export async function deleteEntry(options) {
                 error: `Key '${key}' not found in namespace '${namespace}'`
             };
         }
+        // Capture the entry ID for HNSW cleanup
+        const entryId = String(checkResult[0].values[0][0]);
         // Delete the entry (soft delete by setting status to 'deleted')
+        // Also null out the embedding to clean up vector data from SQLite
         db.run(`
       UPDATE memory_entries
-      SET status = 'deleted', updated_at = strftime('%s', 'now') * 1000
-      WHERE key = '${key.replace(/'/g, "''")}'
-        AND namespace = '${namespace.replace(/'/g, "''")}'
+      SET status = 'deleted',
+          embedding = NULL,
+          updated_at = strftime('%s', 'now') * 1000
+      WHERE key = ?
+        AND namespace = ?
         AND status = 'active'
-    `);
+    `, [key, namespace]);
         // Get remaining count
         const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
         const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
@@ -1890,6 +2156,17 @@ export async function deleteEntry(options) {
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
         db.close();
+        // Clean up in-memory HNSW index so ghost vectors don't appear in searches.
+        // Remove the entry from the HNSW entries map and invalidate the index.
+        // The next search will rebuild the HNSW index from the remaining DB rows.
+        if (hnswIndex?.entries) {
+            hnswIndex.entries.delete(entryId);
+            saveHNSWMetadata();
+            // Invalidate the HNSW index so it rebuilds from DB on next search.
+            // We can't surgically remove a vector from the HNSW graph, so we
+            // clear the entire index; it will be lazily rebuilt from SQLite.
+            rebuildSearchIndex();
+        }
         return {
             success: true,
             deleted: true,
@@ -1923,6 +2200,7 @@ export default {
     listEntries,
     getEntry,
     deleteEntry,
+    rebuildSearchIndex,
     MEMORY_SCHEMA_V3,
     getInitialMetadata
 };