@claude-flow/cli 3.6.30 → 3.7.0-alpha.10

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

@@ -471,25 +471,25 @@ function getDb(registry) {
     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)
+        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)`);
@@ -545,15 +545,15 @@ export async function bridgeStoreEntry(options) {
         }
         // 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
+            ? `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
+            : `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);
@@ -612,11 +612,11 @@ export async function bridgeSearchEntries(options) {
             : '';
         let rows;
         try {
-            const stmt = ctx.db.prepare(`
-        SELECT id, key, namespace, content, embedding
-        FROM memory_entries
-        WHERE status = 'active' ${nsFilter}
-        LIMIT 1000
+            const stmt = ctx.db.prepare(`
+        SELECT id, key, namespace, content, embedding
+        FROM memory_entries
+        WHERE status = 'active' ${nsFilter}
+        LIMIT 1000
       `);
             rows = effectiveNamespace !== 'all' ? stmt.all(effectiveNamespace) : stmt.all();
         }
@@ -707,12 +707,12 @@ export async function bridgeListEntries(options) {
         // 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 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) {
@@ -775,11 +775,11 @@ export async function bridgeGetEntry(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
+            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);
         }
@@ -843,10 +843,10 @@ export async function bridgeDeleteEntry(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'
+            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;
         }
@@ -991,11 +991,11 @@ export async function bridgeSearchHNSW(queryEmbedding, options, dbPath) {
             : '';
         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
+            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)
@@ -1047,12 +1047,12 @@ export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
     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')
+        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;
     }
