@levalicious/server-memory 0.0.11 → 0.0.12

package/dist/tests/memory-server.test.js

@@ -44,9 +44,10 @@ describe('MCP Memory Server E2E Tests', () => {
             await callTool(client, 'create_entities', {
                 entities: [{ name: 'Alice', entityType: 'Person', observations: ['First'] }]
             });
+            // Exact same entity should be silently skipped
             const result = await callTool(client, 'create_entities', {
                 entities: [
-                    { name: 'Alice', entityType: 'Person', observations: ['Second'] },
+                    { name: 'Alice', entityType: 'Person', observations: ['First'] },
                     { name: 'Bob', entityType: 'Person', observations: ['New'] }
                 ]
             });
@@ -54,6 +55,19 @@ describe('MCP Memory Server E2E Tests', () => {
             expect(result).toHaveLength(1);
             expect(result[0].name).toBe('Bob');
         });
+        it('should error on duplicate name with different data', async () => {
+            await callTool(client, 'create_entities', {
+                entities: [{ name: 'Alice', entityType: 'Person', observations: ['First'] }]
+            });
+            // Same name, different type — should error
+            await expect(callTool(client, 'create_entities', {
+                entities: [{ name: 'Alice', entityType: 'Organization', observations: ['First'] }]
+            })).rejects.toThrow(/already exists/);
+            // Same name, different observations — should error
+            await expect(callTool(client, 'create_entities', {
+                entities: [{ name: 'Alice', entityType: 'Person', observations: ['Different'] }]
+            })).rejects.toThrow(/already exists/);
+        });
         it('should reject entities with more than 2 observations', async () => {
             await expect(callTool(client, 'create_entities', {
                 entities: [{
@@ -257,13 +271,6 @@ describe('MCP Memory Server E2E Tests', () => {
             // A->B and A->C both have from='A' which is in the set
             expect(result.relations.items).toHaveLength(2);
         });
-        it('should open nodes filtered (only internal relations)', async () => {
-            const result = await callTool(client, 'open_nodes_filtered', {
-                names: ['B', 'C']
-            });
-            expect(result.entities.items).toHaveLength(2);
-            expect(result.relations.items).toHaveLength(0); // No relations between B and C
-        });
     });
     describe('Graph Traversal', () => {
         beforeEach(async () => {
@@ -446,15 +453,21 @@ describe('MCP Memory Server E2E Tests', () => {
             const names = strict.items.map(e => e.name).sort();
             expect(names).toEqual(['Island1', 'Island2']);
         });
-        it('should validate graph and report violations', async () => {
-            // Directly write invalid data to test validation
-            const invalidData = [
-                JSON.stringify({ type: 'entity', name: 'Valid', entityType: 'Test', observations: [] }),
-                JSON.stringify({ type: 'relation', from: 'Valid', to: 'Missing', relationType: 'refs' })
-            ].join('\n');
-            await fs.writeFile(memoryFile, invalidData);
+        it('should validate graph and report no violations on clean graph', async () => {
+            // Create a valid graph through the API
+            await callTool(client, 'create_entities', {
+                entities: [
+                    { name: 'Valid', entityType: 'Test', observations: [] },
+                    { name: 'Also_Valid', entityType: 'Test', observations: ['Short obs'] }
+                ]
+            });
+            await callTool(client, 'create_relations', {
+                relations: [{ from: 'Valid', to: 'Also_Valid', relationType: 'refs' }]
+            });
             const result = await callTool(client, 'validate_graph', {});
-            expect(result.missingEntities).toContain('Missing');
+            // Binary store enforces referential integrity — no missing entities possible
+            expect(result.missingEntities).toHaveLength(0);
+            expect(result.observationViolations).toHaveLength(0);
         });
     });
     describe('Sequential Thinking', () => {
@@ -620,12 +633,16 @@ describe('MCP Memory Server E2E Tests', () => {
                     { name: 'Gamma', entityType: 'Letter', observations: ['Third letter'] }
                 ]);
             });
-            it('should preserve insertion order when sortBy is omitted', async () => {
+            it('should use llmrank as default sort when sortBy is omitted', async () => {
                 const result = await callTool(client, 'search_nodes', {
                     query: 'Letter'
                 });
+                // With llmrank default, all entities returned (order varies due to random tiebreak)
                 const names = result.entities.items.map(e => e.name);
-                expect(names).toEqual(['Alpha', 'Beta', 'Gamma']);
+                expect(names).toHaveLength(3);
+                expect(names).toContain('Alpha');
+                expect(names).toContain('Beta');
+                expect(names).toContain('Gamma');
             });
             it('should sort by name ascending', async () => {
                 const result = await callTool(client, 'search_nodes', {
@@ -689,12 +706,16 @@ describe('MCP Memory Server E2E Tests', () => {
                     { name: 'Monkey', entityType: 'Animal', observations: ['Clever'] }
                 ]);
             });
-            it('should preserve insertion order when sortBy is omitted', async () => {
+            it('should use llmrank as default sort when sortBy is omitted', async () => {
                 const result = await callTool(client, 'get_entities_by_type', {
                     entityType: 'Animal'
                 });
+                // With llmrank default, all entities returned (order varies due to random tiebreak)
                 const names = result.items.map(e => e.name);
-                expect(names).toEqual(['Zebra', 'Aardvark', 'Monkey']);
+                expect(names).toHaveLength(3);
+                expect(names).toContain('Zebra');
+                expect(names).toContain('Aardvark');
+                expect(names).toContain('Monkey');
             });
             it('should sort by name ascending (default for name)', async () => {
                 const result = await callTool(client, 'get_entities_by_type', {
@@ -742,10 +763,14 @@ describe('MCP Memory Server E2E Tests', () => {
                     { name: 'Orphan_M', entityType: 'Orphan', observations: ['Isolated'] }
                 ]);
             });
-            it('should preserve insertion order when sortBy is omitted', async () => {
+            it('should use llmrank as default sort when sortBy is omitted', async () => {
                 const result = await callTool(client, 'get_orphaned_entities', {});
+                // With llmrank default, all entities returned (order varies due to random tiebreak)
                 const names = result.items.map(e => e.name);
-                expect(names).toEqual(['Orphan_Z', 'Orphan_A', 'Orphan_M']);
+                expect(names).toHaveLength(3);
+                expect(names).toContain('Orphan_Z');
+                expect(names).toContain('Orphan_A');
+                expect(names).toContain('Orphan_M');
             });
             it('should sort by name ascending', async () => {
                 const result = await callTool(client, 'get_orphaned_entities', {
@@ -807,12 +832,12 @@ describe('MCP Memory Server E2E Tests', () => {
                     ]
                 });
             });
-            it('should return unsorted neighbors when sortBy is omitted', async () => {
+            it('should use llmrank as default sort when sortBy is omitted', async () => {
                 const result = await callTool(client, 'get_neighbors', {
                     entityName: 'Hub'
                 });
+                // With llmrank default, all neighbors returned (order varies due to random tiebreak)
                 expect(result.items).toHaveLength(3);
-                // Just verify all neighbors are present
                 const names = result.items.map(n => n.name);
                 expect(names).toContain('Neighbor_Z');
                 expect(names).toContain('Neighbor_A');
@@ -915,5 +940,91 @@ describe('MCP Memory Server E2E Tests', () => {
                 expect(names).toEqual(sortedNames);
             });
         });
+        describe('pagerank sorting', () => {
+            it('should sort by pagerank (structural rank)', async () => {
+                // Build a star graph: Hub -> A, Hub -> B, Hub -> C
+                // A, B, C are dangling nodes
+                await callTool(client, 'create_entities', {
+                    entities: [
+                        { name: 'Hub', entityType: 'Node', observations: ['Central node'] },
+                        { name: 'LeafA', entityType: 'Node', observations: ['Leaf A'] },
+                        { name: 'LeafB', entityType: 'Node', observations: ['Leaf B'] },
+                        { name: 'LeafC', entityType: 'Node', observations: ['Leaf C'] },
+                    ]
+                });
+                await callTool(client, 'create_relations', {
+                    relations: [
+                        { from: 'Hub', to: 'LeafA', relationType: 'LINKS' },
+                        { from: 'Hub', to: 'LeafB', relationType: 'LINKS' },
+                        { from: 'Hub', to: 'LeafC', relationType: 'LINKS' },
+                    ]
+                });
+                // Sort by pagerank descending (default for ranks)
+                const result = await callTool(client, 'search_nodes', {
+                    query: 'Node',
+                    sortBy: 'pagerank'
+                });
+                // All entities should be returned
+                expect(result.entities.items).toHaveLength(4);
+                // With structural rank, the leaves should rank higher than the hub
+                // because they receive visits from Hub's walks.
+                // We just verify the sort works and returns all entities.
+                const names = result.entities.items.map(e => e.name);
+                expect(names).toContain('Hub');
+                expect(names).toContain('LeafA');
+                expect(names).toContain('LeafB');
+                expect(names).toContain('LeafC');
+            });
+        });
+        describe('llmrank sorting', () => {
+            it('should sort by llmrank (walker visits)', async () => {
+                await callTool(client, 'create_entities', {
+                    entities: [
+                        { name: 'Hot', entityType: 'Test', observations: ['Frequently accessed'] },
+                        { name: 'Cold', entityType: 'Test', observations: ['Rarely accessed'] },
+                    ]
+                });
+                // Access 'Hot' multiple times via open_nodes (which increments walker visits)
+                await callTool(client, 'open_nodes', { names: ['Hot'] });
+                await callTool(client, 'open_nodes', { names: ['Hot'] });
+                await callTool(client, 'open_nodes', { names: ['Hot'] });
+                await callTool(client, 'open_nodes', { names: ['Hot'] });
+                await callTool(client, 'open_nodes', { names: ['Hot'] });
+                // Access 'Cold' just once
+                await callTool(client, 'open_nodes', { names: ['Cold'] });
+                // Sort by llmrank descending
+                const result = await callTool(client, 'search_nodes', {
+                    query: 'Test',
+                    sortBy: 'llmrank'
+                });
+                // 'Hot' should rank higher than 'Cold' due to more walker visits
+                expect(result.entities.items).toHaveLength(2);
+                expect(result.entities.items[0].name).toBe('Hot');
+                expect(result.entities.items[1].name).toBe('Cold');
+            });
+            it('should fall back to pagerank on llmrank tie', async () => {
+                // Create entities with no prior walker visits
+                await callTool(client, 'create_entities', {
+                    entities: [
+                        { name: 'Center', entityType: 'Fallback', observations: ['Hub'] },
+                        { name: 'Spoke', entityType: 'Fallback', observations: ['Leaf'] },
+                    ]
+                });
+                // Create a relation so structural rank differs
+                await callTool(client, 'create_relations', {
+                    relations: [{ from: 'Center', to: 'Spoke', relationType: 'POINTS_TO' }]
+                });
+                // Both have 0 walker visits (tie), so llmrank should fall back to pagerank
+                const result = await callTool(client, 'search_nodes', {
+                    query: 'Fallback',
+                    sortBy: 'llmrank'
+                });
+                // Just verify we get both entities (ordering depends on structural rank + random tiebreak)
+                expect(result.entities.items).toHaveLength(2);
+                const names = result.entities.items.map(e => e.name);
+                expect(names).toContain('Center');
+                expect(names).toContain('Spoke');
+            });
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levalicious/server-memory",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",
@@ -14,13 +14,14 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "node-gyp rebuild && tsc && shx chmod +x dist/*.js",
+    "build:native": "node-gyp rebuild",
     "prepare": "husky && npm run build",
     "watch": "tsc --watch",
     "test": "NODE_OPTIONS='--experimental-vm-modules' jest"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.25.1",
+    "@modelcontextprotocol/sdk": "1.26.0",
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {