server-memory-enhanced 2.3.0 → 2.3.2

package/dist/lib/analysis/path-finder.js

@@ -0,0 +1,77 @@
+/**
+ * Path finding service for the knowledge graph
+ */
+/**
+ * Find the shortest path between two entities in the knowledge graph
+ * Uses BFS algorithm with bidirectional search
+ */
+export async function findRelationPath(storage, from, to, maxDepth = 5) {
+    const graph = await storage.loadGraph();
+    if (from === to) {
+        return { found: true, path: [from], relations: [] };
+    }
+    // Build indexes for efficient relation lookup
+    const relationsFrom = new Map();
+    const relationsTo = new Map();
+    for (const rel of graph.relations) {
+        if (!relationsFrom.has(rel.from)) {
+            relationsFrom.set(rel.from, []);
+        }
+        relationsFrom.get(rel.from).push(rel);
+        if (!relationsTo.has(rel.to)) {
+            relationsTo.set(rel.to, []);
+        }
+        relationsTo.get(rel.to).push(rel);
+    }
+    // BFS to find shortest path
+    const queue = [
+        { entity: from, path: [from], relations: [] }
+    ];
+    const visited = new Set([from]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.path.length > maxDepth) {
+            continue;
+        }
+        // Find all relations connected to current entity (both outgoing and incoming for bidirectional search)
+        const outgoing = relationsFrom.get(current.entity) || [];
+        const incoming = relationsTo.get(current.entity) || [];
+        // Check outgoing relations
+        for (const rel of outgoing) {
+            if (rel.to === to) {
+                return {
+                    found: true,
+                    path: [...current.path, rel.to],
+                    relations: [...current.relations, rel]
+                };
+            }
+            if (!visited.has(rel.to)) {
+                visited.add(rel.to);
+                queue.push({
+                    entity: rel.to,
+                    path: [...current.path, rel.to],
+                    relations: [...current.relations, rel]
+                });
+            }
+        }
+        // Check incoming relations (traverse backwards)
+        for (const rel of incoming) {
+            if (rel.from === to) {
+                return {
+                    found: true,
+                    path: [...current.path, rel.from],
+                    relations: [...current.relations, rel]
+                };
+            }
+            if (!visited.has(rel.from)) {
+                visited.add(rel.from);
+                queue.push({
+                    entity: rel.from,
+                    path: [...current.path, rel.from],
+                    relations: [...current.relations, rel]
+                });
+            }
+        }
+    }
+    return { found: false, path: [], relations: [] };
+}

package/dist/lib/collaboration/conversation-service.js

@@ -0,0 +1,43 @@
+/**
+ * Conversation service (agent threads)
+ */
+/**
+ * List all conversations (agent threads) with summary information
+ */
+export async function listConversations(storage) {
+    const graph = await storage.loadGraph();
+    // Group data by agent thread
+    const threadMap = new Map();
+    // Collect entities by thread
+    for (const entity of graph.entities) {
+        if (!threadMap.has(entity.agentThreadId)) {
+            threadMap.set(entity.agentThreadId, { entities: [], relations: [], timestamps: [] });
+        }
+        const threadData = threadMap.get(entity.agentThreadId);
+        threadData.entities.push(entity);
+        threadData.timestamps.push(entity.timestamp);
+    }
+    // Collect relations by thread
+    for (const relation of graph.relations) {
+        if (!threadMap.has(relation.agentThreadId)) {
+            threadMap.set(relation.agentThreadId, { entities: [], relations: [], timestamps: [] });
+        }
+        const threadData = threadMap.get(relation.agentThreadId);
+        threadData.relations.push(relation);
+        threadData.timestamps.push(relation.timestamp);
+    }
+    // Build conversation summaries
+    const conversations = Array.from(threadMap.entries()).map(([agentThreadId, data]) => {
+        const timestamps = data.timestamps.sort((a, b) => a.localeCompare(b));
+        return {
+            agentThreadId,
+            entityCount: data.entities.length,
+            relationCount: data.relations.length,
+            firstCreated: timestamps[0] || '',
+            lastUpdated: timestamps[timestamps.length - 1] || ''
+        };
+    });
+    // Sort by last updated (most recent first)
+    conversations.sort((a, b) => b.lastUpdated.localeCompare(a.lastUpdated));
+    return { conversations };
+}

package/dist/lib/collaboration/flag-manager.js

@@ -0,0 +1,38 @@
+/**
+ * Collaboration features (flagging, review)
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Flag an entity for review
+ */
+export async function flagForReview(storage, entityName, reason, reviewer) {
+    const graph = await storage.loadGraph();
+    const entity = graph.entities.find(e => e.name === entityName);
+    if (!entity) {
+        throw new Error(`Entity with name ${entityName} not found`);
+    }
+    // Add a special observation to mark for review
+    const flagContent = `[FLAGGED FOR REVIEW: ${reason}${reviewer ? ` - Reviewer: ${reviewer}` : ''}]`;
+    // Check if this flag already exists (by content)
+    if (!entity.observations.some(o => o.content === flagContent)) {
+        const flagObservation = {
+            id: `obs_${randomUUID()}`,
+            content: flagContent,
+            timestamp: new Date().toISOString(),
+            version: 1,
+            agentThreadId: entity.agentThreadId,
+            confidence: 1.0, // Flag observations have full confidence
+            importance: 1.0 // Flag observations are highly important
+        };
+        entity.observations.push(flagObservation);
+        entity.timestamp = new Date().toISOString();
+        await storage.saveGraph(graph);
+    }
+}
+/**
+ * Get all entities flagged for review
+ */
+export async function getFlaggedEntities(storage) {
+    const graph = await storage.loadGraph();
+    return graph.entities.filter(e => e.observations.some(obs => obs.content.includes('[FLAGGED FOR REVIEW:')));
+}

package/dist/lib/jsonl-storage-adapter.js

@@ -240,10 +240,14 @@ export class JsonlStorageAdapter {
      * Serialize thread data to JSONL lines
      */
     serializeThreadData(threadData) {
-        return [
-            ...threadData.entities.map(e => this.serializeEntity(e)),
-            ...threadData.relations.map(r => this.serializeRelation(r))
-        ];
+        const lines = [];
+        for (const e of threadData.entities) {
+            lines.push(this.serializeEntity(e));
+        }
+        for (const r of threadData.relations) {
+            lines.push(this.serializeRelation(r));
+        }
+        return lines;
     }
     /**
      * Save data for a specific thread