@@ -1340,9 +1340,9 @@ export async function bridgeRecordCausalEdge(options) {
         const ctx = getDb(registry);
         if (ctx) {
             try {
-                ctx.db.prepare(`
-          INSERT OR REPLACE INTO memory_entries (id, key, namespace, content, type, created_at, updated_at, status)
-          VALUES (?, ?, 'causal-edges', ?, 'procedural', ?, ?, 'active')
+                ctx.db.prepare(`
+          INSERT OR REPLACE INTO memory_entries (id, key, namespace, content, type, created_at, updated_at, status)
+          VALUES (?, ?, 'causal-edges', ?, 'procedural', ?, ?, 'active')
         `).run(generateId('edge'), `${options.sourceId}→${options.targetId}`, JSON.stringify(options), Date.now(), Date.now());
                 return { success: true, controller: 'bridge-fallback' };
             }
@@ -1354,6 +1354,259 @@ export async function bridgeRecordCausalEdge(options) {
         return null;
     }
 }
+// ===== #1784: Delete tools for hierarchical + causal-graph =====
+/**
+ * Delete a hierarchical-memory entry by key (#1784).
+ *
+ * Reality check: agentdb's HierarchicalMemory class doesn't expose a public
+ * delete API today, so the real-backend path falls back to direct SQL on
+ * the underlying SQLite tables (status flip to 'deleted' + AttestationLog
+ * audit). The bridge-fallback path that bridgeHierarchicalStore uses when
+ * HierarchicalMemory isn't loaded writes plain memory_entries rows that
+ * `bridgeDeleteEntry` already handles.
+ *
+ * Returns { controller: 'native-unsupported' } when the real HM is loaded
+ * and the SQL fallback can't reach its private tables — surfacing the
+ * limitation honestly instead of silently returning success.
+ */
+export async function bridgeDeleteHierarchical(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { key, tier } = options;
+        // MutationGuard validation
+        const guardResult = await guardValidate(registry, 'delete', { key, namespace: 'hierarchical' });
+        if (!guardResult.allowed) {
+            return { success: false, deleted: false, key, tier, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        const hm = registry.get('hierarchicalMemory');
+        // 1. agentdb@3.0.0-alpha.13+: ReflexionMemory.deleteEpisode propagates through
+        //    graph adapter / generic graph backend / vector backend AND purges SQL
+        //    episodes + episode_embeddings rows. Single call, durably consistent.
+        //    See agentic-flow#150/#151 (closes ruvnet/RuVector#427 the cli-visible way).
+        const reflexion = registry.get('reflexionMemory');
+        if (reflexion && typeof reflexion.deleteEpisode === 'function') {
+            try {
+                const removed = await reflexion.deleteEpisode(key);
+                if (removed) {
+                    await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                    return { success: true, deleted: true, key, tier, controller: 'reflexionMemory', guarded: true };
+                }
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Try HierarchicalMemory's own delete API if it ever ships one.
+        if (hm && typeof hm.delete === 'function') {
+            try {
+                await hm.delete(key);
+                await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                return { success: true, deleted: true, key, tier, controller: 'hierarchicalMemory', guarded: true };
+            }
+            catch (err) {
+                // Fall through to SQL fallback
+            }
+        }
+        // 3. Stub HierarchicalMemory may expose `remove` or `forget`
+        if (hm && typeof hm.remove === 'function') {
+            try {
+                await hm.remove(key);
+                await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                return { success: true, deleted: true, key, tier, controller: 'hierarchicalMemory-stub', guarded: true };
+            }
+            catch { /* fall through */ }
+        }
+        // 3. Bridge-fallback: HM stored to memory_entries with namespace prefix
+        //    (used when the real controller isn't loaded). Soft-delete via SQL.
+        const ctx = getDb(registry);
+        if (ctx) {
+            try {
+                const result = ctx.db.prepare(`
+          UPDATE memory_entries
+          SET status = 'deleted', updated_at = ?
+          WHERE key = ? AND namespace LIKE 'hierarchical%' AND status = 'active'
+        `).run(Date.now(), key);
+                const changes = result?.changes ?? 0;
+                if (changes > 0) {
+                    await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                    return { success: true, deleted: true, key, tier, controller: 'bridge-fallback', guarded: true };
+                }
+                // Nothing to delete in SQL fallback — and no real-HM delete API.
+                // Surface the situation honestly.
+                return {
+                    success: false, deleted: false, key, tier,
+                    controller: hm ? 'native-unsupported' : 'not-found',
+                    error: hm
+                        ? 'HierarchicalMemory has no public delete API; entry remains in native storage'
+                        : 'No hierarchical entry found with this key',
+                };
+            }
+            catch (err) {
+                return { success: false, deleted: false, key, tier, controller: 'sql-error', error: err.message };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Delete a causal edge between two memory entries (#1784).
+ *
+ * The bridge stores fallback edges in namespace='causal-edges' with key
+ * '{sourceId}→{targetId}'. Those CAN be soft-deleted. The native graph-node
+ * backend has no delete API (createNode/createEdge/createHyperedge only),
+ * so an edge that landed in graph-node native storage stays there. We
+ * surface that explicitly via controller: 'native-unsupported'.
+ */
+export async function bridgeDeleteCausalEdge(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { sourceId, targetId, relation } = options;
+        const edgeKey = `${sourceId}→${targetId}`;
+        const guardResult = await guardValidate(registry, 'delete', { key: edgeKey, namespace: 'causal-edges' });
+        if (!guardResult.allowed) {
+            return { success: false, deleted: false, sourceId, targetId, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        const causalGraph = registry.get('causalGraph');
+        // 1. agentdb@3.0.0-alpha.13+: GraphDatabaseAdapter.deleteEdgesByEndpoints
+        //    handles the (sourceId, targetId, relation?) tuple case directly via
+        //    Cypher MATCH … DETACH DELETE. Cypher-injection-safe (label validated
+        //    against /^[A-Za-z_][A-Za-z0-9_]*$/ upstream).
+        if (causalGraph && typeof causalGraph.deleteEdgesByEndpoints === 'function') {
+            try {
+                const r = await causalGraph.deleteEdgesByEndpoints(sourceId, targetId, relation);
+                const deletedCount = typeof r === 'object' && r ? (r.deleted ?? 0) : (r ? 1 : 0);
+                if (deletedCount > 0) {
+                    await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation, count: deletedCount });
+                    return { success: true, deleted: true, sourceId, targetId, controller: 'causalGraph-cypher', guarded: true };
+                }
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Pre-alpha.13 / different controller: try removeEdge() if exposed.
+        if (causalGraph && typeof causalGraph.removeEdge === 'function') {
+            try {
+                await causalGraph.removeEdge(sourceId, targetId, relation);
+                await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation });
+                return { success: true, deleted: true, sourceId, targetId, controller: 'causalGraph', guarded: true };
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Bridge-fallback: soft-delete the memory_entries row.
+        const ctx = getDb(registry);
+        if (ctx) {
+            try {
+                const result = ctx.db.prepare(`
+          UPDATE memory_entries
+          SET status = 'deleted', updated_at = ?
+          WHERE key = ? AND namespace = 'causal-edges' AND status = 'active'
+        `).run(Date.now(), edgeKey);
+                const changes = result?.changes ?? 0;
+                if (changes > 0) {
+                    await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation });
+                    return { success: true, deleted: true, sourceId, targetId, controller: 'bridge-fallback', guarded: true };
+                }
+                return {
+                    success: false, deleted: false, sourceId, targetId,
+                    controller: 'native-unsupported',
+                    error: 'graph-node native backend has no delete API; edge cannot be removed from native storage. SQL fallback found no matching row.',
+                };
+            }
+            catch (err) {
+                return { success: false, deleted: false, sourceId, targetId, controller: 'sql-error', error: err.message };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cascade-delete a causal node and all its incident edges (#1784).
+ *
+ * Same constraint as bridgeDeleteCausalEdge — native graph-node lacks a
+ * delete API. SQL fallback path soft-deletes the node (if stored as a
+ * memory_entries row) and every edge whose key contains the nodeId.
+ */
+export async function bridgeDeleteCausalNode(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { nodeId } = options;
+        const guardResult = await guardValidate(registry, 'delete', { key: nodeId, namespace: 'causal-nodes' });
+        if (!guardResult.allowed) {
+            return { success: false, deletedNode: false, deletedEdges: 0, nodeId, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        // 1. agentdb@3.0.0-alpha.13+: GraphDatabaseAdapter.deleteNode(id, {cascade})
+        //    counts incident edges before delete so we get accurate audit numbers
+        //    regardless of binding stats. Cypher MATCH (n {id}) DETACH DELETE n.
+        const causalGraph = registry.get('causalGraph');
+        if (causalGraph && typeof causalGraph.deleteNode === 'function') {
+            try {
+                const r = await causalGraph.deleteNode(nodeId, { cascade: true });
+                if (r && typeof r === 'object') {
+                    const deletedNodeNative = !!r.deletedNode;
+                    const deletedEdgesNative = typeof r.deletedEdges === 'number' ? r.deletedEdges : 0;
+                    await logAttestation(registry, 'delete', nodeId, { namespace: 'causal-nodes', deletedEdges: deletedEdgesNative });
+                    return {
+                        success: true,
+                        deletedNode: deletedNodeNative,
+                        deletedEdges: deletedEdgesNative,
+                        nodeId,
+                        controller: 'causalGraph-cypher',
+                        guarded: true,
+                    };
+                }
+            }
+            catch { /* fall through to SQL */ }
+        }
+        // 2. SQL fallback: soft-delete the node row + every causal-edges row whose
+        //    key contains nodeId on either side. Used when agentdb pre-alpha.13 OR
+        //    when the entry was stored via the bridge's SQL fallback path.
+        const ctx = getDb(registry);
+        if (!ctx)
+            return null;
+        let deletedEdges = 0;
+        let deletedNode = false;
+        try {
+            const edgeResult = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE namespace = 'causal-edges'
+          AND status = 'active'
+          AND (key LIKE ? OR key LIKE ?)
+      `).run(Date.now(), `${nodeId}→%`, `%→${nodeId}`);
+            deletedEdges = edgeResult?.changes ?? 0;
+            const nodeResult = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE key = ? AND status = 'active'
+      `).run(Date.now(), nodeId);
+            deletedNode = (nodeResult?.changes ?? 0) > 0;
+            await logAttestation(registry, 'delete', nodeId, { namespace: 'causal-nodes', deletedEdges });
+        }
+        catch (err) {
+            return { success: false, deletedNode: false, deletedEdges: 0, nodeId, controller: 'sql-error', error: err.message };
+        }
+        return {
+            success: true,
+            deletedNode,
+            deletedEdges,
+            nodeId,
+            controller: 'bridge-fallback',
+            guarded: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 // ===== Phase 5: ReflexionMemory session lifecycle =====
 /**
  * Start a session with ReflexionMemory episodic replay.
@@ -1766,11 +2019,11 @@ export async function bridgeGetAllEmbeddings(options) {
     try {
         const dims = options?.dimensions ?? 384;
         const maxRows = options?.limit ?? 50000;
-        const rows = ctx.db.prepare(`
-      SELECT id, key, namespace, embedding
-      FROM memory_entries
-      WHERE status = 'active' AND embedding IS NOT NULL
-      LIMIT ?
+        const rows = ctx.db.prepare(`
+      SELECT id, key, namespace, embedding
+      FROM memory_entries
+      WHERE status = 'active' AND embedding IS NOT NULL
+      LIMIT ?
     `).all(maxRows);
         const results = [];
         for (const row of rows) {