koishi-plugin-chat-analyse 0.1.1 → 0.2.0

package/lib/CmdStat.d.ts

@@ -0,0 +1,34 @@
+import { Context, Command } from 'koishi';
+import { Renderer } from './Renderer';
+declare module 'koishi' {
+    interface Tables {
+        analyse_cmd: {
+            channelId: string;
+            userId: string;
+            command: string;
+            count: number;
+            timestamp: Date;
+        };
+    }
+}
+/**
+ * @class CmdStat
+ * @description 负责提供命令执行所需的服务，并管理插件的核心逻辑。
+ */
+export declare class CmdStat {
+    renderer: Renderer;
+    ctx: Context;
+    constructor(context: Context);
+    /**
+     * @method registerCommands
+     * @description 注册命令，并通过选项支持不同维度的查询。
+     */
+    registerCommands(analyse: Command): void;
+    /**
+     * @private
+     * @method getCommandStats
+     * @description 从数据库获取并处理命令统计数据，兼容全局、群组和个人查询。
+     * @returns 返回一个包含二维数组列表和总数的对象，或错误字符串。
+     */
+    private getCommandStats;
+}

package/lib/Collector.d.ts

@@ -0,0 +1,61 @@
+import { Context } from 'koishi';
+declare module 'koishi' {
+    interface Tables {
+        analyse_msg: {
+            channelId: string;
+            userId: string;
+            type: string;
+            content: string;
+            timestamp: Date;
+        };
+        analyse_name: {
+            channelId: string;
+            channelName: string;
+            userId: string;
+            userName: string;
+        };
+    }
+}
+/**
+ * @class Collector
+ * @description
+ * 负责初始化数据库表、监听消息，并将处理后的数据高效存入数据库。
+ */
+export declare class Collector {
+    private ctx;
+    private static readonly FLUSH_INTERVAL;
+    private static readonly BUFFER_THRESHOLD;
+    private msgBuffer;
+    private flushInterval;
+    private nameCache;
+    /**
+     * @constructor
+     * @param ctx {Context} Koishi 的上下文对象
+     */
+    constructor(ctx: Context);
+    /**
+     * 核心消息处理函数。
+     * @param session {Session} 消息会话对象
+     */
+    private handleMessage;
+    /**
+     * 从消息元素中提取并汇总类型。
+     * @example
+     * // returns "[text][img]"
+     * summarizeElementTypes([{type: 'text'}, {type: 'img'}])
+     */
+    private summarizeElementTypes;
+    /**
+     * 从消息元素中提取文本化、安全的内容。
+     */
+    private sanitizeContent;
+    /**
+     * 将内存缓冲区的消息数据批量写入数据库。
+     */
+    private flushBuffer;
+    /**
+     * 检查并更新用户和群组的名称信息。
+     * 如果名称不在缓存或缓存已过期 (超过24小时)，则从 API 获取并更新到数据库。
+     */
+    private updateNameIfNeeded;
+}

package/lib/Renderer.d.ts

