n8n-nodes-engram 0.2.0

package/dist/storage/Neo4jStorage.js

@@ -0,0 +1,949 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo4jStorage = void 0;
+const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
+const uuid_1 = require("../utils/uuid");
+const temporal_1 = require("../utils/temporal");
+const cosine_1 = require("../embeddings/cosine");
+class Neo4jStorage {
+    constructor(uri, username, password, database) {
+        this.initialized = false;
+        this.vectorIndexCreated = false;
+        const resolvedUri = uri.replace('://localhost:', '://127.0.0.1:');
+        this.driver = neo4j_driver_1.default.driver(resolvedUri, neo4j_driver_1.default.auth.basic(username, password));
+        this.database = database !== null && database !== void 0 ? database : 'neo4j';
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.driver.verifyConnectivity();
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run('CREATE INDEX IF NOT EXISTS FOR (e:Entity) ON (e.uuid)');
+                await tx.run('CREATE INDEX IF NOT EXISTS FOR (e:Entity) ON (e.group_id)');
+                await tx.run('CREATE INDEX IF NOT EXISTS FOR (e:Entity) ON (e.name)');
+                await tx.run('CREATE INDEX IF NOT EXISTS FOR (ep:Episode) ON (ep.uuid)');
+                await tx.run('CREATE INDEX IF NOT EXISTS FOR (ep:Episode) ON (ep.group_id)');
+                await tx.run('CREATE FULLTEXT INDEX entitySearch IF NOT EXISTS FOR (e:Entity) ON EACH [e.name, e.summary, e.entity_type]');
+                await tx.run('CREATE FULLTEXT INDEX edgeSearch IF NOT EXISTS FOR ()-[r:RELATES_TO]-() ON EACH [r.name, r.fact]');
+            });
+        }
+        finally {
+            await session.close();
+        }
+        this.initialized = true;
+    }
+    async close() {
+        await this.driver.close();
+    }
+    getSession() {
+        return this.driver.session({ database: this.database });
+    }
+    async addEntity(input) {
+        var _a, _b, _c, _d;
+        const now = (0, temporal_1.nowIso)();
+        const entity = {
+            uuid: (0, uuid_1.generateUuid)(),
+            name: input.name,
+            group_id: input.group_id,
+            summary: (_a = input.summary) !== null && _a !== void 0 ? _a : '',
+            entity_type: (_b = input.entity_type) !== null && _b !== void 0 ? _b : 'unknown',
+            name_embedding: (_c = input.name_embedding) !== null && _c !== void 0 ? _c : null,
+            attributes: (_d = input.attributes) !== null && _d !== void 0 ? _d : {},
+            created_at: now,
+            updated_at: now,
+        };
+        if (entity.name_embedding && entity.name_embedding.length > 0) {
+            await this.ensureVectorIndex(entity.name_embedding.length);
+        }
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run(`CREATE (e:Entity {
+						uuid: $uuid,
+						name: $name,
+						group_id: $group_id,
+						summary: $summary,
+						entity_type: $entity_type,
+						name_embedding: $name_embedding,
+						attributes: $attributes,
+						created_at: $created_at,
+						updated_at: $updated_at
+					})`, {
+                    ...entity,
+                    attributes: JSON.stringify(entity.attributes),
+                    name_embedding: entity.name_embedding,
+                });
+            });
+        }
+        finally {
+            await session.close();
+        }
+        return entity;
+    }
+    async getEntity(uuid) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run('MATCH (e:Entity {uuid: $uuid}) RETURN e', { uuid });
+            });
+            if (result.records.length === 0)
+                return null;
+            return this.recordToEntity(result.records[0].get('e').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getEntityByName(name, groupId) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run('MATCH (e:Entity {group_id: $groupId}) WHERE toLower(e.name) = toLower($name) RETURN e LIMIT 1', { name, groupId });
+            });
+            if (result.records.length === 0)
+                return null;
+            return this.recordToEntity(result.records[0].get('e').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async updateEntity(uuid, updates) {
+        const session = this.getSession();
+        try {
+            const setClauses = ['e.updated_at = $updated_at'];
+            const params = {
+                uuid,
+                updated_at: (0, temporal_1.nowIso)(),
+            };
+            if (updates.name !== undefined) {
+                setClauses.push('e.name = $name');
+                params.name = updates.name;
+            }
+            if (updates.summary !== undefined) {
+                setClauses.push('e.summary = $summary');
+                params.summary = updates.summary;
+            }
+            if (updates.entity_type !== undefined) {
+                setClauses.push('e.entity_type = $entity_type');
+                params.entity_type = updates.entity_type;
+            }
+            if (updates.attributes !== undefined) {
+                setClauses.push('e.attributes = $attributes');
+                params.attributes = JSON.stringify(updates.attributes);
+            }
+            if (updates.name_embedding !== undefined) {
+                setClauses.push('e.name_embedding = $name_embedding');
+                params.name_embedding = updates.name_embedding;
+                if (updates.name_embedding && updates.name_embedding.length > 0) {
+                    await this.ensureVectorIndex(updates.name_embedding.length);
+                }
+            }
+            const result = await session.executeWrite(async (tx) => {
+                return tx.run(`MATCH (e:Entity {uuid: $uuid}) SET ${setClauses.join(', ')} RETURN e`, params);
+            });
+            if (result.records.length === 0) {
+                throw new Error(`Entity not found: ${uuid}`);
+            }
+            return this.recordToEntity(result.records[0].get('e').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async deleteEntity(uuid) {
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run('MATCH (e:Entity {uuid: $uuid}) DETACH DELETE e', { uuid });
+            });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async listEntities(groupId, options) {
+        const session = this.getSession();
+        try {
+            let query = 'MATCH (e:Entity {group_id: $groupId})';
+            const params = { groupId };
+            if (options === null || options === void 0 ? void 0 : options.entity_type) {
+                query += ' WHERE e.entity_type = $entity_type';
+                params.entity_type = options.entity_type;
+            }
+            query += ' RETURN e ORDER BY e.created_at DESC';
+            if (options === null || options === void 0 ? void 0 : options.offset) {
+                query += ' SKIP $offset';
+                params.offset = neo4j_driver_1.default.int(options.offset);
+            }
+            if (options === null || options === void 0 ? void 0 : options.limit) {
+                query += ' LIMIT $limit';
+                params.limit = neo4j_driver_1.default.int(options.limit);
+            }
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(query, params);
+            });
+            return result.records.map((r) => this.recordToEntity(r.get('e').properties));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async addEdge(input) {
+        var _a, _b, _c, _d, _e, _f;
+        const now = (0, temporal_1.nowIso)();
+        const edge = {
+            uuid: (0, uuid_1.generateUuid)(),
+            group_id: input.group_id,
+            source_node_uuid: input.source_node_uuid,
+            target_node_uuid: input.target_node_uuid,
+            name: input.name,
+            fact: input.fact,
+            fact_embedding: (_a = input.fact_embedding) !== null && _a !== void 0 ? _a : null,
+            episodes: (_b = input.episodes) !== null && _b !== void 0 ? _b : [],
+            valid_at: (_c = input.valid_at) !== null && _c !== void 0 ? _c : null,
+            invalid_at: (_d = input.invalid_at) !== null && _d !== void 0 ? _d : null,
+            expired_at: (_e = input.expired_at) !== null && _e !== void 0 ? _e : null,
+            attributes: (_f = input.attributes) !== null && _f !== void 0 ? _f : {},
+            created_at: now,
+            updated_at: now,
+        };
+        if (edge.fact_embedding && edge.fact_embedding.length > 0) {
+            await this.ensureVectorIndex(edge.fact_embedding.length);
+        }
+        const session = this.getSession();
+        try {
+            const result = await session.executeWrite(async (tx) => {
+                return tx.run(`MATCH (source:Entity {uuid: $source_node_uuid})
+					 MATCH (target:Entity {uuid: $target_node_uuid})
+					 CREATE (source)-[r:RELATES_TO {
+						uuid: $uuid,
+						group_id: $group_id,
+						source_node_uuid: $source_node_uuid,
+						target_node_uuid: $target_node_uuid,
+						name: $name,
+						fact: $fact,
+						fact_embedding: $fact_embedding,
+						episodes: $episodes,
+						valid_at: $valid_at,
+						invalid_at: $invalid_at,
+						expired_at: $expired_at,
+						attributes: $attributes,
+						created_at: $created_at,
+						updated_at: $updated_at
+					 }]->(target)
+					 RETURN r`, {
+                    ...edge,
+                    attributes: JSON.stringify(edge.attributes),
+                });
+            });
+            if (result.records.length === 0) {
+                throw new Error(`Cannot create edge: source entity (${input.source_node_uuid}) or target entity (${input.target_node_uuid}) not found`);
+            }
+        }
+        finally {
+            await session.close();
+        }
+        return edge;
+    }
+    async getEdge(uuid) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run('MATCH ()-[r:RELATES_TO {uuid: $uuid}]->() RETURN r', { uuid });
+            });
+            if (result.records.length === 0)
+                return null;
+            return this.recordToEdge(result.records[0].get('r').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getEdgesBetween(sourceUuid, targetUuid) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (s:Entity {uuid: $sourceUuid})-[r:RELATES_TO]->(t:Entity {uuid: $targetUuid})
+					 RETURN r
+					 UNION
+					 MATCH (s:Entity {uuid: $targetUuid})-[r:RELATES_TO]->(t:Entity {uuid: $sourceUuid})
+					 RETURN r`, { sourceUuid, targetUuid });
+            });
+            return result.records.map((rec) => this.recordToEdge(rec.get('r').properties));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getEdgesForEntity(entityUuid) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (e:Entity {uuid: $entityUuid})-[r:RELATES_TO]->()
+					 RETURN r
+					 UNION
+					 MATCH (e:Entity {uuid: $entityUuid})<-[r:RELATES_TO]-()
+					 RETURN r`, { entityUuid });
+            });
+            return result.records.map((rec) => this.recordToEdge(rec.get('r').properties));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async updateEdge(uuid, updates) {
+        const session = this.getSession();
+        try {
+            const setClauses = ['r.updated_at = $updated_at'];
+            const params = {
+                uuid,
+                updated_at: (0, temporal_1.nowIso)(),
+            };
+            if (updates.name !== undefined) {
+                setClauses.push('r.name = $name');
+                params.name = updates.name;
+            }
+            if (updates.fact !== undefined) {
+                setClauses.push('r.fact = $fact');
+                params.fact = updates.fact;
+            }
+            if (updates.valid_at !== undefined) {
+                setClauses.push('r.valid_at = $valid_at');
+                params.valid_at = updates.valid_at;
+            }
+            if (updates.invalid_at !== undefined) {
+                setClauses.push('r.invalid_at = $invalid_at');
+                params.invalid_at = updates.invalid_at;
+            }
+            if (updates.expired_at !== undefined) {
+                setClauses.push('r.expired_at = $expired_at');
+                params.expired_at = updates.expired_at;
+            }
+            if (updates.episodes !== undefined) {
+                setClauses.push('r.episodes = $episodes');
+                params.episodes = updates.episodes;
+            }
+            if (updates.attributes !== undefined) {
+                setClauses.push('r.attributes = $attributes');
+                params.attributes = JSON.stringify(updates.attributes);
+            }
+            if (updates.fact_embedding !== undefined) {
+                setClauses.push('r.fact_embedding = $fact_embedding');
+                params.fact_embedding = updates.fact_embedding;
+                if (updates.fact_embedding && updates.fact_embedding.length > 0) {
+                    await this.ensureVectorIndex(updates.fact_embedding.length);
+                }
+            }
+            const result = await session.executeWrite(async (tx) => {
+                return tx.run(`MATCH ()-[r:RELATES_TO {uuid: $uuid}]->()
+					 SET ${setClauses.join(', ')}
+					 RETURN r`, params);
+            });
+            if (result.records.length === 0) {
+                throw new Error(`Edge not found: ${uuid}`);
+            }
+            return this.recordToEdge(result.records[0].get('r').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async deleteEdge(uuid) {
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run('MATCH ()-[r:RELATES_TO {uuid: $uuid}]->() DELETE r', { uuid });
+            });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async addEpisode(input) {
+        var _a, _b;
+        const episode = {
+            uuid: (0, uuid_1.generateUuid)(),
+            group_id: input.group_id,
+            content: input.content,
+            role: input.role,
+            source_type: (_a = input.source_type) !== null && _a !== void 0 ? _a : 'message',
+            reference_time: input.reference_time,
+            previous_episode_uuid: (_b = input.previous_episode_uuid) !== null && _b !== void 0 ? _b : null,
+            created_at: (0, temporal_1.nowIso)(),
+        };
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run(`CREATE (ep:Episode {
+						uuid: $uuid,
+						group_id: $group_id,
+						content: $content,
+						role: $role,
+						source_type: $source_type,
+						reference_time: $reference_time,
+						previous_episode_uuid: $previous_episode_uuid,
+						created_at: $created_at
+					})`, episode);
+                if (episode.previous_episode_uuid) {
+                    await tx.run(`MATCH (prev:Episode {uuid: $prevUuid})
+						 MATCH (curr:Episode {uuid: $currUuid})
+						 CREATE (prev)-[:NEXT_EPISODE]->(curr)`, {
+                        prevUuid: episode.previous_episode_uuid,
+                        currUuid: episode.uuid,
+                    });
+                }
+            });
+        }
+        finally {
+            await session.close();
+        }
+        return episode;
+    }
+    async getEpisode(uuid) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run('MATCH (ep:Episode {uuid: $uuid}) RETURN ep', { uuid });
+            });
+            if (result.records.length === 0)
+                return null;
+            return this.recordToEpisode(result.records[0].get('ep').properties);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getRecentEpisodes(groupId, limit) {
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (ep:Episode {group_id: $groupId})
+					 RETURN ep
+					 ORDER BY ep.created_at DESC
+					 LIMIT $limit`, { groupId, limit: neo4j_driver_1.default.int(limit) });
+            });
+            const episodes = result.records.map((r) => this.recordToEpisode(r.get('ep').properties));
+            return episodes.reverse();
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getEpisodeCount(groupId) {
+        var _a, _b;
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run('MATCH (ep:Episode {group_id: $groupId}) RETURN count(ep) as cnt', {
+                    groupId,
+                });
+            });
+            return (_b = (_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('cnt').toNumber()) !== null && _b !== void 0 ? _b : 0;
+        }
+        finally {
+            await session.close();
+        }
+    }
+    sanitizeLuceneQuery(query) {
+        const sanitized = query.replace(/[+\-&|!(){}[\]^"~*?:\\/]/g, (ch) => `\\${ch}`);
+        return sanitized.trim();
+    }
+    async searchEntities(query, groupId, options) {
+        var _a;
+        const safeQuery = this.sanitizeLuceneQuery(query);
+        if (!safeQuery)
+            return [];
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const session = this.getSession();
+        try {
+            let cypher = `CALL db.index.fulltext.queryNodes('entitySearch', $query)
+				YIELD node, score
+				WHERE node.group_id = $groupId`;
+            const params = { query: safeQuery, groupId };
+            if (options === null || options === void 0 ? void 0 : options.entity_type) {
+                cypher += ' AND node.entity_type = $entityType';
+                params.entityType = options.entity_type;
+            }
+            cypher += ' RETURN node, score ORDER BY score DESC LIMIT $limit';
+            params.limit = neo4j_driver_1.default.int(limit);
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(cypher, params);
+            });
+            const maxScore = result.records.length > 0 ? result.records[0].get('score') : 1;
+            return result.records
+                .filter((r) => {
+                var _a;
+                const score = r.get('score') / (maxScore || 1);
+                return score >= ((_a = options === null || options === void 0 ? void 0 : options.min_score) !== null && _a !== void 0 ? _a : 0);
+            })
+                .map((r) => ({
+                entity: this.recordToEntity(r.get('node').properties),
+                score: r.get('score') / (maxScore || 1),
+            }));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async searchEdges(query, groupId, options) {
+        var _a, _b;
+        const safeQuery = this.sanitizeLuceneQuery(query);
+        if (!safeQuery)
+            return [];
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const includeExpired = (_b = options === null || options === void 0 ? void 0 : options.include_expired) !== null && _b !== void 0 ? _b : false;
+        const session = this.getSession();
+        try {
+            let cypher = `CALL db.index.fulltext.queryRelationships('edgeSearch', $query)
+				YIELD relationship, score
+				WHERE relationship.group_id = $groupId`;
+            if (!includeExpired) {
+                cypher += ' AND relationship.expired_at IS NULL';
+            }
+            cypher += ` WITH relationship, score
+				ORDER BY score DESC LIMIT $limit
+				MATCH (source:Entity {uuid: relationship.source_node_uuid})
+				MATCH (target:Entity {uuid: relationship.target_node_uuid})
+				RETURN relationship, source, target, score`;
+            const params = {
+                query: safeQuery,
+                groupId,
+                limit: neo4j_driver_1.default.int(limit),
+            };
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(cypher, params);
+            });
+            const maxScore = result.records.length > 0 ? result.records[0].get('score') : 1;
+            return result.records
+                .filter((r) => {
+                var _a;
+                const score = r.get('score') / (maxScore || 1);
+                return score >= ((_a = options === null || options === void 0 ? void 0 : options.min_score) !== null && _a !== void 0 ? _a : 0);
+            })
+                .map((r) => ({
+                edge: this.recordToEdge(r.get('relationship').properties),
+                sourceEntity: this.recordToEntity(r.get('source').properties),
+                targetEntity: this.recordToEntity(r.get('target').properties),
+                score: r.get('score') / (maxScore || 1),
+            }));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async ensureVectorIndex(dimensions) {
+        if (this.vectorIndexCreated)
+            return;
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run(`CREATE VECTOR INDEX entityNameEmbedding IF NOT EXISTS
+					 FOR (e:Entity)
+					 ON (e.name_embedding)
+					 OPTIONS {indexConfig: {
+						\`vector.dimensions\`: $dimensions,
+						\`vector.similarity_function\`: 'cosine'
+					 }}`, { dimensions: neo4j_driver_1.default.int(dimensions) });
+            });
+            this.vectorIndexCreated = true;
+        }
+        catch (error) {
+            console.warn('Engram: Could not create vector indexes (Neo4j may not support them):', error.message);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async searchEntitiesByVector(vector, groupId, options) {
+        var _a, _b;
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const minScore = (_b = options === null || options === void 0 ? void 0 : options.min_score) !== null && _b !== void 0 ? _b : 0;
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`CALL db.index.vector.queryNodes('entityNameEmbedding', $topK, $vector)
+					 YIELD node, score
+					 WHERE node.group_id = $groupId AND score >= $minScore
+					 RETURN node, score
+					 ORDER BY score DESC
+					 LIMIT $limit`, {
+                    vector,
+                    groupId,
+                    topK: neo4j_driver_1.default.int(limit * 2),
+                    minScore,
+                    limit: neo4j_driver_1.default.int(limit),
+                });
+            });
+            return result.records.map((r) => ({
+                entity: this.recordToEntity(r.get('node').properties),
+                score: r.get('score'),
+            }));
+        }
+        catch {
+            return this.bruteForceEntityVectorSearch(vector, groupId, options);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async searchEdgesByVector(vector, groupId, options) {
+        var _a, _b;
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const minScore = (_b = options === null || options === void 0 ? void 0 : options.min_score) !== null && _b !== void 0 ? _b : 0;
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (source:Entity)-[r:RELATES_TO]->(target:Entity)
+					 WHERE r.group_id = $groupId
+					   AND r.fact_embedding IS NOT NULL
+					   AND r.expired_at IS NULL
+					 RETURN r, source, target`, { groupId });
+            });
+            const scored = [];
+            for (const rec of result.records) {
+                const edgeProps = rec.get('r').properties;
+                const embedding = edgeProps.fact_embedding;
+                if (!embedding || embedding.length !== vector.length)
+                    continue;
+                try {
+                    const score = (0, cosine_1.cosineSimilarity)(vector, embedding);
+                    if (score < minScore)
+                        continue;
+                    scored.push({
+                        edge: this.recordToEdge(edgeProps),
+                        sourceEntity: this.recordToEntity(rec.get('source').properties),
+                        targetEntity: this.recordToEntity(rec.get('target').properties),
+                        score,
+                    });
+                }
+                catch {
+                }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            return scored.slice(0, limit);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async bruteForceEntityVectorSearch(vector, groupId, options) {
+        var _a, _b;
+        const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 10;
+        const minScore = (_b = options === null || options === void 0 ? void 0 : options.min_score) !== null && _b !== void 0 ? _b : 0;
+        const session = this.getSession();
+        try {
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (e:Entity {group_id: $groupId})
+					 WHERE e.name_embedding IS NOT NULL
+					 RETURN e`, { groupId });
+            });
+            const scored = [];
+            for (const rec of result.records) {
+                const entity = this.recordToEntity(rec.get('e').properties);
+                if (!entity.name_embedding || entity.name_embedding.length !== vector.length)
+                    continue;
+                try {
+                    const score = (0, cosine_1.cosineSimilarity)(vector, entity.name_embedding);
+                    if (score >= minScore) {
+                        scored.push({ entity, score });
+                    }
+                }
+                catch {
+                }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            return scored.slice(0, limit);
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async clearGroup(groupId) {
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run(`MATCH ()-[r:RELATES_TO {group_id: $groupId}]->()
+					 DELETE r`, { groupId });
+                await tx.run(`MATCH (n)
+					 WHERE n.group_id = $groupId AND (n:Entity OR n:Episode)
+					 DETACH DELETE n`, { groupId });
+            });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async clearAll() {
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                await tx.run('MATCH (n) WHERE n:Entity OR n:Episode DETACH DELETE n');
+            });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async exportGraph(groupId) {
+        const entities = [];
+        const edges = [];
+        const episodes = [];
+        const session = this.getSession();
+        try {
+            const entityQuery = groupId
+                ? 'MATCH (e:Entity {group_id: $groupId}) RETURN e'
+                : 'MATCH (e:Entity) RETURN e';
+            const entityResult = await session.executeRead(async (tx) => {
+                return tx.run(entityQuery, groupId ? { groupId } : {});
+            });
+            for (const r of entityResult.records) {
+                entities.push(this.recordToEntity(r.get('e').properties));
+            }
+            const edgeQuery = groupId
+                ? 'MATCH ()-[r:RELATES_TO {group_id: $groupId}]->() RETURN r'
+                : 'MATCH ()-[r:RELATES_TO]->() RETURN r';
+            const edgeResult = await session.executeRead(async (tx) => {
+                return tx.run(edgeQuery, groupId ? { groupId } : {});
+            });
+            for (const r of edgeResult.records) {
+                edges.push(this.recordToEdge(r.get('r').properties));
+            }
+            const episodeQuery = groupId
+                ? 'MATCH (ep:Episode {group_id: $groupId}) RETURN ep'
+                : 'MATCH (ep:Episode) RETURN ep';
+            const episodeResult = await session.executeRead(async (tx) => {
+                return tx.run(episodeQuery, groupId ? { groupId } : {});
+            });
+            for (const r of episodeResult.records) {
+                episodes.push(this.recordToEpisode(r.get('ep').properties));
+            }
+        }
+        finally {
+            await session.close();
+        }
+        return {
+            version: '1.0',
+            exported_at: (0, temporal_1.nowIso)(),
+            group_id: groupId,
+            entities,
+            edges,
+            episodes,
+        };
+    }
+    async importGraph(data) {
+        const session = this.getSession();
+        try {
+            await session.executeWrite(async (tx) => {
+                for (const entity of data.entities) {
+                    await tx.run(`MERGE (e:Entity {uuid: $uuid})
+						 SET e += {
+							name: $name,
+							group_id: $group_id,
+							summary: $summary,
+							entity_type: $entity_type,
+							name_embedding: $name_embedding,
+							attributes: $attributes,
+							created_at: $created_at,
+							updated_at: $updated_at
+						 }`, {
+                        ...entity,
+                        attributes: JSON.stringify(entity.attributes),
+                    });
+                }
+                for (const episode of data.episodes) {
+                    await tx.run(`MERGE (ep:Episode {uuid: $uuid})
+						 SET ep += {
+							group_id: $group_id,
+							content: $content,
+							role: $role,
+							source_type: $source_type,
+							reference_time: $reference_time,
+							previous_episode_uuid: $previous_episode_uuid,
+							created_at: $created_at
+						 }`, episode);
+                }
+                for (const edge of data.edges) {
+                    await tx.run(`MATCH (source:Entity {uuid: $source_node_uuid})
+						 MATCH (target:Entity {uuid: $target_node_uuid})
+						 MERGE (source)-[r:RELATES_TO {uuid: $uuid}]->(target)
+						 SET r += {
+							group_id: $group_id,
+							source_node_uuid: $source_node_uuid,
+							target_node_uuid: $target_node_uuid,
+							name: $name,
+							fact: $fact,
+							fact_embedding: $fact_embedding,
+							episodes: $episodes,
+							valid_at: $valid_at,
+							invalid_at: $invalid_at,
+							expired_at: $expired_at,
+							attributes: $attributes,
+							created_at: $created_at,
+							updated_at: $updated_at
+						 }`, {
+                        ...edge,
+                        attributes: JSON.stringify(edge.attributes),
+                    });
+                }
+                for (const episode of data.episodes) {
+                    if (episode.previous_episode_uuid) {
+                        await tx.run(`MATCH (prev:Episode {uuid: $prevUuid})
+							 MATCH (curr:Episode {uuid: $currUuid})
+							 MERGE (prev)-[:NEXT_EPISODE]->(curr)`, {
+                            prevUuid: episode.previous_episode_uuid,
+                            currUuid: episode.uuid,
+                        });
+                    }
+                }
+            });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getStats(groupId) {
+        var _a, _b, _c;
+        const session = this.getSession();
+        try {
+            const where = groupId ? ' WHERE n.group_id = $groupId' : '';
+            const params = groupId ? { groupId } : {};
+            const result = await session.executeRead(async (tx) => {
+                return tx.run(`MATCH (n)
+					 ${where}
+					 WITH n
+					 WHERE n:Entity OR n:Episode
+					 RETURN
+						sum(CASE WHEN n:Entity THEN 1 ELSE 0 END) as entityCount,
+						sum(CASE WHEN n:Episode THEN 1 ELSE 0 END) as episodeCount,
+						collect(DISTINCT n.group_id) as groupIds,
+						collect(CASE WHEN n:Entity THEN n.entity_type ELSE null END) as entityTypes,
+						min(CASE WHEN n:Episode THEN n.created_at ELSE null END) as oldestEpisode,
+						max(CASE WHEN n:Episode THEN n.created_at ELSE null END) as newestEpisode`, params);
+            });
+            const edgeResult = await session.executeRead(async (tx) => {
+                const edgeWhere = groupId ? 'WHERE r.group_id = $groupId' : '';
+                return tx.run(`MATCH ()-[r:RELATES_TO]->() ${edgeWhere} RETURN count(r) as edgeCount`, params);
+            });
+            const record = result.records[0];
+            const entityTypesList = record.get('entityTypes').filter(Boolean);
+            const entityTypes = {};
+            for (const t of entityTypesList) {
+                entityTypes[t] = ((_a = entityTypes[t]) !== null && _a !== void 0 ? _a : 0) + 1;
+            }
+            return {
+                entity_count: record.get('entityCount').toNumber(),
+                edge_count: edgeResult.records[0].get('edgeCount').toNumber(),
+                episode_count: record.get('episodeCount').toNumber(),
+                group_ids: record.get('groupIds'),
+                entity_types: entityTypes,
+                oldest_episode: (_b = record.get('oldestEpisode')) !== null && _b !== void 0 ? _b : null,
+                newest_episode: (_c = record.get('newestEpisode')) !== null && _c !== void 0 ? _c : null,
+            };
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async applyRetention(groupId, policy) {
+        var _a, _b, _c, _d, _e, _f;
+        if (policy.type === 'forever')
+            return 0;
+        const session = this.getSession();
+        try {
+            if (policy.type === 'days' && policy.value) {
+                const cutoffDate = new Date(Date.now() - policy.value * 24 * 60 * 60 * 1000).toISOString();
+                const result = await session.executeWrite(async (tx) => {
+                    return tx.run(`MATCH (ep:Episode {group_id: $groupId})
+						 WHERE ep.created_at < $cutoffDate
+						 DETACH DELETE ep
+						 RETURN count(*) as removed`, { groupId, cutoffDate });
+                });
+                return (_c = (_b = (_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('removed')) === null || _b === void 0 ? void 0 : _b.toNumber()) !== null && _c !== void 0 ? _c : 0;
+            }
+            if (policy.type === 'max_episodes' && policy.value) {
+                const result = await session.executeWrite(async (tx) => {
+                    return tx.run(`MATCH (ep:Episode {group_id: $groupId})
+						 WITH ep ORDER BY ep.created_at DESC
+						 SKIP $maxEpisodes
+						 WITH collect(ep) as toDelete, count(ep) as cnt
+						 UNWIND toDelete as ep
+						 DETACH DELETE ep
+						 RETURN cnt as removed`, { groupId, maxEpisodes: neo4j_driver_1.default.int(policy.value) });
+                });
+                return (_f = (_e = (_d = result.records[0]) === null || _d === void 0 ? void 0 : _d.get('removed')) === null || _e === void 0 ? void 0 : _e.toNumber()) !== null && _f !== void 0 ? _f : 0;
+            }
+            return 0;
+        }
+        finally {
+            await session.close();
+        }
+    }
+    recordToEntity(props) {
+        var _a, _b, _c;
+        return {
+            uuid: props.uuid,
+            name: props.name,
+            group_id: props.group_id,
+            summary: (_a = props.summary) !== null && _a !== void 0 ? _a : '',
+            entity_type: (_b = props.entity_type) !== null && _b !== void 0 ? _b : 'unknown',
+            name_embedding: (_c = props.name_embedding) !== null && _c !== void 0 ? _c : null,
+            attributes: this.parseJsonField(props.attributes, {}),
+            created_at: props.created_at,
+            updated_at: props.updated_at,
+        };
+    }
+    recordToEdge(props) {
+        var _a, _b, _c, _d, _e;
+        return {
+            uuid: props.uuid,
+            group_id: props.group_id,
+            source_node_uuid: props.source_node_uuid,
+            target_node_uuid: props.target_node_uuid,
+            name: props.name,
+            fact: props.fact,
+            fact_embedding: (_a = props.fact_embedding) !== null && _a !== void 0 ? _a : null,
+            episodes: (_b = props.episodes) !== null && _b !== void 0 ? _b : [],
+            valid_at: (_c = props.valid_at) !== null && _c !== void 0 ? _c : null,
+            invalid_at: (_d = props.invalid_at) !== null && _d !== void 0 ? _d : null,
+            expired_at: (_e = props.expired_at) !== null && _e !== void 0 ? _e : null,
+            attributes: this.parseJsonField(props.attributes, {}),
+            created_at: props.created_at,
+            updated_at: props.updated_at,
+        };
+    }
+    recordToEpisode(props) {
+        var _a, _b;
+        return {
+            uuid: props.uuid,
+            group_id: props.group_id,
+            content: props.content,
+            role: props.role,
+            source_type: (_a = props.source_type) !== null && _a !== void 0 ? _a : 'message',
+            reference_time: props.reference_time,
+            previous_episode_uuid: (_b = props.previous_episode_uuid) !== null && _b !== void 0 ? _b : null,
+            created_at: props.created_at,
+        };
+    }
+    parseJsonField(value, fallback) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return fallback;
+            }
+        }
+        if (typeof value === 'object' && value !== null) {
+            return value;
+        }
+        return fallback;
+    }
+}
+exports.Neo4jStorage = Neo4jStorage;
+//# sourceMappingURL=Neo4jStorage.js.map