memories-lite 0.9.5 → 0.99.1

package/dist/prompts/index.js

@@ -1,37 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMemoriesAsSystem = exports.getMemoriesAsPrefix = exports.MEMORY_STRING_SYSTEM_OLD = exports.MEMORY_STRING_PREFIX = exports.MEMORY_STRING_SYSTEM = exports.MemoryUpdateSchema = exports.FactRetrievalSchema_extended = exports.FactRetrievalSchema_simple = void 0;
+exports.getMemoriesAsSystem = exports.getMemoriesAsPrefix = exports.MEMORY_STRING_PREFIX = exports.MEMORY_STRING_SYSTEM = exports.MemoryUpdateSchema = exports.FactRetrievalSchema_extended = exports.FactRetrievalSchema_simple = exports.DEFAULT_DISCUSSION_PROMPT = exports.DiscussionSynthesisSchema = void 0;
+exports.getDiscussionSynthesisMessages = getDiscussionSynthesisMessages;
 exports.getFactRetrievalMessages = getFactRetrievalMessages;
 exports.getUpdateMemoryMessages = getUpdateMemoryMessages;
 exports.parseMessages = parseMessages;
 exports.removeCodeBlocks = removeCodeBlocks;
 const zod_1 = require("zod");
-// Define Zod schema for fact retrieval output
+// ══════════════════════════════════════════════════════════════════════════════
+// DISCUSSION SYNTHESIS - Nouveau système de mémoire
+// ══════════════════════════════════════════════════════════════════════════════
+/**
+ * Schema pour la synthèse de discussion
+ * Produit un titre court et une synthèse opérationnelle
+ */
+exports.DiscussionSynthesisSchema = zod_1.z.object({
+    title: zod_1.z.string().describe("Titre court et descriptif (6-10 mots)"),
+    summary: zod_1.z.string().describe("Synthèse opérationnelle des points clés (50-100 mots)")
+});
+/**
+ * Prompt par défaut pour la synthèse de discussion
+ * Peut être remplacé via capturePrompt dans AddMemoryOptions
+ */
+exports.DEFAULT_DISCUSSION_PROMPT = `Tu es un expert en synthèse opérationnelle.
+
+À partir de cette discussion, génère :
+1. TITRE: Un titre court et descriptif (6-10 mots) qui capture l'essence de la demande
+2. SUMMARY: Les points clés du chemin de résolution (50-100 mots)
+
+Cette synthèse servira à retrouver et réappliquer ce pattern de résolution similaire.
+Utilise la même langue que la discussion.
+
+Discussion à synthétiser:
+`;
+/**
+ * Génère les messages pour la synthèse de discussion
+ * @param discussion - Contenu de la discussion formatée
+ * @param capturePrompt - Prompt custom optionnel (remplace DEFAULT_DISCUSSION_PROMPT)
+ * @returns [systemPrompt, userPrompt]
+ */
+function getDiscussionSynthesisMessages(discussion, capturePrompt) {
+    const systemPrompt = capturePrompt || exports.DEFAULT_DISCUSSION_PROMPT;
+    return [systemPrompt, discussion];
+}
+// ══════════════════════════════════════════════════════════════════════════════
+// @deprecated - Ancien système de capture (todo, factual)
+// Ces exports sont conservés pour compatibilité mais ne doivent plus être utilisés
+// ══════════════════════════════════════════════════════════════════════════════
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ */
 exports.FactRetrievalSchema_simple = zod_1.z.object({
     facts: zod_1.z
         .array(zod_1.z.string())
         .describe("An array of distinct facts extracted from the conversation."),
 });
-//1. **Factual memory** – stable facts & preferences  
-//2. **Episodic memory** – time‑stamped events / interactions  
-//3. **Procedural memory** – step‑by‑step know‑how  
-//4. **Todo memory** – explicit user tasks to remember
-//
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ * Types todo et factual supprimés - seul assistant_preference reste pour compatibilité
+ */
 exports.FactRetrievalSchema_extended = zod_1.z.object({
     facts: zod_1.z
         .array(zod_1.z.object({
         fact: zod_1.z.string().describe("The fact extracted from the conversation."),
         existing: zod_1.z.boolean().describe("Whether the fact is already present"),
-        type: zod_1.z.enum(["assistant_preference", "factual", "episodic", "procedural", "todo"])
-            .describe(`The type of the fact.
-        Use 'assistant_preference' for Assistant behavior preferences (style/language/constraints/commands).
-        Use 'episodic' always for time-based events.
-        Use 'procedural' for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
-        Use 'todo' ONLY if the user explicitly asks to save/keep as a todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Do not infer todos.
-        `),
+        type: zod_1.z.enum(["assistant_preference"])
+            .describe(`The type of the fact. Only 'assistant_preference' is supported.`),
     }))
 });
