@framers/agentos 0.1.101 → 0.1.102

package/dist/memory/store/SqliteMemoryGraph.js

@@ -0,0 +1,637 @@
+/**
+ * @fileoverview SQLite-backed implementation of IMemoryGraph.
+ *
+ * Stores memory graph nodes in the `knowledge_nodes` table (type = 'memory_graph')
+ * and memory association edges in the `knowledge_edges` table — both managed by
+ * SqliteBrain. All node metadata is serialised into the `properties` JSON column.
+ *
+ * ## Algorithms
+ *
+ * ### Spreading activation (Anderson's ACT-R model)
+ * BFS from each seed node. At each hop the activation value is multiplied by
+ * `(1 - decayPerHop) * edgeWeight`, modelling the attenuation of priming
+ * signals as they propagate through associative memory. Multiple paths to the
+ * same node are resolved by keeping the maximum activation reached so far
+ * (best-path semantics). The BFS terminates when:
+ * - the current activation falls below `activationThreshold`, or
+ * - the hop count exceeds `maxDepth`.
+ *
+ * ### Hebbian co-activation (recordCoActivation)
+ * For every unordered pair (A, B) in `memoryIds`, a CO_ACTIVATED edge is
+ * upserted. If the edge already exists its weight is incremented by
+ * `learningRate` (capped at 1.0). This implements the classic Hebbian rule:
+ * "neurons that fire together wire together".
+ *
+ * ### Connected-component clustering (detectClusters)
+ * Union-Find (path-compressed) over all edges in the graph. Each component
+ * with at least `minSize` members is returned as a {@link MemoryCluster}.
+ * The `centroidId` is chosen as the member with the highest total edge weight
+ * (i.e. the most central node in the component's subgraph).
+ *
+ * @module memory/store/SqliteMemoryGraph
+ */
+import crypto from 'node:crypto';
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+/** Default spreading activation parameters (ACT-R reasonable defaults). */
+const SA_DEFAULTS = {
+    maxDepth: 3,
+    decayPerHop: 0.5,
+    activationThreshold: 0.1,
+    maxResults: 20,
+};
+/** Node type discriminator stored in knowledge_nodes.type. */
+const NODE_TYPE = 'memory_graph';
+// ---------------------------------------------------------------------------
+// SqliteMemoryGraph
+// ---------------------------------------------------------------------------
+/**
+ * SQLite-backed implementation of {@link IMemoryGraph}.
+ *
+ * **Thread safety**: inherits `better-sqlite3`'s single-writer model.
+ * All synchronous operations (reads) are safe to call from multiple places
+ * concurrently; writes serialise automatically through the WAL.
+ *
+ * **Usage:**
+ * ```ts
+ * const brain = new SqliteBrain('/path/to/brain.sqlite');
+ * const graph = new SqliteMemoryGraph(brain);
+ * await graph.initialize();
+ *
+ * await graph.addNode('mem-1', { type: 'episodic', scope: 'session', scopeId: 's1', strength: 1.0, createdAt: Date.now() });
+ * await graph.addEdge({ sourceId: 'mem-1', targetId: 'mem-2', type: 'SAME_TOPIC', weight: 0.8, createdAt: Date.now() });
+ *
+ * const activated = await graph.spreadingActivation(['mem-1']);
+ * ```
+ */
+export class SqliteMemoryGraph {
+    // ---------------------------------------------------------------------------
+    // Constructor
+    // ---------------------------------------------------------------------------
+    /**
+     * @param brain - The shared SqliteBrain connection for this agent.
+     *   The `knowledge_nodes` and `knowledge_edges` tables must already exist
+     *   (SqliteBrain creates them in its constructor).
+     */
+    constructor(brain) {
+        this.brain = brain;
+        /**
+         * In-memory node index: maps memoryId → MemoryGraphNodeMeta.
+         *
+         * We keep an in-memory cache so that `hasNode()` and `nodeCount()` are O(1)
+         * without requiring a synchronous SQLite query (both are called from
+         * hot-path retrieval code). The cache is hydrated during `initialize()` and
+         * kept in sync through every `addNode` / `removeNode` / `clear` call.
+         */
+        this._nodes = new Map();
+        /**
+         * In-memory edge index: maps `${sourceId}:${targetId}` → MemoryEdge.
+         *
+         * Edges are also kept in-memory for O(1) adjacency lookups used by
+         * spreading activation and cluster detection. Persisted to SQLite on every
+         * write so the graph survives restarts.
+         */
+        this._edges = new Map();
+    }
+    // ---------------------------------------------------------------------------
+    // Lifecycle
+    // ---------------------------------------------------------------------------
+    /**
+     * Hydrate the in-memory node and edge caches from the SQLite database.
+     *
+     * Must be called once before any other method. Safe to call multiple times
+     * (idempotent — fully replaces in-memory state each time).
+     */
+    async initialize() {
+        this._nodes.clear();
+        this._edges.clear();
+        // Load all memory graph nodes.
+        const nodeRows = this.brain.db
+            .prepare(`SELECT id, properties FROM knowledge_nodes WHERE type = ?`)
+            .all(NODE_TYPE);
+        for (const row of nodeRows) {
+            try {
+                const meta = JSON.parse(row.properties);
+                this._nodes.set(row.id, meta);
+            }
+            catch {
+                // Skip rows with corrupted JSON — log is intentionally omitted to
+                // avoid pulling in a logger dependency here.
+            }
+        }
+        // Load all edges whose source node is a memory graph node.
+        // We identify them by checking the source_id against known node IDs.
+        // Because the edge type column stores the MemoryEdgeType string directly,
+        // we can filter by the set of known types.
+        const edgeRows = this.brain.db
+            .prepare(`SELECT id, source_id, target_id, type, weight, created_at
+         FROM knowledge_edges
+         WHERE type IN (
+           'SHARED_ENTITY','TEMPORAL_SEQUENCE','SAME_TOPIC',
+           'CONTRADICTS','SUPERSEDES','CAUSED_BY','CO_ACTIVATED','SCHEMA_INSTANCE'
+         )`)
+            .all();
+        for (const row of edgeRows) {
+            const key = `${row.source_id}:${row.target_id}`;
+            this._edges.set(key, {
+                sourceId: row.source_id,
+                targetId: row.target_id,
+                type: row.type,
+                weight: row.weight,
+                createdAt: row.created_at,
+            });
+        }
+    }
+    /**
+     * Shut down the memory graph.
+     *
+     * Currently a no-op because SqliteBrain owns the DB connection lifetime.
+     * Provided for interface compliance and forward compatibility.
+     */
+    async shutdown() {
+        // No-op: SqliteBrain owns the connection; callers must call brain.close().
+    }
+    // ---------------------------------------------------------------------------
+    // Node operations
+    // ---------------------------------------------------------------------------
+    /**
+     * Add a memory node to the graph.
+     *
+     * The node is persisted to `knowledge_nodes` (type = 'memory_graph') with
+     * the metadata serialised into the `properties` JSON column. If a node with
+     * the same `memoryId` already exists it is silently replaced (upsert).
+     *
+     * @param memoryId - Unique identifier for the memory trace this node represents.
+     * @param metadata - Structural metadata describing the memory.
+     */
+    async addNode(memoryId, metadata) {
+        const now = Date.now();
+        this.brain.db
+            .prepare(`INSERT OR REPLACE INTO knowledge_nodes
+           (id, type, label, properties, confidence, source, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(memoryId, NODE_TYPE, memoryId, JSON.stringify(metadata), metadata.strength, JSON.stringify({}), metadata.createdAt ?? now);
+        this._nodes.set(memoryId, metadata);
+    }
+    /**
+     * Remove a node and all its incident edges from the graph.
+     *
+     * Edges referencing the removed node are deleted from both SQLite and the
+     * in-memory cache to keep the graph consistent.
+     *
+     * @param memoryId - ID of the node to remove.
+     */
+    async removeNode(memoryId) {
+        // Delete incident edges first (FK enforcement is ON, but we also want
+        // to clean up the in-memory cache).
+        const toDelete = [];
+        for (const [key, edge] of this._edges) {
+            if (edge.sourceId === memoryId || edge.targetId === memoryId) {
+                toDelete.push(key);
+            }
+        }
+        if (toDelete.length > 0) {
+            const delEdge = this.brain.db.prepare(`DELETE FROM knowledge_edges WHERE source_id = ? OR target_id = ?`);
+            delEdge.run(memoryId, memoryId);
+            for (const key of toDelete) {
+                this._edges.delete(key);
+            }
+        }
+        // Now delete the node itself.
+        this.brain.db
+            .prepare(`DELETE FROM knowledge_nodes WHERE id = ? AND type = ?`)
+            .run(memoryId, NODE_TYPE);
+        this._nodes.delete(memoryId);
+    }
+    /**
+     * Check whether a node exists in the graph.
+     *
+     * O(1) in-memory lookup — does not touch SQLite.
+     *
+     * @param memoryId - ID to check.
+     * @returns `true` if the node is present, `false` otherwise.
+     */
+    hasNode(memoryId) {
+        return this._nodes.has(memoryId);
+    }
+    // ---------------------------------------------------------------------------
+    // Edge operations
+    // ---------------------------------------------------------------------------
+    /**
+     * Add a directed edge between two memory nodes.
+     *
+     * If an edge with the same `(sourceId, targetId)` pair already exists it is
+     * replaced (upsert by composite key). The underlying SQLite row is identified
+     * by a deterministic UUID derived from the source/target pair so that
+     * repeated upserts land on the same row.
+     *
+     * @param edge - Edge descriptor including type, weight, and timestamp.
+     */
+    async addEdge(edge) {
+        const edgeId = this._edgeId(edge.sourceId, edge.targetId);
+        const key = `${edge.sourceId}:${edge.targetId}`;
+        this.brain.db
+            .prepare(`INSERT OR REPLACE INTO knowledge_edges
+           (id, source_id, target_id, type, weight, bidirectional, metadata, created_at)
+         VALUES (?, ?, ?, ?, ?, 0, '{}', ?)`)
+            .run(edgeId, edge.sourceId, edge.targetId, edge.type, edge.weight, edge.createdAt);
+        this._edges.set(key, { ...edge });
+    }
+    /**
+     * Retrieve all edges incident to a memory node.
+     *
+     * Returns edges where `memoryId` appears as either source or target.
+     * Optionally filters by edge type.
+     *
+     * O(E) scan over the in-memory edge map — acceptable for typical graph sizes
+     * (< 10k edges).
+     *
+     * @param memoryId - Node ID to query.
+     * @param type     - Optional edge type filter.
+     * @returns Array of matching {@link MemoryEdge} objects.
+     */
+    getEdges(memoryId, type) {
+        const result = [];
+        for (const edge of this._edges.values()) {
+            if (edge.sourceId !== memoryId && edge.targetId !== memoryId)
+                continue;
+            if (type !== undefined && edge.type !== type)
+                continue;
+            result.push({ ...edge });
+        }
+        return result;
+    }
+    /**
+     * Remove a directed edge from the graph.
+     *
+     * @param sourceId - Source node ID.
+     * @param targetId - Target node ID.
+     */
+    async removeEdge(sourceId, targetId) {
+        const edgeId = this._edgeId(sourceId, targetId);
+        this.brain.db
+            .prepare(`DELETE FROM knowledge_edges WHERE id = ?`)
+            .run(edgeId);
+        this._edges.delete(`${sourceId}:${targetId}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Spreading activation (ACT-R)
+    // ---------------------------------------------------------------------------
+    /**
+     * Run spreading activation from a set of seed nodes.
+     *
+     * Implements Anderson's ACT-R spreading activation model using BFS:
+     *
+     * 1. Each seed node starts with activation = 1.0.
+     * 2. When a node propagates to a neighbour, the neighbour's activation
+     *    receives: `parentActivation * (1 - decayPerHop) * edgeWeight`.
+     * 3. If a node is reached by multiple paths, the maximum activation is kept.
+     * 4. Nodes below `activationThreshold` are not expanded further.
+     * 5. BFS stops at depth `maxDepth`.
+     *
+     * Seed nodes are excluded from the returned list (they are the query, not
+     * the result).
+     *
+     * @param seedIds - IDs of the memory nodes that trigger the activation.
+     * @param config  - Optional tuning parameters.
+     * @returns Activated nodes sorted by activation descending, capped at `maxResults`.
+     */
+    async spreadingActivation(seedIds, config) {
+        const { maxDepth, decayPerHop, activationThreshold, maxResults } = {
+            ...SA_DEFAULTS,
+            ...config,
+        };
+        const seedSet = new Set(seedIds);
+        /**
+         * Maps memoryId → best (activation, depth, activatedBy set) seen so far.
+         * We track activatedBy to attribute which seeds contributed.
+         */
+        const visited = new Map();
+        const queue = [];
+        // Initialise the queue with each seed at full activation.
+        for (const seedId of seedIds) {
+            if (!this._nodes.has(seedId))
+                continue;
+            queue.push({ nodeId: seedId, activation: 1.0, depth: 0, seedOrigin: seedId });
+        }
+        // Process the queue.
+        while (queue.length > 0) {
+            const { nodeId, activation, depth, seedOrigin } = queue.shift();
+            // Propagate to neighbours if we have headroom.
+            if (depth < maxDepth && activation >= activationThreshold) {
+                for (const edge of this._edges.values()) {
+                    let neighbourId = null;
+                    if (edge.sourceId === nodeId) {
+                        neighbourId = edge.targetId;
+                    }
+                    else if (edge.targetId === nodeId) {
+                        // Treat all edges as bidirectional for spreading activation —
+                        // associative priming flows both ways in memory research.
+                        neighbourId = edge.sourceId;
+                    }
+                    if (neighbourId === null)
+                        continue;
+                    if (seedSet.has(neighbourId))
+                        continue; // don't activate seeds
+                    const newActivation = activation * (1 - decayPerHop) * edge.weight;
+                    if (newActivation < activationThreshold)
+                        continue;
+                    const existing = visited.get(neighbourId);
+                    if (existing) {
+                        if (newActivation > existing.activation) {
+                            // Better path found — update and re-enqueue.
+                            existing.activation = newActivation;
+                            existing.depth = depth + 1;
+                            existing.activatedBy.add(seedOrigin);
+                            queue.push({
+                                nodeId: neighbourId,
+                                activation: newActivation,
+                                depth: depth + 1,
+                                seedOrigin,
+                            });
+                        }
+                        else {
+                            // Just attribute this seed to the existing entry.
+                            existing.activatedBy.add(seedOrigin);
+                        }
+                    }
+                    else {
+                        visited.set(neighbourId, {
+                            activation: newActivation,
+                            depth: depth + 1,
+                            activatedBy: new Set([seedOrigin]),
+                        });
+                        queue.push({
+                            nodeId: neighbourId,
+                            activation: newActivation,
+                            depth: depth + 1,
+                            seedOrigin,
+                        });
+                    }
+                }
+            }
+        }
+        // Convert to ActivatedNode[], sort descending by activation, cap at maxResults.
+        const results = [];
+        for (const [memoryId, { activation, depth, activatedBy }] of visited) {
+            results.push({
+                memoryId,
+                activation,
+                depth,
+                activatedBy: Array.from(activatedBy),
+            });
+        }
+        results.sort((a, b) => b.activation - a.activation);
+        return results.slice(0, maxResults);
+    }
+    // ---------------------------------------------------------------------------
+    // Hebbian co-activation
+    // ---------------------------------------------------------------------------
+    /**
+     * Record that a set of memories were activated together (Hebbian learning).
+     *
+     * For every unordered pair (A, B) in `memoryIds`, a CO_ACTIVATED edge is
+     * upserted:
+     * - If no edge exists, it is created with `weight = learningRate`.
+     * - If an edge already exists, its weight is incremented by `learningRate`
+     *   and capped at 1.0.
+     *
+     * This implements the Hebbian rule "neurons that fire together wire together"
+     * at the memory graph level, gradually strengthening associations between
+     * memories that are frequently retrieved in the same context.
+     *
+     * @param memoryIds    - IDs of co-activated memories.
+     * @param learningRate - Weight increment per co-activation event. @default 0.1
+     */
+    async recordCoActivation(memoryIds, learningRate = 0.1) {
+        if (memoryIds.length < 2)
+            return;
+        const now = Date.now();
+        // Process all unordered pairs.
+        for (let i = 0; i < memoryIds.length; i++) {
+            for (let j = i + 1; j < memoryIds.length; j++) {
+                const sourceId = memoryIds[i];
+                const targetId = memoryIds[j];
+                const key = `${sourceId}:${targetId}`;
+                const existing = this._edges.get(key);
+                if (existing && existing.type === 'CO_ACTIVATED') {
+                    // Increment weight, capped at 1.0.
+                    const newWeight = Math.min(1.0, existing.weight + learningRate);
+                    existing.weight = newWeight;
+                    // Update SQLite row weight in-place.
+                    const edgeId = this._edgeId(sourceId, targetId);
+                    this.brain.db
+                        .prepare(`UPDATE knowledge_edges SET weight = ? WHERE id = ?`)
+                        .run(newWeight, edgeId);
+                }
+                else {
+                    // Create a new CO_ACTIVATED edge.
+                    await this.addEdge({
+                        sourceId,
+                        targetId,
+                        type: 'CO_ACTIVATED',
+                        weight: learningRate,
+                        createdAt: now,
+                    });
+                }
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Conflict detection
+    // ---------------------------------------------------------------------------
+    /**
+     * Return all CONTRADICTS edges incident to a given memory node.
+     *
+     * A CONTRADICTS edge signals that two memories express mutually incompatible
+     * beliefs or facts. The consolidation engine uses this to trigger
+     * conflict-resolution passes.
+     *
+     * @param memoryId - The memory node to check for contradictions.
+     * @returns Array of CONTRADICTS edges (may be empty).
+     */
+    getConflicts(memoryId) {
+        return this.getEdges(memoryId, 'CONTRADICTS');
+    }
+    // ---------------------------------------------------------------------------
+    // Cluster detection (Union-Find)
+    // ---------------------------------------------------------------------------
+    /**
+     * Detect connected components (clusters) in the memory graph.
+     *
+     * Uses path-compressed Union-Find over all edges. Components are filtered
+     * to those with at least `minSize` members.
+     *
+     * The `centroidId` of each cluster is the member with the highest total
+     * incident edge weight (most central node). If the cluster has only one
+     * member, `centroidId` equals that member.
+     *
+     * The `density` of a cluster is computed as:
+     * `actualEdges / maxPossibleEdges` where `maxPossibleEdges = n*(n-1)`.
+     * For single-member clusters, density = 0.
+     *
+     * @param minSize - Minimum component size to include. @default 2
+     * @returns Array of {@link MemoryCluster} objects.
+     */
+    async detectClusters(minSize = 2) {
+        const nodeIds = Array.from(this._nodes.keys());
+        if (nodeIds.length === 0)
+            return [];
+        // ---------------------------------------------------------------------------
+        // Union-Find with path compression + union by rank.
+        // ---------------------------------------------------------------------------
+        const parent = new Map();
+        const rank = new Map();
+        const find = (id) => {
+            if (!parent.has(id)) {
+                parent.set(id, id);
+                rank.set(id, 0);
+            }
+            if (parent.get(id) !== id) {
+                parent.set(id, find(parent.get(id)));
+            }
+            return parent.get(id);
+        };
+        const union = (a, b) => {
+            const ra = find(a);
+            const rb = find(b);
+            if (ra === rb)
+                return;
+            const rankA = rank.get(ra) ?? 0;
+            const rankB = rank.get(rb) ?? 0;
+            if (rankA < rankB) {
+                parent.set(ra, rb);
+            }
+            else if (rankA > rankB) {
+                parent.set(rb, ra);
+            }
+            else {
+                parent.set(rb, ra);
+                rank.set(ra, rankA + 1);
+            }
+        };
+        // Initialise every known node.
+        for (const id of nodeIds) {
+            find(id);
+        }
+        // Merge components using all edges.
+        for (const edge of this._edges.values()) {
+            // Only union nodes that exist in the graph.
+            if (this._nodes.has(edge.sourceId) && this._nodes.has(edge.targetId)) {
+                union(edge.sourceId, edge.targetId);
+            }
+        }
+        // ---------------------------------------------------------------------------
+        // Collect members per root.
+        // ---------------------------------------------------------------------------
+        const components = new Map();
+        for (const id of nodeIds) {
+            const root = find(id);
+            if (!components.has(root))
+                components.set(root, []);
+            components.get(root).push(id);
+        }
+        // ---------------------------------------------------------------------------
+        // Build cluster objects for components >= minSize.
+        // ---------------------------------------------------------------------------
+        const clusters = [];
+        for (const [, members] of components) {
+            if (members.length < minSize)
+                continue;
+            // Compute per-member total edge weight to find the centroid.
+            const weightSum = new Map();
+            for (const m of members)
+                weightSum.set(m, 0);
+            const memberSet = new Set(members);
+            let internalEdgeCount = 0;
+            for (const edge of this._edges.values()) {
+                if (memberSet.has(edge.sourceId) && memberSet.has(edge.targetId)) {
+                    weightSum.set(edge.sourceId, (weightSum.get(edge.sourceId) ?? 0) + edge.weight);
+                    weightSum.set(edge.targetId, (weightSum.get(edge.targetId) ?? 0) + edge.weight);
+                    internalEdgeCount++;
+                }
+            }
+            // Centroid = member with highest total incident weight.
+            let centroidId = members[0];
+            let maxWeight = -Infinity;
+            for (const m of members) {
+                const w = weightSum.get(m) ?? 0;
+                if (w > maxWeight) {
+                    maxWeight = w;
+                    centroidId = m;
+                }
+            }
+            // Density = actualEdges / (n * (n-1))  — directed graph formula.
+            const n = members.length;
+            const maxEdges = n * (n - 1);
+            const density = maxEdges > 0 ? internalEdgeCount / maxEdges : 0;
+            clusters.push({
+                clusterId: centroidId,
+                memberIds: members,
+                density,
+            });
+        }
+        return clusters;
+    }
+    // ---------------------------------------------------------------------------
+    // Stats & lifecycle
+    // ---------------------------------------------------------------------------
+    /**
+     * Return the number of nodes currently in the graph.
+     * O(1) — backed by the in-memory Map size.
+     */
+    nodeCount() {
+        return this._nodes.size;
+    }
+    /**
+     * Return the number of edges currently in the graph.
+     * O(1) — backed by the in-memory Map size.
+     */
+    edgeCount() {
+        return this._edges.size;
+    }
+    /**
+     * Remove all nodes and edges from the graph (both in-memory and SQLite).
+     *
+     * This is a destructive, irreversible operation. Intended for tests and
+     * administrative resets only.
+     */
+    clear() {
+        // Delete all knowledge_edges whose type is a MemoryEdgeType value.
+        this.brain.db.exec(`DELETE FROM knowledge_edges
+       WHERE type IN (
+         'SHARED_ENTITY','TEMPORAL_SEQUENCE','SAME_TOPIC',
+         'CONTRADICTS','SUPERSEDES','CAUSED_BY','CO_ACTIVATED','SCHEMA_INSTANCE'
+       )`);
+        // Delete all memory_graph nodes.
+        this.brain.db
+            .prepare(`DELETE FROM knowledge_nodes WHERE type = ?`)
+            .run(NODE_TYPE);
+        this._nodes.clear();
+        this._edges.clear();
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Derive a deterministic, stable UUID for a directed edge from
+     * `sourceId` to `targetId`.
+     *
+     * Using a deterministic ID means that calling `addEdge` twice with the same
+     * source/target lands on the same SQLite row — enabling the `INSERT OR REPLACE`
+     * upsert semantics.
+     *
+     * @param sourceId - Edge source node ID.
+     * @param targetId - Edge target node ID.
+     * @returns A UUID v5-style hex string.
+     */
+    _edgeId(sourceId, targetId) {
+        return crypto
+            .createHash('sha256')
+            .update(`mem_edge:${sourceId}:${targetId}`)
+            .digest('hex')
+            .slice(0, 32);
+    }
+}
+//# sourceMappingURL=SqliteMemoryGraph.js.map

package/dist/memory/store/SqliteMemoryGraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteMemoryGraph.js","sourceRoot":"","sources":["../../../src/memory/store/SqliteMemoryGraph.ts"],"names":[],"mappings":"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"}