memo-grafter 0.1.1 → 0.2.0

package/dist/store/postgres-pgvector/GraphStore.js

@@ -0,0 +1,782 @@
+import { randomUUID } from "node:crypto";
+import postgres, {} from "postgres";
+import { cosineSimilarity } from "../../utils/drift/cosineSimilarity.js";
+import { parseVector, toVectorLiteral } from "../../utils/vector/vectorLiteral.js";
+export class PostgresGraphStore {
+    sql;
+    constructor(connectionString) {
+        this.sql = postgres(connectionString, {
+            max: 10,
+            idle_timeout: 30,
+            connect_timeout: 10,
+        });
+    }
+    async initialize() {
+        await this.sql `CREATE EXTENSION IF NOT EXISTS vector`;
+        await this.sql `CREATE EXTENSION IF NOT EXISTS pgcrypto`;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_message_buffer (
+        session_id    TEXT NOT NULL,
+        message_index INT NOT NULL,
+        role          TEXT NOT NULL,
+        content       TEXT NOT NULL,
+        PRIMARY KEY (session_id, message_index)
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_segments (
+        id          TEXT PRIMARY KEY,
+        session_id  TEXT NOT NULL,
+        start_index INT NOT NULL,
+        end_index   INT NOT NULL,
+        topic_order INT NOT NULL,
+        drift_score FLOAT NOT NULL,
+        created_at  TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE (session_id, start_index, end_index)
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_topic_nodes (
+        id            TEXT PRIMARY KEY,
+        session_id    TEXT NOT NULL,
+        segment_id    TEXT NOT NULL REFERENCES mg_segments(id) ON DELETE CASCADE,
+        label         TEXT,
+        summary       TEXT,
+        embedding     vector(1536),
+        message_range INT[],
+        topic_order   INT NOT NULL DEFAULT 0,
+        drift_score   FLOAT NOT NULL DEFAULT 0,
+        agent_color   TEXT,
+        fleet_id      TEXT,
+        agent_id      TEXT,
+        created_at    TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE (segment_id)
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_topic_edges (
+        src_id  TEXT NOT NULL,
+        dst_id  TEXT NOT NULL,
+        weight  FLOAT NOT NULL,
+        type    TEXT NOT NULL,
+        PRIMARY KEY (src_id, dst_id)
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_memory_nodes (
+        id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        segment_id    TEXT NOT NULL REFERENCES mg_segments(id) ON DELETE CASCADE,
+        topic_node_id TEXT NOT NULL REFERENCES mg_topic_nodes(id) ON DELETE CASCADE,
+        agent_id      TEXT,
+        session_id    TEXT NOT NULL,
+        memory_type   TEXT NOT NULL CHECK (memory_type IN ('fact','insight','question','task','reference')),
+        source_type   TEXT NOT NULL DEFAULT 'conversation' CHECK (source_type IN ('conversation','note','document','code')),
+        subject       TEXT NOT NULL,
+        predicate     TEXT NOT NULL,
+        value         TEXT NOT NULL,
+        confidence    FLOAT NOT NULL DEFAULT 1.0,
+        embedding     vector(1536),
+        source_url    TEXT,
+        source_title  TEXT,
+        superseded_by UUID REFERENCES mg_memory_nodes(id),
+        decayed       BOOLEAN NOT NULL DEFAULT FALSE,
+        agent_color   TEXT,
+        fleet_id      TEXT,
+        created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_memory_edges (
+        id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        source_id  UUID NOT NULL REFERENCES mg_memory_nodes(id) ON DELETE CASCADE,
+        target_id  UUID NOT NULL REFERENCES mg_memory_nodes(id) ON DELETE CASCADE,
+        edge_type  TEXT NOT NULL CHECK (edge_type IN ('semantic','conflicts','updates','related')),
+        weight     FLOAT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_fleets (
+        id         TEXT PRIMARY KEY,
+        name       TEXT,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS mg_fleet_agents (
+        id          TEXT PRIMARY KEY,
+        fleet_id    TEXT NOT NULL REFERENCES mg_fleets(id) ON DELETE CASCADE,
+        session_id  TEXT NOT NULL,
+        agent_color TEXT NOT NULL,
+        created_at  TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE (fleet_id, agent_color)
+      )
+    `;
+        await this.migrateExistingNodeTable();
+        await this.createIndexes();
+    }
+    async saveMessages(sessionId, messages) {
+        await this.saveMessagesAt(sessionId, 0, messages);
+    }
+    async saveMessagesAt(sessionId, startIndex, messages) {
+        for (const [index, message] of messages.entries()) {
+            await this.sql `
+        INSERT INTO mg_message_buffer (session_id, message_index, role, content)
+        VALUES (${sessionId}, ${startIndex + index}, ${message.role}, ${message.content})
+        ON CONFLICT (session_id, message_index)
+        DO UPDATE SET role = EXCLUDED.role, content = EXCLUDED.content
+      `;
+        }
+    }
+    async saveSegment(segment) {
+        const rows = await this.sql `
+      INSERT INTO mg_segments (id, session_id, start_index, end_index, topic_order, drift_score, created_at)
+      VALUES (
+        ${segment.id},
+        ${segment.sessionId},
+        ${segment.startIndex},
+        ${segment.endIndex},
+        ${segment.topicOrder},
+        ${segment.driftScore},
+        ${segment.createdAt}
+      )
+      ON CONFLICT (session_id, start_index, end_index)
+      DO UPDATE SET
+        topic_order = EXCLUDED.topic_order,
+        drift_score = EXCLUDED.drift_score
+      RETURNING *
+    `;
+        return this.rowToSegment(rows[0]);
+    }
+    async saveNode(node) {
+        await this.sql `
+      INSERT INTO mg_topic_nodes (
+        id,
+        session_id,
+        segment_id,
+        label,
+        summary,
+        embedding,
+        message_range,
+        topic_order,
+        drift_score,
+        agent_color,
+        fleet_id,
+        agent_id,
+        created_at
+      )
+      VALUES (
+        ${node.id},
+        ${node.sessionId},
+        ${node.segmentId},
+        ${node.label},
+        ${node.summary},
+        ${toVectorLiteral(node.embedding)}::vector,
+        ${node.messageRange},
+        ${node.topicOrder},
+        ${node.driftScore},
+        ${node.agentColor},
+        ${node.fleetId},
+        ${node.agentId},
+        ${node.createdAt}
+      )
+      ON CONFLICT (segment_id)
+      DO UPDATE SET
+        id = EXCLUDED.id,
+        session_id = EXCLUDED.session_id,
+        label = EXCLUDED.label,
+        summary = EXCLUDED.summary,
+        embedding = EXCLUDED.embedding,
+        message_range = EXCLUDED.message_range,
+        topic_order = EXCLUDED.topic_order,
+        drift_score = EXCLUDED.drift_score,
+        agent_color = EXCLUDED.agent_color,
+        fleet_id = EXCLUDED.fleet_id,
+        agent_id = EXCLUDED.agent_id,
+        created_at = EXCLUDED.created_at
+    `;
+    }
+    async saveEdge(edge) {
+        await this.sql `
+      INSERT INTO mg_topic_edges (src_id, dst_id, weight, type)
+      VALUES (${edge.srcId}, ${edge.dstId}, ${edge.weight}, ${edge.type})
+      ON CONFLICT (src_id, dst_id)
+      DO UPDATE SET weight = EXCLUDED.weight, type = EXCLUDED.type
+    `;
+    }
+    async getEdgesByType(sessionId, type) {
+        const rows = await this.sql `
+      SELECT e.*
+      FROM mg_topic_edges e
+      JOIN mg_topic_nodes n ON n.id = e.src_id
+      WHERE n.session_id = ${sessionId}
+        AND e.type = ${type}
+    `;
+        return rows.map((row) => ({
+            srcId: row.src_id,
+            dstId: row.dst_id,
+            weight: row.weight,
+            type: row.type,
+        }));
+    }
+    async clearSession(sessionId) {
+        const nodeRows = await this.sql `
+      SELECT id FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+    `;
+        const nodeIds = nodeRows.map((row) => row.id);
+        if (nodeIds.length > 0) {
+            await this.sql `
+        DELETE FROM mg_topic_edges
+        WHERE src_id = ANY(${this.sql.array(nodeIds)})
+           OR dst_id = ANY(${this.sql.array(nodeIds)})
+      `;
+        }
+        await this.sql `
+      DELETE FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+    `;
+        await this.sql `
+      DELETE FROM mg_segments
+      WHERE session_id = ${sessionId}
+    `;
+    }
+    async clearSessionGraph(sessionId) {
+        await this.clearSession(sessionId);
+    }
+    async getTopicNode(topicNodeId, sessionId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_topic_nodes
+      WHERE id = ${topicNodeId}
+        ${sessionId ? this.sql `AND session_id = ${sessionId}` : this.sql ``}
+      LIMIT 1
+    `;
+        return rows[0] ? this.rowToNode(rows[0]) : null;
+    }
+    async getNodeBySegment(segmentId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_topic_nodes
+      WHERE segment_id = ${segmentId}
+      LIMIT 1
+    `;
+        return rows[0] ? this.rowToNode(rows[0]) : null;
+    }
+    async getNodesBySession(sessionId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+      ORDER BY topic_order ASC, created_at ASC
+    `;
+        return rows.map((row) => this.rowToNode(row));
+    }
+    async getSegmentsBySession(sessionId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_segments
+      WHERE session_id = ${sessionId}
+      ORDER BY topic_order ASC, created_at ASC
+    `;
+        return rows.map((row) => this.rowToSegment(row));
+    }
+    async insertMemories(nodes) {
+        if (nodes.length === 0)
+            return;
+        const rows = nodes.map((node) => ({
+            id: node.id,
+            segment_id: node.segmentId,
+            topic_node_id: node.topicNodeId,
+            agent_id: node.agentId,
+            session_id: node.sessionId,
+            memory_type: node.memoryType,
+            source_type: node.sourceType,
+            subject: node.subject,
+            predicate: node.predicate,
+            value: node.value,
+            confidence: node.confidence,
+            embedding: toVectorLiteral(node.embedding),
+            source_url: node.sourceUrl,
+            source_title: node.sourceTitle,
+            superseded_by: node.supersededBy,
+            decayed: node.decayed,
+            agent_color: node.agentColor,
+            fleet_id: node.fleetId,
+        }));
+        await this.sql `
+      INSERT INTO mg_memory_nodes ${this.sql(rows, "id", "segment_id", "topic_node_id", "agent_id", "session_id", "memory_type", "source_type", "subject", "predicate", "value", "confidence", "embedding", "source_url", "source_title", "superseded_by", "decayed", "agent_color", "fleet_id")}
+    `;
+    }
+    async getMemoriesBySegment(segmentId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_memory_nodes
+      WHERE segment_id = ${segmentId}
+      ORDER BY created_at ASC
+    `;
+        return rows.map((row) => this.rowToMemoryNode(row));
+    }
+    async getMemoriesByTopic(topicNodeId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_memory_nodes
+      WHERE topic_node_id = ${topicNodeId}
+        AND decayed = false
+        AND superseded_by IS NULL
+      ORDER BY created_at ASC
+    `;
+        return rows.map((row) => this.rowToMemoryNode(row));
+    }
+    async searchMemories(embedding, sessionId, limit, minSimilarity) {
+        const rows = await this.sql `
+      SELECT *, 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) AS similarity
+      FROM mg_memory_nodes
+      WHERE session_id = ${sessionId}
+        AND decayed = false
+        AND superseded_by IS NULL
+        AND 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) >= ${minSimilarity}
+      ORDER BY similarity DESC
+      LIMIT ${limit}
+    `;
+        return rows.map((row) => ({
+            ...this.rowToMemoryNode(row),
+            similarity: row.similarity,
+        }));
+    }
+    async buildMemoryEdges(topicNodeId, sessionId, threshold) {
+        try {
+            const memories = (await this.getMemoriesByTopic(topicNodeId))
+                .filter((memory) => memory.sessionId === sessionId);
+            if (memories.length < 2)
+                return;
+            for (let sourceIndex = 0; sourceIndex < memories.length; sourceIndex += 1) {
+                const source = memories[sourceIndex];
+                if (!source)
+                    continue;
+                for (let targetIndex = sourceIndex + 1; targetIndex < memories.length; targetIndex += 1) {
+                    const target = memories[targetIndex];
+                    if (!target || source.id === target.id)
+                        continue;
+                    const similarity = cosineSimilarity(source.embedding, target.embedding);
+                    if (!Number.isFinite(similarity) || similarity < threshold)
+                        continue;
+                    const existing = await this.sql `
+            SELECT id FROM mg_memory_edges
+            WHERE (source_id = ${source.id}::uuid AND target_id = ${target.id}::uuid)
+               OR (source_id = ${target.id}::uuid AND target_id = ${source.id}::uuid)
+            LIMIT 1
+          `;
+                    if (existing.length > 0)
+                        continue;
+                    await this.sql `
+            INSERT INTO mg_memory_edges (source_id, target_id, edge_type, weight)
+            VALUES (${source.id}::uuid, ${target.id}::uuid, 'semantic', ${similarity})
+          `;
+                }
+            }
+        }
+        catch (error) {
+            console.warn("GraphStore memory edge build warning:", error);
+        }
+    }
+    async getTopKSimilar(nodeId, embedding, sessionId, k) {
+        return this.getSimilarNodes(embedding, sessionId, { k, excludeNodeId: nodeId });
+    }
+    async getSimilarNodes(embedding, sessionId, options = {}) {
+        const rows = await this.sql `
+      SELECT *, 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) AS similarity
+      FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+        ${options.excludeNodeId ? this.sql `AND id != ${options.excludeNodeId}` : this.sql ``}
+        ${options.minSimilarity === undefined ? this.sql `` : this.sql `AND 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) >= ${options.minSimilarity}`}
+      ORDER BY embedding <=> ${toVectorLiteral(embedding)}::vector ASC
+      LIMIT ${options.k ?? 5}
+    `;
+        return rows.map((row) => this.rowToNode(row));
+    }
+    async getSimilarNodesAcrossFleet(fleetId, embedding, options = {}) {
+        const rows = await this.sql `
+      SELECT *, 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) AS similarity
+      FROM mg_topic_nodes
+      WHERE fleet_id = ${fleetId}
+        ${options.agentColor ? this.sql `AND agent_color = ${options.agentColor}` : this.sql ``}
+        ${options.excludeNodeId ? this.sql `AND id != ${options.excludeNodeId}` : this.sql ``}
+        ${options.minSimilarity === undefined ? this.sql `` : this.sql `AND 1 - (embedding <=> ${toVectorLiteral(embedding)}::vector) >= ${options.minSimilarity}`}
+      ORDER BY embedding <=> ${toVectorLiteral(embedding)}::vector ASC
+      LIMIT ${options.k ?? 5}
+    `;
+        return rows.map((row) => this.rowToNode(row));
+    }
+    async getNodesByColor(fleetId, agentColor) {
+        const rows = await this.sql `
+      SELECT * FROM mg_topic_nodes
+      WHERE fleet_id = ${fleetId}
+        AND agent_color = ${agentColor}
+      ORDER BY topic_order ASC, created_at ASC
+    `;
+        return rows.map((row) => this.rowToNode(row));
+    }
+    async saveFleet(fleetId, name) {
+        await this.sql `
+      INSERT INTO mg_fleets (id, name)
+      VALUES (${fleetId}, ${name ?? null})
+      ON CONFLICT (id)
+      DO UPDATE SET name = COALESCE(EXCLUDED.name, mg_fleets.name)
+    `;
+    }
+    async saveFleetAgent(agent) {
+        await this.sql `
+      INSERT INTO mg_fleet_agents (id, fleet_id, session_id, agent_color)
+      VALUES (${agent.id}, ${agent.fleetId}, ${agent.sessionId}, ${agent.agentColor})
+      ON CONFLICT (fleet_id, agent_color)
+      DO UPDATE SET
+        id = EXCLUDED.id,
+        session_id = EXCLUDED.session_id
+    `;
+    }
+    async getFleetAgents(fleetId) {
+        const rows = await this.sql `
+      SELECT * FROM mg_fleet_agents
+      WHERE fleet_id = ${fleetId}
+      ORDER BY created_at ASC
+    `;
+        return rows.map((row) => ({
+            id: row.id,
+            fleetId: row.fleet_id,
+            sessionId: row.session_id,
+            agentColor: row.agent_color,
+            createdAt: row.created_at,
+        }));
+    }
+    async tagSessionNodes(sessionId, metadata) {
+        await this.sql `
+      UPDATE mg_topic_nodes
+      SET
+        fleet_id = ${metadata.fleetId},
+        agent_id = ${metadata.agentId},
+        agent_color = ${metadata.agentColor}
+      WHERE session_id = ${sessionId}
+    `;
+    }
+    async getPreviousNode(sessionId, topicOrder) {
+        const rows = await this.sql `
+      SELECT *
+      FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+        AND topic_order = ${topicOrder - 1}
+      LIMIT 1
+    `;
+        return rows[0] ? this.rowToNode(rows[0]) : null;
+    }
+    async nodeSimilarity(nodeAId, nodeBId) {
+        const rows = await this.sql `
+      SELECT 1 - (n1.embedding <=> n2.embedding) AS similarity
+      FROM mg_topic_nodes n1, mg_topic_nodes n2
+      WHERE n1.id = ${nodeAId}
+        AND n2.id = ${nodeBId}
+    `;
+        return rows[0]?.similarity ?? 0;
+    }
+    async getNeighbours(nodeIds, hopDepth, sessionId) {
+        const visited = new Set(nodeIds);
+        let frontier = [...nodeIds];
+        for (let hop = 0; hop < hopDepth; hop += 1) {
+            if (frontier.length === 0)
+                break;
+            const edges = await this.sql `
+        SELECT * FROM mg_topic_edges
+        WHERE src_id = ANY(${this.sql.array(frontier)})
+           OR dst_id = ANY(${this.sql.array(frontier)})
+      `;
+            const nextFrontier = [];
+            for (const edge of edges) {
+                const candidates = [edge.src_id, edge.dst_id];
+                for (const candidate of candidates) {
+                    if (!visited.has(candidate)) {
+                        visited.add(candidate);
+                        nextFrontier.push(candidate);
+                    }
+                }
+            }
+            frontier = nextFrontier;
+        }
+        const ids = Array.from(visited);
+        if (ids.length === 0)
+            return [];
+        const rows = await this.sql `
+      SELECT * FROM mg_topic_nodes
+      WHERE id = ANY(${this.sql.array(ids)})
+        ${sessionId ? this.sql `AND session_id = ${sessionId}` : this.sql ``}
+      ORDER BY topic_order ASC, created_at ASC
+    `;
+        return rows.map((row) => this.rowToNode(row));
+    }
+    async getBufferMessages(sessionId, start, end, maxChars = 600) {
+        const rows = await this.sql `
+      SELECT * FROM mg_message_buffer
+      WHERE session_id = ${sessionId}
+        AND message_index >= ${start}
+        AND message_index <= ${end}
+      ORDER BY message_index ASC
+    `;
+        return rows.map((row) => ({
+            role: row.role,
+            content: row.role === "assistant" ? this.cleanAssistantMessage(row.content, maxChars) : row.content,
+        }));
+    }
+    async absorbNodes(nodes, targetSessionId, options = {}) {
+        const copiedNodes = [];
+        const nextMessageIndex = await this.getNextMessageIndex(targetSessionId);
+        const nextTopicOrder = await this.getNextTopicOrder(targetSessionId);
+        for (const [index, node] of nodes.entries()) {
+            const messageIndex = nextMessageIndex + index;
+            await this.saveMessagesAt(targetSessionId, messageIndex, [{
+                    role: "assistant",
+                    content: this.formatGraftedMemoryMessage(node),
+                }]);
+            const segment = await this.saveSegment({
+                id: randomUUID(),
+                sessionId: targetSessionId,
+                startIndex: messageIndex,
+                endIndex: messageIndex,
+                topicOrder: nextTopicOrder + index,
+                driftScore: node.driftScore,
+                createdAt: new Date(),
+            });
+            const copy = {
+                ...node,
+                id: randomUUID(),
+                sessionId: targetSessionId,
+                segmentId: segment.id,
+                messageRange: [segment.startIndex, segment.endIndex],
+                topicOrder: segment.topicOrder,
+                driftScore: segment.driftScore,
+                agentColor: options.agentColor ?? node.agentColor,
+                fleetId: options.fleetId ?? node.fleetId,
+                agentId: options.agentId ?? node.agentId,
+                createdAt: new Date(),
+            };
+            await this.saveNode(copy);
+            await this.saveEdge({
+                srcId: copy.id,
+                dstId: node.id,
+                weight: 1,
+                type: "grafted",
+            });
+            copiedNodes.push(copy);
+        }
+        return copiedNodes;
+    }
+    async rebuildEdgesForSession(sessionId, semanticTopK = 5, semanticThreshold = 0.6) {
+        const nodes = await this.getNodesBySession(sessionId);
+        const nodeIds = nodes.map((node) => node.id);
+        if (nodeIds.length > 0) {
+            await this.sql `
+        DELETE FROM mg_topic_edges
+        WHERE type != 'grafted'
+          AND (
+            src_id = ANY(${this.sql.array(nodeIds)})
+            OR dst_id = ANY(${this.sql.array(nodeIds)})
+          )
+      `;
+        }
+        for (let index = 1; index < nodes.length; index += 1) {
+            const current = nodes[index];
+            const previous = nodes[index - 1];
+            if (!current || !previous)
+                continue;
+            await this.saveEdge({
+                srcId: current.id,
+                dstId: previous.id,
+                weight: await this.nodeSimilarity(current.id, previous.id),
+                type: "temporal",
+            });
+        }
+        for (const node of nodes) {
+            const similarNodes = await this.getSimilarNodes(node.embedding, sessionId, {
+                k: semanticTopK,
+                excludeNodeId: node.id,
+                minSimilarity: semanticThreshold,
+            });
+            for (const similarNode of similarNodes) {
+                await this.saveEdge({
+                    srcId: node.id,
+                    dstId: similarNode.id,
+                    weight: await this.nodeSimilarity(node.id, similarNode.id),
+                    type: "semantic",
+                });
+            }
+        }
+    }
+    async close() {
+        await this.sql.end();
+    }
+    async migrateExistingNodeTable() {
+        await this.sql `ALTER TABLE mg_segments DROP COLUMN IF EXISTS node_id`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS segment_id TEXT`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS topic_order INT NOT NULL DEFAULT 0`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS drift_score FLOAT NOT NULL DEFAULT 0`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS agent_color TEXT`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS fleet_id TEXT`;
+        await this.sql `ALTER TABLE mg_topic_nodes ADD COLUMN IF NOT EXISTS agent_id TEXT`;
+        await this.sql `
+      UPDATE mg_topic_nodes n
+      SET
+        topic_order = s.topic_order,
+        drift_score = s.drift_score
+      FROM mg_segments s
+      WHERE s.id = n.segment_id
+    `;
+        await this.sql `
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'mg_topic_nodes_segment_id_key'
+        ) THEN
+          ALTER TABLE mg_topic_nodes
+          ADD CONSTRAINT mg_topic_nodes_segment_id_key UNIQUE (segment_id);
+        END IF;
+      END $$;
+    `;
+    }
+    async createIndexes() {
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_message_buffer_session_idx
+      ON mg_message_buffer(session_id, message_index)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_segments_session_idx
+      ON mg_segments(session_id, topic_order)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_nodes_session_idx
+      ON mg_topic_nodes(session_id, topic_order)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_nodes_fleet_idx
+      ON mg_topic_nodes(fleet_id, agent_color)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_fleet_agents_fleet_idx
+      ON mg_fleet_agents(fleet_id, agent_color)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS mg_nodes_embedding_idx
+      ON mg_topic_nodes
+      USING ivfflat (embedding vector_cosine_ops)
+      WITH (lists = 100)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_nodes_topic
+      ON mg_memory_nodes(topic_node_id)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_nodes_segment
+      ON mg_memory_nodes(segment_id)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_nodes_session
+      ON mg_memory_nodes(session_id)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_nodes_embedding
+      ON mg_memory_nodes
+      USING ivfflat (embedding vector_cosine_ops)
+      WITH (lists = 100)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_edges_source
+      ON mg_memory_edges(source_id)
+    `;
+        await this.sql `
+      CREATE INDEX IF NOT EXISTS idx_memory_edges_target
+      ON mg_memory_edges(target_id)
+    `;
+    }
+    cleanAssistantMessage(content, maxChars) {
+        const withoutCodeBlocks = content.replace(/```[\s\S]*?```/g, "[code omitted]");
+        if (withoutCodeBlocks.length <= maxChars)
+            return withoutCodeBlocks;
+        const truncated = withoutCodeBlocks.slice(0, maxChars);
+        const sentenceEnd = Math.max(truncated.lastIndexOf("."), truncated.lastIndexOf("!"), truncated.lastIndexOf("?"));
+        if (sentenceEnd >= Math.floor(maxChars * 0.5)) {
+            return `${truncated.slice(0, sentenceEnd + 1)} [truncated]`;
+        }
+        return `${truncated.trimEnd()} [truncated]`;
+    }
+    async getNextMessageIndex(sessionId) {
+        const rows = await this.sql `
+      SELECT COALESCE(MAX(message_index) + 1, 0) AS next_index
+      FROM mg_message_buffer
+      WHERE session_id = ${sessionId}
+    `;
+        return rows[0]?.next_index ?? 0;
+    }
+    async getNextTopicOrder(sessionId) {
+        const rows = await this.sql `
+      SELECT COALESCE(MAX(topic_order) + 1, 1) AS next_order
+      FROM mg_topic_nodes
+      WHERE session_id = ${sessionId}
+    `;
+        return rows[0]?.next_order ?? 1;
+    }
+    formatGraftedMemoryMessage(node) {
+        return [
+            `Grafted memory: ${node.label}`,
+            node.summary,
+        ].filter(Boolean).join("\n");
+    }
+    rowToNode(row) {
+        const [start = 0, end = start] = row.message_range ?? [];
+        return {
+            id: row.id,
+            sessionId: row.session_id,
+            segmentId: row.segment_id,
+            label: row.label ?? "Untitled topic",
+            summary: row.summary ?? "",
+            embedding: parseVector(row.embedding),
+            messageRange: [start, end],
+            topicOrder: row.topic_order ?? 0,
+            driftScore: row.drift_score ?? 0,
+            agentColor: row.agent_color,
+            fleetId: row.fleet_id,
+            agentId: row.agent_id,
+            createdAt: row.created_at,
+        };
+    }
+    rowToMemoryNode(row) {
+        return {
+            id: row.id,
+            segmentId: row.segment_id,
+            topicNodeId: row.topic_node_id,
+            agentId: row.agent_id,
+            sessionId: row.session_id,
+            memoryType: row.memory_type,
+            sourceType: row.source_type,
+            subject: row.subject,
+            predicate: row.predicate,
+            value: row.value,
+            confidence: row.confidence,
+            embedding: parseVector(row.embedding),
+            sourceUrl: row.source_url,
+            sourceTitle: row.source_title,
+            supersededBy: row.superseded_by,
+            decayed: row.decayed,
+            agentColor: row.agent_color,
+            fleetId: row.fleet_id,
+            createdAt: row.created_at,
+        };
+    }
+    rowToSegment(row) {
+        if (!row) {
+            throw new Error("Expected segment row.");
+        }
+        return {
+            id: row.id,
+            sessionId: row.session_id,
+            startIndex: row.start_index,
+            endIndex: row.end_index,
+            topicOrder: row.topic_order,
+            driftScore: row.drift_score,
+            createdAt: row.created_at,
+        };
+    }
+}
+//# sourceMappingURL=GraphStore.js.map