koishi-plugin-chat-analyse 1.3.1 → 1.3.3

package/lib/Renderer.d.ts

@@ -0,0 +1,90 @@
+import { Context } from 'koishi';
+import { WordCloudData } from './Analyse';
+/**
+ * @interface ListRenderData
+ * @description 定义了调用 `renderList` 方法所需的数据结构。
+ */
+export interface ListRenderData {
+    title: string;
+    time: Date;
+    total?: string | number;
+    list: (string | number | Date)[][];
+}
+/**
+ * @interface LineChartData
+ * @description 定义了调用 `renderLineChart` 方法所需的数据结构，支持多组数据系列。
+ */
+export interface LineChartData {
+    title: string;
+    time: Date;
+    series: {
+        name: string;
+        data: number[];
+    }[];
+    labels: string[];
+}
+/**
+ * @class Renderer
+ * @description 负责将结构化的数据渲染为设计精美的 PNG 图片。
+ */
+export declare class Renderer {
+    private ctx;
+    private readonly COLOR_PALETTES;
+    private readonly COMMON_STYLE;
+    /**
+     * @constructor
+     * @description Renderer 类的构造函数。
+     * @param {Context} ctx - Koishi 的插件上下文，用于访问 logger 和 puppeteer 服务。
+     */
+    constructor(ctx: Context);
+    /**
+     * @private
+     * @method generateFullHtml
+     * @description 将卡片内容和特定样式组合成一个完整的 HTML 文档，以便进行渲染。
+     * @param {string} cardContent - 卡片主体部分的 HTML 字符串。
+     * @param {string} specificStyles - 针对该卡片类型的特定 CSS 样式字符串。
+     * @returns {string} - 一个完整的、可被浏览器渲染的 HTML 字符串。
+     */
+    private generateFullHtml;
+    /**
+     * @private
+     * @method htmlToImage
+     * @description 使用 puppeteer 将给定的 HTML 字符串内容渲染成 PNG 图片的 Buffer。
+     * @param {string} fullHtmlContent - 完整的 HTML 内容字符串。
+     * @returns {Promise<Buffer | null>} - 成功时返回包含 PNG 图片数据的 Buffer，失败则返回 null。
+     */
+    private htmlToImage;
+    /**
+     * @private
+     * @method formatDate
+     * @description 将 Date 对象格式化为易于理解的相对时间字符串（如“刚刚”，“5分钟前”）。
+     * @param {Date} date - 需要格式化的日期对象。
+     * @returns {string} - 格式化后的时间字符串。
+     */
+    private formatDate;
+    /**
+     * @public
+     * @method renderList
+     * @description 将表格型数据渲染成列表形式的图片。如果数据过多，会通过异步生成器逐个产出图片。
+     * @param {ListRenderData} data - 包含标题、时间、总计和列表数据的对象。
+     * @param {string[]} [headers] - （可选）列表的表头数组。
+     * @returns {AsyncGenerator<Buffer>} - 一个异步生成器，每次迭代产出一张图片的 Buffer。
+     */
+    renderList(data: ListRenderData, headers?: string[]): AsyncGenerator<Buffer>;
+    /**
+     * @public
+     * @method renderLineChart
+     * @description 将时间序列数据（如活跃度）渲染成一张基于 SVG 的折线图。支持单组或多组数据进行对比。
+     * @param {LineChartData} data - 包含标题、时间、数据系列和标签的对象。
+     * @returns {AsyncGenerator<Buffer>} - 一个异步生成器，产出渲染后的图片 Buffer。
+     */
+    renderLineChart(data: LineChartData): AsyncGenerator<Buffer>;
+    /**
+     * @public
+     * @method renderWordCloud
+     * @description 将词频数据渲染成一张词云图片，使用 Puppeteer 和 wordcloud2.js。
+     * @param {WordCloudData} data - 包含标题、时间和词汇列表的对象。
+     * @returns {AsyncGenerator<Buffer>} - 一个异步生成器，产出渲染后的图片 Buffer。
+     */
+    renderWordCloud(data: WordCloudData): AsyncGenerator<Buffer>;
+}

package/lib/index.d.ts

