@claude-flow/cli 3.1.0-alpha.50 → 3.1.0-alpha.51

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

@@ -0,0 +1,693 @@
+/**
+ * Memory Bridge — Routes CLI memory operations through ControllerRegistry + AgentDB v3
+ *
+ * Per ADR-053: Replaces raw sql.js operations in memory-initializer.ts with
+ * ControllerRegistry → HybridBackend → AgentDB v3 pipeline.
+ *
+ * All functions match memory-initializer.ts signatures exactly so consumers
+ * need zero changes. The bridge is loaded lazily on first call and cached.
+ *
+ * Uses better-sqlite3 API (synchronous .all()/.get()/.run()) since that's
+ * what AgentDB v3 uses internally.
+ *
+ * @module v3/cli/memory-bridge
+ */
+import * as path from 'path';
+// ===== Lazy singleton =====
+let registryPromise = null;
+let registryInstance = null;
+let bridgeAvailable = null;
+function getDbPath(customPath) {
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    return customPath || path.join(swarmDir, 'memory.db');
+}
+/**
+ * Lazily initialize the ControllerRegistry singleton.
+ * Returns null if @claude-flow/memory is not available.
+ */
+async function getRegistry(dbPath) {
+    if (bridgeAvailable === false)
+        return null;
+    if (registryInstance)
+        return registryInstance;
+    if (!registryPromise) {
+        registryPromise = (async () => {
+            try {
+                const { ControllerRegistry } = await import('@claude-flow/memory');
+                const registry = new ControllerRegistry();
+                // Suppress noisy console.log during init
+                const origLog = console.log;
+                console.log = (...args) => {
+                    const msg = String(args[0] ?? '');
+                    if (msg.includes('Transformers.js') ||
+                        msg.includes('better-sqlite3') ||
+                        msg.includes('[AgentDB]') ||
+                        msg.includes('[HNSWLibBackend]') ||
+                        msg.includes('RuVector graph'))
+                        return;
+                    origLog.apply(console, args);
+                };
+                try {
+                    await registry.initialize({
+                        dbPath: dbPath || getDbPath(),
+                        dimension: 384,
+                        controllers: {
+                            reasoningBank: true,
+                            learningBridge: false,
+                            tieredCache: true,
+                        },
+                    });
+                }
+                finally {
+                    console.log = origLog;
+                }
+                registryInstance = registry;
+                bridgeAvailable = true;
+                return registry;
+            }
+            catch {
+                bridgeAvailable = false;
+                registryPromise = null;
+                return null;
+            }
+        })();
+    }
+    return registryPromise;
+}
+/**
+ * Get the AgentDB database handle and ensure memory_entries table exists.
+ * Returns null if not available.
+ */
+function getDb(registry) {
+    const agentdb = registry.getAgentDB();
+    if (!agentdb?.database)
+        return null;
+    const db = agentdb.database;
+    // Ensure memory_entries table exists (idempotent)
+    try {
+        db.exec(`CREATE TABLE IF NOT EXISTS memory_entries (
+      id TEXT PRIMARY KEY,
+      key TEXT NOT NULL,
+      namespace TEXT DEFAULT 'default',
+      content TEXT NOT NULL,
+      type TEXT DEFAULT 'semantic',
+      embedding TEXT,
+      embedding_model TEXT DEFAULT 'local',
+      embedding_dimensions INTEGER,
+      tags TEXT,
+      metadata TEXT,
+      owner_id TEXT,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+      expires_at INTEGER,
+      last_accessed_at INTEGER,
+      access_count INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'active',
+      UNIQUE(namespace, key)
+    )`);
+        // Ensure indexes
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_ns ON memory_entries(namespace)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_key ON memory_entries(key)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_bridge_status ON memory_entries(status)`);
+    }
+    catch {
+        // Table already exists or db is read-only — that's fine
+    }
+    return { db, agentdb };
+}
+// ===== Bridge functions — match memory-initializer.ts signatures =====
+/**
+ * Store an entry via AgentDB v3.
+ * Returns null to signal fallback to sql.js.
+ */
+export async function bridgeStoreEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, value, namespace = 'default', tags = [], ttl } = options;
+        const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const now = Date.now();
+        // Generate embedding via AgentDB's embedder
+        let embeddingJson = null;
+        let dimensions = 0;
+        let model = 'local';
+        if (options.generateEmbeddingFlag !== false && value.length > 0) {
+            try {
+                const embedder = ctx.agentdb.embedder;
+                if (embedder) {
+                    const emb = await embedder.embed(value);
+                    if (emb) {
+                        embeddingJson = JSON.stringify(Array.from(emb));
+                        dimensions = emb.length;
+                        model = 'Xenova/all-MiniLM-L6-v2';
+                    }
+                }
+            }
+            catch {
+                // Embedding failed — store without
+            }
+        }
+        // better-sqlite3 uses synchronous .run() with positional params
+        const insertSql = options.upsert
+            ? `INSERT OR REPLACE INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`
+            : `INSERT INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          tags, metadata, created_at, updated_at, expires_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, ?, ?, ?, 'active')`;
+        const stmt = ctx.db.prepare(insertSql);
+        stmt.run(id, key, namespace, value, embeddingJson, dimensions || null, model, tags.length > 0 ? JSON.stringify(tags) : null, '{}', now, now, ttl ? now + (ttl * 1000) : null);
+        return {
+            success: true,
+            id,
+            embedding: embeddingJson ? { dimensions, model } : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Search entries via AgentDB v3.
+ */
+export async function bridgeSearchEntries(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { query: queryStr, namespace = 'default', limit = 10, threshold = 0.3 } = options;
+        const startTime = Date.now();
+        // Generate query embedding
+        let queryEmbedding = null;
+        try {
+            const embedder = ctx.agentdb.embedder;
+            if (embedder) {
+                const emb = await embedder.embed(queryStr);
+                queryEmbedding = Array.from(emb);
+            }
+        }
+        catch {
+            // Fall back to keyword search
+        }
+        // better-sqlite3: .prepare().all() returns array of objects
+        const nsFilter = namespace !== 'all'
+            ? `AND namespace = ?`
+            : '';
+        let rows;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding
+        FROM memory_entries
+        WHERE status = 'active' ${nsFilter}
+        LIMIT 1000
+      `);
+            rows = namespace !== 'all' ? stmt.all(namespace) : stmt.all();
+        }
+        catch {
+            return null;
+        }
+        const results = [];
+        for (const row of rows) {
+            let score = 0;
+            if (queryEmbedding && row.embedding) {
+                try {
+                    const embedding = JSON.parse(row.embedding);
+                    score = cosineSim(queryEmbedding, embedding);
+                }
+                catch {
+                    // Invalid embedding
+                }
+            }
+            // Keyword fallback
+            if (score < threshold) {
+                const lowerContent = (row.content || '').toLowerCase();
+                const words = queryStr.toLowerCase().split(/\s+/);
+                const matchCount = words.filter((w) => lowerContent.includes(w)).length;
+                score = Math.max(score, (matchCount / words.length) * 0.5);
+            }
+            if (score >= threshold) {
+                results.push({
+                    id: String(row.id).substring(0, 12),
+                    key: row.key || String(row.id).substring(0, 15),
+                    content: (row.content || '').substring(0, 60) + ((row.content || '').length > 60 ? '...' : ''),
+                    score,
+                    namespace: row.namespace || 'default',
+                });
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return {
+            success: true,
+            results: results.slice(0, limit),
+            searchTime: Date.now() - startTime,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List entries via AgentDB v3.
+ */
+export async function bridgeListEntries(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { namespace, limit = 20, offset = 0 } = options;
+        const nsFilter = namespace ? `AND namespace = ?` : '';
+        const nsParams = namespace ? [namespace] : [];
+        // Count
+        let total = 0;
+        try {
+            const countStmt = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' ${nsFilter}`);
+            const countRow = countStmt.get(...nsParams);
+            total = countRow?.cnt || 0;
+        }
+        catch {
+            return null;
+        }
+        // List
+        const entries = [];
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at
+        FROM memory_entries
+        WHERE status = 'active' ${nsFilter}
+        ORDER BY updated_at DESC
+        LIMIT ? OFFSET ?
+      `);
+            const rows = stmt.all(...nsParams, limit, offset);
+            for (const row of rows) {
+                entries.push({
+                    id: String(row.id).substring(0, 20),
+                    key: row.key || String(row.id).substring(0, 15),
+                    namespace: row.namespace || 'default',
+                    size: (row.content || '').length,
+                    accessCount: row.access_count || 0,
+                    createdAt: row.created_at || new Date().toISOString(),
+                    updatedAt: row.updated_at || new Date().toISOString(),
+                    hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
+                });
+            }
+        }
+        catch {
+            return null;
+        }
+        return { success: true, entries, total };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get a specific entry via AgentDB v3.
+ */
+export async function bridgeGetEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, namespace = 'default' } = options;
+        let row;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at, tags
+        FROM memory_entries
+        WHERE status = 'active' AND key = ? AND namespace = ?
+        LIMIT 1
+      `);
+            row = stmt.get(key, namespace);
+        }
+        catch {
+            return null;
+        }
+        if (!row) {
+            return { success: true, found: false };
+        }
+        // Update access count
+        try {
+            ctx.db.prepare(`UPDATE memory_entries SET access_count = access_count + 1, last_accessed_at = ? WHERE id = ?`).run(Date.now(), row.id);
+        }
+        catch {
+            // Non-fatal
+        }
+        let tags = [];
+        if (row.tags) {
+            try {
+                tags = JSON.parse(row.tags);
+            }
+            catch { /* invalid */ }
+        }
+        return {
+            success: true,
+            found: true,
+            entry: {
+                id: String(row.id),
+                key: row.key || String(row.id),
+                namespace: row.namespace || 'default',
+                content: row.content || '',
+                accessCount: (row.access_count || 0) + 1,
+                createdAt: row.created_at || new Date().toISOString(),
+                updatedAt: row.updated_at || new Date().toISOString(),
+                hasEmbedding: !!(row.embedding && String(row.embedding).length > 10),
+                tags,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Delete an entry via AgentDB v3.
+ */
+export async function bridgeDeleteEntry(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const { key, namespace = 'default' } = options;
+        // Soft delete using parameterized query
+        let changes = 0;
+        try {
+            const result = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE key = ? AND namespace = ? AND status = 'active'
+      `).run(Date.now(), key, namespace);
+            changes = result?.changes ?? 0;
+        }
+        catch {
+            return null;
+        }
+        let remaining = 0;
+        try {
+            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active'`).get();
+            remaining = row?.cnt || 0;
+        }
+        catch {
+            // Non-fatal
+        }
+        return {
+            success: true,
+            deleted: changes > 0,
+            key,
+            namespace,
+            remainingEntries: remaining,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ===== Phase 2: Embedding bridge =====
+/**
+ * Generate embedding via AgentDB v3's embedder.
+ * Returns null if bridge unavailable — caller falls back to own ONNX/hash.
+ */
+export async function bridgeGenerateEmbedding(text, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const agentdb = registry.getAgentDB();
+        const embedder = agentdb?.embedder;
+        if (!embedder)
+            return null;
+        const emb = await embedder.embed(text);
+        if (!emb)
+            return null;
+        return {
+            embedding: Array.from(emb),
+            dimensions: emb.length,
+            model: 'Xenova/all-MiniLM-L6-v2',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load embedding model via AgentDB v3 (it loads on init).
+ * Returns null if unavailable.
+ */
+export async function bridgeLoadEmbeddingModel(dbPath) {
+    const startTime = Date.now();
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const agentdb = registry.getAgentDB();
+        const embedder = agentdb?.embedder;
+        if (!embedder)
+            return null;
+        // Verify embedder works by generating a test embedding
+        const test = await embedder.embed('test');
+        if (!test)
+            return null;
+        return {
+            success: true,
+            dimensions: test.length,
+            modelName: 'Xenova/all-MiniLM-L6-v2',
+            loadTime: Date.now() - startTime,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ===== Phase 3: HNSW bridge =====
+/**
+ * Get HNSW status from AgentDB v3's vector backend or HNSW index.
+ * Returns null if unavailable.
+ */
+export async function bridgeGetHNSWStatus(dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        const ctx = getDb(registry);
+        if (!ctx)
+            return null;
+        // Count entries with embeddings
+        let entryCount = 0;
+        try {
+            const row = ctx.db.prepare(`SELECT COUNT(*) as cnt FROM memory_entries WHERE status = 'active' AND embedding IS NOT NULL`).get();
+            entryCount = row?.cnt || 0;
+        }
+        catch {
+            // Table might not exist
+        }
+        return {
+            available: true,
+            initialized: true,
+            entryCount,
+            dimensions: 384,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Search using AgentDB v3's embedder + SQLite entries.
+ * This is the HNSW-equivalent search through the bridge.
+ * Returns null if unavailable.
+ */
+export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const k = options?.k ?? 10;
+        const threshold = options?.threshold ?? 0.3;
+        const nsFilter = options?.namespace && options.namespace !== 'all'
+            ? `AND namespace = ?`
+            : '';
+        let rows;
+        try {
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding
+        FROM memory_entries
+        WHERE status = 'active' AND embedding IS NOT NULL ${nsFilter}
+        LIMIT 10000
+      `);
+            rows = nsFilter
+                ? stmt.all(options.namespace)
+                : stmt.all();
+        }
+        catch {
+            return null;
+        }
+        const results = [];
+        for (const row of rows) {
+            if (!row.embedding)
+                continue;
+            try {
+                const emb = JSON.parse(row.embedding);
+                const score = cosineSim(queryEmbedding, emb);
+                if (score >= threshold) {
+                    results.push({
+                        id: String(row.id).substring(0, 12),
+                        key: row.key || String(row.id).substring(0, 15),
+                        content: (row.content || '').substring(0, 60) +
+                            ((row.content || '').length > 60 ? '...' : ''),
+                        score,
+                        namespace: row.namespace || 'default',
+                    });
+                }
+            }
+            catch {
+                // Skip invalid embeddings
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, k);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Add entry to the bridge's database with embedding.
+ * Returns null if unavailable.
+ */
+export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const now = Date.now();
+        const embeddingJson = JSON.stringify(embedding);
+        ctx.db.prepare(`
+      INSERT OR REPLACE INTO memory_entries (
+        id, key, namespace, content, type,
+        embedding, embedding_dimensions, embedding_model,
+        created_at, updated_at, status
+      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, 'Xenova/all-MiniLM-L6-v2', ?, ?, 'active')
+    `).run(id, entry.key, entry.namespace, entry.content, embeddingJson, embedding.length, now, now);
+        return true;
+    }
+    catch {
+        return null;
+    }
+}
+// ===== Phase 4: Controller access =====
+/**
+ * Get a named controller from AgentDB v3 via ControllerRegistry.
+ * Returns null if unavailable.
+ */
+export async function bridgeGetController(name, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        return registry.get(name) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a controller is available.
+ */
+export async function bridgeHasController(name, dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return false;
+    try {
+        const controller = registry.get(name);
+        return controller !== null && controller !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * List all controllers and their status.
+ */
+export async function bridgeListControllers(dbPath) {
+    const registry = await getRegistry(dbPath);
+    if (!registry)
+        return null;
+    try {
+        return registry.listControllers();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the AgentDB v3 bridge is available.
+ */
+export async function isBridgeAvailable(dbPath) {
+    if (bridgeAvailable !== null)
+        return bridgeAvailable;
+    const registry = await getRegistry(dbPath);
+    return registry !== null;
+}
+/**
+ * Get the ControllerRegistry instance (for advanced consumers).
+ */
+export async function getControllerRegistry(dbPath) {
+    return getRegistry(dbPath);
+}
+/**
+ * Shutdown the bridge and release resources.
+ */
+export async function shutdownBridge() {
+    if (registryInstance) {
+        try {
+            await registryInstance.shutdown();
+        }
+        catch {
+            // Best-effort
+        }
+        registryInstance = null;
+        registryPromise = null;
+        bridgeAvailable = null;
+    }
+}
+// ===== Utility =====
+function cosineSim(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < len; i++) {
+        const ai = a[i], bi = b[i];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const mag = Math.sqrt(normA * normB);
+    return mag === 0 ? 0 : dot / mag;
+}
+//# sourceMappingURL=memory-bridge.js.map