memories-lite 0.10.1 → 0.99.1

package/tests/memory.discussion.test.ts

@@ -0,0 +1,279 @@
+/// <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(60000); // 60s pour les tests avec LLM
+
+/**
+ * Tests pour le nouveau type de mémoire 'discussion'
+ * Permet de mémoriser une discussion avec synthèse (title + summary)
+ */
+describe("Memory Discussion - Synthèse de discussions", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  //
+  // Exemple de discussion à synthétiser
+  const discussionMessages = [
+    {
+      role: "user",
+      content: "Tu dois vérifier les autorisations (ou APA) de la FAO de Genève, et ensuite tu dois extraire toutes les adresses et chercher nos immeubles. Merci de me mettre les liens des FAO que tu jugeras utiles."
+    },
+    {
+      role: "assistant", 
+      content: `Voici un premier lot traité. Dites-moi si vous voulez que je continue sur plus d'avis.
+
+Adresses extraites et recherche de nos immeubles
+- Chemin Émile-Bressler 19, 1226 Thônex
+  - Immeubles PRSA à proximité (200 m) : aucun trouvé.
+  - FAO: Requête M/341685/1 — Démolition d'une villa
+- Chemin du Port 9, 1246 Corsier
+  - À vérifier (souhaitez-vous que je cherche nos immeubles autour de cette adresse ?)
+  - FAO: Requête M/341714/1 — Démolition
+- Boulevard de Saint‑Georges 46, 1205 Genève (Plainpalais)
+  - À vérifier (je peux lancer la recherche de nos immeubles).
+  - FAO: Autorisation DD 330818 — Transformation`
+    },
+    {
+      role: "user",
+      content: "oui merci pour le premier"
+    },
+    {
+      role: "assistant",
+      content: `Parfait. Je poursuis avec ces trois adresses et vous reviens avec:
+- adresses exactes confirmées
+- présence/absence de nos immeubles à 200 m
+- liens FAO utiles
+
+Cibles:
+- Chemin du Port 9, 1246 Corsier
+- Boulevard de Saint‑Georges 46, 1205 Genève
+- Chemin du Champ‑des‑Bois 8, 1255 Veyrier`
+    },
+    {
+      role: "user",
+      content: "oui"
+    },
+    {
+      role: "assistant",
+      content: `Voici la suite.
+
+Résultats par adresse (rayon 200 m)
+- Chemin du Port 9, 1246 Corsier — aucun immeuble PRSA trouvé.
+- Boulevard de Saint‑Georges 46, 1205 Genève — aucun immeuble PRSA trouvé.
+- Chemin du Champ‑des‑Bois 8, 1255 Veyrier — aucun immeuble PRSA trouvé.
+
+Souhaitez-vous que je:
+- élargisse à 300–500 m,
+- continue l'extraction sur d'autres avis FAO récents (démolitions/transformations/APA), 
+- ou cible des communes/quartiers spécifiques ?`
+    }
+  ];
+
+  beforeEach(async () => {
+    ({ memory, userId } = createTestMemory({}));
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    await memory.reset(userId);
+  });
+
+  describe("Capture de discussion", () => {
+    
+    it("should capture a discussion and generate exactly ONE memory with title + summary", async () => {
+      //
+      // Capturer la discussion avec type 'discussion'
+      const result = await memory.capture(discussionMessages, userId, {
+        metadata: { 
+          type: 'discussion',
+          discussionId: '7c3e43ac-7621-470d-a22e-82713c3a113e'
+        }
+      }) as SearchResult;
+
+      expect(result).toBeDefined();
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.results)).toBe(true);
+      
+      //
+      // ✅ Vérifier qu'UNE SEULE mémoire est créée par capture
+      expect(result.results.length).toBe(1);
+
+      //
+      // Vérifier que la mémoire contient title et type
+      const mem = result.results[0];
+      expect(mem.id).toBeDefined();
+      expect(mem.type).toBe('discussion');
+      expect(mem.memory).toBeDefined(); // summary
+      expect(mem.metadata?.title).toBeDefined();
+      
+      console.log('--- Title:', mem.metadata?.title);
+      console.log('--- Summary:', mem.memory);
+      
+      //
+      // ✅ Vérifier qu'il n'y a bien qu'une seule mémoire stockée
+      const allMemories = await memory.getAll(userId, { type: 'discussion' });
+      expect(allMemories.results.length).toBe(1);
+    });
+
+    it("should use custom capturePrompt when provided", async () => {
+      const customPrompt = `Tu es un expert en synthèse. Génère:
+1. TITRE: Un titre technique en français (max 8 mots)
+2. SUMMARY: Résumé technique des actions effectuées (max 50 mots)
+
+Discussion:
+`;
+      
+      const result = await memory.capture(discussionMessages, userId, {
+        capturePrompt: customPrompt,
+        metadata: { 
+          type: 'discussion',
+          discussionId: 'custom-test-id'
+        }
+      }) as SearchResult;
+
+      expect(result).toBeDefined();
+      expect(result.results.length).toBeGreaterThan(0);
+      expect(result.results[0].type).toBe('discussion');
+    });
+
+    it("should retrieve discussion memories by semantic search with title in metadata", async () => {
+      //
+      // D'abord capturer la discussion
+      const captureResult = await memory.capture(discussionMessages, userId, {
+        metadata: { 
+          type: 'discussion',
+          discussionId: 'search-test-id'
+        }
+      }) as SearchResult;
+      
+      const originalTitle = captureResult.results[0].metadata?.title;
+      expect(originalTitle).toBeDefined();
+
+      //
+      // Recherche sémantique avec retrieve()
+      const searchResult = await memory.retrieve(
+        "recherche FAO autorisation immeuble Genève",
+        userId,
+        { filters: { type: 'discussion' } }
+      ) as SearchResult;
+
+      expect(searchResult).toBeDefined();
+      expect(searchResult.results).toBeDefined();
+      expect(searchResult.results.length).toBeGreaterThan(0);
+      
+      //
+      // ✅ Vérifier que le title est dans metadata
+      expect(searchResult.results[0].metadata?.title).toBeDefined();
+      expect(searchResult.results[0].metadata?.title).toBe(originalTitle);
+      expect(searchResult.results[0].score).toBeDefined();
+      expect(searchResult.results[0].type).toBe('discussion');
+      
+      console.log('--- retrieve() title:', searchResult.results[0].metadata?.title);
+    });
+
+    it("should list all discussion memories with title in metadata (getAll)", async () => {
+      //
+      // Capturer plusieurs discussions
+      const capture1 = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'disc-1' }
+      }) as SearchResult;
+      
+      const capture2 = await memory.capture([
+        { role: "user", content: "Comment résilier un bail ?" },
+        { role: "assistant", content: "Voici la procédure de résiliation..." }
+      ], userId, {
+        metadata: { type: 'discussion', discussionId: 'disc-2' }
+      }) as SearchResult;
+
+      //
+      // Lister toutes les mémoires discussion avec getAll()
+      const allResult = await memory.getAll(userId, { type: 'discussion' }) as SearchResult;
+
+      expect(allResult).toBeDefined();
+      expect(allResult.results.length).toBe(2);
+      expect(allResult.results.every(r => r.type === 'discussion')).toBe(true);
+      
+      //
+      // ✅ Vérifier que chaque mémoire a un title dans metadata
+      expect(allResult.results.every(r => r.metadata?.title !== undefined)).toBe(true);
+      
+      console.log('--- getAll() titles:', allResult.results.map(r => r.metadata?.title));
+    });
+
+    it("should get a single discussion memory with title in metadata (get)", async () => {
+      //
+      // Capturer
+      const captureResult = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'get-test' }
+      }) as SearchResult;
+
+      const memoryId = captureResult.results[0].id;
+      const originalTitle = captureResult.results[0].metadata?.title;
+
+      //
+      // Récupérer avec get()
+      const getResult = await memory.get(memoryId, userId);
+
+      expect(getResult).not.toBeNull();
+      expect(getResult?.type).toBe('discussion');
+      expect(getResult?.memory).toBeDefined();
+      
+      //
+      // ✅ Vérifier que le title est dans metadata
+      expect(getResult?.metadata?.title).toBeDefined();
+      expect(getResult?.metadata?.title).toBe(originalTitle);
+      
+      console.log('--- get() title:', getResult?.metadata?.title);
+    });
+
+    it("should delete a discussion memory", async () => {
+      //
+      // Capturer
+      const result = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'delete-test' }
+      }) as SearchResult;
+
+      const memoryId = result.results[0].id;
+
+      //
+      // Supprimer
+      await memory.delete(memoryId, userId);
+
+      //
+      // Vérifier suppression
+      const deleted = await memory.get(memoryId, userId);
+      expect(deleted).toBeNull();
+    });
+  });
+
+  describe("Scoring discussion", () => {
+    
+    it("should have constant score (beta=1, halfLife=Infinity)", async () => {
+      //
+      // Capturer une discussion
+      await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'score-test' }
+      });
+
+      //
+      // Rechercher immédiatement
+      const result1 = await memory.retrieve("FAO Genève", userId, {
+        filters: { type: 'discussion' }
+      }) as SearchResult;
+
+      //
+      // Le score ne devrait pas dépendre du temps (halfLife=Infinity)
+      // Avec alpha=0, beta=1, gamma=0, le score = recency = 1 (constant)
+      expect(result1.results.length).toBeGreaterThan(0);
+      expect(result1.results[0].score).toBeDefined();
+      
+      console.log('--- Score:', result1.results[0].score);
+    });
+  });
+});
+