@@ -0,0 +1,49 @@
+import { Context } from 'koishi';
+/**
+ * 渲染列表中的一行数据。每个元素代表一列。
+ * 这是一个灵活的元组类型，可以包含字符串、数字或日期。
+ * @example ['ping', 150, new Date()]
+ */
+export type RenderListItem = (string | number | Date)[];
+/**
+ * 渲染列表图片所需的数据结构。
+ */
+export interface ListRenderData {
+    title: string;
+    time: Date;
+    total?: string | number;
+    list: RenderListItem[];
+}
+/**
+ * @class Renderer
+ * @description 使用 Puppeteer 服务将格式化的数据渲染成图片。
+ * 这是一个通用的列表渲染器，能够处理任意列数的数据，并根据数据类型智能应用样式。
+ */
+export declare class Renderer {
+    private ctx;
+    /**
+     * @constructor
+     * @param ctx {Context} Koishi 的上下文对象
+     */
+    constructor(ctx: Context);
+    /**
+     * 将列表数据渲染为图片。
+     * @param data {ListRenderData} 待渲染的列表数据。
+     * @param headers {string[]} (可选) 表头数组。如果不提供或为空，则不渲染表头部分。
+     * @returns {Promise<string | Buffer>} 成功时返回图片 Buffer，失败或无数据时返回提示文本。
+     */
+    renderList(data: ListRenderData, headers?: string[]): Promise<string | Buffer>;
+    /**
+     * 格式化日期，提供相对时间和绝对时间显示。
+     * @param date {Date} 日期对象
+     * @returns {string} 格式化后的日期字符串
+     */
+    private formatDate;
+    /**
+     * 根据列表数据动态生成 HTML 字符串。
+     * @param data {ListRenderData} 列表数据
+     * @param headers {string[]} (可选) 表头数组
+     * @returns {string | null} 生成的 HTML 字符串，如果无数据则返回 null。
+     */
+    private generateListHtml;
+}

package/lib/index.d.ts

@@ -5,4 +5,8 @@ export interface Config {
 }
 export declare const Config: Schema<Config>;
 export declare const using: string[];
