@bbigbang/core 0.1.0

package/dist/services/memoryService.js

@@ -0,0 +1,386 @@
+import { randomUUID } from 'node:crypto';
+const MEMORY_CATEGORIES = [
+    'project_knowledge',
+    'person',
+    'preference',
+    'decision',
+    'procedure',
+];
+const MEMORY_NODE_STATUSES = ['draft', 'confirmed', 'retired'];
+const MEMORY_EDGE_RELATIONS = [
+    'related_to',
+    'depends_on',
+    'contradicts',
+    'evolved_from',
+];
+const SNIPPET_MAX_CHARS = 200;
+export class MemoryServiceError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function normalizeCategory(value) {
+    const normalized = value.trim();
+    if (!MEMORY_CATEGORIES.includes(normalized)) {
+        throw new MemoryServiceError(400, `Invalid memory category: ${value}`);
+    }
+    return normalized;
+}
+function normalizeStatus(value) {
+    const normalized = value.trim();
+    if (!MEMORY_NODE_STATUSES.includes(normalized)) {
+        throw new MemoryServiceError(400, `Invalid memory status: ${value}`);
+    }
+    return normalized;
+}
+function normalizeRelation(value) {
+    const normalized = value.trim();
+    if (!MEMORY_EDGE_RELATIONS.includes(normalized)) {
+        throw new MemoryServiceError(400, `Invalid memory relation: ${value}`);
+    }
+    return normalized;
+}
+function clampImportance(value) {
+    if (!Number.isFinite(value))
+        return 0.5;
+    return Math.min(1, Math.max(0, value));
+}
+function clampStrength(value) {
+    return clampImportance(value);
+}
+function parseSourceRefs(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return undefined;
+        const refs = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const messageId = typeof item.messageId === 'string'
+                ? item.messageId.trim()
+                : '';
+            const snippet = typeof item.snippet === 'string'
+                ? item.snippet.trim().slice(0, SNIPPET_MAX_CHARS)
+                : '';
+            if (!messageId || !snippet)
+                continue;
+            refs.push({ messageId, snippet });
+        }
+        return refs.length > 0 ? refs : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function serializeSourceRefs(refs) {
+    if (!refs || refs.length === 0)
+        return null;
+    return JSON.stringify(refs.map((ref) => ({
+        messageId: ref.messageId,
+        snippet: ref.snippet.slice(0, SNIPPET_MAX_CHARS),
+    })));
+}
+function rowToNode(row) {
+    const sourceRefs = parseSourceRefs(row.sourceRefsJson);
+    return {
+        nodeId: row.nodeId,
+        agentId: row.agentId,
+        topic: row.topic,
+        summary: row.summary,
+        category: normalizeCategory(row.category),
+        importance: row.importance,
+        ...(sourceRefs ? { sourceRefs } : {}),
+        status: normalizeStatus(row.status),
+        firstSeenAt: row.firstSeenAt,
+        lastReinforcedAt: row.lastReinforcedAt,
+        ...(row.retiredAt != null ? { retiredAt: row.retiredAt } : {}),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function rowToEdge(row) {
+    return {
+        edgeId: row.edgeId,
+        agentId: row.agentId,
+        sourceNodeId: row.sourceNodeId,
+        targetNodeId: row.targetNodeId,
+        relation: normalizeRelation(row.relation),
+        strength: row.strength,
+        createdAt: row.createdAt,
+    };
+}
+export function countAgentMessagesSinceSeq(db, agentId, sinceSeq) {
+    const row = db.prepare(`SELECT COUNT(*) as count
+       FROM channel_messages cm
+       JOIN agent_channel_memberships m ON m.channel_id = cm.channel_id
+      WHERE m.agent_id = ?
+        AND cm.deleted_at IS NULL
+        AND cm.seq > COALESCE(?, 0)`).get(agentId, sinceSeq ?? 0);
+    return row.count;
+}
+export function listAgentMessagesSinceSeq(db, agentId, sinceSeq, limit = 200) {
+    const safeLimit = Math.max(1, Math.min(Math.floor(limit), 500));
+    return db.prepare(`SELECT cm.message_id as messageId,
+            cm.seq as seq,
+            cm.sender_name as senderName,
+            cm.sender_type as senderType,
+            cm.content as content,
+            cm.created_at as createdAt
+       FROM channel_messages cm
+       JOIN agent_channel_memberships m ON m.channel_id = cm.channel_id
+      WHERE m.agent_id = ?
+        AND cm.deleted_at IS NULL
+        AND cm.seq > COALESCE(?, 0)
+      ORDER BY cm.seq ASC
+      LIMIT ?`).all(agentId, sinceSeq ?? 0, safeLimit);
+}
+export function buildDreamContextText(messages) {
+    if (messages.length === 0)
+        return null;
+    return messages.map((message) => (`[seq=${message.seq} id=${message.messageId}] ${message.senderName} (${message.senderType}): ${message.content}`)).join('\n');
+}
+export function getMaxAgentMessageSeq(db, agentId) {
+    const row = db.prepare(`SELECT COALESCE(MAX(cm.seq), 0) as maxSeq
+       FROM channel_messages cm
+       JOIN agent_channel_memberships m ON m.channel_id = cm.channel_id
+      WHERE m.agent_id = ?
+        AND cm.deleted_at IS NULL`).get(agentId);
+    return row.maxSeq;
+}
+function isDreamRunFailure(error, stopReason) {
+    if (error?.trim())
+        return true;
+    if (!stopReason?.trim())
+        return false;
+    const normalized = stopReason.trim().toLowerCase();
+    return normalized.includes('cancel') || normalized === 'error';
+}
+export function createMemoryNode(db, params) {
+    const now = Date.now();
+    const nodeId = randomUUID();
+    const topic = params.topic.trim();
+    const summary = params.summary.trim();
+    if (!topic || !summary) {
+        throw new MemoryServiceError(400, 'topic and summary are required');
+    }
+    const category = normalizeCategory(params.category);
+    const status = params.status ? normalizeStatus(params.status) : 'draft';
+    const importance = clampImportance(params.importance ?? 0.5);
+    const sourceRefs = params.sourceRefs
+        ?? (params.sourceMessageId && params.sourceSnippet
+            ? [{ messageId: params.sourceMessageId, snippet: params.sourceSnippet.slice(0, SNIPPET_MAX_CHARS) }]
+            : undefined);
+    db.prepare(`INSERT INTO memory_nodes(
+       node_id, agent_id, topic, summary, category, importance, source_refs, status,
+       first_seen_at, last_reinforced_at, retired_at, created_at, updated_at
+     ) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(nodeId, params.agentId, topic, summary, category, importance, serializeSourceRefs(sourceRefs), status, now, now, now, now);
+    return rowToNode(db.prepare(`SELECT node_id as nodeId, agent_id as agentId, topic, summary, category, importance,
+            source_refs as sourceRefsJson, status,
+            first_seen_at as firstSeenAt, last_reinforced_at as lastReinforcedAt,
+            retired_at as retiredAt, created_at as createdAt, updated_at as updatedAt
+       FROM memory_nodes
+      WHERE node_id = ?`).get(nodeId));
+}
+export function listMemoryNodes(db, params) {
+    const filters = ['agent_id = ?'];
+    const values = [params.agentId];
+    if (params.category) {
+        filters.push('category = ?');
+        values.push(normalizeCategory(params.category));
+    }
+    if (params.status) {
+        filters.push('status = ?');
+        values.push(normalizeStatus(params.status));
+    }
+    if (params.since != null) {
+        filters.push('updated_at >= ?');
+        values.push(params.since);
+    }
+    if (params.query?.trim()) {
+        filters.push('(topic LIKE ? OR summary LIKE ?)');
+        const pattern = `%${params.query.trim()}%`;
+        values.push(pattern, pattern);
+    }
+    const rows = db.prepare(`SELECT node_id as nodeId, agent_id as agentId, topic, summary, category, importance,
+            source_refs as sourceRefsJson, status,
+            first_seen_at as firstSeenAt, last_reinforced_at as lastReinforcedAt,
+            retired_at as retiredAt, created_at as createdAt, updated_at as updatedAt
+       FROM memory_nodes
+      WHERE ${filters.join(' AND ')}
+      ORDER BY importance DESC, last_reinforced_at DESC`).all(...values);
+    return rows.map(rowToNode);
+}
+export function getMemoryNode(db, agentId, nodeId) {
+    const row = db.prepare(`SELECT node_id as nodeId, agent_id as agentId, topic, summary, category, importance,
+            source_refs as sourceRefsJson, status,
+            first_seen_at as firstSeenAt, last_reinforced_at as lastReinforcedAt,
+            retired_at as retiredAt, created_at as createdAt, updated_at as updatedAt
+       FROM memory_nodes
+      WHERE node_id = ? AND agent_id = ?`).get(nodeId, agentId);
+    return row ? rowToNode(row) : null;
+}
+export function updateMemoryNode(db, agentId, nodeId, params) {
+    const existing = getMemoryNode(db, agentId, nodeId);
+    if (!existing)
+        throw new MemoryServiceError(404, 'Memory node not found');
+    const now = Date.now();
+    let status = existing.status;
+    let importance = existing.importance;
+    let lastReinforcedAt = existing.lastReinforcedAt;
+    let retiredAt = existing.retiredAt ?? null;
+    if (params.confirm) {
+        status = 'confirmed';
+        retiredAt = null;
+    }
+    if (params.retire) {
+        status = 'retired';
+        retiredAt = now;
+    }
+    if (params.reinforce) {
+        lastReinforcedAt = now;
+        importance = clampImportance(Math.min(1, existing.importance + 0.05));
+        if (status === 'draft')
+            status = 'confirmed';
+    }
+    const topic = params.topic?.trim() || existing.topic;
+    const summary = params.summary?.trim() || existing.summary;
+    if (params.importance != null) {
+        importance = clampImportance(params.importance);
+    }
+    db.prepare(`UPDATE memory_nodes
+        SET topic = ?, summary = ?, importance = ?, status = ?,
+            last_reinforced_at = ?, retired_at = ?, updated_at = ?
+      WHERE node_id = ? AND agent_id = ?`).run(topic, summary, importance, status, lastReinforcedAt, retiredAt, now, nodeId, agentId);
+    return getMemoryNode(db, agentId, nodeId);
+}
+export function deleteMemoryNode(db, agentId, nodeId) {
+    const result = db.prepare(`DELETE FROM memory_nodes WHERE node_id = ? AND agent_id = ?`).run(nodeId, agentId);
+    return result.changes > 0;
+}
+export function createMemoryEdge(db, params) {
+    const source = getMemoryNode(db, params.agentId, params.sourceNodeId);
+    const target = getMemoryNode(db, params.agentId, params.targetNodeId);
+    if (!source || !target)
+        throw new MemoryServiceError(404, 'Memory node not found');
+    const relation = normalizeRelation(params.relation);
+    const existing = db.prepare(`SELECT edge_id as edgeId FROM memory_edges
+      WHERE agent_id = ?
+        AND source_node_id = ?
+        AND target_node_id = ?
+        AND relation = ?`).get(params.agentId, params.sourceNodeId, params.targetNodeId, relation);
+    if (existing)
+        throw new MemoryServiceError(409, 'Memory edge already exists');
+    const edgeId = randomUUID();
+    const now = Date.now();
+    db.prepare(`INSERT INTO memory_edges(edge_id, agent_id, source_node_id, target_node_id, relation, strength, created_at)
+     VALUES(?, ?, ?, ?, ?, ?, ?)`).run(edgeId, params.agentId, params.sourceNodeId, params.targetNodeId, relation, clampStrength(params.strength ?? 0.5), now);
+    return rowToEdge(db.prepare(`SELECT edge_id as edgeId, agent_id as agentId, source_node_id as sourceNodeId,
+            target_node_id as targetNodeId, relation, strength, created_at as createdAt
+       FROM memory_edges
+      WHERE edge_id = ?`).get(edgeId));
+}
+export function listMemoryEdges(db, params) {
+    const filters = ['agent_id = ?'];
+    const values = [params.agentId];
+    if (params.nodeId) {
+        filters.push('(source_node_id = ? OR target_node_id = ?)');
+        values.push(params.nodeId, params.nodeId);
+    }
+    const rows = db.prepare(`SELECT edge_id as edgeId, agent_id as agentId, source_node_id as sourceNodeId,
+            target_node_id as targetNodeId, relation, strength, created_at as createdAt
+       FROM memory_edges
+      WHERE ${filters.join(' AND ')}
+      ORDER BY created_at DESC`).all(...values);
+    return rows.map(rowToEdge);
+}
+export function deleteMemoryEdge(db, agentId, edgeId) {
+    const result = db.prepare(`DELETE FROM memory_edges WHERE edge_id = ? AND agent_id = ?`).run(edgeId, agentId);
+    return result.changes > 0;
+}
+export function getMemoryGraph(db, agentId) {
+    return {
+        nodes: listMemoryNodes(db, { agentId }),
+        edges: listMemoryEdges(db, { agentId }),
+    };
+}
+export function countDreamMemoryActivitySince(db, agentId, sinceMs) {
+    const nodeRow = db.prepare(`SELECT COUNT(*) as count FROM memory_nodes WHERE agent_id = ? AND updated_at > ?`).get(agentId, sinceMs);
+    const edgeRow = db.prepare(`SELECT COUNT(*) as count FROM memory_edges WHERE agent_id = ? AND created_at > ?`).get(agentId, sinceMs);
+    return (nodeRow.count ?? 0) + (edgeRow.count ?? 0);
+}
+export function updateDreamWatermark(db, agentId, seq, options) {
+    if (!Number.isFinite(seq) || seq < 0) {
+        throw new MemoryServiceError(400, 'seq must be a non-negative number');
+    }
+    const nextSeq = Math.floor(seq);
+    const agent = db.prepare(`SELECT last_dream_seq as lastDreamSeq FROM agents WHERE agent_id = ?`).get(agentId);
+    if (!agent) {
+        throw new MemoryServiceError(404, 'Agent not found');
+    }
+    if (agent.lastDreamSeq != null && nextSeq < agent.lastDreamSeq) {
+        throw new MemoryServiceError(409, 'dream-watermark cannot move backwards');
+    }
+    if (options?.requireMemoryActivitySince != null) {
+        const activity = countDreamMemoryActivitySince(db, agentId, options.requireMemoryActivitySince);
+        if (activity <= 0) {
+            throw new MemoryServiceError(400, 'dream-watermark requires at least one bigbang memory node or edge write in this dream run');
+        }
+    }
+    const now = Date.now();
+    const result = db.prepare(`UPDATE agents SET last_dream_seq = ?, updated_at = ? WHERE agent_id = ?`).run(nextSeq, now, agentId);
+    if (result.changes <= 0) {
+        throw new MemoryServiceError(404, 'Agent not found');
+    }
+    return { lastDreamSeq: nextSeq };
+}
+export function markDreamCompleted(db, agentId) {
+    const now = Date.now();
+    db.prepare(`UPDATE agents SET last_dream_at = ?, updated_at = ? WHERE agent_id = ?`).run(now, now, agentId);
+}
+export function finalizeDreamRun(db, agentId, params) {
+    if (isDreamRunFailure(params.error, params.stopReason)) {
+        releaseDreamRunLock(db, agentId);
+        return false;
+    }
+    const agent = db.prepare(`SELECT last_dream_seq as lastDreamSeq FROM agents WHERE agent_id = ?`).get(agentId);
+    if (!agent) {
+        releaseDreamRunLock(db, agentId);
+        return false;
+    }
+    const baseline = params.startSeq ?? 0;
+    if ((agent.lastDreamSeq ?? 0) <= baseline) {
+        releaseDreamRunLock(db, agentId);
+        return false;
+    }
+    const now = Date.now();
+    db.prepare(`UPDATE agents
+        SET last_dream_at = ?, dream_run_in_progress_at = NULL, updated_at = ?
+      WHERE agent_id = ?`).run(now, now, agentId);
+    return true;
+}
+export function claimDreamRunLock(db, agentId, now = Date.now(), ttlMs = 30 * 60 * 1000) {
+    const staleBefore = now - ttlMs;
+    const result = db.prepare(`UPDATE agents
+        SET dream_run_in_progress_at = ?, updated_at = ?
+      WHERE agent_id = ?
+        AND (dream_run_in_progress_at IS NULL OR dream_run_in_progress_at < ?)`).run(now, now, agentId, staleBefore);
+    return result.changes > 0;
+}
+export function releaseDreamRunLock(db, agentId) {
+    const now = Date.now();
+    db.prepare(`UPDATE agents
+        SET dream_run_in_progress_at = NULL, updated_at = ?
+      WHERE agent_id = ?`).run(now, agentId);
+}
+export function getDreamAgentState(db, agentId) {
+    const row = db.prepare(`SELECT last_dream_seq as lastDreamSeq,
+            dream_run_in_progress_at as dreamRunInProgressAt
+       FROM agents
+      WHERE agent_id = ?`).get(agentId);
+    return row ?? null;
+}