package/tests/memory.update.test.ts

@@ -8,7 +8,11 @@ dotenv.config();
 
 jest.setTimeout(30000); // Increase timeout to 30 seconds
 
-describe("Memory Updates - Type Preservation", () => {
+/**
+ * @deprecated Tests use factual/episodic types that have been removed
+ * These tests are skipped - see migration to discussion memory type
+ */
+describe.skip("Memory Updates - Type Preservation (DEPRECATED)", () => {
   let memory: MemoriesLite;
   let userId: string;
 

package/tests/memory.facts.test.ts

@@ -1,175 +0,0 @@
-/// <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 Class facts regression tests", () => {
-  let memory: MemoriesLite;
-  let userId: string;
-
-  beforeEach(async () => {
-    // Initialize memory via helper
-    ({ memory, userId } = createTestMemory({customPrompt:"L'utilisateur travail pour une régie immobilière!"}));
-    // Reset all memories before each test
-    await memory.reset(userId);
-  });
-
-  afterEach(async () => {
-    // Clean up after each test
-    await memory.reset(userId);
-  });
-
-  describe("Edge cases for Facts", () => {
-
-
-    it("should not add memory: Qui suis-je ?", async () => {
-      const customFacts = "Je suis Olivier Poulain\nIT et je travaille chez Immeuble SA";
-      const result = (await memory.capture([
-        {role:"user", content:"Qui suis-je ?"},
-        {role:"assistant", content:"Vous êtes Olivier Poulain, Chef de Projets au département IT & Gestion de projet, dans l'équipe IT de Immeuble SA"}],
-        userId,
-        {customFacts},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(result.results.length).toBe(0);
-      // expect(result.results[0]?.type).toBe("factual");
-    });
-    it("should not create memory for temporal events (episodic removed)", async () => {
-      const customFacts = "Je suis Olivier Poulain\nIT et je travaille chez Immeuble SA";
-      const result = (await memory.capture([
-        {role:"user", content:"J'ai faim, je veux manger des sushis pour ma pause de midi."},
-        {role:"user", content:"Cherche un restaurant de sushis près de chez moi."}],
-        userId,
-        {customFacts},
-      )) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      // Should not create memory for temporal events or action requests
-      expect(result.results.length).toBe(0);
-    });
-
-
-    it("should add assistant_preference memory", async () => {
-      const result = (await memory.capture(
-        "tu dois répondre de manière concise et précise",
-        userId,
-        {},
-      )) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      expect(result.results.length).toBeGreaterThan(0);
-      expect(result.results[0]?.id).toBeDefined();
-      expect(result.results[0]?.type).toBe("assistant_preference");
-    });
-
-    it("business: should not create memory for business queries", async () => {
-      // Capture a query that contains a name but is asking for contact information
-      const result = (await memory.capture(
-        "je cherche le téléphone de mon client Alphonse MAGLOIRE",
-        userId,
-        {},
-      )) as SearchResult;
-
-      // Verify no memory was created (business query - procedural removed)
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Business queries should not create memories anymore
-      expect(result.results.length).toBe(0);
-    });
-
-    it("business: should not create memory for business property questions", async () => {
-      const result = (await memory.capture([
-        {role:"user", content:"Le logement de Alphonse MAGLOIRE  au 5ème étage est de combien pièces.",},
-        {role:"assitant", content:"Alphonse MAGLOIRE a un logement de 4 pièces au 5ème étage",}],
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Business information should not be stored (procedural removed)
-      expect(result.results.length).toBe(0);
-    });
-    
-
-    it("business: should not create memory for procedure questions", async () => {
-      const result = (await memory.capture([
-        {role:"user", content:"Quelle est la procédure pour résilier un bail chez Pouet & Compagnie SA ?"}],        
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Procedure questions should not create memories (procedural removed)
-      expect(result.results.length).toBe(0);
-    });
-
-    it("business: should not create memory for client status queries", async () => {
-      const result = (await memory.capture([
-        {role:"user", content:"Est-ce que Claude RIBUR est à jour avec son loyer ?"}],
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Business/client queries should not create memories (procedural removed)
-      expect(result.results.length).toBe(0);
-    });
-
-
-    it("should add and remove a single memory", async () => {
-      const result = (await memory.capture(
-        "je veux que tu répondes en italien",
-        userId,
-        {},
-      )) as SearchResult;
-      expect(result.results?.[0]?.id).toBeDefined();
-      const memoryId = result.results[0]?.id;
-      await memory.capture(
-        "je veux que tu répondes en français",
-        userId,
-        {},
-      ) as SearchResult;
-
-      const id = await memory.get(memoryId, userId);
-      console.log("-- DBG id:", id);
-      // expect(id).toBeNull();
-
-    });
-
-    it.skip("should add and remove a single memory", async () => {
-      const result = (await memory.capture(
-        "je veux que tu répondes en italien",
-        userId,
-        {},
-      )) as SearchResult;
-      expect(result.results?.[0]?.id).toBeDefined();
-      const memoryId = result.results[0]?.id;
-      await memory.capture(
-        "je ne veux plus que tu répondes en Italien",
-        userId,
-        {},
-      ) as SearchResult;
-
-      const id = await memory.get(memoryId, userId);
-      console.log("-- DBG id:", id);
-      expect(id).toBeNull();
-
-    });
-
-
-  });
-});

package/tests/memory.todo.test.ts

@@ -1,126 +0,0 @@
-/// <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("Memory Class TODO regression tests", () => {
-  let memory: MemoriesLite;
-  let userId: string;
-
-  beforeEach(async () => {
-    // Initialize memory via helper
-    ({ memory, userId } = createTestMemory({ customPrompt: "L'utilisateur travail pour une régie immobilière!" }));
-    // Reset all memories before each test
-    await memory.reset(userId);
-  });
-
-  afterEach(async () => {
-    // Clean up after each test
-    await memory.reset(userId);
-  });
-
-  describe("Manage TODOs (add/remove/update)", () => {
-    it("should add a TODO when explicitly asked with 'ajoute un todo'", async () => {
-      const result = (await memory.capture([
-        { role: "user", content: "Ajoute un todo: appeler la banque demain à 09:00" },
-        { role: "assistant", content: "Compris, j'ajoute un todo." }
-      ], userId, {})) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // At least one TODO should be captured when explicitly asked
-      expect(result.results.some(r => r.type === "todo")).toBe(true);
-    });
-
-    it("should not create a TODO when task is implicit only", async () => {
-      const result = (await memory.capture([
-        { role: "user", content: "Je dois appeler la banque demain à 09:00" },
-        { role: "assistant", content: "Très bien." }
-      ], userId, {})) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Must not infer TODO without explicit user request
-      expect(result.results.every(r => r.type !== "todo")).toBe(true);
-    });
-
-    it("should not create memory for how-to business requests (procedural removed)", async () => {
-      const result = (await memory.capture([
-        { role: "user", content: "Je veux résilier un bail, comment faire ?" },
-        { role: "assistant", content: "Voici la procédure..." }
-      ], userId, {})) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      // Business procedures should not create memories (procedural type removed)
-      expect(result.results.length).toBe(0);
-    });
-
-    it("should add then update a TODO via new capture", async () => {
-      const add = (await memory.capture([
-        { role: "user", content: "Ajoute un todo: appeler la banque demain à 09:00" },
-        { role: "assistant", content: "Compris, j'ajoute un todo." }
-      ], userId, {})) as SearchResult;
-
-      expect(add).toBeDefined();
-      const todo = add.results.find(r => r.type === "todo");
-      expect(todo?.id).toBeDefined();
-
-      const newText = "Appeler la banque lundi à 10:00";
-      const updateRes = (await memory.capture([
-        { role: "user", content: `Mets à jour ce todo: ${newText}` },
-        { role: "assistant", content: "OK, je mets à jour le todo." }
-      ], userId, {})) as SearchResult;
-
-      expect(updateRes).toBeDefined();
-      // Expect an UPDATE event captured (merger decides UPDATE vs ADD)
-      const updatedItem = updateRes.results.find(r => (r as any).metadata?.event === 'UPDATE' && r.type === 'todo');
-      expect(updatedItem).toBeDefined();
-      // Allow optional suffix from LLM like annotations removal; assert containment
-      expect(updatedItem?.memory?.toLowerCase().includes("appeler la banque lundi à 10:00".toLowerCase())).toBe(true);
-
-      const persisted = await memory.get(updatedItem!.id, userId);
-      expect(persisted).not.toBeNull();
-      expect(persisted?.memory?.toLowerCase().includes("appeler la banque lundi à 10:00".toLowerCase())).toBe(true);
-      expect(persisted?.type).toBe("todo");
-    });
-
-    it("should add then delete a TODO via new capture", async () => {
-      const add = (await memory.capture([
-        { role: "user", content: "Ajoute un todo: appeler la banque demain à 09:00" },
-        { role: "assistant", content: "Compris, j'ajoute un todo." }
-      ], userId, {})) as SearchResult;
-
-      const todo = add.results.find(r => r.type === "todo");
-      expect(todo?.id).toBeDefined();
-
-      const delRes = (await memory.capture([
-        { role: "user", content: `Supprime ce todo: ${todo!.memory}` },
-        { role: "assistant", content: "Je supprime le todo." }
-      ], userId, {})) as SearchResult;
-
-      expect(delRes).toBeDefined();
-      const deletedItem = delRes.results.find(r => (r as any).metadata?.event === 'DELETE' && r.type === 'todo');
-      expect(deletedItem).toBeDefined();
-
-      const persisted = await memory.get(deletedItem!.id, userId);
-      expect(persisted).toBeNull();
-    });
-
-    it("should add a TODO using 'tâche' wording (synonym)", async () => {
-      const result = (await memory.capture([
-        { role: "user", content: "Ajoute une tâche: appeler la banque demain à 09:00" },
-        { role: "assistant", content: "C'est noté, j'ajoute la tâche." }
-      ], userId, {})) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      expect(result.results.some(r => r.type === "todo")).toBe(true);
-    });
-  });
-});