whats-mcp 0.1.0

package/src/store.js

@@ -0,0 +1,925 @@
+/**
+ * whats-mcp — In-memory store.
+ *
+ * Captures Baileys events to maintain a searchable cache of chats,
+ * contacts, messages, and group metadata.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const { formatMessage, isGroupJid } = require("./helpers");
+
+const ANALYTICS_STOP_WORDS = new Set([
+  "a", "an", "and", "are", "as", "at", "be", "by", "de", "des", "du", "en", "est",
+  "et", "for", "how", "il", "in", "is", "je", "la", "le", "les", "mais", "of", "on",
+  "or", "ou", "pour", "que", "qui", "the", "to", "tu", "un", "une", "vous", "with",
+]);
+
+class Store {
+  /**
+   * @param {{ max_messages_per_chat?: number, max_chats?: number }} opts
+   */
+  constructor(opts = {}) {
+    this.maxMessagesPerChat = opts.max_messages_per_chat || 500;
+    this.maxChats = opts.max_chats || 1000;
+    this.onChange = typeof opts.onChange === "function" ? opts.onChange : null;
+
+    /** @type {Map<string, object>} jid → chat */
+    this.chats = new Map();
+
+    /** @type {Map<string, object>} jid → contact */
+    this.contacts = new Map();
+
+    /** @type {Map<string, object[]>} jid → messages (newest last) */
+    this.messages = new Map();
+
+    /** @type {Map<string, object>} jid → group metadata cache */
+    this.groupMeta = new Map();
+
+    /** @type {Map<string, object>} msgId → message (for quick lookup) */
+    this.messageIndex = new Map();
+
+    /** @type {object | null} lazily built analytics cache */
+    this.analyticsCache = null;
+
+    /** @type {Map<string, string[]>} jid → custom tags */
+    this.contactTags = new Map();
+
+    /** @type {Map<string, string[]>} name → JID array (dynamic, persisted watchlists) */
+    this.watchlists = new Map();
+  }
+
+  // ── Chat operations ──────────────────────────────────────────────────────
+
+  upsertChats(chats) {
+    for (const chat of chats) {
+      const existing = this.chats.get(chat.id) || {};
+      this.chats.set(chat.id, { ...existing, ...chat });
+    }
+    this._trimChats();
+    this._notifyChanged();
+  }
+
+  updateChats(updates) {
+    for (const update of updates) {
+      const existing = this.chats.get(update.id);
+      if (existing) {
+        Object.assign(existing, update);
+      }
+    }
+    this._notifyChanged();
+  }
+
+  deleteChats(ids) {
+    for (const id of ids) {
+      this.chats.delete(id);
+      this.messages.delete(id);
+    }
+    this._notifyChanged();
+  }
+
+  getChat(jid) {
+    return this.chats.get(jid) || null;
+  }
+
+  listChats(limit = 50, offset = 0) {
+    const all = Array.from(this.chats.values());
+    // Sort by timestamp descending
+    all.sort((a, b) => {
+      const ta = Number(a.conversationTimestamp || 0);
+      const tb = Number(b.conversationTimestamp || 0);
+      return tb - ta;
+    });
+    return all.slice(offset, offset + limit);
+  }
+
+  // ── Contact operations ───────────────────────────────────────────────────
+
+  upsertContacts(contacts) {
+    for (const contact of contacts) {
+      const jid = contact.id;
+      if (!jid) continue;
+      const existing = this.contacts.get(jid) || {};
+      this.contacts.set(jid, { ...existing, ...contact });
+    }
+    this._notifyChanged();
+  }
+
+  updateContacts(updates) {
+    for (const update of updates) {
+      const jid = update.id;
+      if (!jid) continue;
+      const existing = this.contacts.get(jid);
+      if (existing) {
+        Object.assign(existing, update);
+      }
+    }
+    this._notifyChanged();
+  }
+
+  getContact(jid) {
+    return this.contacts.get(jid) || null;
+  }
+
+  listContacts(options = {}) {
+    let contacts = Array.from(this.contacts.values());
+    if (options.name) {
+      const lower = options.name.toLowerCase();
+      contacts = contacts.filter((c) => {
+        const name = (c.name || c.notify || c.verifiedName || c.short || "").toLowerCase();
+        return name.includes(lower);
+      });
+    }
+    if (options.tag) {
+      const taggedJids = new Set(this.listByTag(options.tag));
+      contacts = contacts.filter((c) => taggedJids.has(c.id));
+    }
+    if (options.has_tags !== undefined) {
+      contacts = options.has_tags
+        ? contacts.filter((c) => (this.contactTags.get(c.id) || []).length > 0)
+        : contacts.filter((c) => (this.contactTags.get(c.id) || []).length === 0);
+    }
+    return contacts;
+  }
+
+  // ── Contact tags ─────────────────────────────────────────────────────────
+
+  setContactTags(jid, tags) {
+    this.contactTags.set(jid, [...new Set(tags)]);
+    this._notifyChanged();
+  }
+
+  addContactTags(jid, tags) {
+    const existing = this.contactTags.get(jid) || [];
+    this.contactTags.set(jid, [...new Set([...existing, ...tags])]);
+    this._notifyChanged();
+  }
+
+  removeContactTags(jid, tags) {
+    const existing = this.contactTags.get(jid) || [];
+    const filtered = existing.filter((t) => !tags.includes(t));
+    if (filtered.length > 0) {
+      this.contactTags.set(jid, filtered);
+    } else {
+      this.contactTags.delete(jid);
+    }
+    this._notifyChanged();
+  }
+
+  getContactTags(jid) {
+    return this.contactTags.get(jid) || [];
+  }
+
+  listByTag(tag) {
+    const results = [];
+    for (const [jid, tags] of this.contactTags) {
+      if (tags.includes(tag)) results.push(jid);
+    }
+    return results;
+  }
+
+  getAllTags() {
+    const tags = new Set();
+    for (const tagList of this.contactTags.values()) {
+      for (const t of tagList) tags.add(t);
+    }
+    return Array.from(tags).sort();
+  }
+
+  // ── Watchlist operations ──────────────────────────────────────────────────
+
+  setWatchlist(name, jids) {
+    this.watchlists.set(name, [...new Set(jids)]);
+    this._notifyChanged();
+  }
+
+  addToWatchlist(name, jids) {
+    const existing = this.watchlists.get(name) || [];
+    this.watchlists.set(name, [...new Set([...existing, ...jids])]);
+    this._notifyChanged();
+  }
+
+  removeFromWatchlist(name, jids) {
+    const existing = this.watchlists.get(name) || [];
+    const jidSet = new Set(jids);
+    const filtered = existing.filter((j) => !jidSet.has(j));
+    if (filtered.length > 0) {
+      this.watchlists.set(name, filtered);
+    } else {
+      this.watchlists.delete(name);
+    }
+    this._notifyChanged();
+  }
+
+  deleteWatchlist(name) {
+    const existed = this.watchlists.has(name);
+    this.watchlists.delete(name);
+    if (existed) this._notifyChanged();
+    return existed;
+  }
+
+  getWatchlist(name) {
+    return this.watchlists.get(name) || null;
+  }
+
+  listWatchlists() {
+    return Object.fromEntries(this.watchlists);
+  }
+
+  /**
+   * Resolve a watchlist name → JID array.
+   * Checks the dynamic store first, then falls back to config watchlists.
+   */
+  resolveWatchlist(name, configWatchlists = {}) {
+    return this.watchlists.get(name) || configWatchlists[name] || null;
+  }
+
+  /**
+   * Import watchlists from config into the store (one-time bootstrap).
+   * Only imports names not already present in the store.
+   * @returns {number} number of watchlists imported
+   */
+  importWatchlistsFromConfig(configWatchlists = {}) {
+    let imported = 0;
+    for (const [name, jids] of Object.entries(configWatchlists)) {
+      if (Array.isArray(jids) && !this.watchlists.has(name)) {
+        this.watchlists.set(name, [...new Set(jids)]);
+        imported++;
+      }
+    }
+    if (imported > 0) this._notifyChanged();
+    return imported;
+  }
+
+  // ── Message operations ───────────────────────────────────────────────────
+
+  upsertMessages(messages) {
+    for (const msg of messages) {
+      const jid = msg.key?.remoteJid;
+      if (!jid) continue;
+
+      this._touchChatFromMessage(msg);
+
+      if (!this.messages.has(jid)) {
+        this.messages.set(jid, []);
+      }
+      const arr = this.messages.get(jid);
+
+      // Dedup by message id
+      const existing = arr.findIndex((m) => m.key?.id === msg.key?.id);
+      if (existing >= 0) {
+        arr[existing] = msg;
+      } else {
+        arr.push(msg);
+      }
+
+      // Index for quick lookup
+      if (msg.key?.id) {
+        this.messageIndex.set(msg.key.id, msg);
+      }
+
+      arr.sort((a, b) => {
+        const ta = Number(a.messageTimestamp || 0);
+        const tb = Number(b.messageTimestamp || 0);
+        if (ta !== tb) return ta - tb;
+        return String(a.key?.id || "").localeCompare(String(b.key?.id || ""));
+      });
+
+      // Trim
+      if (arr.length > this.maxMessagesPerChat) {
+        const removed = arr.splice(0, arr.length - this.maxMessagesPerChat);
+        for (const r of removed) {
+          if (r.key?.id) this.messageIndex.delete(r.key.id);
+        }
+      }
+    }
+    this._notifyChanged();
+  }
+
+  deleteMessages(keys) {
+    for (const key of keys) {
+      const jid = key.remoteJid;
+      const arr = this.messages.get(jid);
+      if (arr) {
+        const idx = arr.findIndex((m) => m.key?.id === key.id);
+        if (idx >= 0) {
+          arr.splice(idx, 1);
+        }
+      }
+      this.messageIndex.delete(key.id);
+    }
+    this._notifyChanged();
+  }
+
+  getMessages(jid, limit = 50, before_id, options = {}) {
+    const arr = this.messages.get(jid) || [];
+    let result = [...arr];
+
+    // Sort by timestamp descending
+    result.sort((a, b) => {
+      const ta = Number(a.messageTimestamp || 0);
+      const tb = Number(b.messageTimestamp || 0);
+      return tb - ta;
+    });
+
+    if (before_id) {
+      const idx = result.findIndex((m) => m.key?.id === before_id);
+      if (idx >= 0) {
+        result = result.slice(idx + 1);
+      }
+    }
+
+    result = this._applyMessageFilters(result, options);
+    return result.slice(0, limit);
+  }
+
+  countMessages(jid) {
+    return (this.messages.get(jid) || []).length;
+  }
+
+  getOldestMessage(jid) {
+    const arr = this.messages.get(jid) || [];
+    if (arr.length === 0) return null;
+
+    return [...arr].sort((a, b) => {
+      const ta = Number(a.messageTimestamp || 0);
+      const tb = Number(b.messageTimestamp || 0);
+      return ta - tb;
+    })[0] || null;
+  }
+
+  getMessage(id) {
+    return this.messageIndex.get(id) || null;
+  }
+
+  /**
+   * Search messages across all chats.
+   * @param {string} query - text to search for (case-insensitive)
+   * @param {string} [jid] - restrict to specific chat
+   * @param {number} [limit=20]
+   */
+  searchMessages(query, jid, limit = 20, options = {}) {
+    const lower = query.toLowerCase();
+    const results = [];
+
+    // Support single JID string, array of JIDs, or null/undefined (all)
+    let chatJids;
+    if (Array.isArray(jid)) {
+      chatJids = jid;
+    } else if (jid) {
+      chatJids = [jid];
+    } else {
+      chatJids = Array.from(this.messages.keys());
+    }
+
+    for (const chatJid of chatJids) {
+      let msgs = this.messages.get(chatJid) || [];
+      msgs = this._applyMessageFilters(msgs, options);
+      for (const msg of msgs) {
+        if (results.length >= limit) break;
+        const formatted = formatMessage(msg);
+        if (formatted && formatted.text.toLowerCase().includes(lower)) {
+          results.push(formatted);
+        }
+      }
+      if (results.length >= limit) break;
+    }
+
+    return results;
+  }
+
+  // ── Group metadata cache ─────────────────────────────────────────────────
+
+  setGroupMeta(jid, meta) {
+    this.groupMeta.set(jid, meta);
+    if (Array.isArray(meta?.participants) && meta.participants.length > 0) {
+      this.upsertContacts(
+        meta.participants
+          .filter((participant) => participant?.id)
+          .map((participant) => ({
+            id: participant.id,
+            admin: participant.admin || null,
+          }))
+      );
+    }
+    const chat = this.chats.get(jid) || { id: jid };
+    this.chats.set(jid, {
+      ...chat,
+      id: jid,
+      name: meta?.subject || chat.name,
+      subject: meta?.subject || chat.subject,
+      conversationTimestamp:
+        Number(chat.conversationTimestamp || 0) ||
+        Number(meta?.subjectTime || 0) ||
+        Number(meta?.creation || 0) ||
+        undefined,
+    });
+    this._trimChats();
+    this._notifyChanged();
+  }
+
+  getGroupMeta(jid) {
+    return this.groupMeta.get(jid) || null;
+  }
+
+  // ── History sync ─────────────────────────────────────────────────────────
+
+  /**
+   * Handle the `messaging-history.set` event.
+   */
+  handleHistorySync({ chats, contacts, messages }) {
+    if (chats) this.upsertChats(chats);
+    if (contacts) this.upsertContacts(contacts);
+    if (messages) {
+      // messages from history are wrapped: { message, ... }
+      const flat = messages.map((m) => m.message || m).filter(Boolean);
+      this.upsertMessages(flat);
+    }
+  }
+
+  saveSnapshot(filePath) {
+    const snapshot = {
+      chats: Array.from(this.chats.values()),
+      contacts: Array.from(this.contacts.values()),
+      messages: Array.from(this.messages.entries()),
+      groupMeta: Array.from(this.groupMeta.entries()),
+      contactTags: Object.fromEntries(this.contactTags),
+      watchlists: Object.fromEntries(this.watchlists),
+    };
+    fs.writeFileSync(filePath, JSON.stringify(snapshot), "utf-8");
+  }
+
+  loadSnapshot(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const snapshot = JSON.parse(raw);
+
+    this.chats = new Map((snapshot.chats || []).map((chat) => [chat.id, chat]));
+    this.contacts = new Map((snapshot.contacts || []).map((contact) => [contact.id, contact]));
+    this.messages = new Map(snapshot.messages || []);
+    this.groupMeta = new Map(snapshot.groupMeta || []);
+    this.contactTags = new Map(Object.entries(snapshot.contactTags || {}));
+    this.watchlists = new Map(Object.entries(snapshot.watchlists || {}));
+    this.messageIndex = new Map();
+
+    for (const msgList of this.messages.values()) {
+      msgList.sort((a, b) => {
+        const ta = Number(a.messageTimestamp || 0);
+        const tb = Number(b.messageTimestamp || 0);
+        if (ta !== tb) return ta - tb;
+        return String(a.key?.id || "").localeCompare(String(b.key?.id || ""));
+      });
+
+      for (const msg of msgList) {
+        if (msg?.key?.id) {
+          this.messageIndex.set(msg.key.id, msg);
+        }
+      }
+    }
+
+    this._trimChats();
+    for (const [jid, arr] of this.messages.entries()) {
+      if (arr.length > this.maxMessagesPerChat) {
+        this.messages.set(jid, arr.slice(-this.maxMessagesPerChat));
+      }
+    }
+
+    return true;
+  }
+
+  // ── Analytics ───────────────────────────────────────────────────────────
+
+  getAnalyticsOverview(options = {}) {
+    const analytics = this._getAnalyticsCache();
+    const topChats = Math.min(options.top_chats || 10, 100);
+    const topTokens = Math.min(options.top_tokens || 20, 100);
+    const topSenders = Math.min(options.top_senders || 10, 100);
+    const days = Math.min(options.days || 30, 365);
+
+    return {
+      totals: analytics.totals,
+      indexed_chats: analytics.chatSummaries.length,
+      indexed_messages: analytics.totals.messages,
+      active_days: analytics.dailyActivity.length,
+      top_chats: analytics.chatSummaries.slice(0, topChats),
+      top_tokens: analytics.topTokens.slice(0, topTokens),
+      top_senders: analytics.topSenders.slice(0, topSenders),
+      message_types: analytics.messageTypes,
+      hourly_activity: analytics.hourlyActivity,
+      daily_activity: analytics.dailyActivity.slice(-days),
+    };
+  }
+
+  listAnalyticsTopChats(options = {}) {
+    const analytics = this._getAnalyticsCache();
+    const limit = Math.min(options.limit || 20, 200);
+    const sortBy = options.sort_by || "message_count";
+    const chats = [...analytics.chatSummaries];
+    const sorters = {
+      message_count: (a, b) => (b.content_message_count - a.content_message_count) || (b.message_count - a.message_count) || (b.last_activity || 0) - (a.last_activity || 0),
+      last_activity: (a, b) => (b.last_activity || 0) - (a.last_activity || 0),
+      active_days: (a, b) => (b.active_days - a.active_days) || (b.content_message_count - a.content_message_count) || (b.message_count - a.message_count),
+      participants: (a, b) => (b.participant_count - a.participant_count) || (b.content_message_count - a.content_message_count) || (b.message_count - a.message_count),
+    };
+    chats.sort(sorters[sortBy] || sorters.message_count);
+    return chats.slice(0, limit);
+  }
+
+  getChatAnalytics(jid, options = {}) {
+    const analytics = this._getAnalyticsCache();
+    const chat = analytics.chatByJid.get(jid);
+    if (!chat) return null;
+
+    const topTokens = Math.min(options.top_tokens || 15, 100);
+    const topSenders = Math.min(options.top_senders || 10, 100);
+    const timelineDays = Math.min(options.days || 30, 365);
+
+    return {
+      ...chat,
+      top_tokens: chat.top_tokens.slice(0, topTokens),
+      top_senders: chat.top_senders.slice(0, topSenders),
+      recent_messages: chat.recent_messages.slice(0, Math.min(options.recent_messages || 5, 20)),
+      daily_activity: chat.daily_activity.slice(-timelineDays),
+    };
+  }
+
+  getActivityTimeline(options = {}) {
+    const analytics = this._getAnalyticsCache();
+    const days = Math.min(options.days || 30, 365);
+
+    if (options.jid) {
+      const chat = analytics.chatByJid.get(options.jid);
+      if (!chat) return null;
+      return {
+        jid: options.jid,
+        days,
+        total_messages: chat.message_count,
+        buckets: chat.daily_activity.slice(-days),
+      };
+    }
+
+    return {
+      days,
+      total_messages: analytics.totals.messages,
+      buckets: analytics.dailyActivity.slice(-days),
+    };
+  }
+
+  analyticsSearch(query, jid, limit = 20, options = {}) {
+    const analytics = this._getAnalyticsCache();
+    const terms = this._tokenize(query);
+    const cappedLimit = Math.min(limit || 20, 200);
+    const { since, until } = options;
+
+    if (terms.length === 0) {
+      return [];
+    }
+
+    // Support single JID, array of JIDs, or null (all)
+    const jidSet = jid
+      ? new Set(Array.isArray(jid) ? jid : [jid])
+      : null;
+
+    const scores = new Map();
+    for (const term of terms) {
+      const refs = analytics.tokenIndex.get(term) || [];
+      for (const ref of refs) {
+        if (jidSet && !jidSet.has(ref.jid)) continue;
+        const existing = scores.get(ref.id) || {
+          jid: ref.jid,
+          id: ref.id,
+          matched_terms: new Set(),
+          score: 0,
+        };
+        existing.matched_terms.add(term);
+        existing.score += ref.weight;
+        scores.set(ref.id, existing);
+      }
+    }
+
+    const ranked = [];
+    for (const entry of scores.values()) {
+      const msg = this.getMessage(entry.id);
+      const formatted = formatMessage(msg);
+      if (!formatted) continue;
+      // Apply temporal filters
+      const ts = Number(formatted.timestamp || 0);
+      if (since != null && ts < since) continue;
+      if (until != null && ts > until) continue;
+      const text = formatted.text.toLowerCase();
+      const phraseBoost = text.includes(query.toLowerCase()) ? 2 : 0;
+      const timestampBoost = formatted.timestamp ? Number(formatted.timestamp) / 1e10 : 0;
+      ranked.push({
+        ...formatted,
+        score: Number((entry.score + phraseBoost + timestampBoost).toFixed(6)),
+        matched_terms: Array.from(entry.matched_terms).sort(),
+      });
+    }
+
+    ranked.sort((a, b) => (b.score - a.score) || ((b.timestamp || 0) - (a.timestamp || 0)));
+    return ranked.slice(0, cappedLimit);
+  }
+
+  // ── Bind to Baileys events ───────────────────────────────────────────────
+
+  /**
+   * Bind all relevant Baileys socket events to this store.
+   * @param {import("@whiskeysockets/baileys").WASocket} sock
+   */
+  bind(sock) {
+    sock.ev.on("messaging-history.set", (data) => this.handleHistorySync(data));
+    sock.ev.on("chats.upsert", (chats) => this.upsertChats(chats));
+    sock.ev.on("chats.update", (updates) => this.updateChats(updates));
+    sock.ev.on("chats.delete", (ids) => this.deleteChats(ids));
+    sock.ev.on("contacts.upsert", (contacts) => this.upsertContacts(contacts));
+    sock.ev.on("contacts.update", (updates) => this.updateContacts(updates));
+    sock.ev.on("messages.upsert", ({ messages }) => this.upsertMessages(messages));
+    sock.ev.on("messages.delete", (info) => {
+      if (info.keys) this.deleteMessages(info.keys);
+    });
+    sock.ev.on("groups.upsert", (groups) => {
+      for (const g of groups) this.setGroupMeta(g.id, g);
+    });
+    sock.ev.on("groups.update", (updates) => {
+      for (const u of updates) {
+        const existing = this.getGroupMeta(u.id) || {};
+        this.setGroupMeta(u.id, { ...existing, ...u });
+      }
+    });
+  }
+
+  // ── Stats ────────────────────────────────────────────────────────────────
+
+  stats() {
+    let totalMessages = 0;
+    for (const msgs of this.messages.values()) {
+      totalMessages += msgs.length;
+    }
+    return {
+      chats: this.chats.size,
+      contacts: this.contacts.size,
+      messages: totalMessages,
+      groups: this.groupMeta.size,
+    };
+  }
+
+  // ── Internal ─────────────────────────────────────────────────────────────
+
+  _applyMessageFilters(messages, options = {}) {
+    const { since, until, types, excludeTypes } = options;
+    let result = messages;
+
+    if (since != null) {
+      result = result.filter((m) => Number(m.messageTimestamp || 0) >= since);
+    }
+    if (until != null) {
+      result = result.filter((m) => Number(m.messageTimestamp || 0) <= until);
+    }
+    if (types && types.length > 0) {
+      const typeSet = new Set(types);
+      result = result.filter((m) => {
+        const formatted = formatMessage(m);
+        return formatted && typeSet.has(formatted.type);
+      });
+    }
+    if (excludeTypes && excludeTypes.length > 0) {
+      const excludeSet = new Set(excludeTypes);
+      result = result.filter((m) => {
+        const formatted = formatMessage(m);
+        return formatted && !excludeSet.has(formatted.type);
+      });
+    }
+    return result;
+  }
+
+  _trimChats() {
+    if (this.chats.size <= this.maxChats) return;
+    const sorted = Array.from(this.chats.entries()).sort(([, a], [, b]) => {
+      return Number(b.conversationTimestamp || 0) - Number(a.conversationTimestamp || 0);
+    });
+    const toRemove = sorted.slice(this.maxChats);
+    for (const [jid] of toRemove) {
+      this.chats.delete(jid);
+    }
+  }
+
+  _notifyChanged() {
+    this.analyticsCache = null;
+    if (this.onChange) {
+      this.onChange();
+    }
+  }
+
+  _touchChatFromMessage(msg) {
+    const jid = msg.key?.remoteJid;
+    if (!jid) return;
+
+    const existing = this.chats.get(jid) || { id: jid };
+    const formatted = formatMessage(msg);
+    const timestamp = msg.messageTimestamp
+      ? Number(msg.messageTimestamp)
+      : Number(existing.conversationTimestamp || 0);
+
+    this.chats.set(jid, {
+      ...existing,
+      id: jid,
+      conversationTimestamp: timestamp || existing.conversationTimestamp,
+      name:
+        existing.name ||
+        existing.subject ||
+        msg.pushName ||
+        formatted?.push_name ||
+        existing.name,
+    });
+
+    this._trimChats();
+  }
+
+  _getAnalyticsCache() {
+    if (this.analyticsCache) {
+      return this.analyticsCache;
+    }
+
+    const tokenIndex = new Map();
+    const globalTokenCounts = new Map();
+    const globalSenderCounts = new Map();
+    const globalTypeCounts = new Map();
+    const globalDailyActivity = new Map();
+    const hourlyActivity = Array.from({ length: 24 }, (_, hour) => ({ hour, count: 0 }));
+    const chatByJid = new Map();
+    const allChatIds = new Set([
+      ...this.chats.keys(),
+      ...this.messages.keys(),
+      ...this.groupMeta.keys(),
+    ]);
+
+    for (const jid of allChatIds) {
+      chatByJid.set(jid, this._createEmptyChatAnalytics(jid));
+    }
+
+    for (const [jid, msgs] of this.messages.entries()) {
+      const chat = chatByJid.get(jid) || this._createEmptyChatAnalytics(jid);
+      for (const msg of msgs) {
+        const formatted = formatMessage(msg);
+        if (!formatted) continue;
+
+        const timestamp = Number(formatted.timestamp || msg.messageTimestamp || 0) || 0;
+        chat.message_count += 1;
+        if (formatted.from_me) {
+          chat.from_me_count += 1;
+        } else {
+          chat.external_count += 1;
+        }
+
+        if (timestamp) {
+          chat.first_activity = chat.first_activity === null ? timestamp : Math.min(chat.first_activity, timestamp);
+          chat.last_activity = Math.max(chat.last_activity || 0, timestamp);
+          const dayKey = this._toDayKey(timestamp);
+          chat.daily_counts.set(dayKey, (chat.daily_counts.get(dayKey) || 0) + 1);
+          globalDailyActivity.set(dayKey, (globalDailyActivity.get(dayKey) || 0) + 1);
+          hourlyActivity[this._toHour(timestamp)].count += 1;
+        }
+
+        const type = formatted.type || "unknown";
+        chat.type_counts.set(type, (chat.type_counts.get(type) || 0) + 1);
+        globalTypeCounts.set(type, (globalTypeCounts.get(type) || 0) + 1);
+
+        const sender = this._getMessageSender(msg);
+        if (sender) {
+          chat.sender_counts.set(sender, (chat.sender_counts.get(sender) || 0) + 1);
+          globalSenderCounts.set(sender, (globalSenderCounts.get(sender) || 0) + 1);
+        }
+
+        const tokens = this._shouldIndexMessageText(formatted)
+          ? this._tokenize(formatted.text)
+          : [];
+        if (tokens.length > 0) {
+          chat.content_message_count += 1;
+        }
+        const uniqueTokens = new Set(tokens);
+        for (const token of tokens) {
+          chat.token_counts.set(token, (chat.token_counts.get(token) || 0) + 1);
+          globalTokenCounts.set(token, (globalTokenCounts.get(token) || 0) + 1);
+        }
+        for (const token of uniqueTokens) {
+          if (!tokenIndex.has(token)) tokenIndex.set(token, []);
+          tokenIndex.get(token).push({
+            jid,
+            id: formatted.id,
+            weight: chat.token_counts.get(token) || 1,
+          });
+        }
+      }
+      chatByJid.set(jid, chat);
+    }
+
+    for (const [jid, chat] of chatByJid.entries()) {
+      const rawChat = this.getChat(jid) || {};
+      const groupMeta = this.getGroupMeta(jid);
+      chat.name = rawChat.name || rawChat.subject || groupMeta?.subject || chat.name;
+      chat.is_group = isGroupJid(jid);
+      chat.participant_count = groupMeta?.participants?.length || 0;
+      chat.active_days = chat.daily_counts.size;
+      chat.last_activity = chat.last_activity || Number(rawChat.conversationTimestamp || groupMeta?.subjectTime || groupMeta?.creation || 0) || null;
+      chat.top_tokens = this._rankCountMap(chat.token_counts, 10);
+      chat.top_senders = this._rankCountMap(chat.sender_counts, 10, "jid");
+      chat.type_breakdown = this._rankCountMap(chat.type_counts, 10, "type");
+      chat.daily_activity = this._mapToSeries(chat.daily_counts, "date");
+      chat.recent_messages = this.getMessages(jid, 5).map((msg) => formatMessage(msg)).filter(Boolean);
+      delete chat.token_counts;
+      delete chat.sender_counts;
+      delete chat.type_counts;
+      delete chat.daily_counts;
+    }
+
+    const chatSummaries = Array.from(chatByJid.values()).sort((a, b) => {
+      return (b.content_message_count - a.content_message_count)
+        || (b.message_count - a.message_count)
+        || ((b.last_activity || 0) - (a.last_activity || 0));
+    });
+
+    this.analyticsCache = {
+      totals: this.stats(),
+      chatByJid,
+      chatSummaries,
+      topTokens: this._rankCountMap(globalTokenCounts, 25),
+      topSenders: this._rankCountMap(globalSenderCounts, 25, "jid"),
+      messageTypes: this._rankCountMap(globalTypeCounts, 25, "type"),
+      hourlyActivity,
+      dailyActivity: this._mapToSeries(globalDailyActivity, "date"),
+      tokenIndex,
+    };
+
+    return this.analyticsCache;
+  }
+
+  _createEmptyChatAnalytics(jid) {
+    const rawChat = this.getChat(jid) || {};
+    return {
+      jid,
+      name: rawChat.name || rawChat.subject || jid,
+      is_group: isGroupJid(jid),
+      participant_count: 0,
+      message_count: 0,
+      content_message_count: 0,
+      from_me_count: 0,
+      external_count: 0,
+      active_days: 0,
+      first_activity: null,
+      last_activity: null,
+      top_tokens: [],
+      top_senders: [],
+      type_breakdown: [],
+      daily_activity: [],
+      recent_messages: [],
+      token_counts: new Map(),
+      sender_counts: new Map(),
+      type_counts: new Map(),
+      daily_counts: new Map(),
+    };
+  }
+
+  _rankCountMap(map, limit, keyName = "token") {
+    return Array.from(map.entries())
+      .sort((a, b) => (b[1] - a[1]) || a[0].localeCompare(b[0]))
+      .slice(0, limit)
+      .map(([key, count]) => ({ [keyName]: key, count }));
+  }
+
+  _mapToSeries(map, keyName) {
+    return Array.from(map.entries())
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([key, count]) => ({ [keyName]: key, count }));
+  }
+
+  _getMessageSender(msg) {
+    if (msg?.key?.fromMe) return "me";
+    return msg?.key?.participant || msg?.key?.remoteJid || null;
+  }
+
+  _toDayKey(timestamp) {
+    return new Date(Number(timestamp) * 1000).toISOString().slice(0, 10);
+  }
+
+  _toHour(timestamp) {
+    return new Date(Number(timestamp) * 1000).getHours();
+  }
+
+  _tokenize(text) {
+    return String(text || "")
+      .toLowerCase()
+      .match(/[\p{L}\p{N}_-]+/gu)
+      ?.filter((token) => token.length >= 2 && !ANALYTICS_STOP_WORDS.has(token) && /\D/.test(token)) || [];
+  }
+
+  _shouldIndexMessageText(message) {
+    const text = String(message?.text || "").trim();
+    if (!text) return false;
+    if (/^\[[^\]]+\]$/.test(text)) return false;
+    return !["protocol", "unknown", "senderKeyDistribution"].includes(message?.type);
+  }
+}
+
+module.exports = Store;