server-memory-enhanced 2.3.1 → 2.3.2

package/dist/lib/analysis/analytics-service.js

@@ -0,0 +1,111 @@
+/**
+ * Analytics service for thread-specific metrics
+ */
+/**
+ * Calculate recent changes for a thread
+ */
+function calculateRecentChanges(threadEntities) {
+    return threadEntities
+        .map(e => ({
+        entityName: e.name,
+        entityType: e.entityType,
+        lastModified: e.timestamp,
+        changeType: 'created' // Simplified: all are 'created' for now
+    }))
+        .sort((a, b) => b.lastModified.localeCompare(a.lastModified))
+        .slice(0, 10);
+}
+/**
+ * Calculate top important entities for a thread
+ */
+function calculateTopImportant(threadEntities) {
+    return threadEntities
+        .map(e => ({
+        entityName: e.name,
+        entityType: e.entityType,
+        importance: e.importance,
+        observationCount: e.observations.length
+    }))
+        .sort((a, b) => b.importance - a.importance)
+        .slice(0, 10);
+}
+/**
+ * Calculate most connected entities for a thread
+ */
+function calculateMostConnected(threadEntities, entityRelationCounts) {
+    return Array.from(entityRelationCounts.entries())
+        .map(([entityName, connectedSet]) => {
+        const entity = threadEntities.find(e => e.name === entityName);
+        return {
+            entityName,
+            entityType: entity.entityType,
+            relationCount: connectedSet.size,
+            connectedTo: Array.from(connectedSet)
+        };
+    })
+        .sort((a, b) => b.relationCount - a.relationCount)
+        .slice(0, 10);
+}
+/**
+ * Calculate orphaned entities for a thread
+ */
+function calculateOrphanedEntities(threadEntities, threadRelations, entityRelationCounts) {
+    const orphaned_entities = [];
+    const allEntityNames = new Set(threadEntities.map(e => e.name));
+    for (const entity of threadEntities) {
+        const relationCount = entityRelationCounts.get(entity.name)?.size || 0;
+        if (relationCount === 0) {
+            orphaned_entities.push({
+                entityName: entity.name,
+                entityType: entity.entityType,
+                reason: 'no_relations'
+            });
+        }
+        else {
+            // Check for broken relations (pointing to non-existent entities)
+            const entityRelations = threadRelations.filter(r => r.from === entity.name || r.to === entity.name);
+            const hasBrokenRelation = entityRelations.some(r => !allEntityNames.has(r.from) || !allEntityNames.has(r.to));
+            if (hasBrokenRelation) {
+                orphaned_entities.push({
+                    entityName: entity.name,
+                    entityType: entity.entityType,
+                    reason: 'broken_relation'
+                });
+            }
+        }
+    }
+    return orphaned_entities;
+}
+/**
+ * Get analytics for a specific thread (limited to 4 core metrics)
+ */
+export async function getAnalytics(storage, threadId) {
+    const graph = await storage.loadGraph();
+    // Filter to thread-specific data
+    const threadEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    const threadRelations = graph.relations.filter(r => r.agentThreadId === threadId);
+    // Calculate all metrics
+    const recent_changes = calculateRecentChanges(threadEntities);
+    const top_important = calculateTopImportant(threadEntities);
+    // Build the relation counts map once for both most_connected and orphaned_entities
+    const entityRelationCounts = new Map();
+    for (const entity of threadEntities) {
+        entityRelationCounts.set(entity.name, new Set());
+    }
+    for (const relation of threadRelations) {
+        if (entityRelationCounts.has(relation.from)) {
+            entityRelationCounts.get(relation.from).add(relation.to);
+        }
+        if (entityRelationCounts.has(relation.to)) {
+            entityRelationCounts.get(relation.to).add(relation.from);
+        }
+    }
+    const most_connected = calculateMostConnected(threadEntities, entityRelationCounts);
+    const orphaned_entities = calculateOrphanedEntities(threadEntities, threadRelations, entityRelationCounts);
+    return {
+        recent_changes,
+        top_important,
+        most_connected,
+        orphaned_entities
+    };
+}

package/dist/lib/analysis/conflict-detector.js