+/**
+ * Koishi 插件的入口函数。
+ * @param ctx {Context} Koishi 的上下文对象，用于访问框架核心功能。
+ */
 export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -27,112 +27,396 @@ __export(src_exports, {
   using: () => using
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
+var import_koishi3 = require("koishi");
 
-// src/collector.ts
-var Collector = class {
+// src/Collector.ts
+var Collector = class _Collector {
+  /**
+   * @constructor
+   * @param ctx {Context} Koishi 的上下文对象
+   */
   constructor(ctx) {
     this.ctx = ctx;
-    ctx.model.extend("analyse_origin_msg", {
-      id: "unsigned",
-      channelId: "string",
-      userId: "string",
-      content: "text",
-      timestamp: "timestamp"
-    }, {
-      autoInc: true,
-      indexes: ["channelId", "userId", "timestamp"]
-    });
-    ctx.model.extend("analyse_origin_cmd", {
-      id: "unsigned",
+    this.ctx.model.extend("analyse_msg", {
       channelId: "string",
       userId: "string",
-      command: "string",
+      type: "string",
       content: "text",
       timestamp: "timestamp"
     }, {
-      autoInc: true,
-      indexes: ["channelId", "userId", "command", "timestamp"]
+      indexes: ["channelId", "userId", "type", "timestamp"]
     });
-    ctx.model.extend("analyse_name_map", {
-      id: "unsigned",
+    this.ctx.model.extend("analyse_name", {
       channelId: "string",
       channelName: "string",
       userId: "string",
-      userName: "string",
-      timestamp: "timestamp"
+      userName: "string"
     }, {
-      autoInc: true,
-      unique: [["channelId", "userId"]]
+      primary: ["channelId", "userId"]
     });
-    ctx.on("command/before-execute", async (argv) => {
-      const effectiveId = argv.session.channelId || argv.session.guildId;
-      if (!effectiveId) return;
-      await ctx.database.create("analyse_origin_cmd", {
-        channelId: effectiveId,
-        userId: argv.session.userId,
-        command: argv.command.name,
-        content: argv.session.content,
-        timestamp: new Date(argv.session.timestamp)
-      });
+    ctx.on("message", (session) => {
+      this.handleMessage(session);
     });
-    ctx.on("message", async (session) => {
-      const { userId, author } = session;
-      const effectiveId = session.channelId || session.guildId;
-      const { channelName, guildName } = session;
-      const effectiveName = channelName || guildName;
-      const currentName = author?.name || author?.nick;
-      if (currentName && effectiveName && effectiveId && userId) {
-        const cacheKey = `${effectiveId}:${userId}`;
-        const cachedName = this.nameCache.get(cacheKey);
-        if (cachedName && currentName !== cachedName) await this.updateName(effectiveId, effectiveName, userId, currentName);
-        else if (!cachedName) {
-          const dbRecord = await ctx.database.get("analyse_name_map", {
-            channelId: effectiveId,
-            userId
-          });
-          const dbName = dbRecord[0]?.userName;
-          if (!dbName || currentName !== dbName) await this.updateName(effectiveId, effectiveName, userId, currentName);
-          else this.nameCache.set(cacheKey, currentName);
-        }
-      }
-      if (session.argv?.command) return;
-      if (!effectiveId) return;
-      const content = session.elements.map((element) => {
-        switch (element.type) {
-          case "text":
-            return element.attrs.content;
-          case "img":
-            return element.attrs.summary === "[动画表情]" ? "[gif]" : `[${element.type}]`;
-          case "at":
-            return `[at:${element.attrs.id}]`;
-          default:
-            return `[${element.type}]`;
-        }
-      }).join("");
-      const sanitizedContent = content.trim();
-      if (!sanitizedContent) return;
-      await ctx.database.create("analyse_origin_msg", {
-        channelId: effectiveId,
-        userId: session.userId,
-        content: sanitizedContent,
-        timestamp: new Date(session.timestamp)
-      });
+    this.flushInterval = setInterval(() => this.flushBuffer(), _Collector.FLUSH_INTERVAL);
+    ctx.on("dispose", () => {
+      clearInterval(this.flushInterval);
+      this.flushBuffer();
     });
   }
   static {
     __name(this, "Collector");
   }
+  // 每隔 1 分钟将缓冲区数据写入数据库
+  static FLUSH_INTERVAL = 60 * 1e3;
+  // 当缓冲区数据达到 100 条时，立即写入数据库
+  static BUFFER_THRESHOLD = 100;
+  // 消息数据写入缓冲区
+  msgBuffer = [];
+  // 定时器，用于周期性地清空缓冲区
+  flushInterval;
+  // 名称缓存，减少不必要的 API 请求 (key: 'channelId:userId')
   nameCache = /* @__PURE__ */ new Map();
-  async updateName(channelId, channelName, userId, userName) {
-    await this.ctx.database.upsert("analyse_name_map", [{
-      channelId,
-      channelName,
+  /**
+   * 核心消息处理函数。
+   * @param session {Session} 消息会话对象
+   */
+  async handleMessage(session) {
+    const { userId, channelId, guildId, content, timestamp, argv, elements } = session;
+    const effectiveId = channelId || guildId;
+    if (!effectiveId || !userId) return;
+    this.updateNameIfNeeded(session, effectiveId);
+    const isCommand = !!argv?.command;
+    const type = isCommand ? argv.command.name : this.summarizeElementTypes(elements);
+    const finalContent = isCommand ? content : this.sanitizeContent(elements);
+    if (!finalContent?.trim()) return;
+    this.msgBuffer.push({
+      channelId: effectiveId,
       userId,
-      userName,
-      timestamp: /* @__PURE__ */ new Date()
-    }]);
-    this.nameCache.set(`${channelId}:${userId}`, userName);
+      type,
+      content: finalContent,
+      timestamp: new Date(timestamp)
+    });
+    if (this.msgBuffer.length >= _Collector.BUFFER_THRESHOLD) {
+      this.flushBuffer();
+    }
+  }
+  /**
+   * 从消息元素中提取并汇总类型。
+   * @example
+   * // returns "[text][img]"
+   * summarizeElementTypes([{type: 'text'}, {type: 'img'}])
+   */
+  summarizeElementTypes(elements) {
+    return [...new Set(elements.map((e) => `[${e.type}]`))].join("");
+  }
+  /**
+   * 从消息元素中提取文本化、安全的内容。
+   */
+  sanitizeContent(elements) {
+    return elements.map((element) => {
+      switch (element.type) {
+        case "text":
+          return element.attrs.content;
+        case "img":
+          return element.attrs.summary === "[动画表情]" ? "[gif]" : `[img]`;
+        case "at":
+          return `[at:${element.attrs.id}]`;
+        default:
+          return `[${element.type}]`;
+      }
+    }).join("");
+  }
+  /**
+   * 将内存缓冲区的消息数据批量写入数据库。
+   */
+  async flushBuffer() {
+    if (this.msgBuffer.length === 0) return;
+    const bufferToFlush = this.msgBuffer;
+    this.msgBuffer = [];
+    try {
+      await this.ctx.database.create("analyse_msg", bufferToFlush);
+    } catch (error) {
+      this.ctx.logger.error("数据库写入失败:", error);
+      this.msgBuffer.unshift(...bufferToFlush);
+    }
+  }
+  /**
+   * 检查并更新用户和群组的名称信息。
+   * 如果名称不在缓存或缓存已过期 (超过24小时)，则从 API 获取并更新到数据库。
+   */
+  async updateNameIfNeeded(session, effectiveId) {
+    const { userId, guildId, bot } = session;
+    const cacheKey = `${effectiveId}:${userId}`;
+    const cached = this.nameCache.get(cacheKey);
+    const CACHE_EXPIRATION = 24 * 60 * 60 * 1e3;
+    if (cached && Date.now() - cached.timestamp < CACHE_EXPIRATION) return;
+    try {
+      const [guild, member] = await Promise.all([
+        bot.getGuild(guildId),
+        bot.getGuildMember(guildId, userId)
+      ]);
+      const channelName = guild?.name;
+      const userName = member?.nick || member?.name;
+      if (!channelName || !userName) return;
+      await this.ctx.database.upsert("analyse_name", [{
+        channelId: effectiveId,
+        channelName,
+        userId,
+        userName
+      }]);
+      this.nameCache.set(cacheKey, { name: userName, timestamp: Date.now() });
+    } catch (error) {
+      this.ctx.logger.warn("更新用户/群组名称失败:", error);
+    }
+  }
+};
+
+// src/CmdStat.ts
+var import_koishi2 = require("koishi");
+
+// src/Renderer.ts
+var import_koishi = require("koishi");
+var Renderer = class {
+  /**
+   * @constructor
+   * @param ctx {Context} Koishi 的上下文对象
+   */
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  static {
+    __name(this, "Renderer");
+  }
+  /**
+   * 将列表数据渲染为图片。
+   * @param data {ListRenderData} 待渲染的列表数据。
+   * @param headers {string[]} (可选) 表头数组。如果不提供或为空，则不渲染表头部分。
+   * @returns {Promise<string | Buffer>} 成功时返回图片 Buffer，失败或无数据时返回提示文本。
+   */
+  async renderList(data, headers) {
+    const htmlContent = this.generateListHtml(data, headers);
+    return this.ctx.puppeteer.render(htmlContent);
+  }
+  /**
+   * 格式化日期，提供相对时间和绝对时间显示。
+   * @param date {Date} 日期对象
+   * @returns {string} 格式化后的日期字符串
+   */
+  formatDate(date) {
+    if (!date) return "未知";
+    const now = Date.now();
+    const diff = now - date.getTime();
+    if (diff < import_koishi.Time.minute) return "刚刚";
+    if (diff < import_koishi.Time.hour) return `${Math.floor(diff / import_koishi.Time.minute)} 分钟前`;
+    if (diff < import_koishi.Time.day) return `${Math.floor(diff / import_koishi.Time.hour)} 小时前`;
+    const pad = /* @__PURE__ */ __name((n) => n.toString().padStart(2, "0"), "pad");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+  }
+  /**
+   * 根据列表数据动态生成 HTML 字符串。
+   * @param data {ListRenderData} 列表数据
+   * @param headers {string[]} (可选) 表头数组
+   * @returns {string | null} 生成的 HTML 字符串，如果无数据则返回 null。
+   */
+  generateListHtml(data, headers) {
+    const { title, time, total, list } = data;
+    if (!list || list.length === 0) return null;
+    let tableHeadHtml = "";
+    if (headers && headers.length > 0) {
+      const numDataColumns = list[0].length;
+      const headerCells = [];
+      for (let i = 0; i < numDataColumns; i++) {
+        const headerText = headers[i] || "";
+        headerCells.push(`<th>${headerText}</th>`);
+      }
+      const allHeaders = `<th class="rank-cell">排名</th>${headerCells.join("")}`;
+      tableHeadHtml = `<thead><tr>${allHeaders}</tr></thead>`;
+    }
+    const tableRows = list.map((rowItems, index) => {
+      const rank = index + 1;
+      let rankClass = "";
+      if (rank === 1) rankClass = "rank-gold";
+      if (rank === 2) rankClass = "rank-silver";
+      if (rank === 3) rankClass = "rank-bronze";
+      const rankCell = `<td class="rank-cell"><span class="rank-badge ${rankClass}">${rank}</span></td>`;
+      const dataCells = rowItems.map((cellData) => {
+        let cellClass = "data-cell";
+        let content;
+        if (cellData instanceof Date) {
+          cellClass += " date-cell";
+          content = this.formatDate(cellData);
+        } else if (typeof cellData === "number") {
+          cellClass += " count-cell";
+          content = cellData;
+        } else {
+          cellClass += " name-cell";
+          content = String(cellData);
+        }
+        return `<td class="${cellClass}">${content}</td>`;
+      }).join("");
+      return `<tr>${rankCell}${dataCells}</tr>`;
+    }).join("");
+    const metaInfo = total !== void 0 ? `<div class="total-count">总计: ${total}</div>` : "";
+    const timeLabel = `生成于 ${time.getFullYear()}-${String(time.getMonth() + 1).padStart(2, "0")}-${String(time.getDate()).padStart(2, "0")} ${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
+    const styles = `
+      :root {
+        --bg-color: #f7f8fa; --card-bg: #ffffff; --text-color: #333;
+        --header-color: #1f2329; --sub-text-color: #646a73;
+        --border-color: #e4e6eb; --accent-color: #4a6ee0;
+        --gold: #ffc327; --silver: #a8b5c1; --bronze: #d69864;
+      }
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+        background: var(--bg-color); margin: 0; padding: 20px;
+        width: 700px; box-sizing: border-box;
+        -webkit-font-smoothing: antialiased;
+      }
+      .container { background: var(--card-bg); border-radius: 12px; box-shadow: 0 6px 16px rgba(0,0,0,0.08); padding: 24px; }
+      .header { display: flex; justify-content: space-between; align-items: flex-start; border-bottom: 1px solid var(--border-color); padding-bottom: 16px; margin-bottom: 16px; }
+      .title-group h1 { font-size: 24px; font-weight: 700; color: var(--header-color); margin: 0; }
+      .meta-group { text-align: right; }
+      .meta-group .total-count { font-size: 22px; font-weight: 700; color: var(--accent-color); }
+      .meta-group .time-label { font-size: 13px; color: var(--sub-text-color); margin-top: 4px; }
+      table { width: 100%; border-collapse: collapse; color: var(--text-color); }
+      th, td { padding: 12px 8px; text-align: left; border-bottom: 1px solid var(--border-color); }
+      th { font-size: 13px; font-weight: 600; color: var(--sub-text-color); }
+      td { font-size: 15px; vertical-align: middle; }
+      tr:last-child td { border-bottom: none; }
+      .rank-cell { width: 50px; text-align: center; }
+      .rank-badge { display: inline-block; width: 24px; height: 24px; line-height: 24px; border-radius: 50%; font-weight: 600; font-size: 14px; color: var(--header-color); background-color: #eef0f3; }
+      .rank-gold { background-color: var(--gold); color: #fff; }
+      .rank-silver { background-color: var(--silver); color: #fff; }
+      .rank-bronze { background-color: var(--bronze); color: #fff; }
+      .data-cell { word-break: break-all; }
+      .name-cell { font-weight: 600; color: var(--header-color); }
+      .count-cell { text-align: right; font-weight: 600; color: var(--accent-color); }
+      .date-cell { text-align: right; font-size: 13px; color: var(--sub-text-color); }
+    `;
+    return `
+      <!DOCTYPE html><html lang="zh-CN">
+      <head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${title}</title><style>${styles}</style></head>
+      <body>
+        <div class="container">
+          <div class="header">
+            <div class="title-group"><h1>${title}</h1></div>
+            <div class="meta-group">${metaInfo}<div class="time-label">${timeLabel}</div></div>
+          </div>
+          <table>
+            ${tableHeadHtml}
+            <tbody>${tableRows}</tbody>
+          </table>
+        </div>
+      </body></html>
+    `;
+  }
+};
+
+// src/CmdStat.ts
+var CmdStat = class {
+  static {
+    __name(this, "CmdStat");
+  }
+  renderer;
+  ctx;
+  constructor(context) {
+    this.ctx = context;
+    this.renderer = new Renderer(this.ctx);
+    this.ctx.model.extend("analyse_cmd", {
+      channelId: "string",
+      userId: "string",
+      command: "string",
+      count: "unsigned",
+      timestamp: "timestamp"
+    }, { primary: ["channelId", "userId", "command"] });
+    this.ctx.on("command/before-execute", async ({ command, session }) => {
+      const { userId, guildId } = session;
+      if (!guildId || !userId || command.name === "analyse" || command.parent?.name === "analyse") return;
+      const commandName = command.name;
+      const query = { channelId: guildId, userId, command: commandName };
+      await this.ctx.database.upsert("analyse_cmd", (row) => [{
+        ...query,
+        count: import_koishi2.$.add(import_koishi2.$.ifNull(row.count, 0), 1),
+        timestamp: /* @__PURE__ */ new Date()
+      }]);
+    });
+  }
+  /**
+   * @method registerCommands
+   * @description 注册命令，并通过选项支持不同维度的查询。
+   */
+  registerCommands(analyse) {
+    analyse.subcommand(".command", "命令使用统计").option("user", "-u [user:user] 指定用户").option("guild", "-g [guildId:string] 指定群组").usage(`查询命令使用统计。默认查询全局统计，可通过选项指定用户和群组。`).action(async ({ session, options }) => {
+      const userId = options.user ? import_koishi2.h.select(options.user, "user")[0]?.attrs.id : void 0;
+      let guildId = options.guild;
+      if (options.guild === "" && !options.user) {
+        if (!session.guildId) return "请指定群组 ID";
+        guildId = session.guildId;
+      }
+      try {
+        const stats = await this.getCommandStats(guildId, userId);
+        if (typeof stats === "string") return stats;
+        let title;
+        const titleParts = [];
+        if (userId) {
+          const user = await session.bot.getUser(userId).catch(() => null);
+          titleParts.push(`用户 ${user?.name || userId}`);
+        }
+        if (guildId) {
+          const guild = await session.bot.getGuild(guildId).catch(() => null);
+          titleParts.push(`群组 ${guild?.name || guildId}`);
+        }
+        if (userId && !guildId) {
+          title = `${titleParts[0]}的全局命令统计`;
+        } else if (titleParts.length > 0) {
+          title = `${titleParts.join("、")}的命令统计`;
+        } else {
+          title = "全局命令统计";
+        }
+        const renderData = {
+          title,
+          time: /* @__PURE__ */ new Date(),
+          total: stats.total,
+          list: stats.list
+        };
+        const headers = ["命令", "次数", "上次使用"];
+        const result = await this.renderer.renderList(renderData, headers);
+        return Buffer.isBuffer(result) ? import_koishi2.Element.image(result, "image/png") : result;
+      } catch (error) {
+        this.ctx.logger.error("渲染统计图片失败:", error);
+        return "渲染统计图片失败";
+      }
+    });
+  }
+  /**
+   * @private
+   * @method getCommandStats
+   * @description 从数据库获取并处理命令统计数据，兼容全局、群组和个人查询。
+   * @returns 返回一个包含二维数组列表和总数的对象，或错误字符串。
+   */
+  async getCommandStats(guildId, userId) {
+    const query = {};
+    if (guildId) query.channelId = guildId;
+    if (userId) query.userId = userId;
+    const records = await this.ctx.database.get("analyse_cmd", query);
+    if (records.length === 0) return "暂无统计数据";
+    const totalCount = records.reduce((sum, record) => sum + record.count, 0);
+    let sortedList;
+    if (userId) {
+      sortedList = records.map((r) => ({ name: r.command, count: r.count, lastUsed: r.timestamp })).sort((a, b) => b.count - a.count);
+    } else {
+      const commandMap = /* @__PURE__ */ new Map();
+      for (const record of records) {
+        const existing = commandMap.get(record.command) || { count: 0, lastUsed: /* @__PURE__ */ new Date(0) };
+        existing.count += record.count;
+        if (record.timestamp > existing.lastUsed) {
+          existing.lastUsed = record.timestamp;
+        }
+        commandMap.set(record.command, existing);
+      }
+      sortedList = Array.from(commandMap.entries()).map(([name2, data]) => ({ name: name2, ...data })).sort((a, b) => b.count - a.count);
+    }
+    const list = sortedList.map((item) => [item.name, item.count, item.lastUsed]);
+    return { list, total: totalCount };
   }
 };
 
@@ -150,10 +434,13 @@ var usage = `
 </div>
 `;
 var name = "chat-analyse";
-var Config = import_koishi.Schema.object({});
-var using = ["database"];
+var Config = import_koishi3.Schema.object({});
+var using = ["database", "puppeteer"];
 function apply(ctx) {
   new Collector(ctx);
+  const cmd = new CmdStat(ctx);
+  const analyse = ctx.command("analyse", "聊天记录分析");
+  cmd.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": "0.1.1",
+  "version": "0.2.0",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],
@@ -16,14 +16,25 @@
     "lib",
     "dist"
   ],
-  "license": "MIT",
+  "license": "AGPL-3.0-only",
   "scripts": {},
   "keywords": [
     "chatbot",
     "koishi",
-    "plugin"
+    "plugin",
+    "chat",
+    "analyse",
+    "statistics",
+    "command",
+    "message",
+    "group",
+    "user",
+    "platform"
   ],
-  "devDependencies": {},
+  "devDependencies": {
+    "koishi-plugin-puppeteer": "^3.5.2",
+    "koishi-plugin-cron": "^3.0.0"
+  },
   "peerDependencies": {
     "koishi": "4.18.8"
   }

package/lib/collector.d.ts

@@ -1,42 +0,0 @@
-import { Context } from 'koishi';
-/**
- * @file collector.ts
- * @description 通过独立的事件监听器，分别持久化存储收到的普通消息和已确认的命令，并高效地维护ID与名称的映射。
- */
-declare module 'koishi' {
-    interface Tables {
-        analyse_origin_msg: {
-            id: number;
-            channelId: string;
-            userId: string;
-            content: string;
-            timestamp: Date;
-        };
-        analyse_origin_cmd: {
-            id: number;
-            channelId: string;
-            userId: string;
-            command: string;
-            content: string;
-            timestamp: Date;
-        };
-        analyse_name_map: {
-            id: number;
-            channelId: string;
-            channelName: string;
-            userId: string;
-            userName: string;
-            timestamp: Date;
-        };
-    }
-}
-/**
- * @class Collector
- * @description 使用双监听器，精确捕获并存储消息和命令，并维护一个ID到名称的映射表。
- */
-export declare class Collector {
-    private ctx;
-    private nameCache;
-    constructor(ctx: Context);
-    private updateName;
-}