memories-lite 0.99.3 → 0.99.5

package/dist/memory/index.d.ts

@@ -33,6 +33,13 @@ export declare class MemoriesLite {
     capture(messages: string | Message[], userId: string, config: AddMemoryOptions): Promise<SearchResult>;
     get(memoryId: string, userId: string): Promise<MemoryItem | null>;
     retrieve(query: string, userId: string, config: SearchMemoryOptions): Promise<SearchResult>;
+    /**
+     * Met à jour une mémoire existante
+     * @param memoryId - ID de la mémoire
+     * @param data - Nouveau contenu
+     * @param userId - ID utilisateur
+     * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+     */
     update(memoryId: string, data: string, userId: string, metadata?: Record<string, any>): Promise<{
         message: string;
     }>;

package/dist/memory/index.js

@@ -132,11 +132,14 @@ class MemoriesLite {
         const embedding = await this.embedder.embed(title);
         //
         // Préparer les métadonnées
+        // applyMode par défaut = MEM_SMART (recherche sémantique)
         const memoryType = metadata.type || 'discussion';
+        const applyMode = metadata.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE;
         const memoryMetadata = {
             ...metadata,
             title,
             type: memoryType,
+            applyMode,
             userId,
         };
         //
@@ -203,6 +206,7 @@ class MemoriesLite {
             id: memory.id,
             memory: memory.payload.data,
             type: memory.payload.type,
+            applyMode: memory.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             hash: memory.payload.hash,
             createdAt: memory.payload.createdAt,
             updatedAt: memory.payload.updatedAt,
@@ -252,12 +256,21 @@ class MemoriesLite {
             "data",
             "createdAt",
             "updatedAt",
+            "applyMode",
         ]);
-        const results = memories.map((mem) => ({
+        //
+        // Filtrer uniquement les mémoires avec applyMode = MEM_SMART (recherche sémantique)
+        // Les MEM_ALWAYS et MEM_MANUAL ne sont pas retournées par retrieve()
+        const filteredMemories = memories.filter((mem) => {
+            const mode = mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE;
+            return mode === 'MEM_SMART';
+        });
+        const results = filteredMemories.map((mem) => ({
             id: mem.id,
             memory: mem.payload.data,
             hash: mem.payload.hash,
             type: mem.payload.type,
+            applyMode: mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             createdAt: mem.payload.createdAt,
             updatedAt: mem.payload.updatedAt,
             score: mem.score,
@@ -271,6 +284,13 @@ class MemoriesLite {
             results,
         };
     }
+    /**
+     * Met à jour une mémoire existante
+     * @param memoryId - ID de la mémoire
+     * @param data - Nouveau contenu
+     * @param userId - ID utilisateur
+     * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+     */
     async update(memoryId, data, userId, metadata = {}) {
         // await this._captureEvent("update", { memory_id: memoryId });
         const embedding = await this.embedder.embed(data);
@@ -350,12 +370,14 @@ class MemoriesLite {
             "data",
             "createdAt",
             "updatedAt",
+            "applyMode",
         ]);
         const results = memories.map((mem) => ({
             id: mem.id,
             memory: mem.payload.data,
             hash: mem.payload.hash,
             type: mem.payload.type,
+            applyMode: mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             createdAt: mem.payload.createdAt,
             updatedAt: mem.payload.updatedAt,
             metadata: Object.entries(mem.payload)
@@ -393,16 +415,23 @@ class MemoriesLite {
         //
         // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
         // - title: keep original unless explicitly changed
+        // - applyMode: keep original unless explicitly changed
         // - discussionId, userId, agentId/runId: always keep original
         const title = (typeof metadata.title === "string" && metadata.title.trim())
             ? metadata.title.trim()
             : originalPayload.title;
+        //
+        // applyMode: si fourni dans metadata, on le prend, sinon on garde l'original ou le défaut
+        const applyMode = (metadata.applyMode && ['MEM_ALWAYS', 'MEM_SMART', 'MEM_MANUAL'].includes(metadata.applyMode))
+            ? metadata.applyMode
+            : (originalPayload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE);
         const newMetadata = {
             ...originalPayload,
             data,
             hash: (0, crypto_1.createHash)("md5").update(data).digest("hex"),
             updatedAt: new Date().toISOString(),
             title: title,
+            applyMode,
         };
         await vectorStore.update(memoryId, embedding, newMetadata);
         await this.db.addHistory(memoryId, prevValue, data, "UPDATE", newMetadata.createdAt, newMetadata.updatedAt);

package/dist/types/index.d.ts

@@ -77,10 +77,24 @@ export interface MemoryConfig {
     capturePrompt?: string;
 }
 export type MemoryType = 'assistant_preference' | 'discussion';
+/**
+ * Mode d'application de la mémoire (inspiré de Cursor AI)
+ * Stocké dans metadata.applyMode avec préfixe MEM_* pour migration soft
+ *
+ * - MEM_ALWAYS: Toujours appliquer - la mémoire est toujours injectée dans le contexte
+ * - MEM_SMART: Appliquer intelligemment - utilisé pour la recherche sémantique (défaut)
+ * - MEM_MANUAL: Appliquer manuellement - la mémoire n'est jamais injectée automatiquement
+ */
+export type MemoryApplyMode = 'MEM_ALWAYS' | 'MEM_SMART' | 'MEM_MANUAL';
+/**
+ * Mode par défaut pour la capture
+ */
+export declare const DEFAULT_MEMORY_APPLY_MODE: MemoryApplyMode;
 export interface MemoryItem {
     id: string;
     memory: string;
     type: MemoryType;
+    applyMode?: MemoryApplyMode;
     event?: "ADD" | "UPDATE" | "DELETE" | "NONE";
     hash?: string;
     createdAt?: string;

package/dist/types/index.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryConfigSchema = void 0;
+exports.MemoryConfigSchema = exports.DEFAULT_MEMORY_APPLY_MODE = void 0;
 const zod_1 = require("zod");
+/**
+ * Mode par défaut pour la capture
+ */
+exports.DEFAULT_MEMORY_APPLY_MODE = 'MEM_SMART';
 exports.MemoryConfigSchema = zod_1.z.object({
     version: zod_1.z.string().optional(),
     embedder: zod_1.z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memories-lite",
-  "version": "0.99.3",
+  "version": "0.99.5",
   "description": "A lightweight memory system for LLM agents",
   "author": "olivier@evaletolab.ch",
   "main": "dist/index.js",

package/src/memory/index.ts

@@ -5,6 +5,8 @@ import {
   MemoryConfigSchema,
   MemoryItem,
   MemoryType,
+  MemoryApplyMode,
+  DEFAULT_MEMORY_APPLY_MODE,
   Message,
   SearchFilters,
   SearchResult,
@@ -208,11 +210,14 @@ export class MemoriesLite {
 
     //
     // Préparer les métadonnées
+    // applyMode par défaut = MEM_SMART (recherche sémantique)
     const memoryType: MemoryType = metadata.type || 'discussion';
+    const applyMode: MemoryApplyMode = metadata.applyMode || DEFAULT_MEMORY_APPLY_MODE;
     const memoryMetadata = {
       ...metadata,
       title,
       type: memoryType,
+      applyMode,
       userId,
     };
 
@@ -315,6 +320,7 @@ export class MemoriesLite {
       id: memory.id,
       memory: memory.payload.data,
       type: memory.payload.type,
+      applyMode: memory.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       hash: memory.payload.hash,
       createdAt: memory.payload.createdAt,
       updatedAt: memory.payload.updatedAt,
@@ -382,12 +388,23 @@ export class MemoriesLite {
       "data",
       "createdAt",
       "updatedAt",
+      "applyMode",
     ]);
-    const results = memories.map((mem) => ({
+
+    //
+    // Filtrer uniquement les mémoires avec applyMode = MEM_SMART (recherche sémantique)
+    // Les MEM_ALWAYS et MEM_MANUAL ne sont pas retournées par retrieve()
+    const filteredMemories = memories.filter((mem) => {
+      const mode = mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE;
+      return mode === 'MEM_SMART';
+    });
+
+    const results = filteredMemories.map((mem) => ({
       id: mem.id,
       memory: mem.payload.data,
       hash: mem.payload.hash,
       type: mem.payload.type,
+      applyMode: mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       createdAt: mem.payload.createdAt,
       updatedAt: mem.payload.updatedAt,
       score: mem.score,
@@ -403,6 +420,13 @@ export class MemoriesLite {
     };
   }
 
+  /**
+   * Met à jour une mémoire existante
+   * @param memoryId - ID de la mémoire
+   * @param data - Nouveau contenu
+   * @param userId - ID utilisateur
+   * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+   */
   async update(
     memoryId: string,
     data: string,
@@ -506,12 +530,14 @@ export class MemoriesLite {
       "data",
       "createdAt",
       "updatedAt",
+      "applyMode",
     ]);
     const results = memories.map((mem) => ({
       id: mem.id,
       memory: mem.payload.data,
       hash: mem.payload.hash,
       type: mem.payload.type,
+      applyMode: mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       createdAt: mem.payload.createdAt,
       updatedAt: mem.payload.updatedAt,
       metadata: Object.entries(mem.payload)
@@ -576,17 +602,27 @@ export class MemoriesLite {
     //
     // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
     // - title: keep original unless explicitly changed
+    // - applyMode: keep original unless explicitly changed
     // - discussionId, userId, agentId/runId: always keep original
     const title =
       (typeof metadata.title === "string" && metadata.title.trim())
         ? metadata.title.trim()
         : originalPayload.title;
+
+    //
+    // applyMode: si fourni dans metadata, on le prend, sinon on garde l'original ou le défaut
+    const applyMode: MemoryApplyMode =
+      (metadata.applyMode && ['MEM_ALWAYS', 'MEM_SMART', 'MEM_MANUAL'].includes(metadata.applyMode))
+        ? metadata.applyMode
+        : (originalPayload.applyMode || DEFAULT_MEMORY_APPLY_MODE);
+
     const newMetadata: Record<string, any> = {
       ...originalPayload,
       data,
       hash: createHash("md5").update(data).digest("hex"),
       updatedAt: new Date().toISOString(),
       title: title,
+      applyMode,
     };
 
     await vectorStore.update(memoryId, embedding, newMetadata);

package/src/types/index.ts

@@ -88,10 +88,26 @@ export interface MemoryConfig {
 
 export type MemoryType = 'assistant_preference' | 'discussion';
 
+/**
+ * Mode d'application de la mémoire (inspiré de Cursor AI)
+ * Stocké dans metadata.applyMode avec préfixe MEM_* pour migration soft
+ * 
+ * - MEM_ALWAYS: Toujours appliquer - la mémoire est toujours injectée dans le contexte
+ * - MEM_SMART: Appliquer intelligemment - utilisé pour la recherche sémantique (défaut)
+ * - MEM_MANUAL: Appliquer manuellement - la mémoire n'est jamais injectée automatiquement
+ */
+export type MemoryApplyMode = 'MEM_ALWAYS' | 'MEM_SMART' | 'MEM_MANUAL';
+
+/**
+ * Mode par défaut pour la capture
+ */
+export const DEFAULT_MEMORY_APPLY_MODE: MemoryApplyMode = 'MEM_SMART';
+
 export interface MemoryItem {
   id: string;
   memory: string;
   type: MemoryType;
+  applyMode?: MemoryApplyMode;
   event?: "ADD" | "UPDATE" | "DELETE" | "NONE";
   hash?: string;
   createdAt?: string;

package/tests/memory.applymode.test.ts

@@ -0,0 +1,228 @@
+/// <reference types="jest" />
+import { MemoriesLite, DEFAULT_MEMORY_APPLY_MODE, MemoryApplyMode } from "../src";
+import { SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000);
+
+/**
+ * Tests pour le MemoryApplyMode (type d'application de mémoire)
+ * - MEM_ALWAYS: Toujours appliquer
+ * - MEM_SMART: Appliquer intelligemment (défaut, recherche sémantique)
+ * - MEM_MANUAL: Appliquer manuellement
+ */
+describe("Memory ApplyMode", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  beforeEach(async () => {
+    ({ memory, userId } = createTestMemory({}));
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    await memory.reset(userId);
+  });
+
+  describe("Default ApplyMode", () => {
+    it("should set applyMode to MEM_SMART by default on capture", async () => {
+      //
+      // Capture une discussion avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Bonjour, comment gérer les congés ?" },
+        { role: "assistant", content: "Pour gérer les congés, vous devez..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const createdMemory = result.results[0];
+      
+      //
+      // Vérifier que le mode par défaut est MEM_SMART
+      expect(createdMemory.metadata?.applyMode || DEFAULT_MEMORY_APPLY_MODE).toBe("MEM_SMART");
+    });
+
+    it("should return DEFAULT_MEMORY_APPLY_MODE as MEM_SMART", () => {
+      expect(DEFAULT_MEMORY_APPLY_MODE).toBe("MEM_SMART");
+    });
+  });
+
+  describe("ApplyMode Update", () => {
+    it("should update applyMode when specified in metadata", async () => {
+      //
+      // Créer une mémoire avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Comment faire une facture ?" },
+        { role: "assistant", content: "Pour créer une facture..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const memoryId = result.results[0].id;
+
+      //
+      // Mettre à jour avec un nouveau mode
+      await memory.update(
+        memoryId,
+        "Procédure de facturation mise à jour",
+        userId,
+        { applyMode: "MEM_ALWAYS" as MemoryApplyMode }
+      );
+
+      //
+      // Vérifier que le mode a été mis à jour
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory).not.toBeNull();
+      expect(updatedMemory?.applyMode).toBe("MEM_ALWAYS");
+    });
+
+    it("should preserve applyMode when not specified in update metadata", async () => {
+      //
+      // Créer une mémoire avec un mode spécifique
+      const messages = [
+        { role: "user", content: "Règles de sécurité" },
+        { role: "assistant", content: "Les règles de sécurité sont..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion", applyMode: "MEM_MANUAL" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const memoryId = result.results[0].id;
+
+      //
+      // Mettre à jour le contenu sans changer le mode
+      await memory.update(
+        memoryId,
+        "Règles de sécurité mises à jour",
+        userId,
+        {} // Pas de applyMode dans les metadata
+      );
+
+      //
+      // Vérifier que le mode est préservé
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory).not.toBeNull();
+      expect(updatedMemory?.applyMode).toBe("MEM_MANUAL");
+    });
+
+    it("should change applyMode from MEM_SMART to MEM_MANUAL", async () => {
+      //
+      // Créer une mémoire avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Comment utiliser l'API ?" },
+        { role: "assistant", content: "L'API s'utilise de la manière suivante..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      const memoryId = result.results[0].id;
+
+      //
+      // Changer de MEM_SMART vers MEM_MANUAL
+      await memory.update(
+        memoryId,
+        "Documentation API mise à jour",
+        userId,
+        { applyMode: "MEM_MANUAL" as MemoryApplyMode }
+      );
+
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory?.applyMode).toBe("MEM_MANUAL");
+    });
+  });
+
+  describe("Retrieve Filtering by ApplyMode", () => {
+    it("should only return MEM_SMART memories in retrieve()", async () => {
+      //
+      // Créer 3 mémoires avec différents modes
+      const messagesBase = [
+        { role: "user", content: "Question sur les procédures" },
+        { role: "assistant", content: "Les procédures sont..." }
+      ];
+
+      //
+      // Mémoire 1: MEM_SMART (par défaut)
+      await memory.capture(messagesBase, userId, {
+        metadata: { type: "discussion", customTag: "smart" }
+      });
+
+      //
+      // Mémoire 2: MEM_ALWAYS
+      await memory.capture([
+        { role: "user", content: "Règle toujours appliquée" },
+        { role: "assistant", content: "Cette règle est toujours appliquée..." }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_ALWAYS", customTag: "always" }
+      });
+
+      //
+      // Mémoire 3: MEM_MANUAL
+      await memory.capture([
+        { role: "user", content: "Note manuelle" },
+        { role: "assistant", content: "Ceci est une note manuelle..." }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_MANUAL", customTag: "manual" }
+      });
+
+      //
+      // Vérifier que getAll retourne les 3 mémoires
+      const allMemories = await memory.getAll(userId, { type: "discussion" });
+      expect(allMemories.results.length).toBe(3);
+
+      //
+      // Vérifier que retrieve() ne retourne que MEM_SMART
+      const searchResult = await memory.retrieve("procédures", userId, { limit: 10 });
+      
+      //
+      // Seule la mémoire MEM_SMART devrait être retournée
+      const smartMemories = searchResult.results.filter(m => m.applyMode === "MEM_SMART");
+      const nonSmartMemories = searchResult.results.filter(m => m.applyMode !== "MEM_SMART");
+      
+      expect(smartMemories.length).toBeGreaterThanOrEqual(0);
+      expect(nonSmartMemories.length).toBe(0);
+    });
+  });
+
+  describe("GetAll returns all ApplyModes", () => {
+    it("should return memories of all applyModes in getAll()", async () => {
+      //
+      // Créer des mémoires avec différents modes
+      await memory.capture([
+        { role: "user", content: "Mémoire intelligente" },
+        { role: "assistant", content: "Réponse intelligente" }
+      ], userId, {
+        metadata: { type: "discussion" } // MEM_SMART par défaut
+      });
+
+      await memory.capture([
+        { role: "user", content: "Mémoire toujours" },
+        { role: "assistant", content: "Réponse toujours" }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_ALWAYS" }
+      });
+
+      //
+      // getAll doit retourner les deux
+      const allMemories = await memory.getAll(userId, { type: "discussion" });
+      expect(allMemories.results.length).toBe(2);
+
+      const modes = allMemories.results.map(m => m.applyMode);
+      expect(modes).toContain("MEM_SMART");
+      expect(modes).toContain("MEM_ALWAYS");
+    });
+  });
+});
+