@@ -0,0 +1,48 @@
+/**
+ * Conflict detection service
+ */
+import { hasNegation, NEGATION_WORDS } from '../utils/negation-detector.js';
+/**
+ * Detect conflicting observations within entities
+ * Identifies potential contradictions by checking for negation patterns
+ */
+export async function detectConflicts(storage) {
+    const graph = await storage.loadGraph();
+    const conflicts = [];
+    for (const entity of graph.entities) {
+        const entityConflicts = [];
+        for (let i = 0; i < entity.observations.length; i++) {
+            for (let j = i + 1; j < entity.observations.length; j++) {
+                const obs1Content = entity.observations[i].content.toLowerCase();
+                const obs2Content = entity.observations[j].content.toLowerCase();
+                // Skip if observations are in the same version chain
+                if (entity.observations[i].supersedes === entity.observations[j].id ||
+                    entity.observations[j].supersedes === entity.observations[i].id ||
+                    entity.observations[i].superseded_by === entity.observations[j].id ||
+                    entity.observations[j].superseded_by === entity.observations[i].id) {
+                    continue;
+                }
+                // Check for negation patterns
+                const obs1HasNegation = hasNegation(obs1Content);
+                const obs2HasNegation = hasNegation(obs2Content);
+                // If one has negation and they share key words, might be a conflict
+                if (obs1HasNegation !== obs2HasNegation) {
+                    const words1 = obs1Content.split(/\s+/).filter(w => w.length > 3);
+                    const words2Set = new Set(obs2Content.split(/\s+/).filter(w => w.length > 3));
+                    const commonWords = words1.filter(w => words2Set.has(w) && !NEGATION_WORDS.has(w));
+                    if (commonWords.length >= 2) {
+                        entityConflicts.push({
+                            obs1: entity.observations[i].content,
+                            obs2: entity.observations[j].content,
+                            reason: 'Potential contradiction with negation'
+                        });
+                    }
+                }
+            }
+        }
+        if (entityConflicts.length > 0) {
+            conflicts.push({ entityName: entity.name, conflicts: entityConflicts });
+        }
+    }
+    return conflicts;
+}

package/dist/lib/analysis/context-builder.js

@@ -0,0 +1,31 @@
+/**
+ * Context builder service
+ */
+/**
+ * Get context (entities related to specified entities up to a certain depth)
+ * Expands to include related entities up to specified depth
+ */
+export async function getContext(storage, entityNames, depth = 1) {
+    const graph = await storage.loadGraph();
+    const contextEntityNames = new Set(entityNames);
+    // Expand to include related entities up to specified depth
+    for (let d = 0; d < depth; d++) {
+        const currentEntities = Array.from(contextEntityNames);
+        for (const entityName of currentEntities) {
+            // Find all relations involving this entity
+            const relatedRelations = graph.relations.filter(r => r.from === entityName || r.to === entityName);
+            // Add related entities
+            relatedRelations.forEach(r => {
+                contextEntityNames.add(r.from);
+                contextEntityNames.add(r.to);
+            });
+        }
+    }
+    // Get all entities and relations in context
+    const contextEntities = graph.entities.filter(e => contextEntityNames.has(e.name));
+    const contextRelations = graph.relations.filter(r => contextEntityNames.has(r.from) && contextEntityNames.has(r.to));
+    return {
+        entities: contextEntities,
+        relations: contextRelations
+    };
+}

package/dist/lib/analysis/memory-stats.js

@@ -0,0 +1,63 @@
+/**
+ * Memory statistics service
+ */
+/**
+ * Get comprehensive memory statistics
+ */
+export async function getMemoryStats(storage) {
+    const graph = await storage.loadGraph();
+    // Count entity types
+    const entityTypes = {};
+    graph.entities.forEach(e => {
+        entityTypes[e.entityType] = (entityTypes[e.entityType] || 0) + 1;
+    });
+    // Calculate averages
+    const avgConfidence = graph.entities.length > 0
+        ? graph.entities.reduce((sum, e) => sum + e.confidence, 0) / graph.entities.length
+        : 0;
+    const avgImportance = graph.entities.length > 0
+        ? graph.entities.reduce((sum, e) => sum + e.importance, 0) / graph.entities.length
+        : 0;
+    // Count unique threads
+    const threads = new Set([
+        ...graph.entities.map(e => e.agentThreadId),
+        ...graph.relations.map(r => r.agentThreadId)
+    ]);
+    // Recent activity (last 7 days, grouped by day)
+    const now = new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const recentEntities = graph.entities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
+    // Group by day
+    const activityByDay = {};
+    recentEntities.forEach(e => {
+        const day = e.timestamp.substring(0, 10); // YYYY-MM-DD
+        activityByDay[day] = (activityByDay[day] || 0) + 1;
+    });
+    const recentActivity = Object.entries(activityByDay)
+        .map(([timestamp, entityCount]) => ({ timestamp, entityCount }))
+        .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return {
+        entityCount: graph.entities.length,
+        relationCount: graph.relations.length,
+        threadCount: threads.size,
+        entityTypes,
+        avgConfidence,
+        avgImportance,
+        recentActivity
+    };
+}
+/**
+ * Get recent changes since a specific timestamp
+ */
+export async function getRecentChanges(storage, since) {
+    const graph = await storage.loadGraph();
+    const sinceDate = new Date(since);
+    // Only return entities and relations that were actually modified since the specified time
+    const recentEntities = graph.entities.filter(e => new Date(e.timestamp) >= sinceDate);
+    // Only include relations that are recent themselves
+    const recentRelations = graph.relations.filter(r => new Date(r.timestamp) >= sinceDate);
+    return {
+        entities: recentEntities,
+        relations: recentRelations
+    };
+}

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:')));
+}