@@ -0,0 +1,66 @@
+import { Context, Schema, Session } from 'koishi';
+/** @name 插件使用说明 */
+export declare const usage = "\n<div style=\"border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);\">\n  <h2 style=\"margin-top: 0; color: #4a6ee0;\">\uD83D\uDCCC \u63D2\u4EF6\u8BF4\u660E</h2>\n  <p>\uD83D\uDCD6 <strong>\u4F7F\u7528\u6587\u6863</strong>\uFF1A\u8BF7\u70B9\u51FB\u5DE6\u4E0A\u89D2\u7684 <strong>\u63D2\u4EF6\u4E3B\u9875</strong> \u67E5\u770B\u63D2\u4EF6\u4F7F\u7528\u6587\u6863</p>\n  <p>\uD83D\uDD0D <strong>\u66F4\u591A\u63D2\u4EF6</strong>\uFF1A\u53EF\u8BBF\u95EE <a href=\"https://github.com/YisRime\" style=\"color:#4a6ee0;text-decoration:none;\">\u82E1\u6DDE\u7684 GitHub</a> \u67E5\u770B\u672C\u4EBA\u7684\u6240\u6709\u63D2\u4EF6</p>\n</div>\n<div style=\"border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);\">\n  <h2 style=\"margin-top: 0; color: #e0574a;\">\u2764\uFE0F \u652F\u6301\u4E0E\u53CD\u9988</h2>\n  <p>\uD83C\uDF1F \u559C\u6B22\u8FD9\u4E2A\u63D2\u4EF6\uFF1F\u8BF7\u5728 <a href=\"https://github.com/YisRime\" style=\"color:#e0574a;text-decoration:none;\">GitHub</a> \u4E0A\u7ED9\u6211\u4E00\u4E2A Star\uFF01</p>\n  <p>\uD83D\uDC1B \u9047\u5230\u95EE\u9898\uFF1F\u8BF7\u901A\u8FC7 <strong>Issues</strong> \u63D0\u4EA4\u53CD\u9988\uFF0C\u6216\u52A0\u5165 QQ \u7FA4 <a href=\"https://qm.qq.com/q/PdLMx9Jowq\" style=\"color:#e0574a;text-decoration:none;\"><strong>855571375</strong></a> \u8FDB\u884C\u4EA4\u6D41</p>\n</div>\n";
+export declare const name = "chat-analyse";
+export declare const using: string[];
+/**
+ * @interface Config
+ * @description 定义插件的配置项结构。
+ */
+export interface Config {
+    enableListener: boolean;
+    enableCmdStat: boolean;
+    enableMsgStat: boolean;
+    enableRankStat: boolean;
+    enableActivity: boolean;
+    enableOriRecord: boolean;
+    enableWhoAt: boolean;
+    enableDataIO: boolean;
+    atRetentionDays: number;
+    rankRetentionDays: number;
+    enableWordCloud: boolean;
+    cacheRetentionDays: number;
+    enableSimilarActivity: boolean;
+}
+/** @description 插件的配置项定义 */
+export declare const Config: Schema<Config>;
+/**
+ * @private @method parseQueryScope
+ * @description 解析命令选项，转换为包含 UIDs 和描述性信息的统一查询范围对象。
+ * @param session - 当前会话对象。
+ * @param options - 命令选项。
+ * @returns 包含 uids、错误或范围描述的查询范围对象。
+ */
+export declare function parseQueryScope(ctx: Context, session: Session, options: {
+    user?: string;
+    guild?: string;
+    all?: boolean;
+}): Promise<{
+    uids?: number[];
+    error?: string;
+    scopeDesc: {
+        guildId?: string;
+        userId?: string;
+    };
+}>;
+/**
+ * @private @method generateTitle
+ * @description 根据查询范围和类型动态生成易于理解的图片标题。
+ * @returns 生成的标题字符串。
+ */
+export declare function generateTitle(ctx: Context, scopeDesc: {
+    guildId?: string;
+    userId?: string;
+}, options: {
+    main: string;
+    subtype?: string;
+    timeRange?: number;
+    timeUnit?: '小时' | '天';
+}): Promise<string>;
+/**
+ * @function apply
+ * @description Koishi 插件的主入口函数，负责初始化和注册所有功能模块。
+ * @param ctx - Koishi 的插件上下文。
+ * @param config - 用户配置对象。
+ */
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -1518,6 +1518,7 @@ var Renderer = class {
     .container {
       display: inline-block; background: var(--card-bg); border-radius: 12px;
       padding: 0; overflow: hidden; box-shadow: 0 4px 6px rgba(0,0,0,.05);
+      width: 600px;
     }
     .header {
       padding: 12px 16px;
@@ -1527,7 +1528,7 @@ var Renderer = class {
       border-bottom: 1px solid var(--border-color);
     }
     .title-text {
-      font-size: 18px; font-weight: 600; color: var(--header-color);
+      font-size: 16px; font-weight: 600; color: var(--header-color);
       margin: 0; text-align: center;
     }
     .stat-chip, .time-label {
@@ -1631,7 +1632,7 @@ var Renderer = class {
       .main-table { border-collapse: collapse; width: 100%; }
       .main-table th, .main-table td { padding: 9px 16px; vertical-align: middle; text-align: left; }
       .main-table thead { border-bottom: 1px solid var(--border-color); }
-      .main-table th { font-size: 12px; font-weight: 500; color: var(--sub-text-color); text-transform: uppercase; }
+      .main-table th { font-size: 12px; font-weight: 500; color: var(--sub-text-color); text-transform: uppercase; white-space: nowrap; }
       .main-table td { font-size: 14px; color: var(--text-color); }
       .main-table tbody tr:nth-child(even) { background-color: var(--stripe-bg); }
       .rank-cell, .count-cell, .date-cell, .percent-cell { text-align: right; white-space: nowrap; width: 1%; font-variant-numeric: tabular-nums; }
@@ -1683,40 +1684,65 @@ var Renderer = class {
   }
   /**
    * @public
-   * @method renderCircadianChart
-   * @description 将 24 小时制的活跃度数据渲染成一张柱状图图片。通过异步生成器产出图片。
-   * @param {CircadianChartData} data - 包含标题、时间、总计和 24 小时数据数组的对象。
+   * @method renderLineChart
+   * @description 将时间序列数据（如活跃度）渲染成一张基于 SVG 的折线图。支持单组或多组数据进行对比。
+   * @param {LineChartData} data - 包含标题、时间、数据系列和标签的对象。
    * @returns {AsyncGenerator<Buffer>} - 一个异步生成器，产出渲染后的图片 Buffer。
    */
-  async *renderCircadianChart(data) {
-    const { title, time, total, data: hourlyCounts, labels } = data;
-    const maxCount = Math.max(...hourlyCounts, 1);
-    const chartStyles = `
-      .chart-container { display: flex; align-items: flex-end; gap: 4px; height: 180px; padding: 30px 15px 10px; }
-      .bar-wrapper { flex: 1; text-align: center; display: flex; flex-direction: column; justify-content: flex-end; height: 100%; }
-      .bar-value { font-size: 11px; color: var(--sub-text-color); height: 16px; line-height: 16px; font-weight: 500; }
-      .bar-container { flex-grow: 1; display: flex; align-items: flex-end; width: 100%; }
-      .bar { width: 100%; background-color: var(--accent-color); opacity: .7; border-radius: 3px 3px 0 0; transition: height .3s ease-out; }
-      .bar-label { font-size: 10px; color: var(--sub-text-color); margin-top: 4px; height: 12px; }
-    `;
+  async *renderLineChart(data) {
+    const { title, time, series, labels } = data;
+    const width = 600, height = 320;
+    const padding = { top: 20, right: 20, bottom: 60, left: 40 };
+    const chartWidth = width - padding.left - padding.right;
+    const chartHeight = height - padding.top - padding.bottom;
+    const maxVal = Math.max(1, ...series.flatMap((s) => s.data));
+    const yTickCount = 5;
+    const yTickValue = Math.ceil(maxVal / yTickCount);
+    const yAxisMax = yTickValue * yTickCount;
+    const getX = /* @__PURE__ */ __name((index) => padding.left + index / (labels.length - 1) * chartWidth, "getX");
+    const getY = /* @__PURE__ */ __name((value) => padding.top + chartHeight - value / yAxisMax * chartHeight, "getY");
+    let svgElements = "";
+    for (let i = 0; i <= yTickCount; i++) {
+      const y = getY(i * yTickValue);
+      const value = i * yTickValue;
+      svgElements += `<line x1="${padding.left}" y1="${y}" x2="${width - padding.right}" y2="${y}" stroke="var(--border-color)" stroke-width="1"/>`;
+      svgElements += `<text x="${padding.left - 8}" y="${y + 4}" font-size="10" fill="var(--sub-text-color)" text-anchor="end">${value}</text>`;
+    }
+    labels.forEach((label, index) => {
+      if (index % Math.ceil(labels.length / 10) === 0) {
+        const x = getX(index);
+        svgElements += `<text x="${x}" y="${height - padding.bottom + 15}" font-size="10" fill="var(--sub-text-color)" text-anchor="middle">${label}</text>`;
+      }
+    });
+    series.forEach((s, seriesIndex) => {
+      const color = this.COLOR_PALETTES[0][seriesIndex % this.COLOR_PALETTES[0].length];
+      const points = s.data.map((value, index) => `${getX(index)},${getY(value)}`).join(" ");
+      svgElements += `<polyline points="${points}" fill="none" stroke="${color}" stroke-width="2"/>`;
+    });
+    let legendX = padding.left;
+    const legendY = height - padding.bottom + 40;
+    series.forEach((s, seriesIndex) => {
+      const color = this.COLOR_PALETTES[0][seriesIndex % this.COLOR_PALETTES[0].length];
+      svgElements += `<rect x="${legendX}" y="${legendY - 8}" width="12" height="8" fill="${color}" rx="2"/>`;
+      const textElement = `<text x="${legendX + 18}" y="${legendY}" font-size="12" fill="var(--text-color)">${s.name}</text>`;
+      svgElements += textElement;
+      legendX += 25 + s.name.length * 8;
+    });
+    const totalMessages = series.reduce((sum, s) => sum + s.data.reduce((a, b) => a + b, 0), 0);
     const cardHtml = `
       <div class="container">
         <div class="header">
-          <div class="stat-chip">总计: <span>${typeof total === "number" ? total.toLocaleString() : total}</span></div>
+          <div class="stat-chip">总计: <span>${totalMessages.toLocaleString()}</span></div>
           <h1 class="title-text">${title}</h1>
           <div class="time-label">${time.toLocaleString("zh-CN", { hour12: false })}</div>
         </div>
-        <div class="chart-container">
-          ${hourlyCounts.map((count, hour) => `
-            <div class="bar-wrapper">
-              <div class="bar-value">${count > 0 ? count : ""}</div>
-              <div class="bar-container">
-                <div class="bar" style="height: ${count / maxCount * 100}%;"></div>
-              </div>
-              <div class="bar-label">${labels ? labels[hour] : hour}</div>
-            </div>`).join("")}
+        <div class="chart-wrapper">
+          <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+            ${svgElements}
+          </svg>
         </div>
       </div>`;
+    const chartStyles = ` .chart-wrapper { padding: 10px; } `;
     const fullHtml = this.generateFullHtml(cardHtml, chartStyles);
     const imageBuffer = await this.htmlToImage(fullHtml);
     if (imageBuffer) yield imageBuffer;
@@ -1843,11 +1869,11 @@ var Stat = class {
       }
     }, "handleAction");
     if (this.config.enableCmdStat) {
-      cmd.subcommand("cmdstat", "命令统计").usage("查询命令统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("separate", "-s 分离展示").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
+      cmd.subcommand("cmdstat", "命令统计").usage("查询命令统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("separate", "-p 分离子命令").option("sortByTime", "-s 以时间排序").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
         const scope = await this.parseScope(session, options);
         if (scope.error) return scope.error;
         const query = scope.uids ? { uid: { $in: scope.uids } } : {};
-        const stats = await this.ctx.database.select("analyse_cmd").where(query).groupBy("command", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).orderBy("count", "desc").execute();
+        const stats = await this.ctx.database.select("analyse_cmd").where(query).groupBy("command", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).execute();
         if (stats.length === 0) return "暂无统计数据";
         let processedStats;
         if (options.separate) {
@@ -1861,7 +1887,12 @@ var Stat = class {
             if (stat.lastUsed > existing.lastUsed) existing.lastUsed = stat.lastUsed;
             merged.set(mainCmd, existing);
           }
-          processedStats = Array.from(merged.entries()).map(([command, data]) => ({ ...data, command })).sort((a, b) => b.count - a.count);
+          processedStats = Array.from(merged.entries()).map(([command, data]) => ({ ...data, command }));
+        }
+        if (options.sortByTime) {
+          processedStats.sort((a, b) => b.lastUsed.getTime() - a.lastUsed.getTime());
+        } else {
+          processedStats.sort((a, b) => b.count - a.count);
         }
         const total = processedStats.reduce((sum, r) => sum + r.count, 0);
         const list = processedStats.map((item) => [item.command, item.count, item.lastUsed]);
@@ -1870,15 +1901,23 @@ var Stat = class {
       })()));
     }
     if (this.config.enableMsgStat) {
-      cmd.subcommand("msgstat", "发言统计").usage("查询发言统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("type", "-t <type:string> 指定类型").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
+      cmd.subcommand("msgstat", "发言统计").usage("查询发言统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("type", "-t <type:string> 指定类型").option("sortByTime", "-s 以时间排序").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
         const scope = await this.parseScope(session, options);
         if (scope.error) return scope.error;
         const query = scope.uids ? { uid: { $in: scope.uids } } : {};
         if (options.type) query.type = options.type;
         const title = await generateTitle(this.ctx, scope.scopeDesc, { main: "发言", subtype: options.type });
+        const applySort = /* @__PURE__ */ __name((stats2) => {
+          if (options.sortByTime) {
+            stats2.sort((a, b) => b.lastUsed.getTime() - a.lastUsed.getTime());
+          } else {
+            stats2.sort((a, b) => b.count - a.count);
+          }
+        }, "applySort");
         if (options.user && options.guild) {
-          const stats2 = await this.ctx.database.select("analyse_msg").where(query).groupBy("type", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).orderBy("count", "desc").execute();
+          const stats2 = await this.ctx.database.select("analyse_msg").where(query).groupBy("type", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).execute();
           if (stats2.length === 0) return "暂无统计数据";
+          applySort(stats2);
           const total2 = stats2.reduce((sum, r) => sum + r.count, 0);
           const list2 = stats2.map((item) => [item.type, item.count, item.lastUsed]);
           return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total: total2, list: list2 }, ["类型", "条数", "最后发言"]);
@@ -1886,20 +1925,29 @@ var Stat = class {
         if (options.user) {
           const userRecords = await this.ctx.database.get("analyse_user", { uid: { $in: scope.uids } });
           const uidToChannelMap = new Map(userRecords.map((u) => [u.uid, u.channelName || u.channelId]));
-          const stats2 = await this.ctx.database.select("analyse_msg").where(query).groupBy("uid", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).orderBy("count", "desc").execute();
+          const stats2 = await this.ctx.database.select("analyse_msg").where(query).groupBy("uid", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).execute();
           if (stats2.length === 0) return "暂无统计数据";
+          applySort(stats2);
           const total2 = stats2.reduce((sum, r) => sum + r.count, 0);
           const list2 = stats2.map((item) => [uidToChannelMap.get(item.uid) || `未知群组`, item.count, item.lastUsed]);
           return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total: total2, list: list2 }, ["群组", "条数", "最后发言"]);
         }
-        const stats = await this.ctx.database.select("analyse_msg").where(query).groupBy("uid", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).orderBy("count", "desc").execute();
+        const stats = await this.ctx.database.select("analyse_msg").where(query).groupBy("uid", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count"), lastUsed: /* @__PURE__ */ __name((row) => import_koishi3.$.max(row.timestamp), "lastUsed") }).execute();
         if (stats.length === 0) return "暂无统计数据";
+        applySort(stats);
         const allUids = stats.map((s) => s.uid);
-        const users = await this.ctx.database.get("analyse_user", { uid: { $in: allUids } }, ["uid", "userName"]);
-        const userNameMap = new Map(users.map((u) => [u.uid, u.userName]));
+        const userNameMap = /* @__PURE__ */ new Map();
+        const BATCH_SIZE2 = 4096;
+        for (let i = 0; i < allUids.length; i += BATCH_SIZE2) {
+          const batchUids = allUids.slice(i, i + BATCH_SIZE2);
+          const users = await this.ctx.database.get("analyse_user", { uid: { $in: batchUids } }, ["uid", "userName"]);
+          for (const user of users) {
+            userNameMap.set(user.uid, user.userName);
+          }
+        }
         const total = stats.reduce((sum, r) => sum + r.count, 0);
         const list = stats.map((item) => [userNameMap.get(item.uid) || `UID ${item.uid}`, item.count, item.lastUsed]);
-        return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total, list }, ["用户", "总计发言", "最后发言"]);
+        return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total, list }, ["用户", "条数", "最后发言"]);
       })()));
     }
     if (this.config.enableRankStat) {
@@ -1931,15 +1979,22 @@ var Stat = class {
         const stats = await this.ctx.database.select("analyse_rank").where(query).groupBy("uid", { count: /* @__PURE__ */ __name((row) => import_koishi3.$.sum(row.count), "count") }).orderBy("count", "desc").execute();
         if (stats.length === 0) return "暂无统计数据";
         const allUids = stats.map((s) => s.uid);
-        const users = await this.ctx.database.get("analyse_user", { uid: { $in: allUids } }, ["uid", "userName"]);
-        const userNameMap = new Map(users.map((u) => [u.uid, u.userName]));
+        const userNameMap = /* @__PURE__ */ new Map();
+        const BATCH_SIZE2 = 4096;
+        for (let i = 0; i < allUids.length; i += BATCH_SIZE2) {
+          const batchUids = allUids.slice(i, i + BATCH_SIZE2);
+          const users = await this.ctx.database.get("analyse_user", { uid: { $in: batchUids } }, ["uid", "userName"]);
+          for (const user of users) {
+            userNameMap.set(user.uid, user.userName);
+          }
+        }
         const total = stats.reduce((sum, r) => sum + r.count, 0);
         const list = stats.map((r) => [userNameMap.get(r.uid) || `UID ${r.uid}`, r.count, total > 0 ? `${(r.count / total * 100).toFixed(2)}%` : "0.00%"]);
-        return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total, list }, ["用户", "总计发言", "占比"]);
+        return this.renderer.renderList({ title, time: /* @__PURE__ */ new Date(), total, list }, ["用户", "条数", "占比"]);
       })()));
     }
     if (this.config.enableActivity) {
-      cmd.subcommand("activity", "活跃统计").usage("查询活跃统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("duration", "-n <units:number> 指定时长", { fallback: 24 }).option("offset", "-o <units:number> 指定偏移").option("days", "-d 切换至天").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
+      cmd.subcommand("activity", "活跃统计").usage("查询活跃统计，可指定查询范围，默认当前群组。").option("user", "-u <user:string> 指定用户").option("guild", "-g <guildId:string> 指定群组").option("duration", "-n <units:number> 指定时长", { fallback: 24 }).option("offset", "-o <units:number> 指定偏移").option("days", "-d 以天为粒度").option("all", "-a 全局统计").action(({ session, options }) => handleAction(session, (async () => {
         const scope = await this.parseScope(session, options);
         if (scope.error) return scope.error;
         const timeUnit = options.days ? import_koishi3.Time.day : import_koishi3.Time.hour;
@@ -1966,9 +2021,9 @@ var Stat = class {
             counts[index] += stat.count;
           }
         });
-        const total = counts.reduce((a, b) => a + b, 0);
         const title = await generateTitle(this.ctx, scope.scopeDesc, { main: "活跃", timeRange: options.duration, timeUnit: timeUnitName });
-        return this.renderer.renderCircadianChart({ title, time: /* @__PURE__ */ new Date(), total, data: counts, labels });
+        const series = [{ name: "活跃度", data: counts }];
+        return this.renderer.renderLineChart({ title, time: /* @__PURE__ */ new Date(), series, labels });
       })()));
     }
   }
