@levalicious/server-memory 0.0.10 → 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,44 +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');
-        });
-    });
-    describe('BCL Evaluator', () => {
-        it('should evaluate K combinator (identity for first arg)', async () => {
-            // K = 00, evaluating K applied to two args should return first
-            // This is a simplified test - BCL semantics are complex
-            const result = await callTool(client, 'evaluate_bcl', {
-                program: '00',
-                maxSteps: 100
-            });
-            expect(result.halted).toBe(true);
-        });
-        it('should construct BCL terms incrementally', async () => {
-            let result = await callTool(client, 'add_bcl_term', { term: 'App' });
-            expect(result).toContain('more term');
-            result = await callTool(client, 'add_bcl_term', { term: 'K' });
-            expect(result).toContain('more term');
-            result = await callTool(client, 'add_bcl_term', { term: 'S' });
-            expect(result).toContain('Constructed Program');
-        });
-        it('should clear BCL constructor state', async () => {
-            await callTool(client, 'add_bcl_term', { term: 'App' });
-            await callTool(client, 'clear_bcl_term', {});
-            // After clearing, we should need to start fresh
-            const result = await callTool(client, 'add_bcl_term', { term: 'K' });
-            expect(result).toContain('Constructed Program');
-        });
-        it('should reject invalid BCL terms', async () => {
-            await expect(callTool(client, 'add_bcl_term', { term: 'invalid' })).rejects.toThrow(/Invalid BCL term/);
+            // Binary store enforces referential integrity — no missing entities possible
+            expect(result.missingEntities).toHaveLength(0);
+            expect(result.observationViolations).toHaveLength(0);
         });
     });
     describe('Sequential Thinking', () => {
@@ -541,6 +525,96 @@ describe('MCP Memory Server E2E Tests', () => {
             expect(thought.obsMtime).toBeDefined();
         });
     });
+    describe('Timestamp Decoding', () => {
+        it('should decode a specific timestamp', async () => {
+            const result = await callTool(client, 'decode_timestamp', {
+                timestamp: 1735200000000 // Known timestamp
+            });
+            expect(result.timestamp).toBe(1735200000000);
+            expect(result.iso8601).toBe('2024-12-26T08:00:00.000Z');
+            expect(result.formatted).toContain('2024');
+        });
+        it('should return current time when no timestamp provided', async () => {
+            const before = Date.now();
+            const result = await callTool(client, 'decode_timestamp', {});
+            const after = Date.now();
+            expect(result.timestamp).toBeGreaterThanOrEqual(before);
+            expect(result.timestamp).toBeLessThanOrEqual(after);
+        });
+        it('should include relative time when requested', async () => {
+            const oneHourAgo = Date.now() - 3600000;
+            const result = await callTool(client, 'decode_timestamp', {
+                timestamp: oneHourAgo,
+                relative: true
+            });
+            expect(result.relative).toContain('hour');
+            expect(result.relative).toContain('ago');
+        });
+        it('should handle future timestamps', async () => {
+            const oneHourFromNow = Date.now() + 3600000;
+            const result = await callTool(client, 'decode_timestamp', {
+                timestamp: oneHourFromNow,
+                relative: true
+            });
+            expect(result.relative).toContain('in');
+        });
+    });
+    describe('Random Walk', () => {
+        beforeEach(async () => {
+            // Create a small graph for walking
+            await callTool(client, 'create_entities', {
+                entities: [
+                    { name: 'Center', entityType: 'Node', observations: ['Hub node'] },
+                    { name: 'North', entityType: 'Node', observations: ['North node'] },
+                    { name: 'South', entityType: 'Node', observations: ['South node'] },
+                    { name: 'East', entityType: 'Node', observations: ['East node'] },
+                    { name: 'Isolated', entityType: 'Node', observations: ['No connections'] },
+                ]
+            });
+            await callTool(client, 'create_relations', {
+                relations: [
+                    { from: 'Center', to: 'North', relationType: 'connects' },
+                    { from: 'Center', to: 'South', relationType: 'connects' },
+                    { from: 'Center', to: 'East', relationType: 'connects' },
+                    { from: 'North', to: 'South', relationType: 'connects' },
+                ]
+            });
+        });
+        it('should perform a walk and return path', async () => {
+            const result = await callTool(client, 'random_walk', {
+                start: 'Center',
+                depth: 2
+            });
+            expect(result.path[0]).toBe('Center');
+            expect(result.path.length).toBeGreaterThanOrEqual(1);
+            expect(result.path.length).toBeLessThanOrEqual(3);
+            expect(result.entity).toBe(result.path[result.path.length - 1]);
+        });
+        it('should terminate early at dead ends', async () => {
+            const result = await callTool(client, 'random_walk', {
+                start: 'Isolated',
+                depth: 5
+            });
+            expect(result.path).toEqual(['Isolated']);
+            expect(result.entity).toBe('Isolated');
+        });
+        it('should produce reproducible walks with same seed', async () => {
+            const result1 = await callTool(client, 'random_walk', {
+                start: 'Center',
+                depth: 3,
+                seed: 'test-seed-123'
+            });
+            const result2 = await callTool(client, 'random_walk', {
+                start: 'Center',
+                depth: 3,
+                seed: 'test-seed-123'
+            });
+            expect(result1.path).toEqual(result2.path);
+        });
+        it('should throw on non-existent start entity', async () => {
+            await expect(callTool(client, 'random_walk', { start: 'NonExistent', depth: 2 })).rejects.toThrow(/not found/);
+        });
+    });
     describe('Sorting', () => {
         // Helper to create entities with controlled timestamps
         async function createEntitiesWithDelay(entities) {
@@ -559,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', {
@@ -628,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', {
@@ -681,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', {
@@ -746,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');
@@ -854,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.10",
+  "version": "0.0.12",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",
@@ -14,19 +14,21 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
-    "prepare": "npm run build",
+    "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": {
     "@types/jest": "^30.0.0",
     "@types/node": "^25",
     "@types/proper-lockfile": "^4.1.4",
+    "husky": "^9.1.7",
     "jest": "^30.2.0",
     "shx": "^0.4.0",
     "ts-jest": "^29.4.5",