-// Define Zod schema for memory update output
+/**
+ * @deprecated Memory updates are disabled - use capture() for new memories
+ */
 exports.MemoryUpdateSchema = zod_1.z.object({
     memory: zod_1.z
         .array(zod_1.z.strictObject({
@@ -48,18 +87,11 @@ exports.MemoryUpdateSchema = zod_1.z.object({
             .string()
             .describe("The reason why you selected this event."),
         type: zod_1.z
-            .enum(["factual", "episodic", "todo", "procedural", "assistant_preference"])
-            .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'procedural' for all business processes."),
+            .enum(["assistant_preference"])
+            .describe("Type of the memory. Only 'assistant_preference' is supported."),
     }))
         .describe("An array representing the state of memory items after processing new facts."),
 });
-/**
- * Practical Application:
- *
- * If the task is "factual" (e.g., "Where do I live?") → retrieve factual memory.
- * If the task is temporal or event-based ("What was I doing yesterday?") → retrieve episodic memory.
- * If the task is a user task/reminder (e.g., "Add a reminder to call the bank tomorrow") → retrieve todo memory.
- */
 exports.MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 - Information stored in memory is always enclosed within the <memories> tag.
 - Prioritize the latest user message over memories (the user's current question is authoritative).
@@ -69,44 +101,37 @@ exports.MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 - By default, do not reference this section or the memories in your response.
 - Use memories only to guide reasoning; do not respond to the memories themselves.`;
 exports.MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories.";
-exports.MEMORY_STRING_SYSTEM_OLD = `# USER AND MEMORIES PREFERENCES:
-- Utilize the provided memories to guide your responses.
-- Disregard any memories that are not relevant.
-- By default, do not reference this section or the memories in your response.
-`;
-// Deprecated: getFactRetrievalMessages_O removed in favor of getFactRetrievalMessages
+/**
+ * @deprecated Use getDiscussionSynthesisMessages instead
+ * Cette fonction est conservée pour compatibilité avec l'ancien système
+ */
 function getFactRetrievalMessages(parsedMessages, customRules = "", defaultLanguage = "French") {
     const injectCustomRules = (customRules) => customRules ? `\n# PRE-EXISTING FACTS\n${customRules}` : "";
-    const systemPrompt = `You are a Personal Information Organizer, specialized in accurately storing facts, user memories, and preferences. You are also an expert in job tasks extraction.
+    const systemPrompt = `You are a Personal Information Organizer, specialized in extracting and structuring user facts and preferences for AI personalization. You also handle explicit task extraction (todos only).
 
 Filter content before extracting triplets:
-  - Relevance: keep only statements directly about the user (preferences, identity, actions, experiences) or explicit tasks; drop weather/small talk.
+  - Relevance: keep only statements directly about the user (preferences with the AI, identity relevant to personalization, actions/experiences that affect responses) or explicit todos; drop weather/small talk.
   - Disinterest: if the user rejects the topic (e.g., "cette information ne m'intéresse pas", "not interested"), return {"facts":[]}.
-  - Business/procedures: if the user asks about processes, regulations, or third-party policies (company workflows, public steps, legal actions), classify as "procedural". This applies even if personal pronouns are used.
-  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, do not create a memory for such requests (return {"facts":[]}).
-  
-You must strictly extract {Subject, Predicate, Object} triplets by following these rules (max 12 triplets):
+  - Ignore business/process/regulation/company-policy content entirely (no extraction, no memory).
+  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, return {"facts":[]}.
+
+You must strictly extract {Subject, Predicate, Object} triplets (max 12):
 1. Identify named entities, preferences, and meaningful user-related concepts:
-  - Extract triplets that describe facts *about the user* based on their statements, covering areas like preferences, beliefs, actions, experiences, learning, identity, work, or relationships (e.g., "I love working").
-  - Apply explicit, precise, and unambiguous predicates (e.g., "owns", "is located at", "is a", "has function", "causes", etc.).
-  - Determine the triplet type ("assistant_preference", "procedural", "episodic", "factual", "todo"):
-    - "assistant_preference": ONLY when the user specifies response style/language/format or interaction constraints.
-    - "procedural": for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
-    - "todo": ONLY if the user explicitly requests to save/keep as todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Never infer todo from intent alone.
-    - If multiple types apply (excluding assistant_preference and todo rules above), priority: procedural > episodic > factual.
-    - "episodic" If a fact depends on a temporal, situational, or immediate personal context, then that fact AND ALL OF ITS sub-facts MUST be classified as episodic.
-    - "procedural" for business processes (e.g., "Looking for customer John Doe address", "How to create a new contract").
-    - "factual" for stable user data (except procedural that prevails).
-    
-  - Eliminate introductions, sub-facts, detailed repetitive elements, stylistic fillers, or vague statements. General facts always takes precedence over multiple sub-facts (signal vs noise).
-  - The query intention can include specific preferences about how the Assistant should respond (e.g., "answer concisely", "explain in detail").   
-  - Compress each OUTPUT (fact and reason) ≤ 10 words.
-  - Do not include type labels or annotations inside the fact text (e.g., avoid "(todo)", "(procedural)"). Use the separate 'type' field only.
-  - DO NOT infer personal facts from third-party informations.
-  - Treat "**ASSISTANT**:" as responses to enrich context of your reasoning process about the USER query.
-2. Use pronoun "I" instead of "The user" in the subject of the triplet.
-3. Do not output any facts already present in section # PRE-EXISTING FACTS.
-  - If you find facts already present in section # PRE-EXISTING FACTS, use field "existing" to store them.
+  - Extract triplets *about the user* that help AI personalization (preferences, stable facts, explicit todos).
+  - Use explicit, precise, unambiguous predicates (e.g., "prefers", "speaks", "is a", "uses").
+  - Triplet type ∈ {"assistant_preference","factual","todo"} only:
+    - "assistant_preference": response style/language/format or interaction constraints.
+    - "factual": stable user data relevant to personalization (e.g., language, timezone, tools used).
+    - "todo": ONLY if the user explicitly asks to save/keep as todo. Never infer from intent alone.
+  - Remove introductions, sub-facts, repetitions, fillers, vague statements; prefer the general fact over details.
+  - Each triplet (S,P,O) ≤ 10 words total.
+  - Do not include type labels inside fact text; use the 'type' field only.
+  - Do not infer personal facts from third-party information.
+  - Treat "**ASSISTANT**:" as context only; never as a fact source.
+
+2. Use pronoun "I" as the Subject (not "The user").
+3. Do not output facts already in # PRE-EXISTING FACTS.
+  - If found, put them in "existing" (list of matched facts or IDs).
 
 ${injectCustomRules(customRules)}
 
@@ -120,52 +145,75 @@ Remember the following:
     const userPrompt = `Extract exact facts from the following conversation in the same language as the user. If the user expresses disinterest or asks to ignore the topic, return {"facts":[]}. Limit output to ≤ 12 triplets and strictly follow the JSON schema.\n${parsedMessages}`;
     return [systemPrompt, userPrompt];
 }
+/**
+ * @deprecated Memory updates are disabled by config
+ */
 function getUpdateMemoryMessages(retrievedOldMemory, newRetrievedFacts, defaultLanguage = "French", userInstruction) {
     const serializeFacts = (facts) => {
         if (facts.length === 0)
             return "";
         if (facts[0].fact) {
-            return facts.map((elem) => `* ${elem.fact} (${elem.type})`).join("\n");
+            return facts.map((elem) => `- "${elem.fact}" (type:${elem.type})`).join("\n");
         }
         else {
             return facts.join("\n");
         }
     };
     const serializeMemory = (memory) => {
-        return memory.map((elem) => `* ${elem.id} - ${elem.text}`).join("\n");
+        return memory.map((elem) => `- "${elem.text}" (id:${elem.id})`).join("\n");
     };
     return `ROLE:
-You are a smart memory manager dedicated on users. You are expert in semantic comparison, RDF inference and boolean logic.
+You are the Memory Manager module of an AI assistant. You are specialized in semantic reasoning, fact consistency, and memory lifecycle operations.  
+Your job is to maintain a coherent, contradiction-free knowledge base (long-term memory) of user facts.
 
 MISSION:
-For each new user fact from "# New Retrieved Facts", you MUSTmerge it into "# Current Memory" by assigning exactly ONE of: ADD, DELETE, UPDATE, or NONE:
-
-1. Semantic compare each new facts to memory, for each fact:
-  - If the new fact **contradicts**, **negates**, **reverses**, **retracts**, or **cancels** the meaning of a memory entry THEN DELETE.
-    ⛔ You MUST NOT treat this as an UPDATE. Contradictions invalidate the original fact.
-  - Else If the new fact **specializes** the previous fact (adds precision, extends the detail without changing the core meaning) THEN UPDATE.
-  - Else If it is **equivalent** → NONE.
-  - Else If it is **completely new** → ADD.
-  - Else (default) → NONE.
-2. Event mapping from user intent (imperatives prevail):
-  - DELETE if user asks to remove.
-  - UPDATE if user asks to change: "mets à jour", "modifie", "corrige", "update", "change", "replace".
-  - ADD if user asks to add: "ajoute", "add" (including explicit todo adds).
-3. If no match is found:
-   - Generate a new ID for ADD
-5. Assign the action (IF you can't find a match, restart the process)
+Given:
+  1. A set of **Current Memory** facts (each with unique ID and textual content).
+  2. A set of **New Retrieved Facts** from the user or external sources.
+  3. (Optional) A **User Instruction** indicating explicit intent (add, modify, delete).
+
+You must process each new fact individually and decide **exactly one** action: **ADD**, **DELETE**, **UPDATE**, or **NONE**, following these rules, in this order:
+
+1. **User intent override**  
+   If the User Instruction clearly requests adding, updating, or removal (e.g. “ajoute X”, “mets à jour Y”, “supprime Z”), you **must** respect that and assign the corresponding action for the matching fact, superseding semantic rules.
+
+2. **Semantic consistency check**  
+   For each new fact:
+   - If it **contradicts**, **negates**, or **cancels** an existing memory item, you **DELETE** the memory item.  
+   - Else, if the new fact is a **specialization** (i.e. same core meaning + additional detail) of an existing one, **UPDATE** that memory (keeping the same ID).  
+   - Else, if it is **semantically equivalent** (i.e. redundant or paraphrased), assign **NONE** (no change).  
+   - Else, if it is entirely **new** (no overlap or relation), **ADD** it (generate a new ID).  
+   - Otherwise (if ambiguous or borderline), assign **NONE** (do not delete).  
+
+3. **ID reuse and consistency**  
+   - For **UPDATE**, reuse the existing memory item’s ID.  
+   - For **DELETE**, simply remove the item from the final memory output.  
+   - For **ADD**, generate a new unique ID (e.g. UUID).  
+   - If memory is initially empty, treat all new facts as **ADD**.
+
+4. **Output formatting**  
+   Return the updated memory state in strict JSON format. Each memory entry must include:
+   - \`id\` (string)  
+   - \`text\` (string, the pure factual content)  
+   - Optionally for updates: \`old_text\` (the prior version)  
+   - *(No extra annotation or type markup in \`text\`)*  
+
+If there are no facts at all, return \`{"memory": []}\`.
+
+*You must not output any other text besides the valid JSON result.*
 
 # Output Instructions
-- Default user language is ${defaultLanguage}.
+- Default user language is "${defaultLanguage}".
 - Each memory item must follow this strict format:
-  - UPDATE also include the previous text: \`old_memory\`.
-  - ⚠️ Reuse correct IDs for UPDATE and DELETE.
-  - Generate random IDs for ADDs.
+  - UPDATE must also include the previous text: \`old_text\`.
+  - Reuse correct IDs for UPDATE.  
+  - For DELETE, exclude the removed item from the final memory list.  
+  - Generate random IDs for ADDs (format: UUID).
   - If memory is empty, treat all facts as ADD.
   - Without facts, return an empty memory: \`{"memory": []}\`
 - Memory must strictly reflect valid facts.  
-- Contradictions, cancellations, negations, or ambiguities must be handled by DELETE.  
- - The field 'text' must be the pure memory content only: do not add any type markers or parentheses like "(todo)".
+- Contradictions, cancellations, or negations must be handled by DELETE. Ambiguities must be handled by NONE.  
+- The field 'text' must be the pure memory content only: do not add any type markers or parentheses.
 
 # Current Memory (extract and reuse their IDs for UPDATE or DELETE events):
 ${serializeMemory(retrievedOldMemory)}
@@ -173,8 +221,7 @@ ${serializeMemory(retrievedOldMemory)}
 # New Retrieved Facts:
 ${serializeFacts(newRetrievedFacts)}
 
-# User Instruction:
-${userInstruction || ""}
+# User Instruction: "${userInstruction || ''}"
 
 Return the updated memory in JSON format only. Do not output anything else.`;
 }
@@ -198,8 +245,10 @@ const getMemoriesAsPrefix = (memories) => {
 };
 exports.getMemoriesAsPrefix = getMemoriesAsPrefix;
 const getMemoriesAsSystem = (memories, facts) => {
+    if (!memories || memories.length === 0)
+        return "";
     const memoryString = memories.map((mem) => `- ${mem.memory}`).concat(facts || []).join("\n");
-    return `${exports.MEMORY_STRING_SYSTEM}\n<memories>${memoryString}\n</memories>`;
+    return `${exports.MEMORY_STRING_SYSTEM}\n<memories>\n${memoryString}\n</memories>`;
 };
 exports.getMemoriesAsSystem = getMemoriesAsSystem;
 function parseMessages(messages) {