kiku-agent 1.0.0

package/server/agent/memory.js

@@ -0,0 +1,566 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const MEMORY_DIR = path.resolve(process.cwd(), '.kiku_sessions');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'long_term_memory.json');
+const SESSIONS_DIR = path.join(MEMORY_DIR, 'sessions');
+
+
+export class AgentMemory {
+  constructor() {
+    this.facts = [];
+    this.preferences = {
+      language: null,          
+      topicsOfInterest: [],    
+      responseStyle: 'default', 
+    };
+    this.sessions = [];         
+    this.summaries = [];       
+    this.stats = {
+      totalFacts: 0,
+      totalSessions: 0,
+      totalConsolidations: 0,
+      lastConsolidationAt: null,
+      createdAt: new Date()
+    };
+    this._loaded = false;
+  }
+
+
+  async init() {
+    try {
+      await fs.mkdir(MEMORY_DIR, { recursive: true });
+      await fs.mkdir(SESSIONS_DIR, { recursive: true });
+    } catch {}
+  }
+
+  
+  async load() {
+    try {
+      await this.init();
+      const data = await fs.readFile(MEMORY_FILE, 'utf-8');
+      const parsed = JSON.parse(data);
+      
+     
+      this.facts = (parsed.facts || []).map(f => ({
+        ...f,
+        createdAt: f.createdAt ? new Date(f.createdAt) : new Date(),
+        lastAccessedAt: f.lastAccessedAt ? new Date(f.lastAccessedAt) : new Date()
+      }));
+      
+      const loadedPrefs = parsed.preferences || {};
+      this.preferences = {
+        ...this.preferences,
+        ...loadedPrefs,
+        topicsOfInterest: (loadedPrefs.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? new Date(t.lastSeen) : new Date()
+        }))
+      };
+      
+      this.sessions = parsed.sessions || [];
+      this.summaries = parsed.summaries || [];
+      this.stats = { ...this.stats, ...(parsed.stats || {}) };
+      this._loaded = true;
+      return true;
+    } catch {
+      this._loaded = true;
+      return false;
+    }
+  }
+
+
+  async save() {
+    try {
+      await this.init();
+      
+      const serializablePrefs = {
+        ...this.preferences,
+        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
+        }))
+      };
+      const data = {
+        facts: this.facts.map(f => ({
+          ...f,
+          createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
+          lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
+        })),
+        preferences: serializablePrefs,
+        sessions: this.sessions,
+        summaries: this.summaries,
+        stats: this.stats,
+        lastSavedAt: new Date().toISOString()
+      };
+      await fs.writeFile(MEMORY_FILE, JSON.stringify(data, null, 2), 'utf-8');
+      return true;
+    } catch (error) {
+      console.error('Failed to save long-term memory:', error);
+      return false;
+    }
+  }
+
+  addFact(fact, meta = {}) {
+    const entry = {
+      id: `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      content: fact,
+      category: meta.category || 'general',
+      source: meta.source || 'conversation',
+      confidence: meta.confidence || 'high',
+      createdAt: new Date(),
+      lastAccessedAt: new Date(),
+      accessCount: 0,
+      tags: meta.tags || []
+    };
+    this.facts.push(entry);
+    this.stats.totalFacts = this.facts.length;
+    this.save().catch(() => {});
+    return entry;
+  }
+
+ 
+  searchFacts(query, options = {}) {
+    const { category, limit = 10 } = options;
+    const q = (query || '').toLowerCase().trim();
+    
+    let results = this.facts;
+    
+    if (category) {
+      results = results.filter(f => f.category === category);
+    }
+    
+    if (q) {
+      results = results.filter(f => 
+        f.content.toLowerCase().includes(q) ||
+        f.tags.some(t => t.toLowerCase().includes(q))
+      );
+    }
+
+   
+    results.sort((a, b) => {
+      const scoreA = (a.accessCount || 0) + (new Date(a.createdAt).getTime() / 1e12);
+      const scoreB = (b.accessCount || 0) + (new Date(b.createdAt).getTime() / 1e12);
+      return scoreB - scoreA;
+    });
+
+  
+    for (const fact of results.slice(0, limit)) {
+      fact.lastAccessedAt = new Date();
+      fact.accessCount = (fact.accessCount || 0) + 1;
+    }
+
+    return results.slice(0, limit);
+  }
+
+  removeFact(factId) {
+    const idx = this.facts.findIndex(f => f.id === factId);
+    if (idx === -1) return false;
+    this.facts.splice(idx, 1);
+    this.stats.totalFacts = this.facts.length;
+    this.save().catch(() => {});
+    return true;
+  }
+
+  
+  getFactsByCategory() {
+    const grouped = {};
+    for (const fact of this.facts) {
+      const cat = fact.category || 'general';
+      if (!grouped[cat]) grouped[cat] = [];
+      grouped[cat].push(fact);
+    }
+    return grouped;
+  }
+
+  setPreference(key, value) {
+    this.preferences[key] = value;
+    this.save().catch(() => {});
+  }
+
+  
+  async savePreferences() {
+    await this.save();
+  }
+
+  
+  trackTopicInterest(topic) {
+    const existing = this.preferences.topicsOfInterest.find(
+      t => t.topic.toLowerCase() === topic.toLowerCase()
+    );
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = new Date();
+    } else {
+      this.preferences.topicsOfInterest.push({
+        topic,
+        count: 1,
+        lastSeen: new Date()
+      });
+    }
+   
+    this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
+    this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
+    this.save().catch(() => {});
+  }
+
+
+  getTopTopics(limit = 5) {
+    return this.preferences.topicsOfInterest.slice(0, limit);
+  }
+
+  
+  async archiveSession(sessionData) {
+    const archive = {
+      id: sessionData.id,
+      createdAt: sessionData.createdAt,
+      endedAt: new Date(),
+      messageCount: sessionData.messages?.length || 0,
+      stats: { ...sessionData.stats },
+      thinkingMode: sessionData.thinkingMode,
+      summary: null 
+    };
+
+   
+    try {
+      const sessionFile = path.join(SESSIONS_DIR, `${sessionData.id}.json`);
+      await fs.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to archive session file:', err);
+    }
+
+    this.sessions.push(archive);
+    this.stats.totalSessions = this.sessions.length;
+    await this.save();
+    return archive;
+  }
+
+  getArchivedSessions(limit = 20) {
+    return this.sessions
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, limit);
+  }
+
+  async loadArchivedSession(sessionId) {
+    try {
+      const sessionFile = path.join(SESSIONS_DIR, `${sessionId}.json`);
+      const data = await fs.readFile(sessionFile, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+
+
+  async consolidateSession(sessionData) {
+    if (!sessionData?.messages?.length) return null;
+
+    const userMessages = sessionData.messages
+      .filter(m => m.role === 'user')
+      .map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return textPart?.content || '';
+      })
+      .filter(Boolean);
+
+    const assistantMessages = sessionData.messages
+      .filter(m => m.role === 'assistant')
+      .map(m => {
+        const textPart = m.parts?.find(p => p.type === 'text');
+        return textPart?.content || '';
+      })
+      .filter(Boolean);
+
+    const topics = this._extractTopics(userMessages);
+
+    for (const topic of topics) {
+      this.trackTopicInterest(topic);
+    }
+
+    const summary = {
+      id: `sum_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      sessionId: sessionData.id,
+      createdAt: new Date(),
+      topics,
+      questionCount: userMessages.length,
+      keyExchanges: userMessages.slice(0, 5).map((q, i) => ({
+        question: q.slice(0, 200),
+        answerPreview: (assistantMessages[i] || '').slice(0, 200)
+      })),
+      durationMs: sessionData.stats?.totalDurationMs || 0,
+      toolCalls: sessionData.stats?.totalToolCalls || 0
+    };
+
+    this.summaries.push(summary);
+    this.stats.totalConsolidations = this.summaries.length;
+    this.stats.lastConsolidationAt = new Date();
+    
+    const archived = this.sessions.find(s => s.id === sessionData.id);
+    if (archived) {
+      archived.summary = summary;
+    }
+
+    await this.save();
+    return summary;
+  }
+
+  _extractTopics(messages) {
+    const topicKeywords = {
+      'drama': ['drama', 'series', 'ละคร', '剧', '电视', 'tv series', 'film', 'movie', 'work'],
+      'music': ['song', 'music', 'mv', 'single', 'ost', 'เพลง', '歌', 'album', 'discography'],
+      'brand': ['brand', 'ambassador', 'endorsement', 'แบรนด์', '品牌', 'commercial'],
+      'awards': ['award', 'honor', 'ceremony', 'รางวัล', '奖', 'winner'],
+      'profile': ['profile', 'bio', 'birthday', 'age', 'ประวัติ', '资料', '个人信息'],
+      'timeline': ['career', 'timeline', 'history', 'era', 'เส้นทาง', '经历', 'ปี'],
+      'news': ['news', 'latest', 'recent', 'update', 'ข่าว', '最新', 'ล่าสุด'],
+      'video': ['video', 'stage', 'performance', 'live', 'คลิป', '视频', '舞台'],
+      'social': ['weibo', 'douyin', 'instagram', 'social media', 'โซเชียล', '微博'],
+      'gallery': ['photo', 'picture', 'gallery', 'fashion', 'photoshoot', 'ภาพ', '照片']
+    };
+
+    const topicCounts = {};
+    const allText = messages.join(' ').toLowerCase();
+
+    for (const [topic, keywords] of Object.entries(topicKeywords)) {
+      const count = keywords.reduce((acc, kw) => {
+        const regex = new RegExp(`\\b${kw}\\b`, 'gi');
+        return acc + (allText.match(regex) || []).length;
+      }, 0);
+      if (count > 0) topicCounts[topic] = count;
+    }
+
+    return Object.entries(topicCounts)
+      .sort(([, a], [, b]) => b - a)
+      .slice(0, 5)
+      .map(([topic]) => topic);
+  }
+
+
+  buildMemoryContext() {
+    const parts = [];
+
+    if (this.preferences.language) {
+      parts.push(`User's preferred language: ${this.preferences.language}`);
+    }
+
+    const topTopics = this.getTopTopics(5);
+    if (topTopics.length > 0) {
+      const topicList = topTopics.map(t => `${t.topic} (${t.count}x)`).join(', ');
+      parts.push(`User frequently asks about: ${topicList}`);
+    }
+
+    const recentFacts = this.facts
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, 8);
+    if (recentFacts.length > 0) {
+      const factList = recentFacts.map(f => `- ${f.content}`).join('\n');
+      parts.push(`Known facts from previous conversations:\n${factList}`);
+    }
+
+    const recentSummaries = this.summaries
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, 3);
+    if (recentSummaries.length > 0) {
+      const sumList = recentSummaries.map(s => {
+        const date = new Date(s.createdAt).toLocaleDateString();
+        const topics = s.topics.join(', ');
+        return `- [${date}] Topics: ${topics} (${s.questionCount} questions)`;
+      }).join('\n');
+      parts.push(`Recent conversation themes:\n${sumList}`);
+    }
+
+    if (parts.length === 0) return '';
+
+    return `\n\n=== LONG-TERM MEMORY CONTEXT ===\n${parts.join('\n\n')}\n=== END MEMORY CONTEXT ===`;
+  }
+
+  getStatus() {
+    return {
+      factsCount: this.facts.length,
+      factsByCategory: this.getFactsByCategory(),
+      preferences: this.preferences,
+      sessionsCount: this.sessions.length,
+      summariesCount: this.summaries.length,
+      topTopics: this.getTopTopics(10),
+      stats: this.stats,
+      lastConsolidationAt: this.stats.lastConsolidationAt,
+      memoryFileSize: null
+    };
+  }
+
+  async importFromJSON(filePath) {
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const data = JSON.parse(raw);
+
+      if (!data.facts && !data.preferences && !data.sessions) {
+        return { success: false, message: 'Invalid memory file format — missing facts, preferences, or sessions.' };
+      }
+
+      let factsImported = 0;
+      let factsSkipped = 0;
+      let topicsImported = 0;
+
+      if (Array.isArray(data.facts)) {
+        for (const fact of data.facts) {
+          const isDuplicate = this.facts.some(
+            existing => existing.content === fact.content
+          );
+          if (!isDuplicate && fact.content) {
+            this.facts.push({
+              id: fact.id || `fact_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+              content: fact.content,
+              category: fact.category || 'imported',
+              source: fact.source || 'import',
+              confidence: fact.confidence || 'high',
+              createdAt: fact.createdAt ? new Date(fact.createdAt) : new Date(),
+              lastAccessedAt: new Date(),
+              accessCount: 0,
+              tags: fact.tags || []
+            });
+            factsImported++;
+          } else {
+            factsSkipped++;
+          }
+        }
+      }
+
+      if (data.preferences) {
+        if (data.preferences.language) {
+          this.preferences.language = data.preferences.language;
+        }
+        if (data.preferences.responseStyle) {
+          this.preferences.responseStyle = data.preferences.responseStyle;
+        }
+        if (Array.isArray(data.preferences.topicsOfInterest)) {
+          for (const topic of data.preferences.topicsOfInterest) {
+            const existing = this.preferences.topicsOfInterest.find(
+              t => t.topic.toLowerCase() === topic.topic.toLowerCase()
+            );
+            if (existing) {
+              existing.count += topic.count || 1;
+              existing.lastSeen = new Date();
+            } else {
+              this.preferences.topicsOfInterest.push({
+                topic: topic.topic,
+                count: topic.count || 1,
+                lastSeen: topic.lastSeen ? new Date(topic.lastSeen) : new Date()
+              });
+              topicsImported++;
+            }
+          }
+          this.preferences.topicsOfInterest.sort((a, b) => b.count - a.count);
+          this.preferences.topicsOfInterest = this.preferences.topicsOfInterest.slice(0, 20);
+        }
+      }
+
+      if (Array.isArray(data.sessions)) {
+        for (const session of data.sessions) {
+          const isDuplicate = this.sessions.some(s => s.id === session.id);
+          if (!isDuplicate) {
+            this.sessions.push(session);
+          }
+        }
+      }
+
+      if (Array.isArray(data.summaries)) {
+        for (const summary of data.summaries) {
+          const isDuplicate = this.summaries.some(s => s.id === summary.id);
+          if (!isDuplicate) {
+            this.summaries.push(summary);
+          }
+        }
+      }
+
+      this.stats.totalFacts = this.facts.length;
+      this.stats.totalSessions = this.sessions.length;
+      this.stats.totalConsolidations = this.summaries.length;
+
+      await this.save();
+
+      return {
+        success: true,
+        factsImported,
+        factsSkipped,
+        topicsImported,
+        totalFacts: this.facts.length,
+        totalSessions: this.sessions.length,
+        totalSummaries: this.summaries.length
+      };
+    } catch (error) {
+      return { success: false, message: error.message };
+    }
+  }
+
+  async exportToJSON() {
+    const exportDir = path.resolve(process.cwd(), 'exports');
+    try {
+      await fs.mkdir(exportDir, { recursive: true });
+    } catch {}
+
+    const now = new Date();
+    const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = `kiku-memory-${timestamp}.json`;
+    const filePath = path.join(exportDir, filename);
+
+    const exportData = {
+      exportedAt: now.toISOString(),
+      stats: this.stats,
+      preferences: {
+        ...this.preferences,
+        topicsOfInterest: (this.preferences.topicsOfInterest || []).map(t => ({
+          ...t,
+          lastSeen: t.lastSeen ? t.lastSeen.toISOString() : null
+        }))
+      },
+      facts: this.facts.map(f => ({
+        ...f,
+        createdAt: f.createdAt ? f.createdAt.toISOString() : f.createdAt,
+        lastAccessedAt: f.lastAccessedAt ? f.lastAccessedAt.toISOString() : f.lastAccessedAt
+      })),
+      factsByCategory: this.getFactsByCategory(),
+      sessions: this.sessions,
+      summaries: this.summaries
+    };
+
+    await fs.writeFile(filePath, JSON.stringify(exportData, null, 2), 'utf-8');
+    return { filePath, filename, size: (await fs.stat(filePath)).size };
+  }
+
+  async clearAll() {
+    this.facts = [];
+    this.preferences = {
+      language: null,
+      topicsOfInterest: [],
+      responseStyle: 'default'
+    };
+    this.sessions = [];
+    this.summaries = [];
+    this.stats = {
+      totalFacts: 0,
+      totalSessions: 0,
+      totalConsolidations: 0,
+      lastConsolidationAt: null,
+      createdAt: new Date()
+    };
+    await this.save();
+    return true;
+  }
+
+  async getStorageSize() {
+    try {
+      const stat = await fs.stat(MEMORY_FILE);
+      return stat.size;
+    } catch {
+      return 0;
+    }
+  }
+
+  static formatBytes(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+  }
+}