@cogitator-ai/memory 0.1.0 → 0.3.0

package/dist/knowledge-graph/graph-adapter.js

@@ -0,0 +1,652 @@
+import { nanoid } from 'nanoid';
+export class PostgresGraphAdapter {
+    pool;
+    schema;
+    vectorDimensions;
+    initialized = false;
+    constructor(config) {
+        this.pool = config.pool;
+        this.schema = config.schema ?? 'cogitator';
+        this.vectorDimensions = config.vectorDimensions ?? 1536;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.schema}.graph_nodes (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        aliases TEXT[] DEFAULT '{}',
+        description TEXT,
+        properties JSONB DEFAULT '{}',
+        embedding vector(${this.vectorDimensions}),
+        confidence REAL NOT NULL DEFAULT 1.0,
+        source TEXT NOT NULL,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        last_accessed_at TIMESTAMPTZ DEFAULT NOW(),
+        access_count INTEGER DEFAULT 0,
+        metadata JSONB DEFAULT '{}'
+      )
+    `);
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.schema}.graph_edges (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source_node_id TEXT NOT NULL REFERENCES ${this.schema}.graph_nodes(id) ON DELETE CASCADE,
+        target_node_id TEXT NOT NULL REFERENCES ${this.schema}.graph_nodes(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        label TEXT,
+        weight REAL NOT NULL DEFAULT 1.0,
+        bidirectional BOOLEAN DEFAULT FALSE,
+        properties JSONB DEFAULT '{}',
+        confidence REAL NOT NULL DEFAULT 1.0,
+        source TEXT NOT NULL,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        valid_from TIMESTAMPTZ,
+        valid_until TIMESTAMPTZ,
+        metadata JSONB DEFAULT '{}'
+      )
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_nodes_agent_id
+      ON ${this.schema}.graph_nodes(agent_id)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_nodes_type
+      ON ${this.schema}.graph_nodes(agent_id, type)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_nodes_name
+      ON ${this.schema}.graph_nodes(agent_id, name)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_edges_agent_id
+      ON ${this.schema}.graph_edges(agent_id)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_edges_source
+      ON ${this.schema}.graph_edges(source_node_id)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_edges_target
+      ON ${this.schema}.graph_edges(target_node_id)
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_graph_edges_type
+      ON ${this.schema}.graph_edges(agent_id, type)
+    `);
+        try {
+            await this.pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_graph_nodes_embedding
+        ON ${this.schema}.graph_nodes
+        USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100)
+      `);
+        }
+        catch { }
+        this.initialized = true;
+    }
+    success(data) {
+        return { success: true, data };
+    }
+    failure(error) {
+        return { success: false, error };
+    }
+    generateId(prefix) {
+        return `${prefix}_${nanoid(12)}`;
+    }
+    async addNode(node) {
+        await this.initialize();
+        const id = this.generateId('node');
+        const now = new Date();
+        const embeddingStr = node.embedding ? `[${node.embedding.join(',')}]` : null;
+        await this.pool.query(`INSERT INTO ${this.schema}.graph_nodes
+       (id, agent_id, type, name, aliases, description, properties, embedding, confidence, source, metadata, created_at, updated_at, last_accessed_at, access_count)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $12, $12, 0)`, [
+            id,
+            node.agentId,
+            node.type,
+            node.name,
+            node.aliases,
+            node.description ?? null,
+            node.properties,
+            embeddingStr,
+            node.confidence,
+            node.source,
+            node.metadata ?? {},
+            now,
+        ]);
+        return this.success({
+            ...node,
+            id,
+            createdAt: now,
+            updatedAt: now,
+            lastAccessedAt: now,
+            accessCount: 0,
+        });
+    }
+    async getNode(nodeId) {
+        await this.initialize();
+        await this.pool.query(`UPDATE ${this.schema}.graph_nodes
+       SET last_accessed_at = NOW(), access_count = access_count + 1
+       WHERE id = $1`, [nodeId]);
+        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes WHERE id = $1`, [nodeId]);
+        if (result.rows.length === 0)
+            return this.success(null);
+        return this.success(this.rowToNode(result.rows[0]));
+    }
+    async getNodeByName(agentId, name) {
+        await this.initialize();
+        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes
+       WHERE agent_id = $1 AND (name = $2 OR $2 = ANY(aliases))`, [agentId, name]);
+        if (result.rows.length === 0)
+            return this.success(null);
+        return this.success(this.rowToNode(result.rows[0]));
+    }
+    async updateNode(nodeId, updates) {
+        await this.initialize();
+        const setClauses = ['updated_at = NOW()'];
+        const params = [];
+        let paramIndex = 1;
+        if (updates.name !== undefined) {
+            setClauses.push(`name = $${paramIndex++}`);
+            params.push(updates.name);
+        }
+        if (updates.aliases !== undefined) {
+            setClauses.push(`aliases = $${paramIndex++}`);
+            params.push(updates.aliases);
+        }
+        if (updates.description !== undefined) {
+            setClauses.push(`description = $${paramIndex++}`);
+            params.push(updates.description);
+        }
+        if (updates.properties !== undefined) {
+            setClauses.push(`properties = $${paramIndex++}`);
+            params.push(updates.properties);
+        }
+        if (updates.confidence !== undefined) {
+            setClauses.push(`confidence = $${paramIndex++}`);
+            params.push(updates.confidence);
+        }
+        if (updates.metadata !== undefined) {
+            setClauses.push(`metadata = $${paramIndex++}`);
+            params.push(updates.metadata);
+        }
+        if (updates.embedding !== undefined) {
+            setClauses.push(`embedding = $${paramIndex++}`);
+            params.push(`[${updates.embedding.join(',')}]`);
+        }
+        params.push(nodeId);
+        const result = await this.pool.query(`UPDATE ${this.schema}.graph_nodes SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
+        if (result.rows.length === 0) {
+            return this.failure(`Node not found: ${nodeId}`);
+        }
+        return this.success(this.rowToNode(result.rows[0]));
+    }
+    async deleteNode(nodeId) {
+        await this.initialize();
+        await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE id = $1`, [nodeId]);
+        return this.success(undefined);
+    }
+    async queryNodes(query) {
+        await this.initialize();
+        let sql = `SELECT * FROM ${this.schema}.graph_nodes WHERE agent_id = $1`;
+        const params = [query.agentId];
+        let paramIndex = 2;
+        if (query.types && query.types.length > 0) {
+            sql += ` AND type = ANY($${paramIndex++})`;
+            params.push(query.types);
+        }
+        if (query.namePattern) {
+            sql += ` AND name ILIKE $${paramIndex++}`;
+            params.push(`%${query.namePattern}%`);
+        }
+        if (query.minConfidence !== undefined) {
+            sql += ` AND confidence >= $${paramIndex++}`;
+            params.push(query.minConfidence);
+        }
+        sql += ' ORDER BY access_count DESC, updated_at DESC';
+        if (query.limit) {
+            sql += ` LIMIT $${paramIndex++}`;
+            params.push(query.limit);
+        }
+        const result = await this.pool.query(sql, params);
+        return this.success(result.rows.map((row) => this.rowToNode(row, query.includeEmbedding)));
+    }
+    async searchNodesSemantic(options) {
+        await this.initialize();
+        if (!options.vector) {
+            return this.failure('searchNodesSemantic requires vector');
+        }
+        const vectorStr = `[${options.vector.join(',')}]`;
+        const limit = options.limit ?? 10;
+        const threshold = options.threshold ?? 0.7;
+        let sql = `
+      SELECT *, 1 - (embedding <=> $1) as score
+      FROM ${this.schema}.graph_nodes
+      WHERE agent_id = $2 AND embedding IS NOT NULL AND 1 - (embedding <=> $1) >= $3
+    `;
+        const params = [vectorStr, options.agentId, threshold];
+        let paramIndex = 4;
+        if (options.entityTypes && options.entityTypes.length > 0) {
+            sql += ` AND type = ANY($${paramIndex++})`;
+            params.push(options.entityTypes);
+        }
+        sql += ` ORDER BY embedding <=> $1 LIMIT $${paramIndex}`;
+        params.push(limit);
+        const result = await this.pool.query(sql, params);
+        return this.success(result.rows.map((row) => ({
+            ...this.rowToNode(row),
+            score: row.score,
+        })));
+    }
+    async addEdge(edge) {
+        await this.initialize();
+        const id = this.generateId('edge');
+        const now = new Date();
+        await this.pool.query(`INSERT INTO ${this.schema}.graph_edges
+       (id, agent_id, source_node_id, target_node_id, type, label, weight, bidirectional, properties, confidence, source, valid_from, valid_until, metadata, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $15)`, [
+            id,
+            edge.agentId,
+            edge.sourceNodeId,
+            edge.targetNodeId,
+            edge.type,
+            edge.label ?? null,
+            edge.weight,
+            edge.bidirectional,
+            edge.properties,
+            edge.confidence,
+            edge.source,
+            edge.validFrom ?? null,
+            edge.validUntil ?? null,
+            edge.metadata ?? {},
+            now,
+        ]);
+        return this.success({
+            ...edge,
+            id,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+    async getEdge(edgeId) {
+        await this.initialize();
+        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges WHERE id = $1`, [edgeId]);
+        if (result.rows.length === 0)
+            return this.success(null);
+        return this.success(this.rowToEdge(result.rows[0]));
+    }
+    async getEdgesBetween(sourceNodeId, targetNodeId) {
+        await this.initialize();
+        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges
+       WHERE (source_node_id = $1 AND target_node_id = $2)
+          OR (bidirectional = TRUE AND source_node_id = $2 AND target_node_id = $1)`, [sourceNodeId, targetNodeId]);
+        return this.success(result.rows.map((row) => this.rowToEdge(row)));
+    }
+    async updateEdge(edgeId, updates) {
+        await this.initialize();
+        const setClauses = ['updated_at = NOW()'];
+        const params = [];
+        let paramIndex = 1;
+        if (updates.weight !== undefined) {
+            setClauses.push(`weight = $${paramIndex++}`);
+            params.push(updates.weight);
+        }
+        if (updates.label !== undefined) {
+            setClauses.push(`label = $${paramIndex++}`);
+            params.push(updates.label);
+        }
+        if (updates.properties !== undefined) {
+            setClauses.push(`properties = $${paramIndex++}`);
+            params.push(updates.properties);
+        }
+        if (updates.confidence !== undefined) {
+            setClauses.push(`confidence = $${paramIndex++}`);
+            params.push(updates.confidence);
+        }
+        if (updates.validFrom !== undefined) {
+            setClauses.push(`valid_from = $${paramIndex++}`);
+            params.push(updates.validFrom);
+        }
+        if (updates.validUntil !== undefined) {
+            setClauses.push(`valid_until = $${paramIndex++}`);
+            params.push(updates.validUntil);
+        }
+        if (updates.metadata !== undefined) {
+            setClauses.push(`metadata = $${paramIndex++}`);
+            params.push(updates.metadata);
+        }
+        params.push(edgeId);
+        const result = await this.pool.query(`UPDATE ${this.schema}.graph_edges SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
+        if (result.rows.length === 0) {
+            return this.failure(`Edge not found: ${edgeId}`);
+        }
+        return this.success(this.rowToEdge(result.rows[0]));
+    }
+    async deleteEdge(edgeId) {
+        await this.initialize();
+        await this.pool.query(`DELETE FROM ${this.schema}.graph_edges WHERE id = $1`, [edgeId]);
+        return this.success(undefined);
+    }
+    async queryEdges(query) {
+        await this.initialize();
+        let sql = `SELECT * FROM ${this.schema}.graph_edges WHERE agent_id = $1`;
+        const params = [query.agentId];
+        let paramIndex = 2;
+        if (query.sourceNodeId) {
+            sql += ` AND source_node_id = $${paramIndex++}`;
+            params.push(query.sourceNodeId);
+        }
+        if (query.targetNodeId) {
+            sql += ` AND target_node_id = $${paramIndex++}`;
+            params.push(query.targetNodeId);
+        }
+        if (query.types && query.types.length > 0) {
+            sql += ` AND type = ANY($${paramIndex++})`;
+            params.push(query.types);
+        }
+        if (query.minWeight !== undefined) {
+            sql += ` AND weight >= $${paramIndex++}`;
+            params.push(query.minWeight);
+        }
+        if (query.minConfidence !== undefined) {
+            sql += ` AND confidence >= $${paramIndex++}`;
+            params.push(query.minConfidence);
+        }
+        if (query.bidirectionalOnly) {
+            sql += ' AND bidirectional = TRUE';
+        }
+        sql += ' ORDER BY weight DESC, confidence DESC';
+        if (query.limit) {
+            sql += ` LIMIT $${paramIndex++}`;
+            params.push(query.limit);
+        }
+        const result = await this.pool.query(sql, params);
+        return this.success(result.rows.map((row) => this.rowToEdge(row)));
+    }
+    async traverse(options) {
+        await this.initialize();
+        const visited = new Set();
+        const visitedEdges = new Set();
+        const paths = [];
+        const allNodes = [];
+        const allEdges = [];
+        const startNodeResult = await this.getNode(options.startNodeId);
+        if (!startNodeResult.success || !startNodeResult.data) {
+            return this.failure(`Start node not found: ${options.startNodeId}`);
+        }
+        const startNode = startNodeResult.data;
+        visited.add(startNode.id);
+        allNodes.push(startNode);
+        await this.traverseRecursive(startNode, [], [], 0, options, visited, visitedEdges, paths, allNodes, allEdges);
+        return this.success({
+            paths,
+            visitedNodes: allNodes,
+            visitedEdges: allEdges,
+            depth: options.maxDepth,
+        });
+    }
+    async traverseRecursive(currentNode, pathNodes, pathEdges, currentDepth, options, visited, visitedEdges, paths, allNodes, allEdges) {
+        if (currentDepth >= options.maxDepth) {
+            if (pathNodes.length > 0) {
+                paths.push({
+                    nodes: [...pathNodes, currentNode],
+                    edges: [...pathEdges],
+                    totalWeight: pathEdges.reduce((sum, e) => sum + e.weight, 0),
+                    length: pathEdges.length,
+                });
+            }
+            return;
+        }
+        if (options.limit && paths.length >= options.limit)
+            return;
+        const neighborsResult = await this.getNeighbors(currentNode.id, options.direction);
+        if (!neighborsResult.success)
+            return;
+        for (const { node, edge } of neighborsResult.data) {
+            if (options.edgeTypes && !options.edgeTypes.includes(edge.type))
+                continue;
+            if (options.minEdgeWeight !== undefined && edge.weight < options.minEdgeWeight)
+                continue;
+            if (options.minConfidence !== undefined && edge.confidence < options.minConfidence)
+                continue;
+            if (!visitedEdges.has(edge.id)) {
+                visitedEdges.add(edge.id);
+                allEdges.push(edge);
+            }
+            if (!visited.has(node.id)) {
+                visited.add(node.id);
+                allNodes.push(node);
+                await this.traverseRecursive(node, [...pathNodes, currentNode], [...pathEdges, edge], currentDepth + 1, options, visited, visitedEdges, paths, allNodes, allEdges);
+            }
+        }
+    }
+    async findShortestPath(agentId, startNodeId, endNodeId, maxDepth = 5) {
+        await this.initialize();
+        const result = await this.pool.query(`
+      WITH RECURSIVE path_search AS (
+        SELECT
+          source_node_id as start_node,
+          target_node_id as end_node,
+          ARRAY[source_node_id, target_node_id] as path,
+          ARRAY[id] as edge_ids,
+          weight as total_weight,
+          1 as depth
+        FROM ${this.schema}.graph_edges
+        WHERE agent_id = $1 AND source_node_id = $2
+
+        UNION ALL
+
+        SELECT
+          ps.start_node,
+          e.target_node_id,
+          ps.path || e.target_node_id,
+          ps.edge_ids || e.id,
+          ps.total_weight + e.weight,
+          ps.depth + 1
+        FROM path_search ps
+        JOIN ${this.schema}.graph_edges e ON e.source_node_id = ps.end_node
+        WHERE e.agent_id = $1
+          AND NOT e.target_node_id = ANY(ps.path)
+          AND ps.depth < $4
+      )
+      SELECT path, edge_ids, total_weight
+      FROM path_search
+      WHERE end_node = $3
+      ORDER BY depth, total_weight
+      LIMIT 1
+      `, [agentId, startNodeId, endNodeId, maxDepth]);
+        if (result.rows.length === 0)
+            return this.success(null);
+        const row = result.rows[0];
+        const nodeIds = row.path;
+        const edgeIds = row.edge_ids;
+        const nodes = [];
+        const edges = [];
+        for (const nodeId of nodeIds) {
+            const nodeResult = await this.getNode(nodeId);
+            if (nodeResult.success && nodeResult.data) {
+                nodes.push(nodeResult.data);
+            }
+        }
+        for (const edgeId of edgeIds) {
+            const edgeResult = await this.getEdge(edgeId);
+            if (edgeResult.success && edgeResult.data) {
+                edges.push(edgeResult.data);
+            }
+        }
+        return this.success({
+            nodes,
+            edges,
+            totalWeight: row.total_weight,
+            length: edges.length,
+        });
+    }
+    async getNeighbors(nodeId, direction = 'both') {
+        await this.initialize();
+        let sql;
+        const params = [nodeId];
+        if (direction === 'outgoing') {
+            sql = `
+        SELECT e.*, n.*,
+          e.id as edge_id, e.agent_id as edge_agent_id, e.type as edge_type,
+          e.source_node_id, e.target_node_id, e.label, e.weight, e.bidirectional,
+          e.properties as edge_properties, e.confidence as edge_confidence,
+          e.source as edge_source, e.valid_from, e.valid_until,
+          e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
+        FROM ${this.schema}.graph_edges e
+        JOIN ${this.schema}.graph_nodes n ON n.id = e.target_node_id
+        WHERE e.source_node_id = $1
+      `;
+        }
+        else if (direction === 'incoming') {
+            sql = `
+        SELECT e.*, n.*,
+          e.id as edge_id, e.agent_id as edge_agent_id, e.type as edge_type,
+          e.source_node_id, e.target_node_id, e.label, e.weight, e.bidirectional,
+          e.properties as edge_properties, e.confidence as edge_confidence,
+          e.source as edge_source, e.valid_from, e.valid_until,
+          e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
+        FROM ${this.schema}.graph_edges e
+        JOIN ${this.schema}.graph_nodes n ON n.id = e.source_node_id
+        WHERE e.target_node_id = $1
+      `;
+        }
+        else {
+            sql = `
+        SELECT e.*, n.*,
+          e.id as edge_id, e.agent_id as edge_agent_id, e.type as edge_type,
+          e.source_node_id, e.target_node_id, e.label, e.weight, e.bidirectional,
+          e.properties as edge_properties, e.confidence as edge_confidence,
+          e.source as edge_source, e.valid_from, e.valid_until,
+          e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
+        FROM ${this.schema}.graph_edges e
+        JOIN ${this.schema}.graph_nodes n ON (
+          (e.source_node_id = $1 AND n.id = e.target_node_id) OR
+          (e.target_node_id = $1 AND n.id = e.source_node_id)
+        )
+        WHERE e.source_node_id = $1 OR e.target_node_id = $1
+      `;
+        }
+        const result = await this.pool.query(sql, params);
+        return this.success(result.rows.map((row) => ({
+            node: this.rowToNode(row),
+            edge: this.rowToEdgeFromJoin(row),
+        })));
+    }
+    async mergeNodes(targetNodeId, sourceNodeIds) {
+        await this.initialize();
+        for (const sourceId of sourceNodeIds) {
+            await this.pool.query(`UPDATE ${this.schema}.graph_edges
+         SET source_node_id = $1 WHERE source_node_id = $2`, [targetNodeId, sourceId]);
+            await this.pool.query(`UPDATE ${this.schema}.graph_edges
+         SET target_node_id = $1 WHERE target_node_id = $2`, [targetNodeId, sourceId]);
+            const sourceNode = await this.getNode(sourceId);
+            if (sourceNode.success && sourceNode.data) {
+                await this.pool.query(`UPDATE ${this.schema}.graph_nodes
+           SET aliases = array_cat(aliases, $1::TEXT[])
+           WHERE id = $2`, [[sourceNode.data.name, ...sourceNode.data.aliases], targetNodeId]);
+            }
+            await this.deleteNode(sourceId);
+        }
+        const mergedNode = await this.getNode(targetNodeId);
+        if (!mergedNode.success || !mergedNode.data) {
+            return this.failure(`Target node not found: ${targetNodeId}`);
+        }
+        return this.success(mergedNode.data);
+    }
+    async clearGraph(agentId) {
+        await this.initialize();
+        await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [agentId]);
+        return this.success(undefined);
+    }
+    async getGraphStats(agentId) {
+        await this.initialize();
+        const nodeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [agentId]);
+        const edgeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1`, [agentId]);
+        const nodesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1 GROUP BY type`, [agentId]);
+        const edgesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1 GROUP BY type`, [agentId]);
+        const nodeCount = parseInt(nodeCountResult.rows[0]?.count ?? '0', 10);
+        const edgeCount = parseInt(edgeCountResult.rows[0]?.count ?? '0', 10);
+        const nodesByType = {};
+        for (const row of nodesByTypeResult.rows) {
+            nodesByType[row.type] = parseInt(row.count, 10);
+        }
+        const edgesByType = {};
+        for (const row of edgesByTypeResult.rows) {
+            edgesByType[row.type] = parseInt(row.count, 10);
+        }
+        return this.success({
+            nodeCount,
+            edgeCount,
+            nodesByType,
+            edgesByType,
+            averageEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
+            maxDepth: 0,
+        });
+    }
+    rowToNode(row, includeEmbedding = false) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            type: row.type,
+            name: row.name,
+            aliases: row.aliases ?? [],
+            description: row.description,
+            properties: row.properties ?? {},
+            embedding: includeEmbedding ? row.embedding : undefined,
+            confidence: row.confidence,
+            source: row.source,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            lastAccessedAt: new Date(row.last_accessed_at),
+            accessCount: row.access_count,
+            metadata: row.metadata,
+        };
+    }
+    rowToEdge(row) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            sourceNodeId: row.source_node_id,
+            targetNodeId: row.target_node_id,
+            type: row.type,
+            label: row.label,
+            weight: row.weight,
+            bidirectional: row.bidirectional,
+            properties: row.properties ?? {},
+            confidence: row.confidence,
+            source: row.source,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+            validFrom: row.valid_from ? new Date(row.valid_from) : undefined,
+            validUntil: row.valid_until ? new Date(row.valid_until) : undefined,
+            metadata: row.metadata,
+        };
+    }
+    rowToEdgeFromJoin(row) {
+        return {
+            id: row.edge_id,
+            agentId: row.edge_agent_id,
+            sourceNodeId: row.source_node_id,
+            targetNodeId: row.target_node_id,
+            type: row.edge_type,
+            label: row.label,
+            weight: row.weight,
+            bidirectional: row.bidirectional,
+            properties: row.edge_properties ?? {},
+            confidence: row.edge_confidence,
+            source: row.edge_source,
+            createdAt: new Date(row.edge_created_at),
+            updatedAt: new Date(row.edge_updated_at),
+            validFrom: row.valid_from ? new Date(row.valid_from) : undefined,
+            validUntil: row.valid_until ? new Date(row.valid_until) : undefined,
+            metadata: row.edge_metadata,
+        };
+    }
+}
+//# sourceMappingURL=graph-adapter.js.map