// ===== KIMI INTELLIGENT MEMORY SYSTEM ===== class KimiMemorySystem { constructor(database) { this.db = database; this.memoryEnabled = true; this.maxMemoryEntries = 100; // Performance optimization: keyword cache with LRU eviction this.keywordCache = new Map(); // keyword_language -> boolean (is common) this.keywordCacheSize = 1000; // Limit memory usage this.keywordCacheHits = 0; this.keywordCacheMisses = 0; // Performance monitoring this.queryStats = { extractionTime: [], addMemoryTime: [], retrievalTime: [] }; // Centralized configuration for all thresholds and magic numbers this.config = { // Content validation thresholds minContentLength: 2, longContentThreshold: 24, titleWordCount: { preferred: 3, min: 1, max: 5 }, // Similarity and confidence thresholds similarity: { personal: 0.6, // Names can vary more (Jean vs Jean-Pierre) preferences: 0.7, // Preferences can be expressed differently default: 0.8, // General similarity threshold veryHigh: 0.9, // For boost_confidence strategy update: 0.3 // Lower threshold for memory updates }, // Confidence scoring confidence: { base: 0.6, explicitRequest: 1.0, naturalExpression: 0.7, bonusForLongContent: 0.1, bonusForExplicitStatement: 0.3, penaltyForUncertainty: 0.2, min: 0.1, max: 1.0 }, // Memory management cleanup: { maxEntries: 100, ttlDays: 365, batchSize: 100, touchMinutes: 60 }, // Performance settings cache: { keywordCacheSize: 1000, statHistorySize: 100 }, // Scoring weights for importance calculation importance: { categoryWeights: { important: 1.0, personal: 0.9, relationships: 0.85, goals: 0.75, experiences: 0.65, preferences: 0.6, activities: 0.5 }, bonuses: { relationshipMilestone: 0.15, boundaries: 0.15, strongEmotion: 0.05, futureReference: 0.05, longContent: 0.05, highConfidence: 0.05 } }, // Relevance calculation weights relevance: { contentSimilarity: 0.35, keywordOverlap: 0.25, categoryRelevance: 0.1, recencyBonus: 0.1, confidenceBonus: 0.05, importanceBonus: 0.05, recentDaysThreshold: 30 } }; this.memoryCategories = { personal: "Personal Information", preferences: "Likes & Dislikes", relationships: "Relationships & People", activities: "Activities & Hobbies", goals: "Goals & Aspirations", experiences: "Shared Experiences", important: "Important Events" }; // Patterns for automatic memory extraction (multilingual) this.extractionPatterns = { personal: [ // English patterns /(?:my name is|i'm called|call me|i am) (\w+)/i, /(?:i am|i'm) (\d+) years? old/i, /(?:i live in|i'm from|from) ([^,.!?]+)/i, /(?:i work as|my job is|i'm a) ([^,.!?]+)/i, // French patterns /(?:je m'appelle|mon nom est|je suis|je me prénomme|je me nomme) ([^,.!?]+)/i, /(?:j'ai) (\d+) ans?/i, /(?:j'habite à|je vis à|je viens de) ([^,.!?]+)/i, /(?:je travaille comme|mon travail est|je suis) ([^,.!?]+)/i, // Spanish patterns /(?:me llamo|mi nombre es|soy) ([^,.!?]+)/i, /(?:tengo) (\d+) años?/i, /(?:vivo en|soy de) ([^,.!?]+)/i, /(?:trabajo como|mi trabajo es|soy) ([^,.!?]+)/i, // Italian patterns /(?:mi chiamo|il mio nome è|sono) ([^,.!?]+)/i, /(?:ho) (\d+) anni?/i, /(?:abito a|vivo a|sono di) ([^,.!?]+)/i, /(?:lavoro come|il mio lavoro è|sono) ([^,.!?]+)/i, // German patterns /(?:ich heiße|mein name ist|ich bin) ([^,.!?]+)/i, /(?:ich bin) (\d+) jahre? alt/i, /(?:ich wohne in|ich lebe in|ich komme aus) ([^,.!?]+)/i, /(?:ich arbeite als|mein beruf ist|ich bin) ([^,.!?]+)/i, // Japanese patterns /私の名前は([^。！？!?、,.]+)[ですだ]?/i, /私は([^。！？!?、,.]+)です/i, /([^、。！？!?,.]+)と申します/i, /([^、。！？!?,.]+)といいます/i, // Chinese patterns /我叫([^，。！？!?,.]+)/i, /我的名字是([^，。！？!?,.]+)/i, /叫我([^，。！？!?,.]+)/i ], preferences: [ // English patterns /(?:i love|i like|i enjoy|i prefer) ([^,.!?]+)/i, /(?:i hate|i dislike|i don't like) ([^,.!?]+)/i, /(?:my favorite|i really like) ([^,.!?]+)/i, // French patterns /(?:j'aime|j'adore|je préfère) ([^,.!?]+)/i, /(?:je déteste|je n'aime pas) ([^,.!?]+)/i, /(?:mon préféré|ma préférée) (?:est|sont) ([^,.!?]+)/i, // Explicit memory requests /(?:ajoute? (?:au|à la) (?:système? )?(?:de )?mémoire|retiens?|mémorise?) (?:que )?(.+)/i, /(?:add to memory|remember|memorize) (?:that )?(.+)/i ], relationships: [ // English patterns /(?:my (?:wife|husband|girlfriend|boyfriend|partner)) (?:is|named?) ([^,.!?]+)/i, /(?:my (?:mother|father|sister|brother|friend)) ([^,.!?]+)/i, // French patterns /(?:ma (?:femme|copine|partenaire)|mon (?:mari|copain|partenaire)) (?:s'appelle|est) ([^,.!?]+)/i, /(?:ma (?:mère|sœur)|mon (?:père|frère|ami)) (?:s'appelle|est) ([^,.!?]+)/i, // Spanish patterns /(?:mi (?:esposa|esposo|novia|novio|pareja)) (?:es|se llama) ([^,.!?]+)/i, /(?:mi (?:madre|padre|hermana|hermano|amigo|amiga)) (?:es|se llama) ([^,.!?]+)/i, // Italian patterns /(?:la mia (?:moglie|fidanzata|compagna)|il mio (?:marito|fidanzato|compagno)) (?:è|si chiama) ([^,.!?]+)/i, /(?:mia (?:madre|sorella)|mio (?:padre|fratello|amico)) (?:è|si chiama) ([^,.!?]+)/i, // German patterns /(?:meine (?:frau|freundin|partnerin)|mein (?:mann|freund|partner)) (?:ist|heißt) ([^,.!?]+)/i, /(?:meine (?:mutter|schwester)|mein (?:vater|bruder|freund)) (?:ist|heißt) ([^,.!?]+)/i, // Japanese patterns /(?:私の(?:妻|夫|彼女|彼氏|パートナー))は([^。！？!?、,.]+)(?:です|といいます)/i, /(?:私の(?:母|父|姉|妹|兄|弟|友達))は([^。！？!?、,.]+)(?:です|といいます)/i, // Chinese patterns /(?:我的(?:妻子|丈夫|女朋友|男朋友|伴侣))叫([^，。！？!?,.]+)/i, /(?:我的(?:妈妈|父亲|姐姐|妹妹|哥哥|弟弟|朋友))叫([^，。！？!?,.]+)/i ], activities: [ // English patterns /(?:i play|i do|i practice) ([^,.!?]+)/i, /(?:my hobby is|i hobby) ([^,.!?]+)/i, // French patterns /(?:je joue|je fais|je pratique) ([^,.!?]+)/i, /(?:mon passe-temps|mon hobby) (?:est|c'est) ([^,.!?]+)/i, // Spanish patterns /(?:juego|hago|practico) ([^,.!?]+)/i, /(?:mi pasatiempo|mi hobby) (?:es) ([^,.!?]+)/i, // Italian patterns /(?:gioco|faccio|pratico) ([^,.!?]+)/i, /(?:il mio passatempo|il mio hobby) (?:è) ([^,.!?]+)/i, // German patterns /(?:ich spiele|ich mache|ich übe) ([^,.!?]+)/i, /(?:mein hobby ist) ([^,.!?]+)/i, // Japanese patterns /(?:私は)?(?:[^、。！？!?,.]+)が趣味です/i, /趣味は([^。！？!?、,.]+)です/i, // Chinese patterns /(?:我玩|我做|我练习)([^，。！？!?,.]+)/i, /(?:我的爱好是)([^，。！？!?,.]+)/i ], goals: [ // English patterns /(?:i want to|i plan to|my goal is) ([^,.!?]+)/i, /(?:i'm learning|i study) ([^,.!?]+)/i, // French patterns /(?:je veux|je vais|mon objectif est) ([^,.!?]+)/i, /(?:j'apprends|j'étudie) ([^,.!?]+)/i, // Spanish patterns /(?:quiero|voy a|mi objetivo es) ([^,.!?]+)/i, /(?:estoy aprendiendo|estudio) ([^,.!?]+)/i, // Italian patterns /(?:voglio|andrò a|il mio obiettivo è) ([^,.!?]+)/i, /(?:sto imparando|studio) ([^,.!?]+)/i, // German patterns /(?:ich möchte|ich will|mein ziel ist) ([^,.!?]+)/i, /(?:ich lerne|ich studiere) ([^,.!?]+)/i, // Japanese patterns /(?:私は)?(?:[^、。！？!?,.]+)したい/i, /(?:学んでいる|勉強している) ([^。！？!?、,.]+)/i, // Chinese patterns /(?:我想|我要|我的目标是)([^，。！？!?,.]+)/i, /(?:我在学习|我学习)([^，。！？!?,.]+)/i ], experiences: [ // English patterns /we went to ([^,.!?]+)/i, /we met (?:at|on|in) ([^,.!?]+)/i, /our (?:first date|first kiss|trip|vacation) (?:was|was at|was on|was in|was to) ([^,.!?]+)/i, /our anniversary (?:is|falls on|will be) ([^,.!?]+)/i, /we moved in (?:together )?(?:on|in)?\s*([^,.!?]+)/i, // French patterns /on s'est rencontr[ée]s? (?:à|au|en|le) ([^,.!?]+)/i, /on est all[ée]s? à ([^,.!?]+)/i, /notre (?:premier rendez-vous|première sortie) (?:était|c'était) ([^,.!?]+)/i, /notre anniversaire (?:est|c'est) ([^,.!?]+)/i, /on a emménagé (?:ensemble\s*)?(?:le|en|à)\s*([^,.!?]+)/i, // Spanish patterns /nos conocimos (?:en|el|la) ([^,.!?]+)/i, /fuimos a ([^,.!?]+)/i, /nuestra (?:primera cita|primera salida) (?:fue|era) ([^,.!?]+)/i, /nuestro aniversario (?:es|cae en|será) ([^,.!?]+)/i, /nos mudamos (?:juntos\s*)?(?:el|en|a)\s*([^,.!?]+)/i, // Italian patterns /ci siamo conosciuti (?:a|al|in|il) ([^,.!?]+)/i, /siamo andati a ([^,.!?]+)/i, /il nostro (?:primo appuntamento|primo bacio|viaggio) (?:era|è stato) ([^,.!?]+)/i, /il nostro anniversario (?:è|cade il|sarà) ([^,.!?]+)/i, /ci siamo trasferiti (?:insieme\s*)?(?:il|in|a)\s*([^,.!?]+)/i, // German patterns /wir haben uns (?:in|am) ([^,.!?]+) kennengelernt/i, /wir sind (?:nach|zu) ([^,.!?]+) (?:gegangen|gefahren)/i, /unser (?:erstes date|erster kuss|urlaub) (?:war|fand statt) ([^,.!?]+)/i, /unser jahrestag (?:ist|fällt auf|wird sein) ([^,.!?]+)/i, /wir sind (?:zusammen )?eingezogen (?:am|im|in)\s*([^,.!?]+)/i, // Japanese patterns /私たちは([^、。！？!?,.]+)で出会った/i, /一緒に([^、。！？!?,.]+)へ行った/i, /私たちの記念日(?:は)?([^、。！？!?,.]+)/i, /一緒に引っ越した(?:のは)?([^、。！？!?,.]+)/i, // Chinese patterns /我们在([^，。！？!?,.]+)认识/i, /我们去了([^，。！？!?,.]+)/i, /我们的纪念日是([^，。！？!?,.]+)/i, /我们一起搬家(?:是在)?([^，。！？!?,.]+)/i ], important: [ // English patterns /it's important (?:to remember|that) (.+)/i, /please remember (.+)/i, // French patterns /c'est important (?:de se souvenir|que) (.+)/i, /merci de te souvenir (.+)/i, // Spanish patterns /es importante (?:recordar|que) (.+)/i, /por favor recuerda (.+)/i, // Italian patterns /è importante (?:ricordare|che) (.+)/i, /per favore ricorda (.+)/i, // German patterns /es ist wichtig (?:zu erinnern|dass) (.+)/i, /bitte erinnere dich an (.+)/i, // Japanese patterns /重要なのは(.+)です/i, /覚えておいてほしいのは(.+)です/i, // Chinese patterns /重要的是(.+)/i, /请记住(.+)/i ] }; // Performance optimization: pre-compile regex patterns this.compiledPatterns = {}; this.initializeCompiledPatterns(); } // Pre-compile all regex patterns for better performance initializeCompiledPatterns() { try { for (const [category, patterns] of Object.entries(this.extractionPatterns)) { this.compiledPatterns[category] = patterns.map(pattern => { if (pattern instanceof RegExp) { return pattern; // Already compiled } return new RegExp(pattern.source, pattern.flags); }); } if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { const totalPatterns = Object.values(this.compiledPatterns).reduce((sum, arr) => sum + arr.length, 0); console.log(`🚀 Pre-compiled ${totalPatterns} regex patterns for memory extraction`); } } catch (error) { console.error("Error pre-compiling regex patterns:", error); // Fallback: use original patterns this.compiledPatterns = this.extractionPatterns; } } // Utility method to get consistent creation timestamp getCreationTimestamp(memory) { // Prefer createdAt, fallback to timestamp for backward compatibility return memory.createdAt || memory.timestamp || new Date(); } // Utility method to calculate days since creation getDaysSinceCreation(memory) { const created = new Date(this.getCreationTimestamp(memory)).getTime(); return (Date.now() - created) / (1000 * 60 * 60 * 24); } async init() { if (!this.db) { console.warn("Database not available for memory system"); return; } try { this.memoryEnabled = await this.db.getPreference( "memorySystemEnabled", window.KIMI_CONFIG?.DEFAULTS?.MEMORY_SYSTEM_ENABLED ?? true ); this.selectedCharacter = await this.db.getSelectedCharacter(); await this.createMemoryTables(); // Legacy migrations disabled - uncomment if needed for old databases // await this.migrateIncompatibleIDs(); // this.populateKeywordsForAllMemories().catch(e => console.warn("Keyword population failed", e)); } catch (error) { console.error("Memory system initialization error:", error); } } async createMemoryTables() { // Ensure memory tables exist in database if (!this.db.db.memories) { console.warn("Memory table not found in database schema"); return; } } // MEMORY EXTRACTION from conversation async extractMemoryFromText(userText, kimiResponse = null) { if (!this.memoryEnabled || !userText) return []; // Ensure selectedCharacter is initialized if (!this.selectedCharacter) { this.selectedCharacter = this.db ? await this.db.getSelectedCharacter() : "kimi"; } const extractedMemories = []; const text = userText.toLowerCase(); // Memory extraction processing (debug info reduced for performance) // Enhanced extraction with context awareness const existingMemories = await this.getAllMemories(); // First, check for explicit memory requests const explicitRequests = this.detectExplicitMemoryRequests(userText); if (explicitRequests.length > 0) { // Explicit memory requests detected extractedMemories.push(...explicitRequests); } // Extract using pre-compiled patterns for better performance const patternsToUse = this.compiledPatterns || this.extractionPatterns; for (const [category, patterns] of Object.entries(patternsToUse)) { for (const pattern of patterns) { const match = text.match(pattern); if (match && match[1]) { const content = match[1].trim(); // Skip very short or generic content if (content.length < this.config.minContentLength || this.isGenericContent(content)) { continue; } // Check if this is a meaningful update to existing memory const isUpdate = await this.isMemoryUpdate(category, content, existingMemories); const memory = { category: category, type: "auto_extracted", content: content, sourceText: userText, confidence: this.calculateExtractionConfidence(match, userText), createdAt: new Date(), // Use createdAt consistently character: this.selectedCharacter || "kimi", // Fallback protection isUpdate: isUpdate }; // Pattern match detected extractedMemories.push(memory); } } } // Enhanced pattern detection for more natural expressions const enhancedMemories = await this.detectNaturalExpressions(userText, existingMemories); extractedMemories.push(...enhancedMemories); // Save extracted memories with intelligent deduplication const savedMemories = []; for (const memory of extractedMemories) { try { console.log("💾 Saving memory:", memory.content); const saved = await this.addMemory(memory); if (saved) { savedMemories.push(saved); } else { console.warn("⚠️ Memory was not saved (possibly filtered or merged):", memory.content); } } catch (error) { console.error("❌ Failed to save memory:", { content: memory.content, category: memory.category, error: error.message }); // Continue processing other memories even if one fails } } if (savedMemories.length > 0) { if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log(`✅ Successfully extracted and saved ${savedMemories.length} memories`); } } else if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log("📝 No memories extracted from this text"); } return savedMemories; } // Detect explicit memory requests like "ajoute en mémoire que..." detectExplicitMemoryRequests(text) { const memories = []; const lowerText = text.toLowerCase(); // French patterns for explicit memory requests const frenchPatterns = [ /(?:ajoute?s?(?:r)?|retiens?|mémorise?s?|enregistre?s?|sauvegarde?s?)\s+(?:au|à|en|dans)\s+(?:la\s+|le\s+)?(?:système?\s+(?:de\s+)?)?mémoire\s+(?:que\s+)?(.+)/i, /(?:peux-tu|pourrais-tu|veux-tu)?\s*(?:ajouter|retenir|mémoriser|enregistrer|sauvegarder)\s+(?:que\s+)?(.+)\s+(?:en|dans)\s+(?:la\s+|le\s+)?mémoire/i, /(?:je\s+veux\s+que\s+tu\s+)?(?:retienne?s|mémorise?s|ajoute?s)\s+(?:que\s+)?(.+)/i ]; // English patterns for explicit memory requests const englishPatterns = [ /(?:add\s+to\s+memory|remember|memorize|save\s+(?:to\s+)?memory)\s+(?:that\s+)?(.+)/i, /(?:can\s+you|could\s+you)?\s*(?:add|remember|memorize|save)\s+(?:that\s+)?(.+)\s+(?:to\s+|in\s+)?memory/i, /(?:i\s+want\s+you\s+to\s+)?(?:remember|memorize|add)\s+(?:that\s+)?(.+)/i ]; // Spanish explicit memory requests const spanishPatterns = [ /(?:añade|agrega|recuerda|memoriza|guarda)\s+(?:en|a)\s+(?:la\s+)?memoria\s+(?:que\s+)?(.+)/i, /(?:puedes|podrías)?\s*(?:añadir|agregar|recordar|memorizar|guardar)\s+(?:que\s+)?(.+)\s+(?:en|a)\s+(?:la\s+)?memoria/i, /(?:quiero\s+que\s+)?(?:recuerdes|memorices|añadas)\s+(?:que\s+)?(.+)/i ]; // Italian explicit memory requests const italianPatterns = [ /(?:aggiungi|ricorda|memorizza|salva)\s+(?:nella|in)\s+memoria\s+(?:che\s+)?(.+)/i, /(?:puoi|potresti)?\s*(?:aggiungere|ricordare|memorizzare|salvare)\s+(?:che\s+)?(.+)\s+(?:nella|in)\s+memoria/i, /(?:voglio\s+che\s+)?(?:ricordi|memorizzi|aggiunga)\s+(?:che\s+)?(.+)/i ]; // German explicit memory requests const germanPatterns = [ /(?:füge|merke|speichere)\s+(?:es\s+)?(?:in|zur)\s+?gedächtnis|speicher\s+(?:dass\s+)?(.+)/i, /(?:kannst\s+du|könntest\s+du)?\s*(?:hinzufügen|merken|speichern)\s+(?:dass\s+)?(.+)\s+(?:in|zum)\s+(?:gedächtnis|speicher)/i, /(?:ich\s+möchte\s+dass\s+du)\s*(?:merkst|speicherst|hinzufügst)\s+(?:dass\s+)?(.+)/i ]; // Japanese explicit memory requests const japanesePatterns = [ /記憶に(?:追加|保存|覚えて)(?:して)?(?:ほしい|ください)?(?:、)?(.+)/i, /(?:覚えて|記憶して)(?:ほしい|ください)?(?:、)?(.+)/i ]; // Chinese explicit memory requests const chinesePatterns = [ /把(.+)记在(?:记忆|内存|记忆库)里/i, /(?:请)?记住(?:这件事|这个|以下)?(.+)/i, /保存到记忆(?:里|中)(?:的是)?(.+)/i ]; const allPatterns = [ ...frenchPatterns, ...englishPatterns, ...spanishPatterns, ...italianPatterns, ...germanPatterns, ...japanesePatterns, ...chinesePatterns ]; for (const pattern of allPatterns) { const match = lowerText.match(pattern); if (match && match[1]) { const content = match[1].trim(); // Determine category based on content const category = this.categorizeExplicitMemory(content); memories.push({ category: category, type: "explicit_request", content: content, sourceText: text, confidence: 1.0, // High confidence for explicit requests timestamp: new Date(), character: this.selectedCharacter, isUpdate: false }); break; // Only take the first match to avoid duplicates } } return memories; } // Categorize explicit memory based on content analysis categorizeExplicitMemory(content) { const lowerContent = content.toLowerCase(); // Preference indicators if ( lowerContent.includes("j'aime") || lowerContent.includes("i like") || lowerContent.includes("j'adore") || lowerContent.includes("i love") || lowerContent.includes("je préfère") || lowerContent.includes("i prefer") || lowerContent.includes("je déteste") || lowerContent.includes("i hate") ) { return "preferences"; } // Personal information indicators if ( lowerContent.includes("je m'appelle") || lowerContent.includes("my name is") || (lowerContent.includes("j'ai") && lowerContent.includes("ans")) || lowerContent.includes("years old") || lowerContent.includes("j'habite") || lowerContent.includes("i live") ) { return "personal"; } // Relationship indicators if ( lowerContent.includes("ma femme") || lowerContent.includes("my wife") || lowerContent.includes("mon mari") || lowerContent.includes("my husband") || lowerContent.includes("mon ami") || lowerContent.includes("my friend") || lowerContent.includes("ma famille") || lowerContent.includes("my family") ) { return "relationships"; } // Activity indicators if ( lowerContent.includes("je joue") || lowerContent.includes("i play") || lowerContent.includes("je pratique") || lowerContent.includes("i practice") || lowerContent.includes("mon hobby") || lowerContent.includes("my hobby") ) { return "activities"; } // Goal indicators if ( lowerContent.includes("je veux") || lowerContent.includes("i want") || lowerContent.includes("mon objectif") || lowerContent.includes("my goal") || lowerContent.includes("j'apprends") || lowerContent.includes("i'm learning") ) { return "goals"; } // Default to preferences for most explicit requests return "preferences"; } // Check if content is too generic to be useful isGenericContent(content) { const genericWords = ["yes", "no", "ok", "okay", "sure", "thanks", "hello", "hi", "bye"]; return genericWords.includes(content.toLowerCase()) || content.length < this.config.minContentLength; } // Calculate confidence based on context and pattern strength calculateExtractionConfidence(match, fullText) { let confidence = this.config.confidence.base; // Base confidence from config // Boost confidence for explicit statements const lower = fullText.toLowerCase(); if ( lower.includes("my name is") || lower.includes("i am called") || lower.includes("je m'appelle") || lower.includes("mon nom est") || lower.includes("je me prénomme") || lower.includes("je me nomme") || lower.includes("me llamo") || lower.includes("mi nombre es") || lower.includes("mi chiamo") || lower.includes("il mio nome è") || lower.includes("ich heiße") || lower.includes("mein name ist") || lower.includes("と申します") || lower.includes("私の名前は") || lower.includes("我叫") || lower.includes("我的名字是") ) { confidence += this.config.confidence.bonusForExplicitStatement; } // Boost for longer, more specific content if (match[1] && match[1].trim().length > this.config.longContentThreshold) { confidence += this.config.confidence.bonusForLongContent; } // Reduce confidence for uncertain language if (fullText.includes("maybe") || fullText.includes("perhaps") || fullText.includes("might")) { confidence -= this.config.confidence.penaltyForUncertainty; } return Math.min(this.config.confidence.max, Math.max(this.config.confidence.min, confidence)); } // Generate a short title (2-5 words max) from content for auto-extracted memories generateTitleFromContent(content) { if (!content || typeof content !== "string") return ""; // Remove surrounding punctuation and collapse whitespace const cleaned = content .replace(/[\n\r]+/g, " ") .replace(/["'“”‘’–—:;()\[\]{}]+/g, "") .trim(); const words = cleaned.split(/\s+/).filter(Boolean); if (words.length === 0) return ""; // Prefer 3 words when available, minimum 2 when possible, maximum 5 let take; if (words.length >= this.config.titleWordCount.preferred) take = this.config.titleWordCount.preferred; else take = words.length; // 1 or 2 take = Math.min(this.config.titleWordCount.max, Math.max(this.config.titleWordCount.min, take)); const slice = words.slice(0, take); // Capitalize first word for nicer title slice[0] = slice[0].charAt(0).toUpperCase() + slice[0].slice(1); return slice.join(" "); } // Check if this is an update to existing memory rather than new info async isMemoryUpdate(category, content, existingMemories) { const categoryMemories = existingMemories.filter(m => m.category === category); for (const memory of categoryMemories) { const similarity = this.calculateSimilarity(memory.content, content); if (similarity > this.config.similarity.update) { // Lower threshold for updates return true; } } return false; } // Detect natural expressions that patterns might miss async detectNaturalExpressions(text, existingMemories) { const naturalMemories = []; const lowerText = text.toLowerCase(); // Detect name mentions in natural context (multilingual) const namePatterns = [ // English /call me (\w+)/i, /(\w+) here[,.]?/i, /this is (\w+)/i, /(\w+) speaking/i, // French /appelle-?moi (\w+)/i, /on m'appelle (\w+)/i, /c'est (\w+)/i, // Spanish /llámame (\w+)/i, /me llaman (\w+)/i, /soy (\w+)/i, // Italian /chiamami (\w+)/i, /mi chiamano (\w+)/i, /sono (\w+)/i, // German /nenn mich (\w+)/i, /man nennt mich (\w+)/i, /ich bin (\w+)/i, // Japanese /(?:私は)?(\w+)です/i, // Chinese /我是(\w+)/i, /叫我(\w+)/i ]; for (const pattern of namePatterns) { const match = lowerText.match(pattern); if (match && match[1] && match[1].length > 1) { const name = match[1].trim(); // Skip if too generic if (!this.isGenericContent(name) && !this.isCommonWord(name)) { naturalMemories.push({ category: "personal", type: "auto_extracted", content: name, sourceText: text, confidence: 0.7, createdAt: new Date(), // Use createdAt consistently character: this.selectedCharacter || "kimi" // Fallback protection }); } } } return naturalMemories; } // Check if word is too common to be a name isCommonWord(word, language = "en") { // Use existing constants if available if (window.KIMI_COMMON_WORDS && window.KIMI_COMMON_WORDS[language]) { return window.KIMI_COMMON_WORDS[language].includes(word.toLowerCase()); } // Fallback to original English list const commonWords = [ "the", "and", "for", "are", "but", "not", "you", "all", "can", "had", "her", "was", "one", "our", "out", "day", "get", "has", "him", "his", "how", "man", "new", "now", "old", "see", "two", "way", "who", "boy", "did", "its", "let", "put", "say", "she", "too", "use" ]; return commonWords.includes(word.toLowerCase()); } // MANUAL MEMORY MANAGEMENT async addMemory(memoryData) { if (!this.db || !this.memoryEnabled) return; try { // Check for duplicates with intelligent merging const existing = await this.findSimilarMemory(memoryData); if (existing) { // Intelligent merge strategy return await this.mergeMemories(existing, memoryData); } // Add memory with metadata (let DB auto-generate ID) const now = new Date(); const memory = { category: memoryData.category || "personal", type: memoryData.type || "manual", content: memoryData.content, // precomputed keywords for faster matching and relevance keywords: this.deriveKeywords(memoryData.content), // Title: use provided title or generate for auto_extracted title: memoryData.title && typeof memoryData.title === "string" ? memoryData.title : memoryData.type === "auto_extracted" ? this.generateTitleFromContent(memoryData.content) : "", sourceText: memoryData.sourceText || "", confidence: memoryData.confidence || 1.0, createdAt: memoryData.createdAt || memoryData.timestamp || now, // Unified timestamp handling character: memoryData.character || this.selectedCharacter || "kimi", // Fallback protection isActive: true, tags: [...new Set([...(memoryData.tags || []), ...this.deriveMemoryTags(memoryData)])], lastModified: now, lastAccess: now, accessCount: 0, importance: this.calculateImportance(memoryData) }; if (this.db.db.memories) { const id = await this.db.db.memories.add(memory); memory.id = id; // Store the auto-generated ID if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log(`Memory added with ID: ${id}`); } } // Cleanup old memories if we exceed limit await this.cleanupOldMemories(); // Notify LLM system to refresh context this.notifyLLMContextUpdate(); return memory; } catch (error) { console.error("Error adding memory:", error); return null; // Return null instead of undefined for clearer error handling } } // Intelligent memory merging async mergeMemories(existingMemory, newMemoryData) { try { // Determine merge strategy based on content and confidence const strategy = this.determineMergeStrategy(existingMemory, newMemoryData); let mergedContent = existingMemory.content; let mergedConfidence = existingMemory.confidence; let mergedTags = [...(existingMemory.tags || [])]; switch (strategy) { case "update_content": // New information is more confident/recent mergedContent = newMemoryData.content; mergedConfidence = Math.max(existingMemory.confidence, newMemoryData.confidence || 0.8); break; case "merge_content": // Combine information intelligently if ( existingMemory.category === "personal" && this.areRelatedNames(existingMemory.content, newMemoryData.content) ) { // Handle name variants mergedContent = this.mergeNames(existingMemory.content, newMemoryData.content); } else { // General merge - keep most specific mergedContent = newMemoryData.content.length > existingMemory.content.length ? newMemoryData.content : existingMemory.content; } mergedConfidence = (existingMemory.confidence + (newMemoryData.confidence || 0.8)) / 2; break; case "add_variant": // Store as variant/alias mergedTags.push(`alias:${newMemoryData.content}`); break; case "boost_confidence": // Same content, boost confidence mergedConfidence = Math.min(1.0, existingMemory.confidence + 0.1); break; } // Update existing memory const updatedMemory = { ...existingMemory, content: mergedContent, confidence: mergedConfidence, tags: [...new Set([...mergedTags, ...this.deriveMemoryTags(newMemoryData)])], // Remove duplicates lastModified: new Date(), accessCount: (existingMemory.accessCount || 0) + 1, importance: Math.max(existingMemory.importance || 0.5, this.calculateImportance(newMemoryData)) }; await this.updateMemory(existingMemory.id, updatedMemory); return updatedMemory; } catch (error) { console.error("Error merging memories:", error); return existingMemory; } } // Simplified memory merge strategy determination determineMergeStrategy(existing, newData) { const similarity = this.calculateSimilarity(existing.content, newData.content); const newConfidence = newData.confidence || this.config.confidence.base; const existingConfidence = existing.confidence || this.config.confidence.base; // Very high similarity (>90%) - boost confidence if new is more confident if (similarity > this.config.similarity.veryHigh) { return newConfidence > existingConfidence ? "boost_confidence" : "merge_content"; } // High similarity (>70%) - decide based on content length and specificity if (similarity > this.config.similarity.preferences) { // If new content is significantly longer (50% more), it's likely more detailed if (newData.content.length > existing.content.length * 1.5) { return "update_content"; } // If existing is longer, merge to preserve information return "merge_content"; } // For personal names, handle as variants if they're related if (existing.category === "personal" && this.areRelatedNames(existing.content, newData.content)) { return "add_variant"; } // Default strategy for moderate similarity return "merge_content"; } // Merge name variants intelligently mergeNames(name1, name2) { // Keep the longest/most formal version as primary if (name1.length > name2.length) { return name1; } else if (name2.length > name1.length) { return name2; } // If same length, keep the first one return name1; } // Calculate importance of memory for prioritization calculateImportance(memoryData) { let importance = 0.5; // Base importance // Category base weights const categoryWeights = { important: 1.0, personal: 0.9, relationships: 0.85, goals: 0.75, experiences: 0.65, preferences: 0.6, activities: 0.5 }; importance = categoryWeights[memoryData.category] || 0.5; const content = (memoryData.content || "").toLowerCase(); const tags = new Set([...(memoryData.tags || []), ...this.deriveMemoryTags(memoryData)]); // Heuristic boosts for meaningful relationship milestones and commitments const milestoneTags = [ "relationship:first_meet", "relationship:first_date", "relationship:first_kiss", "relationship:anniversary", "relationship:moved_in", "relationship:engaged", "relationship:married", "relationship:breakup" ]; if ([...tags].some(t => milestoneTags.includes(t))) importance += 0.15; // Boundaries and consent are high priority to remember if ([...tags].some(t => t.startsWith("boundary:"))) importance += 0.15; // Preferences tied to strong like/dislike if ( content.includes("i love") || content.includes("j'adore") || content.includes("i hate") || content.includes("je déteste") ) { importance += 0.05; } // Temporal cues: future commitments or dates if (/(\bnext\b|\btomorrow\b|\bce soir\b|\bdemain\b|\bmañana\b|\bdomani\b|\bmorgen\b)/i.test(content)) { importance += 0.05; } // Longer details and high confidence if (memoryData.content && memoryData.content.length > this.config.longContentThreshold) importance += this.config.importance.bonuses.longContent; if (memoryData.confidence && memoryData.confidence > 0.9) importance += this.config.importance.bonuses.highConfidence; // Round to two decimals to avoid floating point artifacts return Math.min(1.0, Math.round(importance * 100) / 100); } // Derive semantic tags from memory content to assist prioritization and merging deriveMemoryTags(memoryData) { const tags = []; const text = (memoryData.content || "").toLowerCase(); const category = memoryData.category || ""; // Relationship status and milestones if (/(single|célibataire|soltero|single|ledig)/i.test(text)) tags.push("relationship:status_single"); if (/(in a relationship|en couple|together|ensemble|pareja|coppia|beziehung)/i.test(text)) tags.push("relationship:status_in_relationship"); if (/(engaged|fiancé|fiancée|promis|promised|verlobt)/i.test(text)) tags.push("relationship:status_engaged"); if (/(married|marié|mariée|casado|sposato|verheiratet)/i.test(text)) tags.push("relationship:status_married"); if (/(broke up|rupture|separated|separado|separati|getrennt)/i.test(text)) tags.push("relationship:breakup"); if (/(first date|premier rendez-vous|primera cita|primo appuntamento)/i.test(text)) tags.push("relationship:first_date"); if (/(first kiss|premier baiser|primer beso|primo bacio)/i.test(text)) tags.push("relationship:first_kiss"); if (/(anniversary|anniversaire|aniversario|anniversario|jahrestag)/i.test(text)) tags.push("relationship:anniversary"); if (/(moved in together|emménagé ensemble|mudamos juntos|trasferiti insieme|zusammen eingezogen)/i.test(text)) tags.push("relationship:moved_in"); if (/(met at|rencontré à|conocimos en|conosciuti a|kennengelernt)/i.test(text)) tags.push("relationship:first_meet"); // Boundaries and consent (keep generic and non-graphic) if (/(i don't like|je n'aime pas|no me gusta|non mi piace|ich mag nicht)\s+[^,.!?]+/i.test(text)) tags.push("boundary:dislike"); if (/(i prefer|je préfère|prefiero|preferisco|ich bevorzuge)\s+[^,.!?]+/i.test(text)) tags.push("boundary:preference"); if (/(no|pas)\s+(?:kissing|baiser|beso|bacio|küssen)/i.test(text)) tags.push("boundary:limit"); if (/(consent|consentement|consentimiento|consenso|einwilligung)/i.test(text)) tags.push("boundary:consent"); // Time-related tags if (/(today|ce jour|hoy|oggi|heute|今日)/i.test(text)) tags.push("time:today"); if (/(tomorrow|demain|mañana|domani|morgen|明日)/i.test(text)) tags.push("time:tomorrow"); if (/(next week|semaine prochaine|la próxima semana|la prossima settimana|nächste woche)/i.test(text)) tags.push("time:next_week"); // Category-specific hints if (category === "preferences") tags.push("type:preference"); if (category === "personal") tags.push("type:personal"); if (category === "relationships") tags.push("type:relationship"); if (category === "experiences") tags.push("type:experience"); if (category === "goals") tags.push("type:goal"); if (category === "important") tags.push("type:important"); return tags; } async updateMemory(memoryId, updateData) { if (!this.db) return false; try { // Ensure memoryId is the correct type const numericId = typeof memoryId === "string" ? parseInt(memoryId) : memoryId; // Vérifier d'abord que la mémoire existe const existingMemory = await this.db.db.memories.get(numericId); if (!existingMemory) { console.error(`❌ Memory with ID ${numericId} not found in database`); return false; } console.log(`🔄 Updating memory ${numericId}:`, { existing: existingMemory, update: updateData }); const update = { ...updateData, lastModified: new Date() }; if (this.db.db.memories) { const result = await this.db.db.memories.update(numericId, update); console.log(`Memory update result for ID ${numericId}:`, result); if (result > 0) { console.log("✅ Memory updated successfully"); // Notify LLM system to refresh context this.notifyLLMContextUpdate(); return true; } else { console.error("❌ Memory update failed - no rows affected"); return false; } } } catch (error) { console.error("Error updating memory:", error, { memoryId, updateData }); return false; } } async deleteMemory(memoryId) { if (!this.db) return false; try { // Ensure memoryId is the correct type const numericId = typeof memoryId === "string" ? parseInt(memoryId) : memoryId; if (this.db.db.memories) { const result = await this.db.db.memories.delete(numericId); console.log(`Memory delete result for ID ${numericId}:`, result); // Notify LLM system to refresh context if (result) { this.notifyLLMContextUpdate(); } return result; } } catch (error) { console.error("Error deleting memory:", error, { memoryId }); return false; } } notifyLLMContextUpdate() { // Debounce context updates to avoid excessive calls if (this.contextUpdateTimeout) { clearTimeout(this.contextUpdateTimeout); } this.contextUpdateTimeout = setTimeout(() => { if (window.kimiLLM && typeof window.kimiLLM.refreshMemoryContext === "function") { window.kimiLLM.refreshMemoryContext(); } }, 500); } async getMemoriesByCategory(category, character = null) { if (!this.db) return []; try { character = character || this.selectedCharacter || "kimi"; // Unified fallback if (this.db.db.memories) { const memories = await this.db.db.memories .where("[character+category]") .equals([character, category]) .and(m => m.isActive) .reverse() .sortBy("timestamp"); // Update lastAccess/accessCount for top results to improve prioritization this._touchMemories(memories, 10).catch(() => {}); return memories; } } catch (error) { console.error("Error getting memories by category:", error); return []; } } async getAllMemories(character = null) { if (!this.db) return []; try { character = character || this.selectedCharacter || "kimi"; if (this.db.db.memories) { // Use simple character filter - compatible with all data const memories = await this.db.db.memories .where("character") .equals(character) .filter(memory => memory.isActive !== false) // Include records without isActive field .reverse() .sortBy("timestamp"); if (window.KIMI_DEBUG_MEMORIES) { console.log(`Retrieved ${memories.length} memories for character: ${character}`); } // Touch top memories to update access metrics this._touchMemories(memories, 10).catch(() => {}); return memories; } } catch (error) { console.error("Error getting all memories:", error); return []; } } async findSimilarMemory(memoryData) { if (!this.db) return null; try { const memories = await this.getMemoriesByCategory(memoryData.category); // Precompute keywords for new memory const newKeys = this.deriveKeywords(memoryData.content || ""); // Enhanced similarity check with multiple criteria for (const memory of memories) { // Prefilter by keyword overlap to reduce false positives and improve perf const memKeys = memory.keywords || this.deriveKeywords(memory.content || ""); const overlap = newKeys.filter(k => memKeys.includes(k)).length; if (newKeys.length > 0 && overlap === 0) continue; // no shared keywords -> likely different const contentSimilarity = this.calculateSimilarity(memory.content, memoryData.content); // Different thresholds based on category const threshold = this.config.similarity[memoryData.category] || this.config.similarity.default; if (contentSimilarity > threshold) { return memory; } // Special handling for names (check if one is contained in the other) if (memoryData.category === "personal" && this.areRelatedNames(memory.content, memoryData.content)) { return memory; } } } catch (error) { console.error("Error finding similar memory:", error); } return null; } // Check if two names are related (nicknames, variants, etc.) areRelatedNames(name1, name2) { const n1 = name1.toLowerCase().trim(); const n2 = name2.toLowerCase().trim(); // Exact match if (n1 === n2) return true; // One contains the other (Jean-Pierre vs Jean) if (n1.includes(n2) || n2.includes(n1)) return true; // Common nickname patterns const nicknames = { jean: ["jp", "jeannot"], pierre: ["pete", "pietro"], marie: ["mary", "maria"], michael: ["mike", "mick"], william: ["bill", "will", "willy"], robert: ["bob", "rob", "bobby"], richard: ["rick", "dick", "richie"], thomas: ["tom", "tommy"], christopher: ["chris", "kit"], anthony: ["tony", "ant"] }; for (const [full, nicks] of Object.entries(nicknames)) { if ((n1 === full && nicks.includes(n2)) || (n2 === full && nicks.includes(n1))) { return true; } } return false; } calculateSimilarity(text1, text2) { // Enhanced similarity calculation const words1 = text1 .toLowerCase() .split(/\s+/) .filter(w => w.length > 2); const words2 = text2 .toLowerCase() .split(/\s+/) .filter(w => w.length > 2); if (words1.length === 0 || words2.length === 0) { return text1.toLowerCase() === text2.toLowerCase() ? 1 : 0; } const intersection = words1.filter(word => words2.includes(word)); const union = [...new Set([...words1, ...words2])]; let similarity = intersection.length / union.length; // Boost similarity for exact substring matches if (text1.toLowerCase().includes(text2.toLowerCase()) || text2.toLowerCase().includes(text1.toLowerCase())) { similarity += 0.2; } return Math.min(1.0, similarity); } // Derive a set of normalized keywords from text deriveKeywords(text) { if (!text || typeof text !== "string") return []; return [ ...new Set( text .toLowerCase() .replace(/[\p{P}\p{S}]/gu, " ") .split(/\s+/) .filter(w => w.length > 2 && !this.isCommonWordSafe(w)) ) ]; } // Safe wrapper for isCommonWord to avoid undefined function errors isCommonWordSafe(word, language = "en") { const cacheKey = `${word.toLowerCase()}_${language}`; // Check cache first if (this.keywordCache.has(cacheKey)) { this.keywordCacheHits++; return this.keywordCache.get(cacheKey); } // Cache miss - compute the result this.keywordCacheMisses++; let isCommon = false; try { isCommon = typeof this.isCommonWord === "function" ? this.isCommonWord(word, language) : false; } catch (error) { console.warn("Error checking common word:", error); isCommon = false; } // Add to cache with LRU eviction if (this.keywordCache.size >= this.keywordCacheSize) { // Simple LRU: remove oldest entry (first in Map) const firstKey = this.keywordCache.keys().next().value; this.keywordCache.delete(firstKey); } this.keywordCache.set(cacheKey, isCommon); return isCommon; } // Get cache statistics for debugging getKeywordCacheStats() { const total = this.keywordCacheHits + this.keywordCacheMisses; return { size: this.keywordCache.size, hits: this.keywordCacheHits, misses: this.keywordCacheMisses, hitRate: total > 0 ? ((this.keywordCacheHits / total) * 100).toFixed(2) + "%" : "0%" }; } // Get performance statistics for debugging and optimization getPerformanceStats() { const calculateStats = times => { if (times.length === 0) return { avg: 0, max: 0, min: 0, count: 0 }; return { avg: Math.round((times.reduce((sum, t) => sum + t, 0) / times.length) * 100) / 100, max: Math.round(Math.max(...times) * 100) / 100, min: Math.round(Math.min(...times) * 100) / 100, count: times.length }; }; return { keywordCache: this.getKeywordCacheStats(), extraction: calculateStats(this.queryStats.extractionTime), addMemory: calculateStats(this.queryStats.addMemoryTime), retrieval: calculateStats(this.queryStats.retrievalTime) }; } // Performance wrapper for memory extraction async extractMemoryFromTextTimed(userText, kimiResponse = null) { const start = performance.now(); const result = await this.extractMemoryFromText(userText, kimiResponse); const duration = performance.now() - start; this.queryStats.extractionTime.push(duration); if (this.queryStats.extractionTime.length > 100) { this.queryStats.extractionTime.shift(); // Keep only last 100 measurements } if (duration > 100 && window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.warn(`🐌 Slow memory extraction: ${duration.toFixed(2)}ms for text length ${userText?.length || 0}`); } return result; } // Get current configuration for debugging and monitoring getConfiguration() { return { ...this.config, memoryCategories: this.memoryCategories, runtime: { memoryEnabled: this.memoryEnabled, maxMemoryEntries: this.maxMemoryEntries, selectedCharacter: this.selectedCharacter, keywordCacheSize: this.keywordCache.size, compiledPatternsCount: Object.values(this.compiledPatterns || {}).reduce((sum, arr) => sum + arr.length, 0) } }; } // Update configuration at runtime (for advanced users) updateConfiguration(configPath, value) { const keys = configPath.split("."); let current = this.config; // Navigate to the parent object for (let i = 0; i < keys.length - 1; i++) { if (!current[keys[i]]) current[keys[i]] = {}; current = current[keys[i]]; } // Set the value const lastKey = keys[keys.length - 1]; const oldValue = current[lastKey]; current[lastKey] = value; if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log(`🔧 Configuration updated: ${configPath} = ${value} (was: ${oldValue})`); } return { oldValue, newValue: value }; } async cleanupOldMemories() { if (!this.db) return; try { // Retrieve all active memories for the current character const memories = await this.getAllMemories(); const maxEntries = window.KIMI_MAX_MEMORIES || this.maxMemoryEntries || 100; const ttlDays = window.KIMI_MEMORY_TTL_DAYS || 365; // Soft-expire memories older than TTL by marking isActive=false const now = Date.now(); const ttlMs = ttlDays * 24 * 60 * 60 * 1000; const expiredMemories = []; for (const mem of memories) { const created = new Date(this.getCreationTimestamp(mem)).getTime(); if (now - created > ttlMs) { try { await this.updateMemory(mem.id, { isActive: false }); expiredMemories.push(mem.id); } catch (e) { console.error(`Memory expiration failed for ID ${mem.id}:`, { error: e.message, memoryId: mem.id, createdAt: this.getCreationTimestamp(mem), character: mem.character }); // Continue with other memories even if one fails } } } if (window.KIMI_CONFIG?.DEBUG?.MEMORY && expiredMemories.length > 0) { console.log(`Successfully expired ${expiredMemories.length} memories:`, expiredMemories); } // Refresh active memories after TTL purge const activeMemories = (await this.getAllMemories()).filter(m => m.isActive); // If still more than maxEntries, mark lowest-priority ones inactive (soft delete) if (activeMemories.length > maxEntries) { // Sort by a combined score: low importance + old timestamp + low access activeMemories.sort((a, b) => { const scoreA = (a.importance || 0.5) * -1 + (a.accessCount || 0) * 0.01 + new Date(this.getCreationTimestamp(a)).getTime() / (1000 * 60 * 60 * 24); const scoreB = (b.importance || 0.5) * -1 + (b.accessCount || 0) * 0.01 + new Date(this.getCreationTimestamp(b)).getTime() / (1000 * 60 * 60 * 24); return scoreB - scoreA; }); const toDeactivate = activeMemories.slice(maxEntries); const deactivatedMemories = []; const failedDeactivations = []; for (const mem of toDeactivate) { try { await this.updateMemory(mem.id, { isActive: false }); deactivatedMemories.push(mem.id); } catch (e) { console.error(`Memory deactivation failed for ID ${mem.id}:`, { error: e.message, memoryId: mem.id, importance: mem.importance, character: mem.character }); failedDeactivations.push(mem.id); } } if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log( `Memory cleanup: ${deactivatedMemories.length} deactivated, ${failedDeactivations.length} failed` ); } } } catch (error) { console.error("Error cleaning up old memories:", error); } } // MEMORY RETRIEVAL FOR LLM async getRelevantMemories(context = "", limit = 10) { if (!this.memoryEnabled) return []; try { const allMemories = await this.getAllMemories(); if (allMemories.length === 0) return []; if (!context) { // Return most important and recent memories const res = this.selectMostImportantMemories(allMemories, limit); // touch top results to update access metrics this._touchMemories(res, limit).catch(() => {}); return res; } // Score memories based on relevance to context const scoredMemories = allMemories.map(memory => ({ ...memory, relevanceScore: this.calculateRelevance(memory, context) })); // Sort by relevance and return top results scoredMemories.sort((a, b) => b.relevanceScore - a.relevanceScore); // Filter out very low relevance memories const relevantMemories = scoredMemories.filter(m => m.relevanceScore > 0.1); const out = relevantMemories.slice(0, limit).map(r => r); // touch top results to update access metrics this._touchMemories( out.map(r => r), limit ).catch(() => {}); return out; } catch (error) { console.error("Error getting relevant memories:", error); return []; } } // Select most important memories when no context is provided selectMostImportantMemories(memories, limit) { // Score by importance, recency, and access count const scoredMemories = memories.map(memory => { let score = memory.importance || 0.5; // Boost recent memories const daysSinceCreation = this.getDaysSinceCreation(memory); score += Math.max(0, (7 - daysSinceCreation) / 7) * 0.2; // Recent boost // Boost frequently accessed memories const accessCount = memory.accessCount || 0; score += Math.min(accessCount / 10, 0.2); // Access boost // Boost high confidence memories score += (memory.confidence || 0.5) * 0.1; return { ...memory, importanceScore: score }; }); scoredMemories.sort((a, b) => b.importanceScore - a.importanceScore); return scoredMemories.slice(0, limit); } calculateRelevance(memory, context) { const contextWords = context .toLowerCase() .split(/\s+/) .filter(w => w.length > 2); const memoryWords = memory.content .toLowerCase() .split(/\s+/) .filter(w => w.length > 2); let score = 0; // Enhanced content similarity with keyword matching score += this.calculateSimilarity(memory.content, context) * this.config.relevance.contentSimilarity; // Keyword overlap boost (derived keywords) try { const memKeys = memory.keywords || this.deriveKeywords(memory.content || ""); const ctxKeys = this.deriveKeywords(context || ""); const keyOverlap = ctxKeys.filter(k => memKeys.includes(k)).length; if (ctxKeys.length > 0) { score += (keyOverlap / ctxKeys.length) * this.config.relevance.keywordOverlap; } } catch (e) { // fallback to original keyword matching let keywordMatches = 0; for (const word of contextWords) { if (memoryWords.includes(word)) { keywordMatches++; } } if (contextWords.length > 0) { score += (keywordMatches / contextWords.length) * this.config.relevance.keywordOverlap; } } // Category relevance bonus based on context score += this.getCategoryRelevance(memory.category, context) * this.config.relevance.categoryRelevance; // Recent memories get bonus for current conversation const daysSinceCreation = this.getDaysSinceCreation(memory); score += Math.max( 0, (this.config.relevance.recentDaysThreshold - daysSinceCreation) / this.config.relevance.recentDaysThreshold ) * this.config.relevance.recencyBonus; // Confidence and importance boost score += (memory.confidence || 0.5) * this.config.relevance.confidenceBonus; score += (memory.importance || 0.5) * this.config.relevance.importanceBonus; return Math.min(1.0, score); } // Determine if memory category is relevant to current context getCategoryRelevance(category, context) { const contextLower = context.toLowerCase(); const categoryKeywords = { personal: [ "name", "age", "live", "work", "job", "who", "am", "myself", "appelle", "nombre", "chiamo", "heiße", "名前", "名字", "我叫" ], preferences: [ "like", "love", "hate", "prefer", "enjoy", "favorite", "dislike", "j'aime", "j'adore", "je préfère", "je déteste", "me gusta", "prefiero", "odio", "mi piace", "preferisco", "ich mag", "ich bevorzuge", "hasse" ], relationships: [ "family", "friend", "wife", "husband", "partner", "mother", "father", "girlfriend", "boyfriend", "anniversary", "date", "kiss", "move in", "famille", "ami", "copine", "copain", "anniversaire", "rendez-vous", "baiser", "emménagé", "pareja", "cita", "beso", "aniversario", "mudarnos", "fidanzata", "fidanzato", "anniversario", "bacio", "trasferiti", "freundin", "freund", "jahrestag", "kuss", "eingezogen" ], activities: [ "play", "hobby", "sport", "activity", "practice", "do", "joue", "passe-temps", "hobby", "juego", "pasatiempo", "gioco", "passatempo", "spiele", "hobby" ], goals: [ "want", "plan", "goal", "dream", "hope", "wish", "future", "veux", "objectif", "apprends", "aprendo", "voglio", "obiettivo", "lerne", "ziel" ], experiences: [ "remember", "happened", "story", "experience", "time", "we met", "first date", "first kiss", "anniversary", "rencontré", "premier rendez-vous", "premier baiser", "anniversaire", "conocimos", "primera cita", "primer beso", "aniversario", "conosciuti", "primo appuntamento", "primo bacio", "anniversario", "kennengelernt", "erstes date", "erster kuss", "jahrestag" ], important: [ "important", "remember", "special", "never forget", "important", "souvenir", "spécial", "importante", "recuerda", "importante", "ricorda", "wichtig", "erinnere" ] }; const keywords = categoryKeywords[category] || []; let relevance = 0; for (const keyword of keywords) { if (contextLower.includes(keyword)) { relevance += 0.2; } } return Math.min(1.0, relevance); } // Update access count when memory is used async recordMemoryAccess(memoryId) { try { const memory = await this.db.db.memories.get(memoryId); if (memory) { memory.accessCount = (memory.accessCount || 0) + 1; memory.lastAccess = new Date(); await this.db.db.memories.put(memory); } } catch (error) { console.error("Error recording memory access:", error); } } // Touch multiple memories to update lastAccess and accessCount async _touchMemories(memories, limit = 5) { if (!this.db || !Array.isArray(memories) || memories.length === 0) return; try { const top = memories.slice(0, limit); const now = new Date(); const minMinutes = window.KIMI_MEMORY_TOUCH_MINUTES || 60; const minTouchInterval = minMinutes * 60 * 1000; // Batch collection: gather all updates before executing const batchUpdates = []; for (const m of top) { try { const id = m.id; const existing = await this.db.db.memories.get(id); if (existing) { const lastAccess = existing.lastAccess ? new Date(existing.lastAccess).getTime() : 0; // Only touch if enough time has passed if (now.getTime() - lastAccess > minTouchInterval) { batchUpdates.push({ key: id, changes: { accessCount: (existing.accessCount || 0) + 1, lastAccess: now } }); } } } catch (e) { console.warn("Error preparing memory touch batch for", m && m.id, e); } } // Execute all updates in a single batch operation if (batchUpdates.length > 0) { if (this.db.db.memories.bulkUpdate) { // Use bulkUpdate if available (Dexie 3.x+) await this.db.db.memories.bulkUpdate(batchUpdates); } else { // Fallback: parallel individual updates (still better than sequential) const updatePromises = batchUpdates.map(update => this.db.db.memories.update(update.key, update.changes)); await Promise.all(updatePromises); } if (window.KIMI_CONFIG?.DEBUG?.MEMORY) { console.log(`📊 Batch touched ${batchUpdates.length} memories`); } } } catch (e) { console.warn("Error in _touchMemories batch processing", e); } } // ===== MEMORY SCORING & RANKING ===== scoreMemory(memory) { // Factors: importance (0-1), recency, frequency, confidence const now = Date.now(); const created = memory.createdAt ? new Date(memory.createdAt).getTime() : memory.timestamp ? new Date(memory.timestamp).getTime() : now; const lastAccess = memory.lastAccess ? new Date(memory.lastAccess).getTime() : created; const ageMs = Math.max(1, now - created); const sinceLastAccessMs = Math.max(1, now - lastAccess); // Recency: exponential decay const recency = Math.exp(-sinceLastAccessMs / (1000 * 60 * 60 * 24 * 14)); // 14-day half-life approx const freshness = Math.exp(-ageMs / (1000 * 60 * 60 * 24 * 60)); // 60-day aging const freq = Math.log10((memory.accessCount || 0) + 1) / Math.log10(50); // normalized frequency (cap ~50) const importance = typeof memory.importance === "number" ? memory.importance : 0.5; const confidence = typeof memory.confidence === "number" ? memory.confidence : 0.5; // Weighted sum using global knobs const wImportance = window.KIMI_WEIGHT_IMPORTANCE || 0.35; const wRecency = window.KIMI_WEIGHT_RECENCY || 0.2; const wFrequency = window.KIMI_WEIGHT_FREQUENCY || 0.15; const wConfidence = window.KIMI_WEIGHT_CONFIDENCE || 0.2; const wFreshness = window.KIMI_WEIGHT_FRESHNESS || 0.1; const score = importance * wImportance + recency * wRecency + freq * wFrequency + confidence * wConfidence + freshness * wFreshness; return Number(score.toFixed(6)); } async getRankedMemories(contextText = "", limit = 7) { const all = await this.getAllMemories(); if (!all.length) return []; // Optional basic context relevance boost const ctxLower = (contextText || "").toLowerCase(); // Favor pinned memories by boosting their base score return all .map(m => { let baseScore = this.scoreMemory(m); if (m.tags && m.tags.includes && m.tags.includes("pinned")) baseScore += 0.2; if (ctxLower && m.content && ctxLower.includes(m.content.toLowerCase().split(" ")[0])) { baseScore += 0.05; // tiny relevance boost } return { memory: m, score: baseScore }; }) .sort((a, b) => b.score - a.score) .slice(0, limit) .map(r => r.memory); } // Pin/unpin APIs to manually mark important memories async pinMemory(memoryId) { if (!this.db) return false; try { const m = await this.db.db.memories.get(memoryId); if (!m) return false; const tags = new Set([...(m.tags || []), "pinned"]); await this.db.db.memories.update(memoryId, { tags: [...tags], importance: Math.max(m.importance || 0.5, 0.95) }); return true; } catch (e) { console.error("Error pinning memory", e); return false; } } async unpinMemory(memoryId) { if (!this.db) return false; try { const m = await this.db.db.memories.get(memoryId); if (!m) return false; const tags = new Set([...(m.tags || [])]); tags.delete("pinned"); await this.db.db.memories.update(memoryId, { tags: [...tags] }); return true; } catch (e) { console.error("Error unpinning memory", e); return false; } } // Summarize recent memories into a non-destructive summary memory async summarizeRecentMemories(days = 7, options = { category: null, archiveSources: false }) { if (!this.db) return null; try { const cutoff = Date.now() - (days || 7) * 24 * 60 * 60 * 1000; const all = await this.getAllMemories(); // Exclude existing summaries to avoid summarizing summaries repeatedly const recent = all.filter( m => new Date(this.getCreationTimestamp(m)).getTime() >= cutoff && m.isActive && m.type !== "summary" && !(m.tags && m.tags.includes("summary")) ); if (!recent.length) return null; // Group by top keyword const groups = {}; for (const m of recent) { const keys = m.keywords && m.keywords.length ? m.keywords : this.deriveKeywords(m.content || ""); const top = keys[0] || "misc"; groups[top] = groups[top] || []; groups[top].push(m); } // Build a simple summary per group const summaries = []; for (const [k, items] of Object.entries(groups)) { const contents = items.map(i => i.content).slice(0, 6); summaries.push(`${k}: ${contents.join(" | ")}`); } const summaryContent = `Summary (${days}d): ` + summaries.join(" \n"); const summaryJson = { summary: summaries }; const summaryMemory = { category: options.category || "experiences", type: "summary", content: summaryContent, sourceText: summaryContent, summaryJson: JSON.stringify(summaryJson), confidence: 0.9, createdAt: new Date(), // Use createdAt consistently character: this.selectedCharacter, isActive: true, tags: ["summary"] }; const saved = await this.addMemory(summaryMemory); // Optionally archive sources (soft-deactivate) if (options.archiveSources) { for (const m of recent) { try { await this.updateMemory(m.id, { isActive: false }); } catch (e) { console.warn("Failed to archive source memory", m.id, e); } } } return saved; } catch (e) { console.error("Error summarizing memories", e); return null; } } // Summarize recent memories and replace sources (hard delete) - destructive async summarizeAndReplace(days = 7, options = { category: null }) { if (!this.db) return null; try { const cutoff = Date.now() - (days || 7) * 24 * 60 * 60 * 1000; const all = await this.getAllMemories(); // Exclude existing summaries to avoid recursive summarization const recent = all.filter( m => new Date(this.getCreationTimestamp(m)).getTime() >= cutoff && m.isActive && m.type !== "summary" && !(m.tags && m.tags.includes("summary")) ); if (!recent.length) return null; // Build aggregate content from readable fields in chronological order recent.sort((a, b) => new Date(this.getCreationTimestamp(a)) - new Date(this.getCreationTimestamp(b))); const texts = recent .map(r => { const raw = (r.title && r.title.trim()) || (r.sourceText && r.sourceText.trim()) || (r.content && r.content.trim()) || ""; if (!raw) return ""; // Normalize whitespace and remove stray leading punctuation let t = raw.replace(/\s+/g, " ").replace(/^[^\p{L}\p{N}]+/u, ""); // Capitalize first meaningful letter if (t && t.length > 0) t = t.charAt(0).toUpperCase() + t.slice(1); return t; }) .filter(Boolean) .slice(0, 200); const summaryContent = `Summary (${days}d):\n` + texts.map(t => `- ${t}`).join("\n"); const summaryJson = { summary: texts }; const summaryMemory = { category: options.category || "experiences", type: "summary", title: `Summary - last ${days} days`, content: summaryContent, // Store the actual summary also in sourceText so editors/UIs show it sourceText: summaryContent, summaryJson: JSON.stringify(summaryJson), confidence: 0.95, timestamp: new Date(), character: this.selectedCharacter, isActive: true, tags: ["summary", "replaced"] }; // Add summary directly to DB to avoid addMemory's merge logic let saved = null; if (this.db && this.db.db && this.db.db.memories) { try { const id = await this.db.db.memories.add(summaryMemory); summaryMemory.id = id; saved = summaryMemory; console.log("Summary added with ID:", id); // Read back the saved record to verify stored fields try { const savedRec = await this.db.db.memories.get(id); console.log("Saved summary record:", { id, content: savedRec.content, sourceText: savedRec.sourceText }); } catch (e) { console.warn("Unable to read back saved summary", e); } } catch (e) { console.error("Failed to write summary directly to DB", e); } } else { // Fallback to addMemory if DB not available saved = await this.addMemory(summaryMemory); } // Hard-delete sources for (const m of recent) { try { if (this.db && this.db.db && this.db.db.memories) { await this.db.db.memories.delete(m.id); } } catch (e) { console.warn("Failed to delete source memory", m.id, e); } } // Notify LLM to refresh context this.notifyLLMContextUpdate(); return saved; } catch (e) { console.error("Error in summarizeAndReplace", e); return null; } } // MEMORY STATISTICS async getMemoryStats() { try { const memories = await this.getAllMemories(); const stats = { total: memories.length, byCategory: {}, averageConfidence: 0, oldestMemory: null, newestMemory: null }; if (memories.length > 0) { // Category breakdown for (const memory of memories) { stats.byCategory[memory.category] = (stats.byCategory[memory.category] || 0) + 1; } // Average confidence stats.averageConfidence = memories.reduce((sum, m) => sum + m.confidence, 0) / memories.length; // Oldest and newest const sortedByDate = [...memories].sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp)); stats.oldestMemory = sortedByDate[0]; stats.newestMemory = sortedByDate[sortedByDate.length - 1]; } return stats; } catch (error) { console.error("Error getting memory stats:", error); return { total: 0, byCategory: {}, averageConfidence: 0 }; } } // MEMORY TOGGLE async toggleMemorySystem(enabled) { this.memoryEnabled = enabled; if (this.db) { await this.db.setPreference("memorySystemEnabled", enabled); } } // EXPORT/IMPORT MEMORIES async exportMemories() { try { const memories = await this.getAllMemories(); return { exportDate: new Date().toISOString(), character: this.selectedCharacter, memories: memories, version: "1.0" }; } catch (error) { console.error("Error exporting memories:", error); return null; } } async importMemories(importData) { if (!importData || !importData.memories) return false; try { for (const memory of importData.memories) { await this.addMemory({ ...memory, type: "imported", character: this.selectedCharacter }); } return true; } catch (error) { console.error("Error importing memories:", error); return false; } } // MIGRATION UTILITIES async migrateIncompatibleIDs() { if (!this.db) return false; try { console.log("🔧 Début de la migration des IDs incompatibles..."); // Récupérer toutes les mémoires const allMemories = await this.db.db.memories.toArray(); console.log(`📊 ${allMemories.length} mémoires trouvées`); const incompatibleMemories = allMemories.filter(memory => { // Les IDs auto-increment sont des entiers séquentiels (1, 2, 3...) // Les anciens IDs manuels sont des nombres très grands (timestamps) return memory.id > 10000; // Seuil arbitraire pour détecter les anciens IDs }); if (incompatibleMemories.length === 0) { console.log("✅ Aucune migration nécessaire"); return true; } console.log(`🔄 Migration de ${incompatibleMemories.length} mémoires avec IDs incompatibles`); // Sauvegarder les données avant suppression const dataToMigrate = incompatibleMemories.map(memory => { const { id, ...memoryData } = memory; // Enlever l'ancien ID return memoryData; }); // Supprimer les anciennes entrées await this.db.db.memories.bulkDelete(incompatibleMemories.map(m => m.id)); // Réinsérer avec de nouveaux IDs auto-générés const newIds = await this.db.db.memories.bulkAdd(dataToMigrate); console.log(`✅ Migration terminée. Nouveaux IDs:`, newIds); return true; } catch (error) { console.error("❌ Erreur lors de la migration:", error); return false; } } // Background migration: populate keywords for all existing memories if missing async populateKeywordsForAllMemories() { if (!this.db || !this.db.db.memories) return false; try { console.log("🔧 Starting background keyword population..."); const all = await this.db.db.memories.toArray(); const ops = []; for (const mem of all) { if (!mem.keywords || !Array.isArray(mem.keywords) || mem.keywords.length === 0) { const keys = this.deriveKeywords(mem.content || ""); ops.push(this.db.db.memories.update(mem.id, { keywords: keys })); } // batch in small chunks to avoid blocking if (ops.length >= 50) { await Promise.all(ops); ops.length = 0; } } if (ops.length) await Promise.all(ops); console.log("✅ Keyword population complete"); return true; } catch (e) { console.warn("Error populating keywords", e); return false; } } } window.KimiMemorySystem = KimiMemorySystem; export default KimiMemorySystem;