koishi-plugin-chat-analyse 0.3.0 → 0.3.2

package/lib/Collector.d.ts

@@ -41,12 +41,11 @@ export declare class Collector {
     private static readonly FLUSH_INTERVAL;
     /** @const {number} BUFFER_THRESHOLD - 内存缓存区触发自动刷新的消息数量阈值。 */
     private static readonly BUFFER_THRESHOLD;
-    /** @member {Omit<Tables['analyse_cache'], 'id'>[]} cacheBuffer - 用于暂存原始消息的内存缓冲区，以减少数据库写入频率。 */
-    private cacheBuffer;
-    /** @member {Map<string, number>} uidCache - 用户 uid 的内存缓存，避免重复查询数据库。*/
-    private uidCache;
-    /** @member {Map<string, Promise<number>>} pendingUidRequests - 用于处理并发获取 uid 的请求锁。*/
-    private pendingUidRequests;
+    private msgStatBuffer;
+    private cmdStatBuffer;
+    private oriCacheBuffer;
+    private userCache;
+    private pendingUserRequests;
     private flushInterval;
     /**
      * @constructor
@@ -71,13 +70,13 @@ export declare class Collector {
     /**
      * @private
      * @async
-     * @method getOrCreateUser
-     * @description 高效地获取或创建用户的中央记录 (`analyse_user`)。
+     * @method getOrCreateCachedUser
+     * @description 高效地获取或创建用户的中央记录，并全面利用缓存。
      * @param {Session} session - Koishi 会话对象，用于获取用户信息和 Bot 实例。
      * @param {string} channelId - 消息所在的频道或群组 ID。
-     * @returns {Promise<number | null>} 返回用户的唯一 `uid`，如果操作失败则返回 `null`。
+     * @returns {Promise<UserCache | null>} 返回用户的缓存对象，如果操作失败则返回 `null`。
      */
-    private getOrCreateUser;
+    private getOrCreateCachedUser;
     /**
      * @private
      * @method sanitizeContent
@@ -89,8 +88,8 @@ export declare class Collector {
     /**
      * @private
      * @async
-     * @method flushCacheBuffer
-     * @description 将内存中的消息缓存 (`cacheBuffer`) 批量写入数据库。
+     * @method flushBuffers
+     * @description 将所有内存中的缓冲区数据批量写入数据库。
      */
-    private flushCacheBuffer;
+    private flushBuffers;
 }

package/lib/Stat.d.ts

