memories-lite 0.9.0 → 0.9.2

package/tests/memory.test.ts

@@ -2,6 +2,7 @@
 import { MemoriesLite } from "../src";
 import { MemoryItem, SearchResult } from "../src/types";
 import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
 
 dotenv.config();
 
@@ -9,41 +10,11 @@ jest.setTimeout(30000); // Increase timeout to 30 seconds
 
 describe("Memory Class", () => {
   let memory: MemoriesLite;
-  const userId =
-    Math.random().toString(36).substring(2, 15) +
-    Math.random().toString(36).substring(2, 15);
-
-  const dimension = 768;
+  let userId: string;
 
   beforeEach(async () => {
-    // Initialize with default configuration
-    memory = new MemoriesLite({
-      version: "v1.1",
-      disableHistory: true,
-      embedder: {
-        provider: "openai",
-        config: {
-          dimension,
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "text-embedding-3-small",
-        },
-      },
-      vectorStore: {
-        provider: "lite",
-        config: {
-          dimension,
-          rootPath: ":memory:",
-        },
-      },
-      llm: {
-        provider: "openai",
-        config: {
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "gpt-4.1-mini",
-        },
-      },
-      historyDbPath: ":memory:", // Use in-memory SQLite for tests
-    });
+    // Initialize memory via helper
+    ({ memory, userId } = createTestMemory({}));
     // Reset all memories before each test
     await memory.reset(userId);
   });
@@ -101,7 +72,7 @@ describe("Memory Class", () => {
       expect(typeof result.memory).toBe("string");
     });
 
-    it("should update a memory", async () => {
+    it("should directly update a memory content", async () => {
       // First add a memory
       const addResult = (await memory.capture(
         "I love speaking foreign languages especially Spanish",
@@ -127,23 +98,19 @@ describe("Memory Class", () => {
     it("should update a memory", async () => {
       // First add a memory
       const init = await memory.capture("I love to drink red wine", userId, {});
-      // expect(init.results?.[0]?.id).toBeDefined();
-      const initId = init.results?.[0]?.id;
+      expect(init.results?.[0]?.id).toBeDefined();
       const addResult = (await memory.capture("I love to drink red wine with friends", userId, {})) as SearchResult;
       expect(addResult.results?.[0]?.id).toBeDefined();
 
-      const memoryId = addResult.results[0].id;
-      expect(memoryId).toBe(initId);
-      // Delete the memory
-      await memory.delete(memoryId, userId);
+      const updated = (await memory.get(addResult.results[0].id, userId))!;
 
-      // Try to get the deleted memory - should throw or return null
-      const result = await memory.get(memoryId, userId);
-      expect(result).toBeNull();
+      expect(updated).toBeDefined();
+      expect(updated.id).toBe(init.results[0].id);
+      expect(updated.type).toBe(init.results[0].type);
     });
 
 
-    it("should get all memories for distinct users", async () => {
+    it.only("should get all memories for distinct users", async () => {
       // Add a few memories
       await memory.capture("I love visiting new places in the winters", userId, {});
       await memory.capture("I like to rule the world", userId, {});
@@ -350,42 +317,17 @@ describe("Memory Class", () => {
 
   describe("Memory with Custom Configuration", () => {
     let customMemory: MemoriesLite;
-
-    beforeEach(() => {
-      customMemory = new MemoriesLite({
-        version: "v1.1",
-        disableHistory: true,
-        embedder: {
-          provider: "openai",
-          config: {
-            dimension,
-            apiKey: process.env.OPENAI_API_KEY || "",
-            model: "text-embedding-3-small",
-          },
-        },
-        vectorStore: {
-          provider: "lite",
-          config: {
-            dimension,
-            rootPath: ":memory:",
-          },
-        },
-        llm: {
-          provider: "openai",
-          config: {
-            apiKey: process.env.OPENAI_API_KEY || "",
-            model: "gpt-4.1-mini",
-          },
-        },
-        historyDbPath: ":memory:", // Use in-memory SQLite for tests
-      });
+    beforeEach(async () => {
+      // Initialize customMemory via helper
+      ({ memory: customMemory, userId } = createTestMemory({}));
+      // Reset before custom tests
+      await customMemory.reset(userId);
     });
 
     afterEach(async () => {
       await customMemory.reset(userId);
     });
 
-
     it("should perform semantic search with custom embeddings", async () => {
       // Add test memories
       await customMemory.capture("The weather in London is rainy today", userId, {});

package/tests/memory.update.test.ts

@@ -0,0 +1,150 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import { MemoryItem, SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000); // Increase timeout to 30 seconds
+
+describe("Memory Updates - Type Preservation", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  beforeEach(async () => {
+    // Initialize memory via helper
+    ({ memory, userId } = createTestMemory({}));
+    // Reset all memories before each test
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    // Clean up after each test
+    await memory.reset(userId);
+  });
+
+  describe("Memory Type Preservation During Updates", () => {
+    it("should preserve memory type when updating content", async () => {
+      // Add a factual memory
+      const factResult = (await memory.capture(
+        "I am allergic to peanuts",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(factResult.results.length).toBeGreaterThan(0);
+      expect(factResult.results[0]?.type).toBe("factual");
+      
+      const factId = factResult.results[0].id;
+      
+      // Update the factual memory
+      await memory.update(factId, "I am severely allergic to peanuts and tree nuts", userId);
+      
+      // Verify type preservation
+      const updatedFact = await memory.get(factId, userId);
+      expect(updatedFact).not.toBeNull();
+      expect(updatedFact?.type).toBe("factual");
+      expect(updatedFact?.memory).toBe("I am severely allergic to peanuts and tree nuts");
+    });
+
+    it("should preserve assistant_preference type when updating", async () => {
+      // Add a preference memory
+      const prefResult = (await memory.capture(
+        "please respond to me in French",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(prefResult.results.length).toBeGreaterThan(0);
+      expect(prefResult.results[0]?.type).toBe("assistant_preference");
+      
+      const prefId = prefResult.results[0].id;
+      
+      // Update the preference memory
+      await memory.update(prefId, "please respond to me in Spanish", userId);
+      
+      // Verify type preservation
+      const updatedPref = await memory.get(prefId, userId);
+      expect(updatedPref).not.toBeNull();
+      expect(updatedPref?.type).toBe("assistant_preference");
+      expect(updatedPref?.memory).toBe("please respond to me in Spanish");
+    });
+
+    it("should preserve episodic memory type when updating", async () => {
+      // Add an episodic memory
+      const episodicResult = (await memory.capture(
+        "I have a doctor's appointment tomorrow at 2pm",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(episodicResult.results.length).toBeGreaterThan(0);
+      expect(episodicResult.results[0]?.type).toBe("episodic");
+      
+      const episodicId = episodicResult.results[0].id;
+      
+      // Update the episodic memory
+      await memory.update(episodicId, "My doctor's appointment was rescheduled to Friday at 3pm", userId);
+      
+      // Verify type preservation
+      const updatedEpisodic = await memory.get(episodicId, userId);
+      expect(updatedEpisodic).not.toBeNull();
+      expect(updatedEpisodic?.type).toBe("episodic");
+      expect(updatedEpisodic?.memory).toBe("My doctor's appointment was rescheduled to Friday at 3pm");
+    });
+    
+    it.skip("should preserve memory metadata when updating content", async () => {
+      // Mock the vector store to verify metadata is preserved
+      const mockVectorStore = {
+        insert: jest.fn().mockResolvedValue(undefined),
+        search: jest.fn().mockResolvedValue([{
+          id: 'test-id',
+          score: 0.9,
+          metadata: { 
+            type: 'factual',
+            userId,
+            timestamp: Date.now(),
+            custom: 'test-value'
+          },
+          values: []
+        }]),
+        get: jest.fn().mockResolvedValue({
+          id: 'test-id',
+          metadata: { 
+            type: 'factual',
+            userId,
+            timestamp: Date.now(),
+            custom: 'test-value'
+          },
+          values: []
+        }),
+        update: jest.fn().mockResolvedValue(undefined),
+        list: jest.fn(),
+        delete: jest.fn(),
+        deleteCol: jest.fn(),
+        ensureCollection: jest.fn(),
+      };
+      
+      // Mock the getVectorStore method to return our mock
+      jest.spyOn(memory, 'getVectorStore').mockResolvedValue(mockVectorStore as any);
+      
+      // Perform an update
+      await memory.update('test-id', 'Updated content', userId);
+      
+      // Verify mockVectorStore.update was called with metadata preserved
+      expect(mockVectorStore.update).toHaveBeenCalled();
+      const updateArgs = mockVectorStore.update.mock.calls[0];
+      
+      // Verify the ID and content are correct
+      expect(updateArgs[0]).toBe('test-id'); // ID
+      
+      // Verify that metadata is passed and preserved in the update call
+      const metadataArg = updateArgs[2];
+      expect(metadataArg).toBeDefined();
+      expect(metadataArg.type).toBe('factual');
+      expect(metadataArg.userId).toBe(userId);
+      expect(metadataArg.custom).toBe('test-value');
+    });
+  });
+}); 

package/tests/memory.users.test.ts

@@ -0,0 +1,235 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import { SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000); // Increase timeout to 30 seconds
+
+describe("MemoriesLite - User Separation Tests", () => {
+  let memory: MemoriesLite;
+  let userAlice: string;
+  let userBob: string;
+  
+
+  beforeEach(async () => {
+    // Initialize a single memory instance that will be shared by both users
+    ({ memory } = createTestMemory({rootPath: process.cwd(), secure: true}));
+    
+    // Create a second userId
+    userAlice = `alice-1`;
+    userBob = `bob-2`;
+    
+    // Reset all memories before each test
+    await memory.reset(userAlice);
+    await memory.reset(userBob);
+  });
+
+  afterEach(async () => {
+    // Clean up after each test
+    await memory.reset(userAlice);
+    await memory.reset(userBob);
+  });
+
+  describe("Basic User Separation", () => {
+    it("should keep memories separate between users", async () => {
+      // Add a memory for user 1
+      const memory1 = "My name is Alice and I love hiking";
+      const result1 = (await memory.capture(memory1, userAlice, {})) as SearchResult;
+      expect(result1.results.length).toBeGreaterThanOrEqual(1);
+
+      // Get all memories for user 1
+      const allbob = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allbob.results.length).toBe(0);
+      
+      // Add a different memory for user 2
+      const memory2 = "My name is Bob and I enjoy swimming";
+      const result2 = (await memory.capture(memory2, userBob, {})) as SearchResult;
+      expect(result2.results.length).toBeGreaterThanOrEqual(1);
+      
+      // Get all memories for user 1
+      const allMemories1 = (await memory.getAll(userAlice, {})) as SearchResult;
+      expect(allMemories1.results.length).toBeGreaterThanOrEqual(1);;
+      
+      // Get all memories for user 2
+      const allMemories2 = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allMemories2.results.length).toBeGreaterThanOrEqual(1);
+      
+      // Verify user 1 can only see their own memories
+      const containsAlice = allMemories1.results.some(item => 
+        item.memory.includes("Alice") || item.memory.includes("hiking"));
+      const containsBob = allMemories1.results.some(item => 
+        item.memory.includes("Bob") || item.memory.includes("swimming"));
+      
+      expect(containsAlice).toBe(true);
+      expect(containsBob).toBe(false);
+      
+      // Verify user 2 can only see their own memories
+      const user2ContainsAlice = allMemories2.results.some(item => 
+        item.memory.includes("Alice") || item.memory.includes("hiking"));
+      const user2ContainsBob = allMemories2.results.some(item => 
+        item.memory.includes("Bob") || item.memory.includes("swimming"));
+      
+      expect(user2ContainsAlice).toBe(false);
+      expect(user2ContainsBob).toBe(true);
+    });
+
+    it("should not allow cross-user memory access", async () => {
+      // Add a memory for user 1
+      const result1 = (await memory.capture(
+        "I prefer to be called Alex instead of Alexander",
+        userAlice,
+        {},
+      )) as SearchResult;
+      
+      expect(result1.results.length).toBe(1);
+      const memoryId = result1.results[0].id;
+      
+      // User 1 can access their memory
+      const memoryForUser1 = await memory.get(memoryId, userAlice);
+      expect(memoryForUser1).not.toBeNull();
+      
+      // User 2 cannot access user 1's memory
+      const memoryForUser2 = await memory.get(memoryId, userBob);
+      expect(memoryForUser2).toBeNull();
+
+      const allMemories2 = (await memory.getAll(userBob, {})) as SearchResult;
+      expect(allMemories2.results.length).toBe(0);
+
+    });
+  });
+
+  describe("Memory Operations Across Users", () => {
+    it("should keep retrieve results separate between users", async () => {
+      // Add similar memories for both users
+      await memory.capture("I live in Paris and love French cuisine", userAlice, {});
+      await memory.capture("I live in Lyon and enjoy French wine", userBob, {});
+      
+      // Search for "France" for both users
+      const results1 = (await memory.retrieve("Where do you live?", userAlice, {})) as SearchResult;
+      const results2 = (await memory.retrieve("France et Lyon", userBob, {})) as SearchResult;
+      
+      // Verify that user 1 only sees their Paris memory
+      const containsParis = results1.results.some(item => item.memory.includes("Paris"));
+      const containsLyon = results1.results.some(item => item.memory.includes("Lyon"));
+      
+      expect(containsParis).toBe(true);
+      expect(containsLyon).toBe(false);
+      
+      // Verify that user 2 only sees their Lyon memory
+      const user2ContainsParis = results2.results.some(item => item.memory.includes("Paris"));
+      const user2ContainsLyon = results2.results.some(item => item.memory.includes("Lyon"));
+      
+      expect(user2ContainsParis).toBe(false);
+      expect(user2ContainsLyon).toBe(true);
+    });
+
+    it("should maintain user separation during updates", async () => {
+      // Add identical memories for both users
+      const result1 = (await memory.capture("My favorite color is blue", userAlice, {})) as SearchResult;
+      const result2 = (await memory.capture("My favorite color is blue", userBob, {})) as SearchResult;
+      
+      const memoryId1 = result1.results[0].id;
+      const memoryId2 = result2.results[0].id;
+      
+      // Update user 1's memory
+      await memory.update(memoryId1, "My favorite color is green", userAlice);
+      
+      // Verify user 1's memory was updated
+      const updatedMemory1 = await memory.get(memoryId1, userAlice);
+      expect(updatedMemory1?.memory).toBe("My favorite color is green");
+      
+      // Verify user 2's memory was NOT updated
+      const memory2 = await memory.get(memoryId2, userBob);
+      expect(memory2?.memory).toContain("blue");
+    });
+
+    it("should maintain user separation during deletes", async () => {
+      // Add identical memories for both users
+      const result1 = (await memory.capture("I enjoy playing tennis", userAlice, {})) as SearchResult;
+      const result2 = (await memory.capture("I enjoy playing tennis", userBob, {})) as SearchResult;
+      
+      const memoryId1 = result1.results[0].id;
+      const memoryId2 = result2.results[0].id;
+      
+      // Delete user 1's memory
+      await memory.delete(memoryId1, userAlice);
+      
+      // Verify user 1's memory was deleted
+      const memory1 = await memory.get(memoryId1, userAlice);
+      expect(memory1).toBeNull();
+      
+      // Verify user 2's memory still exists
+      const memory2 = await memory.get(memoryId2, userBob);
+      expect(memory2).not.toBeNull();
+      expect(memory2?.memory).toBe("I enjoy playing tennis");
+    });
+    
+    it("should reset only the targeted user's memories", async () => {
+      // Add memories for both users
+      await memory.capture("I'm learning to play piano", userAlice, {});
+      await memory.capture("I'm taking guitar lessons", userBob, {});
+      
+      // Reset only user1's memories
+      await memory.reset(userAlice);
+      
+      // Verify user1 has no memories
+      const memories1 = await memory.getAll(userAlice, {});
+      expect(memories1.results.length).toBe(0);
+      
+      // Verify user2 still has memories
+      const memories2 = await memory.getAll(userBob, {});
+      expect(memories2.results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Memory Type Preservation Across Users", () => {
+    it("should preserve memory types distinctly for each user", async () => {
+      // Add memories with specific types for different users
+      const message1 = [
+        {role: "user", content: "Je préfère que tu me tutoies"},
+        {role: "assistant", content: "D'accord, je te tutoierai à partir de maintenant."}
+      ];
+      
+      const message2 = [
+        {role: "user", content: "Je préfère que vous me vouvoyiez"},
+        {role: "assistant", content: "D'accord, je vous vouvoierai à partir de maintenant."}
+      ];
+      
+      // Capture for user 1 (tutoring preference)
+      const result1 = (await memory.capture(message1, userAlice, {})) as SearchResult;
+      expect(result1.results.length).toBeGreaterThan(0);
+      expect(result1.results[0]?.type).toBe("assistant_preference");
+      
+      // Capture for user 2 (formal preference)
+      const result2 = (await memory.capture(message2, userBob, {})) as SearchResult;
+      expect(result2.results.length).toBeGreaterThan(0);
+      expect(result2.results[0]?.type).toBe("assistant_preference");
+      
+      // Retrieve preferences for both users
+      const retrieve1 = await memory.retrieve("How should I address the user?", userAlice, {});
+      const retrieve2 = await memory.retrieve("How should I address the user?", userBob, {});
+      
+      // Verify the correct preferences are returned for each user
+      const user1HasTutoring = retrieve1.results.some(item => 
+        item.memory.toLowerCase().includes("tutoie") || 
+        item.memory.toLowerCase().includes("tutoierai"));
+      
+      const user2HasFormal = retrieve2.results.some(item => 
+        item.memory.toLowerCase().includes("vouvoyiez") || 
+        item.memory.toLowerCase().includes("vouvoierai"));
+      
+      expect(user1HasTutoring).toBe(true);
+      expect(user2HasFormal).toBe(true);
+      
+      // Cross-check: User 1 should not have user 2's preference
+      const user1HasFormal = retrieve1.results.some(item => 
+        item.memory.toLowerCase().includes("vouvoyiez") || 
+        item.memory.toLowerCase().includes("vouvoierai"));
+      
+      expect(user1HasFormal).toBe(false);
+    });
+  });
+});