@@ -2101,7 +2156,7 @@ var Data = class {
         return "数据恢复失败";
       }
     });
-    cmd.subcommand(".clear", "清除数据", { authority: 4 }).usage(`清除指定统计数据，可精确控制清除范围。`).option("table", "-t <table:string> 指定表名").option("guild", "-g <guildId:string> 指定群组").option("user", "-u <user:string> 指定用户").option("days", "-d <days:number> 指定天数").option("command", "-c <command:string> 指定命令").option("all", "-a 清除全部").action(async ({ options }) => {
+    cmd.subcommand(".clear", "清除数据", { authority: 4 }).usage(`清除指定统计数据，可精确控制清除范围。`).option("table", "-t <table:string> 指定表名").option("guild", "-g <guildId:string> 指定群组").option("user", "-u <user:string> 指定用户").option("days", "-d <days:number> 指定天数").option("command", "-c <command:string> 指定命令").option("all", "-a 全部清除").action(async ({ options }) => {
       if (Object.keys(options).length === 0) return "请指定清除条件";
       if (options.table && !ALL_TABLES.includes(options.table)) return `表名 ${options.table} 无效`;
       try {
@@ -2176,6 +2231,21 @@ ${commandOutput}`;
 var import_koishi6 = require("koishi");
 var import_jieba = require("@node-rs/jieba");
 var import_dict = require("@node-rs/jieba/dict");
+function cosineSimilarity(vecA, vecB) {
+  let dotProduct = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < vecA.length; i++) {
+    dotProduct += (vecA[i] || 0) * (vecB[i] || 0);
+    magA += (vecA[i] || 0) * (vecA[i] || 0);
+    magB += (vecB[i] || 0) * (vecB[i] || 0);
+  }
+  magA = Math.sqrt(magA);
+  magB = Math.sqrt(magB);
+  if (magA === 0 || magB === 0) return 0;
+  return dotProduct / (magA * magB);
+}
+__name(cosineSimilarity, "cosineSimilarity");
 var Analyse = class {
   constructor(ctx, config) {
     this.ctx = ctx;
@@ -2232,6 +2302,49 @@ var Analyse = class {
         }
       });
     }
+    if (this.config.enableSimilarActivity) {
+      cmd.subcommand("simiactive", "相似活跃分析").usage("分析你和群友的活跃度，找出谁和你的活跃度最相似。").option("hours", "-n <hours:number> 指定分析时长(小时)", { fallback: 24 }).action(async ({ session, options }) => {
+        if (!session.guildId) return "请在群组中使用此命令";
+        try {
+          const until = /* @__PURE__ */ new Date();
+          const since = new Date(until.getTime() - options.hours * import_koishi6.Time.hour);
+          const points = options.hours;
+          const guildUsers = await this.ctx.database.get("analyse_user", { channelId: session.guildId });
+          if (guildUsers.length < 2) return "暂无用户数据";
+          const selfUser = guildUsers.find((u) => u.userId === session.userId);
+          const guildUserUids = guildUsers.map((u) => u.uid);
+          const uidToNameMap = new Map(guildUsers.map((u) => [u.uid, u.userName]));
+          const records = await this.ctx.database.get("analyse_rank", { uid: { $in: guildUserUids }, timestamp: { $gte: since } });
+          if (records.length === 0) return "暂无统计数据";
+          const activityVectors = /* @__PURE__ */ new Map();
+          guildUserUids.forEach((uid) => activityVectors.set(uid, Array(points).fill(0)));
+          records.forEach((stat) => {
+            const diff = until.getTime() - stat.timestamp.getTime();
+            const index = points - 1 - Math.floor(diff / import_koishi6.Time.hour);
+            if (index >= 0 && index < points) {
+              activityVectors.get(stat.uid)[index] += stat.count;
+            }
+          });
+          const selfVector = activityVectors.get(selfUser.uid);
+          if (!selfVector || selfVector.every((v) => v === 0)) return "暂无统计数据";
+          const similarities = guildUserUids.filter((uid) => uid !== selfUser.uid && !activityVectors.get(uid).every((v) => v === 0)).map((uid) => ({ uid, score: cosineSimilarity(selfVector, activityVectors.get(uid)) })).sort((a, b) => b.score - a.score);
+          if (similarities.length === 0) return "暂无相似用户";
+          const top5 = similarities.slice(0, 5);
+          const series = [{ name: uidToNameMap.get(selfUser.uid) || "您", data: selfVector }];
+          top5.forEach((sim) => {
+            const name2 = uidToNameMap.get(sim.uid) || `UID ${sim.uid}`;
+            series.push({ name: `${name2} (${(sim.score * 100).toFixed(1)}%)`, data: activityVectors.get(sim.uid) });
+          });
+          const labels = Array.from({ length: points }, (_, i) => String(new Date(until.getTime() - (points - 1 - i) * import_koishi6.Time.hour).getHours()));
+          const title = `${options.hours}小时相似活跃分析`;
+          const imageGenerator = this.renderer.renderLineChart({ title, time: /* @__PURE__ */ new Date(), series, labels });
+          for await (const buffer of imageGenerator) await session.send(import_koishi6.h.image(buffer, "image/png"));
+        } catch (error) {
+          this.ctx.logger.error("生成作息分析图片失败:", error);
+          return "图片渲染失败";
+        }
+      });
+    }
   }
 };
 
@@ -2267,7 +2380,8 @@ var Config3 = import_koishi7.Schema.intersect([
   import_koishi7.Schema.object({
     enableOriRecord: import_koishi7.Schema.boolean().default(true).description("启用原始记录"),
     cacheRetentionDays: import_koishi7.Schema.number().min(0).default(30).description("记录保留天数"),
-    enableWordCloud: import_koishi7.Schema.boolean().default(true).description("启用词云生成")
+    enableWordCloud: import_koishi7.Schema.boolean().default(true).description("启用词云生成"),
+    enableSimilarActivity: import_koishi7.Schema.boolean().default(true).description("启用相似活跃分析")
   }).description("高级分析配置")
 ]);
 async function parseQueryScope(ctx, session, options) {
@@ -2314,7 +2428,7 @@ function apply(ctx, config) {
   new Stat(ctx, config).registerCommands(analyse);
   if (config.enableWhoAt) new WhoAt(ctx, config).registerCommand(analyse);
   if (config.enableDataIO) new Data(ctx).registerCommands(analyse);
-  if (config.enableOriRecord && config.enableWordCloud) new Analyse(ctx, config).registerCommands(analyse);
+  if (config.enableWordCloud || config.enableSimilarActivity) new Analyse(ctx, config).registerCommands(analyse);
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chat-analyse",
   "description": "强大而全面的聊天数据分析，支持统计命令，发言，消息类型，活跃度，支持发言排行和生成词云",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],

package/readme.md

@@ -8,98 +8,111 @@
 
 - **高效数据收集**：采用异步、高并发和缓存机制，在不影响机器人性能的前提下，精确高效地收集聊天数据。
 - **多维度统计分析**：
-  - **命令统计** (`cmdstat`)：追踪指令使用频率，了解用户最常用的功能。
-  - **发言统计** (`msgstat`)：分析用户发言类型与数量，掌握核心用户群体。
-  - **发言排行** (`rankstat`)：生成指定时间范围内的用户发言排行榜。
-  - **活跃度分析** (`activity`)：以小时或天为单位，生成直观的周期性活跃度图表。
+  - **命令统计** (`cmdstat`)：追踪指令使用频率，了解用户最常用的功能，支持按次数或时间排序。
+  - **发言统计** (`msgstat`)：分析用户发言类型与数量，掌握核心用户群体，支持按条数或时间排序。
+  - **发言排行** (`rankstat`)：生成指定时间范围内的用户发言排行榜，发掘群聊中的“龙王”。
+  - **活跃度分析** (`activity`)：以小时或天为单位，生成直观的周期性活跃度图表，洞察社群活跃时段。
 - **高级文本分析**：
-  - **词云生成** (`wordcloud`)：基于聊天记录，利用 Jieba 分词生成热门话题词云图。
-  - **提及追踪** (`whoatme`)：轻松查询谁在什么时候因为什么内容提及了您。
+  - **词云生成** (`wordcloud`)：基于聊天记录，利用 Jieba 分词生成热门话题词云图，快速了解近期热点。
+  - **相似活跃分析** (`simiactive`): 分析指定时间内，找出与您作息模式最相似的群友，并通过对比图表直观展示。
+  - **提及追踪** (`whoatme`)：轻松查询谁在什么时候因为什么内容提及了您，不再错过重要信息。
 - **强大的数据管理**：
-  - **备份与恢复** (`backup`/`restore`)：一键备份所有统计数据至本地，并可随时恢复，保障数据安全。
-  - **精确清理** (`clear`)：提供多维度的筛选条件（如按时间、用户、群组、命令），精确清理不再需要的数据。
+  - **备份与恢复** (`.backup`/`.restore`)：一键备份所有统计数据至本地，并可随时恢复，保障数据安全。
+  - **精确清理** (`.clear`)：提供多维度的筛选条件（如按时间、用户、群组、命令），精确清理不再需要的数据。
 - **精美图表渲染**：借助 Puppeteer 服务，将复杂的统计数据渲染成美观、易读的图片，方便在聊天中分享。
 - **高度可配置**：所有功能模块均可独立开关，并可自定义数据保留时长等核心参数，以适应不同场景的需求。
 
-### 前置服务
+## ⚙️ 前置服务
 
 本插件依赖以下 Koishi 服务，请确保您已正确安装并启用了它们：
 
-- `database`：用于存储所有统计分析数据。
-- `puppeteer`：用于将统计结果渲染成图片。
-- `cron`：用于执行数据定时清理任务。
+- **`database`**：用于存储所有统计分析数据。
+- **`puppeteer`**：用于将统计结果渲染成图片。
+- **`cron`**：用于执行数据定时清理任务。
 
 ## 📝 使用说明
 
-所有功能都集成在主指令 `analyse` 之下。
+所有功能都集成在主指令 `analyse` 之下。大部分指令不加任何参数时，默认查询**当前群组**的数据。
 
 ### 指令列表
 
 | 指令 | 别名 | 描述 | 选项 |
-| --- | --- | --- | --- |
-| `analyse.cmdstat` | 命令统计 | 查询命令使用情况，展示方式根据选项变化 | `-u <user>`, `-g <guild>`, `-a` (全局), `-s` (分离子指令) |
-| `analyse.msgstat` | 发言统计 | 查询用户发言统计，展示方式根据选项变化 | `-u <user>`, `-g <guild>`, `-a` (全局), `-t <type>` (指定消息类型) |
-| `analyse.rankstat` | 发言排行 | 查询指定时间内的发言排行，展示方式根据选项变化 | `-u <user>`, `-g <guild>`, `-a` (全局), `-t <type>`, `-n <hours>`, `-o <hours>` |
-| `analyse.activity` | 活跃统计 | 查询周期性活跃度图表 | `-u <user>`, `-g <guild>`, `-a` (全局), `-d` (按天), `-n <units>`, `-o <units>` |
-| `analyse.wordcloud` | 生成词云 | 基于聊天记录生成词云图 | `-u <user>`, `-g <guild>`, `-t <hours>` (默认24小时) |
-| `analyse.whoatme` | 谁提及我 | 查看最近谁提及了您 | (无) |
-| `analyse.list` | 列出数据 | 列出已记录的频道和命令 | (无) |
-| `analyse.backup` | 备份数据 | 将所有数据备份为本地 JSON 文件 | (无) |
-| `analyse.restore` | 恢复数据 | 从本地 JSON 文件恢复数据 | (无) |
-| `analyse.clear` | 清除数据 | 根据条件精确清理数据 | `-t <table>`, `-g <guild>`, `-u <user>`, `-d <days>`, `-c <command>`, `-a` (全部) |
+| :--- | :--- | :--- | :--- |
+| `cmdstat` | 命令统计 | 查询命令使用情况，展示方式根据选项变化 | `-u`, `-g`, `-a`, `-p`, `-s` |
+| `msgstat` | 发言统计 | 查询用户发言统计，展示方式根据选项变化 | `-u`, `-g`, `-a`, `-t`, `-s` |
+| `rankstat` | 发言排行 | 查询指定时间内的发言排行 | `-u`, `-g`, `-a`, `-t`, `-n`, `-o` |
+| `activity` | 活跃统计 | 查询周期性活跃度图表 | `-u`, `-g`, `-a`, `-d`, `-n`, `-o` |
+| `wordcloud` | 生成词云 | 基于聊天记录生成词云图 | `-u`, `-g`, `-t` |
+| `simiactive`| 作息分析 | 分析并找出与您作息相似的群友 | `-n` |
+| `whoatme` | 谁提及我 | 查看最近谁提及了您 | (无) |
+| `analyse.list` | 列出数据 | (管理) 列出已记录的频道和命令 | (无) |
+| `analyse.backup` | 备份数据 | (管理) 将所有数据备份为本地 JSON 文件 | (无) |
+| `analyse.restore` | 恢复数据 | (管理) 从本地 JSON 文件恢复数据 | (无) |
+| `analyse.clear` | 清除数据 | (管理) 根据条件精确清理数据 | `-t`, `-g`, `-u`, `-d`, `-c`, `-a` |
+
+**通用选项说明:**
+
+- `-u, --user <user>`: 指定用户 (可使用 @ 或 userID)。
+- `-g, --guild <guild>`: 指定群组 (需使用群组ID)。
+- `-a, --all`: 查询全局数据。
 
 ### 🔎 指令详解
 
-#### `analyse.cmdstat` (命令统计)
+#### `cmdstat` (命令统计)
 
-- **`analyse cmdstat`**: 查询**当前群组**所有用户的命令统计。
-- **`analyse cmdstat -u @用户`**: 查询**指定用户**在**所有群组**的命令统计。
-- **`analyse cmdstat -g <群组ID>`**: 查询**指定群组**所有用户的命令统计。
-- **`analyse cmdstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的命令统计。
-- **`analyse cmdstat -a`**: 查询**全局**（所有用户+所有群组）的命令统计。
-- **选项 `-s`**: 分离展示子命令，不合并到主命令。
+- **`cmdstat`**: 查询**当前群组**所有用户的命令统计。
+- **`cmdstat -u @用户`**: 查询**指定用户**在**所有群组**的命令统计。
+- **`cmdstat -g <群组ID>`**: 查询**指定群组**所有用户的命令统计。
+- **`cmdstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的命令统计。
+- **`cmdstat -a`**: 查询**全局**（所有用户+所有群组）的命令统计。
+- **选项 `-p, --separate`**: 分离展示子命令，不合并到主命令。
+- **选项 `-s, --sortByTime`**: 按最后使用时间降序排序（默认按使用次数）。
 
-#### `analyse.msgstat` (发言统计)
+#### `msgstat` (发言统计)
 
-- **`analyse msgstat`**: 查询**当前群组**的发言统计 (按**用户**展示)。
-- **`analyse msgstat -u @用户`**: 查询**指定用户**的发言统计 (按**群组**展示)。
-- **`analyse msgstat -g <群组ID>`**: 查询**指定群组**的发言统计 (按**用户**展示)。
-- **`analyse msgstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的发言统计 (按**消息类型**展示)。
-- **`analyse msgstat -a`**: 查询**全局**发言统计 (按**用户**展示)。
-- **选项 `-t <类型>`**: 筛选指定消息类型，不改变上述展示逻辑。
+- **`msgstat`**: 查询**当前群组**的发言统计 (按**用户**展示)。
+- **`msgstat -u @用户`**: 查询**指定用户**的发言统计 (按**群组**展示)。
+- **`msgstat -g <群组ID>`**: 查询**指定群组**的发言统计 (按**用户**展示)。
+- **`msgstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的发言统计 (按**消息类型**展示)。
+- **`msgstat -a`**: 查询**全局**发言统计 (按**用户**展示)。
+- **选项 `-t, --type <类型>`**: 筛选指定消息类型 (`text`, `face`, `image` 等)，不改变上述展示逻辑。
+- **选项 `-s, --sortByTime`**: 按最后发言时间降序排序（默认按发言条数）。
 
-#### `analyse.rankstat` (发言排行)
+#### `rankstat` (发言排行)
 
-- **`analyse rankstat`**: 查询**当前群组**的发言排行 (按**用户**排名)。
-- **`analyse rankstat -u @用户`**: 查询**指定用户**的发言排行 (按**群组**排名)。
-- **`analyse rankstat -g <群组ID>`**: 查询**指定群组**的发言排行 (按**用户**排名)。
-- **`analyse rankstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的发言排行 (按**消息类型**排名)。
-- **`analyse rankstat -a`**: 查询**全局**发言排行 (按**用户**排名)。
-- **选项 `-n <小时数>`**: 指定查询范围的时长，默认为 `24`。
-- **选项 `-o <小时数>`**: 指定查询结束时间的偏移量（从现在往前推的小时数），默认为 `0`。
-- **选项 `-t <类型>`**: 筛选指定消息类型，不改变上述展示逻辑。
+- **`rankstat`**: 查询**当前群组**的发言排行 (按**用户**排名)。
+- **`rankstat -u @用户`**: 查询**指定用户**的发言排行 (按**群组**排名)。
+- **`rankstat -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的发言排行 (按**消息类型**排名)。
+- **`rankstat -a`**: 查询**全局**发言排行 (按**用户**排名)。
+- **选项 `-n, --duration <小时数>`**: 指定查询范围的时长，默认为 `24`。
+- **选项 `-o, --offset <小时数>`**: 指定查询结束时间的偏移量（从现在往前推的小时数），默认为 `0`。
+- **选项 `-t, --type <类型>`**: 筛选指定消息类型。
 
-#### `analyse.activity` (活跃统计)
+#### `activity` (活跃统计)
 
-- **`analyse activity`**: 查询**当前群组**的活跃度。
-- **`analyse activity -u @用户`**: 查询**指定用户**在**所有群组**的活跃度。
-- **`analyse activity -g <群组ID>`**: 查询**指定群组**的活跃度。
-- **`analyse activity -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的活跃度。
-- **`analyse activity -a`**: 查询**全局**活跃度。
-- **选项 `-n <数值>`**: 指定查询范围的时长，默认为 `24`。
-- **选项 `-o <数值>`**: 指定查询结束时间的偏移量，默认为 `0`。
-- **选项 `-d`**: 将 `-n` 和 `-o` 的单位从**小时**切换为**天**。
+- **`activity`**: 查询**当前群组**的活跃度。
+- **`activity -a`**: 查询**全局**活跃度。
+- **`activity -u @用户 -g <群组ID>`**: 查询**指定用户**在**指定群组**的活跃度。
+- **选项 `-n, --duration <数值>`**: 指定查询范围的时长，默认为 `24`。
+- **选项 `-o, --offset <数值>`**: 指定查询结束时间的偏移量，默认为 `0`。
+- **选项 `-d, --days`**: 将 `-n` 和 `-o` 的单位从**小时**切换为**天**。
 
-### 配置项
+#### `simiactive` (相似活跃分析)
+
+- **`simiactive`**: 在**当前群组**中，分析最近 **24 小时**内与您作息最相似的群友。
+- **`simiactive -n 48`**: 指定分析最近 **48 小时**的数据。
+- **选项 `-n, --hours <小时数>`**: 指定查询范围的时长，默认为 `24`。
+
+## 🔧 配置项
 
 您可以在插件的配置页面中调整以下选项：
 
-#### 杂项配置
+### 杂项配置
 
 - `enableListener`: **启用消息监听**。总开关，关闭后插件将停止所有数据收集。 (默认: `true`)
-- `enableDataIO`: **启用数据管理**。控制 `.backup`, `.restore`, `.clear`, `.list` 等指令的可用性。 (默认: `true`)
+- `enableDataIO`: **启用数据管理**。控制 `.backup`, `.restore`, `.clear`, `.list` 等管理指令的可用性。 (默认: `true`)
 
-#### 基础分析配置
+### 基础分析配置
 
 - `enableCmdStat`: **启用命令统计**。 (默认: `true`)
 - `enableMsgStat`: **启用消息统计**。 (默认: `true`)
@@ -109,8 +122,16 @@
 - `enableWhoAt`: **启用提及记录**。 (默认: `true`)
 - `atRetentionDays`: **提及保留天数**。`whoatme` 数据的保留时长（天），`0` 为永久保留。 (默认: `3`)
 
-#### 高级分析配置
+### 高级分析配置
 
 - `enableOriRecord`: **启用原始记录**。是否记录原始消息内容以供词云等功能使用。 (默认: `true`)
-- `enableWordCloud`: **启用词云生成**。 (默认: `true`)
 - `cacheRetentionDays`: **原始记录保留天数**。原始消息记录的保留时长（天），`0` 为永久保留。 (默认: `30`)
+- `enableWordCloud`: **启用词云生成** (依赖`原始记录`)。 (默认: `true`)
+- `enablesimiactive`: **启用相似活跃分析** (依赖`发言排行`或`活跃统计`)。 (默认: `true`)
+
+## 📌 注意事项
+
+1. **Puppeteer 配置**：本插件的图片渲染强依赖 `puppeteer` 服务。请确保您已正确安装并配置了该服务，包括正确设置了可执行文件路径（如有需要）。渲染失败通常与此有关。
+2. **初始数据积累**：插件启用后，需要一段时间来收集数据。因此，在刚安装插件后立即查询可能不会返回任何结果。
+3. **数据清理**：插件会根据您设置的保留天数自动清理过期数据。对于手动清理 (`.clear`)，请谨慎操作，特别是 `-a` (清除全部) 选项，该操作不可逆。
+4. **性能考虑**：尽管插件经过优化，但在极大规模的机器人（数千群聊）上，长时间积累的大量数据仍可能对数据库造成压力。建议定期使用 `.clear -d <天数>` 清理过旧的数据。