n8n-nodes-engram 0.2.0

package/dist/storage/GraphologyStorage.js

@@ -0,0 +1,665 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphologyStorage = void 0;
+const graphology_1 = require("graphology");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("../utils/uuid");
+const temporal_1 = require("../utils/temporal");
+const MinisearchProvider_1 = require("../search/MinisearchProvider");
+const cosine_1 = require("../embeddings/cosine");
+class GraphologyStorage {
+    constructor(persistPath) {
+        this.initialized = false;
+        this.episodeOrder = new Map();
+        this.nextOrder = 0;
+        this.graph = new graphology_1.MultiDirectedGraph();
+        this.searchProvider = new MinisearchProvider_1.MinisearchProvider();
+        if (persistPath) {
+            const resolved = path.resolve(persistPath);
+            if (resolved.includes('..') || resolved.startsWith('/etc') || resolved.startsWith('/dev')) {
+                throw new Error(`Invalid persist path: ${persistPath}`);
+            }
+            this.persistPath = resolved;
+        }
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.persistPath) {
+            await this.loadFromDisk();
+        }
+        this.initialized = true;
+    }
+    async close() {
+        if (this.persistPath) {
+            await this.saveToDisk();
+        }
+    }
+    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,
+        };
+        this.graph.addNode(entity.uuid, { type: 'entity', data: entity });
+        this.searchProvider.indexEntity(entity.uuid, {
+            name: entity.name,
+            summary: entity.summary,
+            entity_type: entity.entity_type,
+        });
+        await this.persistIfConfigured();
+        return entity;
+    }
+    async getEntity(uuid) {
+        if (!this.graph.hasNode(uuid))
+            return null;
+        const attrs = this.graph.getNodeAttributes(uuid);
+        if (attrs.type !== 'entity')
+            return null;
+        return attrs.data;
+    }
+    async getEntityByName(name, groupId) {
+        const normalized = name.toLowerCase().trim();
+        let found = null;
+        this.graph.forEachNode((key, attrs) => {
+            if (found)
+                return;
+            if (attrs.type !== 'entity')
+                return;
+            const entity = attrs.data;
+            if (entity.group_id === groupId && entity.name.toLowerCase().trim() === normalized) {
+                found = entity;
+            }
+        });
+        return found;
+    }
+    async updateEntity(uuid, updates) {
+        const existing = await this.getEntity(uuid);
+        if (!existing)
+            throw new Error(`Entity not found: ${uuid}`);
+        const updated = {
+            ...existing,
+            ...updates,
+            uuid: existing.uuid,
+            created_at: existing.created_at,
+            updated_at: (0, temporal_1.nowIso)(),
+        };
+        this.graph.setNodeAttribute(uuid, 'data', updated);
+        this.searchProvider.indexEntity(updated.uuid, {
+            name: updated.name,
+            summary: updated.summary,
+            entity_type: updated.entity_type,
+        });
+        await this.persistIfConfigured();
+        return updated;
+    }
+    async deleteEntity(uuid) {
+        if (!this.graph.hasNode(uuid))
+            return;
+        this.graph.forEachEdge(uuid, (edgeKey, attrs) => {
+            if (attrs.type === 'entity_edge') {
+                this.searchProvider.removeEdge(edgeKey);
+            }
+        });
+        this.searchProvider.removeEntity(uuid);
+        this.graph.dropNode(uuid);
+        await this.persistIfConfigured();
+    }
+    async listEntities(groupId, options) {
+        var _a, _b;
+        const entities = [];
+        this.graph.forEachNode((_key, attrs) => {
+            if (attrs.type !== 'entity')
+                return;
+            const entity = attrs.data;
+            if (entity.group_id !== groupId)
+                return;
+            if ((options === null || options === void 0 ? void 0 : options.entity_type) && entity.entity_type !== options.entity_type)
+                return;
+            entities.push(entity);
+        });
+        entities.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+        const offset = (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : 0;
+        const limit = (_b = options === null || options === void 0 ? void 0 : options.limit) !== null && _b !== void 0 ? _b : entities.length;
+        return entities.slice(offset, offset + limit);
+    }
+    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 (!this.graph.hasNode(edge.source_node_uuid) || !this.graph.hasNode(edge.target_node_uuid)) {
+            throw new Error(`Cannot create edge: source (${edge.source_node_uuid}) or target (${edge.target_node_uuid}) node not found`);
+        }
+        this.graph.addEdgeWithKey(edge.uuid, edge.source_node_uuid, edge.target_node_uuid, {
+            type: 'entity_edge',
+            data: edge,
+        });
+        this.searchProvider.indexEdge(edge.uuid, {
+            name: edge.name,
+            fact: edge.fact,
+        });
+        await this.persistIfConfigured();
+        return edge;
+    }
+    async getEdge(uuid) {
+        if (!this.graph.hasEdge(uuid))
+            return null;
+        const attrs = this.graph.getEdgeAttributes(uuid);
+        if (attrs.type !== 'entity_edge')
+            return null;
+        return attrs.data;
+    }
+    async getEdgesBetween(sourceUuid, targetUuid) {
+        const edges = [];
+        if (!this.graph.hasNode(sourceUuid) || !this.graph.hasNode(targetUuid))
+            return edges;
+        this.graph.forEachEdge(sourceUuid, (edgeKey, attrs, source, target) => {
+            if (attrs.type !== 'entity_edge' || !attrs.data)
+                return;
+            if ((source === sourceUuid && target === targetUuid) ||
+                (source === targetUuid && target === sourceUuid)) {
+                edges.push(attrs.data);
+            }
+        });
+        return edges;
+    }
+    async getEdgesForEntity(entityUuid) {
+        const edges = [];
+        if (!this.graph.hasNode(entityUuid))
+            return edges;
+        this.graph.forEachEdge(entityUuid, (_edgeKey, attrs) => {
+            if (attrs.type !== 'entity_edge' || !attrs.data)
+                return;
+            edges.push(attrs.data);
+        });
+        return edges;
+    }
+    async updateEdge(uuid, updates) {
+        const existing = await this.getEdge(uuid);
+        if (!existing)
+            throw new Error(`Edge not found: ${uuid}`);
+        const updated = {
+            ...existing,
+            ...updates,
+            uuid: existing.uuid,
+            source_node_uuid: existing.source_node_uuid,
+            target_node_uuid: existing.target_node_uuid,
+            created_at: existing.created_at,
+            updated_at: (0, temporal_1.nowIso)(),
+        };
+        this.graph.setEdgeAttribute(uuid, 'data', updated);
+        this.searchProvider.indexEdge(updated.uuid, {
+            name: updated.name,
+            fact: updated.fact,
+        });
+        await this.persistIfConfigured();
+        return updated;
+    }
+    async deleteEdge(uuid) {
+        if (!this.graph.hasEdge(uuid))
+            return;
+        this.searchProvider.removeEdge(uuid);
+        this.graph.dropEdge(uuid);
+        await this.persistIfConfigured();
+    }
+    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)(),
+        };
+        this.graph.addNode(episode.uuid, { type: 'episode', data: episode });
+        this.episodeOrder.set(episode.uuid, this.nextOrder++);
+        if (episode.previous_episode_uuid && this.graph.hasNode(episode.previous_episode_uuid)) {
+            const chainKey = `next_${episode.previous_episode_uuid}_${episode.uuid}`;
+            this.graph.addEdgeWithKey(chainKey, episode.previous_episode_uuid, episode.uuid, {
+                type: 'next_episode',
+                data: null,
+            });
+        }
+        await this.persistIfConfigured();
+        return episode;
+    }
+    async getEpisode(uuid) {
+        if (!this.graph.hasNode(uuid))
+            return null;
+        const attrs = this.graph.getNodeAttributes(uuid);
+        if (attrs.type !== 'episode')
+            return null;
+        return attrs.data;
+    }
+    async getRecentEpisodes(groupId, limit) {
+        const episodes = [];
+        this.graph.forEachNode((_key, attrs) => {
+            if (attrs.type !== 'episode')
+                return;
+            const episode = attrs.data;
+            if (episode.group_id !== groupId)
+                return;
+            episodes.push(episode);
+        });
+        episodes.sort((a, b) => {
+            var _a, _b;
+            const timeDiff = new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+            if (timeDiff !== 0)
+                return timeDiff;
+            return ((_a = this.episodeOrder.get(b.uuid)) !== null && _a !== void 0 ? _a : 0) - ((_b = this.episodeOrder.get(a.uuid)) !== null && _b !== void 0 ? _b : 0);
+        });
+        return episodes.slice(0, limit).reverse();
+    }
+    async getEpisodeCount(groupId) {
+        let count = 0;
+        this.graph.forEachNode((_key, attrs) => {
+            if (attrs.type !== 'episode')
+                return;
+            const episode = attrs.data;
+            if (episode.group_id === groupId)
+                count++;
+        });
+        return count;
+    }
+    async searchEntities(query, 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 textResults = this.searchProvider.searchEntities(query, limit * 3);
+        const results = [];
+        for (const tr of textResults) {
+            if (tr.score < minScore)
+                continue;
+            const entity = await this.getEntity(tr.id);
+            if (!entity || entity.group_id !== groupId)
+                continue;
+            if ((options === null || options === void 0 ? void 0 : options.entity_type) && entity.entity_type !== options.entity_type)
+                continue;
+            results.push({ entity, score: tr.score });
+        }
+        return results.slice(0, limit);
+    }
+    async searchEdges(query, groupId, options) {
+        var _a, _b, _c;
+        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 includeExpired = (_c = options === null || options === void 0 ? void 0 : options.include_expired) !== null && _c !== void 0 ? _c : false;
+        const textResults = this.searchProvider.searchEdges(query, limit * 3);
+        const results = [];
+        for (const tr of textResults) {
+            if (tr.score < minScore)
+                continue;
+            const edge = await this.getEdge(tr.id);
+            if (!edge || edge.group_id !== groupId)
+                continue;
+            if (!includeExpired && edge.expired_at !== null)
+                continue;
+            const sourceEntity = await this.getEntity(edge.source_node_uuid);
+            const targetEntity = await this.getEntity(edge.target_node_uuid);
+            if (!sourceEntity || !targetEntity)
+                continue;
+            results.push({ edge, sourceEntity, targetEntity, score: tr.score });
+        }
+        return results.slice(0, limit);
+    }
+    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 results = [];
+        this.graph.forEachNode((_key, attrs) => {
+            if (attrs.type !== 'entity')
+                return;
+            const entity = attrs.data;
+            if (entity.group_id !== groupId)
+                return;
+            if (!entity.name_embedding || entity.name_embedding.length !== vector.length)
+                return;
+            try {
+                const score = (0, cosine_1.cosineSimilarity)(vector, entity.name_embedding);
+                if (score >= minScore) {
+                    results.push({ entity, score });
+                }
+            }
+            catch {
+            }
+        });
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    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 results = [];
+        this.graph.forEachEdge((_edgeKey, attrs) => {
+            if (attrs.type !== 'entity_edge' || !attrs.data)
+                return;
+            const edge = attrs.data;
+            if (edge.group_id !== groupId)
+                return;
+            if (!edge.fact_embedding || edge.fact_embedding.length !== vector.length)
+                return;
+            try {
+                const score = (0, cosine_1.cosineSimilarity)(vector, edge.fact_embedding);
+                if (score < minScore)
+                    return;
+                const sourceNode = this.graph.hasNode(edge.source_node_uuid)
+                    ? this.graph.getNodeAttributes(edge.source_node_uuid)
+                    : null;
+                const targetNode = this.graph.hasNode(edge.target_node_uuid)
+                    ? this.graph.getNodeAttributes(edge.target_node_uuid)
+                    : null;
+                if (!sourceNode || !targetNode)
+                    return;
+                if (sourceNode.type !== 'entity' || targetNode.type !== 'entity')
+                    return;
+                results.push({
+                    edge,
+                    sourceEntity: sourceNode.data,
+                    targetEntity: targetNode.data,
+                    score,
+                });
+            }
+            catch {
+            }
+        });
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    async clearGroup(groupId) {
+        const nodesToRemove = [];
+        this.graph.forEachNode((key, attrs) => {
+            const data = attrs.data;
+            if ('group_id' in data && data.group_id === groupId) {
+                nodesToRemove.push(key);
+            }
+        });
+        const edgesToRemove = [];
+        this.graph.forEachEdge((edgeKey, attrs) => {
+            if (attrs.type === 'entity_edge' && attrs.data) {
+                const edge = attrs.data;
+                if (edge.group_id === groupId) {
+                    edgesToRemove.push(edgeKey);
+                }
+            }
+        });
+        for (const edgeKey of edgesToRemove) {
+            this.searchProvider.removeEdge(edgeKey);
+            if (this.graph.hasEdge(edgeKey)) {
+                this.graph.dropEdge(edgeKey);
+            }
+        }
+        for (const key of nodesToRemove) {
+            this.searchProvider.removeEntity(key);
+            if (this.graph.hasNode(key)) {
+                this.graph.dropNode(key);
+            }
+        }
+        await this.persistIfConfigured();
+    }
+    async clearAll() {
+        this.graph.clear();
+        this.searchProvider.clear();
+        this.episodeOrder.clear();
+        this.nextOrder = 0;
+        await this.persistIfConfigured();
+    }
+    async exportGraph(groupId) {
+        const entities = [];
+        const edges = [];
+        const episodes = [];
+        this.graph.forEachNode((_key, attrs) => {
+            if (attrs.type === 'entity') {
+                const entity = attrs.data;
+                if (!groupId || entity.group_id === groupId)
+                    entities.push(entity);
+            }
+            else if (attrs.type === 'episode') {
+                const episode = attrs.data;
+                if (!groupId || episode.group_id === groupId)
+                    episodes.push(episode);
+            }
+        });
+        this.graph.forEachEdge((_edgeKey, attrs) => {
+            if (attrs.type === 'entity_edge' && attrs.data) {
+                const edge = attrs.data;
+                if (!groupId || edge.group_id === groupId)
+                    edges.push(edge);
+            }
+        });
+        return {
+            version: '1.0',
+            exported_at: (0, temporal_1.nowIso)(),
+            group_id: groupId,
+            entities,
+            edges,
+            episodes,
+        };
+    }
+    async importGraph(data) {
+        for (const entity of data.entities) {
+            if (!this.graph.hasNode(entity.uuid)) {
+                this.graph.addNode(entity.uuid, { type: 'entity', data: entity });
+                this.searchProvider.indexEntity(entity.uuid, {
+                    name: entity.name,
+                    summary: entity.summary,
+                    entity_type: entity.entity_type,
+                });
+            }
+        }
+        const sortedEpisodes = [...data.episodes].sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+        for (const episode of sortedEpisodes) {
+            if (!this.graph.hasNode(episode.uuid)) {
+                this.graph.addNode(episode.uuid, { type: 'episode', data: episode });
+                this.episodeOrder.set(episode.uuid, this.nextOrder++);
+            }
+        }
+        for (const edge of data.edges) {
+            if (!this.graph.hasEdge(edge.uuid) &&
+                this.graph.hasNode(edge.source_node_uuid) &&
+                this.graph.hasNode(edge.target_node_uuid)) {
+                this.graph.addEdgeWithKey(edge.uuid, edge.source_node_uuid, edge.target_node_uuid, {
+                    type: 'entity_edge',
+                    data: edge,
+                });
+                this.searchProvider.indexEdge(edge.uuid, {
+                    name: edge.name,
+                    fact: edge.fact,
+                });
+            }
+        }
+        for (const episode of data.episodes) {
+            if (episode.previous_episode_uuid &&
+                this.graph.hasNode(episode.previous_episode_uuid) &&
+                this.graph.hasNode(episode.uuid)) {
+                const chainKey = `next_${episode.previous_episode_uuid}_${episode.uuid}`;
+                if (!this.graph.hasEdge(chainKey)) {
+                    this.graph.addEdgeWithKey(chainKey, episode.previous_episode_uuid, episode.uuid, {
+                        type: 'next_episode',
+                        data: null,
+                    });
+                }
+            }
+        }
+        await this.persistIfConfigured();
+    }
+    async getStats(groupId) {
+        let entityCount = 0;
+        let edgeCount = 0;
+        let episodeCount = 0;
+        const groupIds = new Set();
+        const entityTypes = {};
+        let oldestEpisode = null;
+        let newestEpisode = null;
+        this.graph.forEachNode((_key, attrs) => {
+            var _a;
+            if (attrs.type === 'entity') {
+                const entity = attrs.data;
+                if (groupId && entity.group_id !== groupId)
+                    return;
+                entityCount++;
+                groupIds.add(entity.group_id);
+                entityTypes[entity.entity_type] = ((_a = entityTypes[entity.entity_type]) !== null && _a !== void 0 ? _a : 0) + 1;
+            }
+            else if (attrs.type === 'episode') {
+                const episode = attrs.data;
+                if (groupId && episode.group_id !== groupId)
+                    return;
+                episodeCount++;
+                groupIds.add(episode.group_id);
+                if (!oldestEpisode || episode.created_at < oldestEpisode) {
+                    oldestEpisode = episode.created_at;
+                }
+                if (!newestEpisode || episode.created_at > newestEpisode) {
+                    newestEpisode = episode.created_at;
+                }
+            }
+        });
+        this.graph.forEachEdge((_edgeKey, attrs) => {
+            if (attrs.type === 'entity_edge' && attrs.data) {
+                const edge = attrs.data;
+                if (groupId && edge.group_id !== groupId)
+                    return;
+                edgeCount++;
+            }
+        });
+        return {
+            entity_count: entityCount,
+            edge_count: edgeCount,
+            episode_count: episodeCount,
+            group_ids: [...groupIds],
+            entity_types: entityTypes,
+            oldest_episode: oldestEpisode,
+            newest_episode: newestEpisode,
+        };
+    }
+    async applyRetention(groupId, policy) {
+        if (policy.type === 'forever')
+            return 0;
+        let removed = 0;
+        if (policy.type === 'days' && policy.value) {
+            const days = policy.value;
+            const episodesToRemove = [];
+            this.graph.forEachNode((key, attrs) => {
+                if (attrs.type !== 'episode')
+                    return;
+                const episode = attrs.data;
+                if (episode.group_id !== groupId)
+                    return;
+                if ((0, temporal_1.isOlderThanDays)(episode.created_at, days)) {
+                    episodesToRemove.push(key);
+                }
+            });
+            for (const key of episodesToRemove) {
+                if (this.graph.hasNode(key)) {
+                    this.graph.dropNode(key);
+                    removed++;
+                }
+            }
+        }
+        if (policy.type === 'max_episodes' && policy.value) {
+            const maxEpisodes = policy.value;
+            const episodes = [];
+            this.graph.forEachNode((_key, attrs) => {
+                if (attrs.type !== 'episode')
+                    return;
+                const episode = attrs.data;
+                if (episode.group_id !== groupId)
+                    return;
+                episodes.push({ uuid: episode.uuid, created_at: episode.created_at });
+            });
+            episodes.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+            const toRemove = episodes.slice(maxEpisodes);
+            for (const ep of toRemove) {
+                if (this.graph.hasNode(ep.uuid)) {
+                    this.graph.dropNode(ep.uuid);
+                    removed++;
+                }
+            }
+        }
+        if (removed > 0) {
+            await this.persistIfConfigured();
+        }
+        return removed;
+    }
+    async persistIfConfigured() {
+        if (this.persistPath) {
+            await this.saveToDisk();
+        }
+    }
+    async saveToDisk() {
+        if (!this.persistPath)
+            return;
+        const data = await this.exportGraph();
+        const dir = path.dirname(this.persistPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(this.persistPath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    async loadFromDisk() {
+        if (!this.persistPath || !fs.existsSync(this.persistPath))
+            return;
+        try {
+            const raw = fs.readFileSync(this.persistPath, 'utf-8');
+            const data = JSON.parse(raw);
+            await this.importGraph(data);
+        }
+        catch {
+            console.error(`Engram: Failed to load graph from ${this.persistPath}, starting fresh`);
+        }
+    }
+}
+exports.GraphologyStorage = GraphologyStorage;
+//# sourceMappingURL=GraphologyStorage.js.map