@@ -17,7 +17,7 @@ export declare class Stat {
     constructor(ctx: Context, config: Config);
     /**
      * @method registerCommands
-     * @description 根据插件配置，动态地将 `.command`, `.message`, `.rank` 子命令注册到主 `analyse` 命令下。
+     * @description 根据插件配置，动态地将 `.cmd`, `.msg`, `.rank` 子命令注册到主 `analyse` 命令下。
      * @param {Command} analyse - 主 `analyse` 命令实例。
      */
     registerCommands(analyse: Command): void;
@@ -28,7 +28,10 @@ export declare class Stat {
      * @description 通用的标题生成器。根据查询参数和类型选项动态生成易于理解的图片标题。
      * @param {string} [guildId] - (可选) 查询的群组 ID。
      * @param {string} [userId] - (可选) 查询的用户 ID。
-     * @param {TitleOptions} options - 标题的配置选项。
+     * @param {object} options - 标题的配置选项。
+     * @param {'命令' | '消息' | '排行'} options.main - 标题主类型。
+     * @param {string} [options.subtype] - (可选) 消息类型的子类型。
+     * @param {number} [options.timeRange] - (可选) 排行的时间范围（小时）。
      * @returns {Promise<string>} 生成的标题字符串。
      */
     private generateTitle;

package/lib/index.d.ts

@@ -14,7 +14,8 @@ export interface Config {
     enableListener: boolean;
     enableCmdStat: boolean;
     enableMsgStat: boolean;
-    enableAdvanced: boolean;
+    enableRankStat: boolean;
+    enableOriRecord: boolean;
 }
 /**
  * @const {Schema<Config>} Config

package/lib/index.js

@@ -42,13 +42,11 @@ var Collector = class _Collector {
     this.config = config;
     this.defineModels();
     ctx.on("message", (session) => this.handleMessage(session));
-    if (this.config.enableAdvanced) {
-      this.flushInterval = setInterval(() => this.flushCacheBuffer(), _Collector.FLUSH_INTERVAL);
-      ctx.on("dispose", () => {
-        clearInterval(this.flushInterval);
-        this.flushCacheBuffer();
-      });
-    }
+    this.flushInterval = setInterval(() => this.flushBuffers(), _Collector.FLUSH_INTERVAL);
+    ctx.on("dispose", () => {
+      clearInterval(this.flushInterval);
+      this.flushBuffers();
+    });
   }
   static {
     __name(this, "Collector");
@@ -57,12 +55,13 @@ var Collector = class _Collector {
   static FLUSH_INTERVAL = 60 * 1e3;
   /** @const {number} BUFFER_THRESHOLD - 内存缓存区触发自动刷新的消息数量阈值。 */
   static BUFFER_THRESHOLD = 100;
-  /** @member {Omit<Tables['analyse_cache'], 'id'>[]} cacheBuffer - 用于暂存原始消息的内存缓冲区，以减少数据库写入频率。 */
-  cacheBuffer = [];
-  /** @member {Map<string, number>} uidCache - 用户 uid 的内存缓存，避免重复查询数据库。*/
-  uidCache = /* @__PURE__ */ new Map();
-  /** @member {Map<string, Promise<number>>} pendingUidRequests - 用于处理并发获取 uid 的请求锁。*/
-  pendingUidRequests = /* @__PURE__ */ new Map();
+  // 统一的缓冲区
+  msgStatBuffer = /* @__PURE__ */ new Map();
+  cmdStatBuffer = /* @__PURE__ */ new Map();
+  oriCacheBuffer = [];
+  // 用户缓存
+  userCache = /* @__PURE__ */ new Map();
+  pendingUserRequests = /* @__PURE__ */ new Map();
   flushInterval;
   /**
    * @private
@@ -90,7 +89,7 @@ var Collector = class _Collector {
       count: "unsigned",
       timestamp: "timestamp"
     }, { primary: ["uid", "type", "hour"] });
-    if (this.config.enableAdvanced) {
+    if (this.config.enableOriRecord) {
       this.ctx.model.extend("analyse_cache", {
         id: "unsigned",
         uid: "unsigned",
@@ -111,35 +110,39 @@ var Collector = class _Collector {
       const { userId, channelId, guildId, content, timestamp, argv, elements } = session;
       const effectiveId = channelId || guildId;
       if (!effectiveId || !userId || !timestamp || !content?.trim()) return;
-      const uid = await this.getOrCreateUser(session, effectiveId);
-      if (!uid) return;
+      const user = await this.getOrCreateCachedUser(session, effectiveId);
+      if (!user) return;
+      const { uid } = user;
+      const messageTime = new Date(timestamp);
       if (argv?.command) {
-        await this.ctx.database.upsert("analyse_cmd", (row) => [{
-          uid,
-          command: argv.command.name,
-          count: import_koishi.$.add(import_koishi.$.ifNull(row.count, import_koishi.$.literal(0)), 1),
-          timestamp: /* @__PURE__ */ new Date()
-        }]);
+        const key = `${uid}:${argv.command.name}`;
+        const existing = this.cmdStatBuffer.get(key);
+        if (existing) {
+          existing.count++;
+          existing.timestamp = messageTime;
+        } else {
+          this.cmdStatBuffer.set(key, { uid, command: argv.command.name, count: 1, timestamp: messageTime });
+        }
       }
-      const messageTime = new Date(timestamp);
       const hourStart = new Date(messageTime.getFullYear(), messageTime.getMonth(), messageTime.getDate(), messageTime.getHours());
       const uniqueElementTypes = new Set(elements.map((e) => e.type));
       for (const type of uniqueElementTypes) {
-        await this.ctx.database.upsert("analyse_msg", (row) => [{
-          uid,
-          type,
-          hour: hourStart,
-          count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), 1),
-          timestamp: messageTime
-        }]);
+        const key = `${uid}:${type}:${hourStart.toISOString()}`;
+        const existing = this.msgStatBuffer.get(key);
+        if (existing) {
+          existing.count++;
+          existing.timestamp = messageTime;
+        } else {
+          this.msgStatBuffer.set(key, { uid, type, hour: hourStart, count: 1, timestamp: messageTime });
+        }
       }
-      if (this.config.enableAdvanced) {
-        this.cacheBuffer.push({
+      if (this.config.enableOriRecord) {
+        this.oriCacheBuffer.push({
           uid,
           content: this.sanitizeContent(elements),
-          timestamp: new Date(timestamp)
+          timestamp: messageTime
         });
-        if (this.cacheBuffer.length >= _Collector.BUFFER_THRESHOLD) await this.flushCacheBuffer();
+        if (this.oriCacheBuffer.length >= _Collector.BUFFER_THRESHOLD) await this.flushBuffers();
       }
     } catch (error) {
       this.ctx.logger.warn("消息处理出错:", error);
@@ -148,45 +151,50 @@ var Collector = class _Collector {
   /**
    * @private
    * @async
-   * @method getOrCreateUser
-   * @description 高效地获取或创建用户的中央记录 (`analyse_user`)。
+   * @method getOrCreateCachedUser
+   * @description 高效地获取或创建用户的中央记录，并全面利用缓存。
    * @param {Session} session - Koishi 会话对象，用于获取用户信息和 Bot 实例。
    * @param {string} channelId - 消息所在的频道或群组 ID。
-   * @returns {Promise<number | null>} 返回用户的唯一 `uid`，如果操作失败则返回 `null`。
+   * @returns {Promise<UserCache | null>} 返回用户的缓存对象，如果操作失败则返回 `null`。
    */
-  async getOrCreateUser(session, channelId) {
+  async getOrCreateCachedUser(session, channelId) {
     const { userId, bot, guildId } = session;
     const cacheKey = `${channelId}:${userId}`;
-    if (this.uidCache.has(cacheKey)) return this.uidCache.get(cacheKey);
-    if (this.pendingUidRequests.has(cacheKey)) return this.pendingUidRequests.get(cacheKey);
+    if (this.userCache.has(cacheKey)) return this.userCache.get(cacheKey);
+    if (this.pendingUserRequests.has(cacheKey)) return this.pendingUserRequests.get(cacheKey);
     const promise = (async () => {
       try {
-        const existing = await this.ctx.database.get("analyse_user", { channelId, userId }, ["uid"]);
+        const existing = await this.ctx.database.get("analyse_user", { channelId, userId });
         if (existing.length > 0) {
-          this.uidCache.set(cacheKey, existing[0].uid);
-          return existing[0].uid;
+          const { uid: uid2, userName: userName2, channelName: channelName2 } = existing[0];
+          const cachedUser2 = { uid: uid2, userName: userName2, channelName: channelName2 };
+          this.userCache.set(cacheKey, cachedUser2);
+          return cachedUser2;
         }
         const [guild, member] = await Promise.all([
           guildId ? bot.getGuild(guildId).catch(() => null) : Promise.resolve(null),
           guildId ? bot.getGuildMember(guildId, userId).catch(() => null) : Promise.resolve(null)
         ]);
         const user = !member ? await bot.getUser(userId).catch(() => null) : null;
-        const newUser = await this.ctx.database.create("analyse_user", {
+        const newUserRecord = {
           channelId,
           userId,
           channelName: guild?.name || channelId,
           userName: member?.nick || member?.name || user?.name || userId
-        });
-        this.uidCache.set(cacheKey, newUser.uid);
-        return newUser.uid;
+        };
+        const createdUser = await this.ctx.database.create("analyse_user", newUserRecord);
+        const { uid, userName, channelName } = createdUser;
+        const cachedUser = { uid, userName, channelName };
+        this.userCache.set(cacheKey, cachedUser);
+        return cachedUser;
       } catch (error) {
-        this.ctx.logger.error(`创建或获取用户(${cacheKey}) UID 失败:`, error);
+        this.ctx.logger.error(`创建或获取用户(${cacheKey})失败:`, error);
         return null;
       } finally {
-        this.pendingUidRequests.delete(cacheKey);
+        this.pendingUserRequests.delete(cacheKey);
       }
     })();
-    this.pendingUidRequests.set(cacheKey, promise);
+    this.pendingUserRequests.set(cacheKey, promise);
     return promise;
   }
   /**
@@ -211,17 +219,43 @@ var Collector = class _Collector {
   /**
    * @private
    * @async
-   * @method flushCacheBuffer
-   * @description 将内存中的消息缓存 (`cacheBuffer`) 批量写入数据库。
+   * @method flushBuffers
+   * @description 将所有内存中的缓冲区数据批量写入数据库。
    */
-  async flushCacheBuffer() {
-    if (this.cacheBuffer.length === 0) return;
-    const bufferToFlush = this.cacheBuffer;
-    this.cacheBuffer = [];
+  async flushBuffers() {
+    const cmdBufferToFlush = Array.from(this.cmdStatBuffer.values());
+    const msgBufferToFlush = Array.from(this.msgStatBuffer.values());
+    const advancedBufferToFlush = this.oriCacheBuffer;
+    this.cmdStatBuffer.clear();
+    this.msgStatBuffer.clear();
+    this.oriCacheBuffer = [];
     try {
-      await this.ctx.database.upsert("analyse_cache", bufferToFlush);
+      if (cmdBufferToFlush.length > 0) {
+        await this.ctx.database.upsert(
+          "analyse_cmd",
+          (row) => cmdBufferToFlush.map((item) => ({
+            uid: item.uid,
+            command: item.command,
+            count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), item.count),
+            timestamp: item.timestamp
+          }))
+        );
+      }
+      if (msgBufferToFlush.length > 0) {
+        await this.ctx.database.upsert(
+          "analyse_msg",
+          (row) => msgBufferToFlush.map((item) => ({
+            uid: item.uid,
+            type: item.type,
+            hour: item.hour,
+            count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), item.count),
+            timestamp: item.timestamp
+          }))
+        );
+      }
+      if (advancedBufferToFlush.length > 0) await this.ctx.database.create("analyse_cache", advancedBufferToFlush);
     } catch (error) {
-      this.ctx.logger.error("写入缓存出错:", error);
+      this.ctx.logger.error("写入数据出错:", error);
     }
   }
 };
@@ -360,12 +394,12 @@ var Stat = class {
   renderer;
   /**
    * @method registerCommands
-   * @description 根据插件配置，动态地将 `.command`, `.message`, `.rank` 子命令注册到主 `analyse` 命令下。
+   * @description 根据插件配置，动态地将 `.cmd`, `.msg`, `.rank` 子命令注册到主 `analyse` 命令下。
    * @param {Command} analyse - 主 `analyse` 命令实例。
    */
   registerCommands(analyse) {
     if (this.config.enableCmdStat) {
-      analyse.subcommand(".command", "命令使用统计").option("user", "-u [user:user] 指定用户").option("guild", "-g [guildId:string] 指定群组").usage("查询用户或群组的命令使用统计，默认展示全局统计。").action(async ({ session, options }) => {
+      analyse.subcommand(".cmd", "命令使用统计").option("user", "-u [user:user] 指定用户").option("guild", "-g [guildId:string] 指定群组").usage("查询用户或群组的命令使用统计，默认展示全局统计。").action(async ({ session, options }) => {
         const userId = options.user ? import_koishi3.h.select(options.user, "user")[0]?.attrs.id : void 0;
         let guildId = options.guild;
         if (!userId && !guildId && session.guildId) {
@@ -393,7 +427,7 @@ var Stat = class {
       });
     }
     if (this.config.enableMsgStat) {
-      analyse.subcommand(".message", "消息发送统计").option("user", "-u [user:user] 指定用户").option("guild", "-g [guildId:string] 指定群组").option("type", "-t <type:string> 指定类型").usage("查询用户或群组的消息发送统计，默认展示全局统计。").action(async ({ session, options }) => {
+      analyse.subcommand(".msg", "消息发送统计").option("user", "-u [user:user] 指定用户").option("guild", "-g [guildId:string] 指定群组").option("type", "-t <type:string> 指定类型").usage("查询用户或群组的消息发送统计，默认展示全局统计。").action(async ({ session, options }) => {
         const userId = options.user ? import_koishi3.h.select(options.user, "user")[0]?.attrs.id : void 0;
         let guildId = options.guild;
         if (!userId && !guildId && !options.type && session.guildId) {
@@ -434,7 +468,9 @@ var Stat = class {
           return "渲染消息统计图片失败";
         }
       });
-      analyse.subcommand(".rank", "用户发言排行").option("guild", "-g [guildId:string] 指定群组").option("hours", "-h <hours:number> 查看过去 N 小时的排行", { fallback: 24 }).usage("查询用户或群组的用户发言排行，默认展示全局统计。").action(async ({ session, options }) => {
+    }
+    if (this.config.enableRankStat) {
+      analyse.subcommand(".rank", "用户发言排行").option("guild", "-g [guildId:string] 指定群组").option("hours", "-h <hours:number> 指定时长", { fallback: 24 }).usage("查询用户或群组的用户发言排行，默认展示全局统计。").action(async ({ session, options }) => {
         let guildId = options.guild;
         if (!guildId && session.guildId) guildId = session.guildId;
         if (!guildId) return "请指定查询范围";
@@ -470,7 +506,10 @@ var Stat = class {
    * @description 通用的标题生成器。根据查询参数和类型选项动态生成易于理解的图片标题。
    * @param {string} [guildId] - (可选) 查询的群组 ID。
    * @param {string} [userId] - (可选) 查询的用户 ID。
-   * @param {TitleOptions} options - 标题的配置选项。
+   * @param {object} options - 标题的配置选项。
+   * @param {'命令' | '消息' | '排行'} options.main - 标题主类型。
+   * @param {string} [options.subtype] - (可选) 消息类型的子类型。
+   * @param {number} [options.timeRange] - (可选) 排行的时间范围（小时）。
    * @returns {Promise<string>} 生成的标题字符串。
    */
   async generateTitle(guildId, userId, options) {
@@ -635,13 +674,14 @@ var name = "chat-analyse";
 var using = ["database", "puppeteer"];
 var Config = import_koishi4.Schema.intersect([
   import_koishi4.Schema.object({
-    enableListener: import_koishi4.Schema.boolean().default(true).description("开启监听")
-  }).description("基本设置"),
+    enableListener: import_koishi4.Schema.boolean().default(true).description("启用消息监听"),
+    enableOriRecord: import_koishi4.Schema.boolean().default(true).description("启用原始记录")
+  }).description("监听配置"),
   import_koishi4.Schema.object({
     enableCmdStat: import_koishi4.Schema.boolean().default(true).description("启用命令统计"),
     enableMsgStat: import_koishi4.Schema.boolean().default(true).description("启用消息统计"),
-    enableAdvanced: import_koishi4.Schema.boolean().default(true).description("启用原始记录")
-  }).description("功能开关")
+    enableRankStat: import_koishi4.Schema.boolean().default(true).description("启用发言排行")
+  }).description("命令配置")
 ]);
 function apply(ctx, config) {
   if (config.enableListener) new Collector(ctx, config);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chat-analyse",
   "description": "聊天记录分析",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],