koishi-plugin-ll-mc 1.0.7 → 2.1.0

package/index.js

@@ -0,0 +1,569 @@
+'use strict'
+
+// koishi-plugin-ll-mc v2.1.0（照抄 astrbot_plugin_message_stats 功能 + 新增群排行）
+// 参考：https://github.com/xiaoruange39/astrbot_plugin_message_stats
+// 移植到 Koishi 的功能：
+//   - 发言榜（今日/昨日/本周/本月/本年/去年/总榜，文字或图片）
+//   - 群发言榜（新增：跨群排行，群名正确）
+//   - 我的发言 / 发言榜帮助
+//   - 设置发言榜数量 / 设置发言榜图片 / 清除发言榜单
+//   - 定时推送（自动 + 手动）
+// 官机（官方QQ）适配：昵称取消息自带，群名走 getGuild + groupNameMap 手动指定兜底
+
+const { Schema, h } = require('koishi')
+
+exports.name = 'll-mc'
+
+exports.usage = `消息统计插件（移植自 astrbot_plugin_message_stats，并新增群排行）。
+
+## 命令
+
+- \`发言榜 [周期] [人数]\`：本群成员发言排行。周期：今日/昨日/本周/本月/本年/去年/总榜（默认总榜）
+- \`群发言榜 [周期] [人数]\`：**所有群的发言排行（群名正确显示）**，当前群带 ★
+- \`今日发言榜\` / \`本周发言榜\` / \`本月发言榜\`：快捷查看
+- \`我的发言\`：自己的发言统计
+- \`设置发言榜数量 <N>\`：设置本群排行显示人数
+- \`设置发言榜图片 <auto|文字|图片>\`：设置本群排行显示模式（auto=有图片服务用图片，否则文字）
+- \`清除发言榜单\`：清空本群统计
+- \`手动推送发言榜 [周期]\`：立即向定时目标群推送排行
+- \`发言榜定时状态\`：查看定时推送配置
+
+## 定时推送（设置页配置）
+
+- \`timerEnabled\`：启用后每天到点自动推送排行
+- \`timerTime\`：推送时间（HH:MM）
+- \`timerType\`：推送内容类型（day=昨日 / week=本周 / month=本月）
+- \`timerGroups\`：推送目标群（留空=推送给所有有数据的群）
+
+## 官机说明
+
+- **群名**：官机消息不带群名，插件用 \`getGuild\` 获取（需在 QQ 开放平台申请「获取群信息」权限）；也可在 \`groupNameMap\` 手动指定（openid → 群名），保证群排行群名正确
+- **昵称**：官机消息自带昵称，零接口权限
+- **图片排行**：需要安装 \`koishi-plugin-puppeteer\` 才显示图片，否则自动降级为文字
+`
+
+const Config = Schema.object({
+  rankLimit: Schema.number()
+    .min(1).max(100).default(20)
+    .description('排行默认显示人数'),
+  imageMode: Schema.union([
+    Schema.const('auto').description('自动：有图片服务用图片，否则文字'),
+    Schema.const('text').description('始终文字'),
+    Schema.const('image').description('始终图片（无服务时降级文字）'),
+  ]).default('auto').description('排行显示模式'),
+  ignoredGroups: Schema.array(String)
+    .default([])
+    .description('不统计的群（填群ID，官机填 openid）'),
+  groupNameMap: Schema.dict(String)
+    .default({})
+    .description('手动指定群名：键=群ID（官机 openid），值=群名。保证群排行群名正确'),
+  refreshGroupNameInterval: Schema.number()
+    .min(60).default(3600)
+    .description('群名自动刷新间隔（秒）'),
+  countBots: Schema.boolean()
+    .default(false)
+    .description('是否统计机器人自己的发言'),
+  timerEnabled: Schema.boolean()
+    .default(false)
+    .description('定时推送：启用后每天到点自动推送排行'),
+  timerTime: Schema.string()
+    .default('00:00')
+    .description('定时推送时间（HH:MM，24小时制）'),
+  timerType: Schema.union([
+    Schema.const('day').description('昨日发言榜'),
+    Schema.const('week').description('本周发言榜'),
+    Schema.const('month').description('本月发言榜'),
+  ]).default('day').description('定时推送的内容类型'),
+  timerGroups: Schema.array(String)
+    .default([])
+    .description('定时推送目标群（留空=所有有数据的群）'),
+  verbose: Schema.boolean()
+    .default(false)
+    .description('调试：控制台打印统计详情'),
+})
+
+exports.Config = Config
+
+exports.inject = { required: ['database'] }
+
+function apply(ctx, config) {
+  const logger = ctx.logger('ll-mc')
+
+  // ===== 数据表 =====
+  ctx.model.extend('ll_mc_stats', {
+    channelId: 'string',
+    userId: 'string',
+    nick: 'string',
+    date: 'string',
+    count: 'unsigned',
+  }, { primary: ['channelId', 'userId', 'date'] })
+  ctx.model.extend('ll_mc_groups', {
+    channelId: 'string',
+    name: 'string',
+    platform: 'string',
+    botSid: 'string',
+    updatedAt: 'timestamp',
+  }, { primary: ['channelId'] })
+  ctx.model.extend('ll_mc_settings', {
+    channelId: 'string',
+    rankLimit: 'unsigned',
+    imageMode: 'string',
+  }, { primary: ['channelId'] })
+
+  // ===== 缓存 =====
+  const nameCache = new Map()
+  const settingsCache = new Map()
+  const lastNameRefresh = new Map()
+  const warnThrottle = new Map()
+  let firedTimer = { date: '' }
+
+  function throttledWarn(key, message) {
+    const now = Date.now()
+    if ((warnThrottle.get(key) || 0) > now - 10 * 60 * 1000) return
+    warnThrottle.set(key, now)
+    logger.warn(message)
+  }
+
+  // ===== 日期工具 =====
+  function dateStr(d) {
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
+  }
+  function nowHM() {
+    const d = new Date()
+    return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
+  }
+  // 解析周期 → { key, label, start, end }（end 可空）
+  function parsePeriod(period) {
+    const p = String(period || '').trim()
+    const now = new Date()
+    if (!p || /总|全部|all/i.test(p)) return { key: 'all', label: '总榜', start: null, end: null }
+    if (/去年/.test(p)) {
+      const y = now.getFullYear() - 1
+      return { key: 'lastyear', label: '去年', start: `${y}-01-01`, end: `${y}-12-31` }
+    }
+    if (/本年|今年|年/.test(p)) {
+      return { key: 'year', label: '本年', start: `${now.getFullYear()}-01-01`, end: null }
+    }
+    if (/本?周/.test(p)) {
+      const d = new Date(now)
+      d.setDate(d.getDate() - ((d.getDay() + 6) % 7))
+      return { key: 'week', label: '本周', start: dateStr(d), end: null }
+    }
+    if (/本?月/.test(p)) {
+      return { key: 'month', label: '本月', start: `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-01`, end: null }
+    }
+    if (/昨|昨天|昨日/.test(p)) {
+      const d = new Date(now)
+      d.setDate(d.getDate() - 1)
+      return { key: 'yesterday', label: '昨日', start: dateStr(d), end: dateStr(d) }
+    }
+    if (/今|今?日|天/.test(p)) return { key: 'day', label: '今日', start: dateStr(now), end: dateStr(now) }
+    return null
+  }
+
+  // ===== 昵称解析 =====
+  async function resolveNick(session, userId) {
+    const author = session.author
+    if (author?.nick) return String(author.nick)
+    if (author?.name) return String(author.name)
+    const raw = session.event?._data?.d
+    if (raw?.member?.nick) return String(raw.member.nick)
+    if (raw?.author?.username) return String(raw.author.username)
+    if (session.guildId && !session.isDirect && typeof session.bot?.getGuildMember === 'function') {
+      try {
+        const member = await session.bot.getGuildMember(session.guildId, userId)
+        const name = member?.name || member?.user?.name
+        if (name) return String(name)
+      }
+      catch (e) {
+        throttledWarn(`member:${session.guildId}:${userId}`, `[ll-mc] 获取成员昵称失败 ${userId}: ${e?.message}（官机需申请"获取群成员信息"权限）`)
+      }
+    }
+    return String(userId)
+  }
+
+  // ===== 群名 =====
+  async function setGroupName(guildId, name, botSid) {
+    if (!name || name === guildId) return
+    nameCache.set(guildId, { name, t: Date.now() })
+    try {
+      await ctx.database.upsert('ll_mc_groups', [{
+        channelId: guildId, name, platform: '', botSid: botSid || '', updatedAt: Date.now(),
+      }], ['channelId'])
+    }
+    catch { /* 忽略 */ }
+  }
+  async function getGroupName(guildId) {
+    if (config.groupNameMap[guildId]) return config.groupNameMap[guildId]
+    const cached = nameCache.get(guildId)
+    if (cached?.name) return cached.name
+    try {
+      const rows = await ctx.database.get('ll_mc_groups', { channelId: guildId })
+      if (rows[0]?.name) {
+        nameCache.set(guildId, { name: rows[0].name, t: Date.now() })
+        return rows[0].name
+      }
+    }
+    catch { /* 忽略 */ }
+    return guildId
+  }
+  async function getGroupBotSid(guildId) {
+    try {
+      const rows = await ctx.database.get('ll_mc_groups', { channelId: guildId })
+      return rows[0]?.botSid || ''
+    }
+    catch { return '' }
+  }
+  async function refreshGroupName(session) {
+    const guildId = session.guildId
+    const now = Date.now()
+    if ((lastNameRefresh.get(guildId) || 0) > now - config.refreshGroupNameInterval * 1000) return
+    lastNameRefresh.set(guildId, now)
+    if (session.event?.channel?.name) {
+      await setGroupName(guildId, session.event.channel.name, session.bot?.sid)
+      return
+    }
+    if (config.groupNameMap[guildId]) {
+      await setGroupName(guildId, config.groupNameMap[guildId], session.bot?.sid)
+      return
+    }
+    if (typeof session.bot?.getGuild === 'function') {
+      try {
+        const g = await session.bot.getGuild(guildId)
+        if (g?.name) {
+          await setGroupName(guildId, g.name, session.bot?.sid)
+          return
+        }
+      }
+      catch (e) {
+        throttledWarn(`guild:${guildId}`, `[ll-mc] 获取群名失败 ${guildId}: ${e?.message}（官机需在QQ开放平台申请"获取群信息"权限，或在配置 groupNameMap 手动指定群名）`)
+      }
+    }
+  }
+
+  // ===== 群设置 =====
+  async function getGroupSettings(guildId) {
+    const cached = settingsCache.get(guildId)
+    if (cached) return cached
+    let s = { rankLimit: config.rankLimit, imageMode: config.imageMode }
+    try {
+      const rows = await ctx.database.get('ll_mc_settings', { channelId: guildId })
+      if (rows[0]) {
+        s = {
+          rankLimit: rows[0].rankLimit || config.rankLimit,
+          imageMode: rows[0].imageMode || config.imageMode,
+        }
+      }
+    }
+    catch { /* 忽略 */ }
+    settingsCache.set(guildId, s)
+    return s
+  }
+  async function setGroupSettings(guildId, patch) {
+    const cur = await getGroupSettings(guildId)
+    const next = { ...cur, ...patch }
+    settingsCache.set(guildId, next)
+    try {
+      await ctx.database.upsert('ll_mc_settings', [{
+        channelId: guildId,
+        rankLimit: next.rankLimit,
+        imageMode: next.imageMode,
+      }], ['channelId'])
+    }
+    catch { /* 忽略 */ }
+    return next
+  }
+
+  // ===== 消息统计 =====
+  ctx.on('message', async (session) => {
+    try {
+      if (session.isDirect || !session.guildId || !session.userId) return
+      const guildId = session.guildId
+      const userId = session.userId
+      if (!config.countBots && session.selfId === session.userId) return
+      if (config.ignoredGroups.includes(guildId)) return
+      const date = todayStr()
+      const rows = await ctx.database.get('ll_mc_stats', { channelId: guildId, userId, date })
+      const count = (rows[0]?.count || 0) + 1
+      const nick = await resolveNick(session, userId)
+      await ctx.database.upsert('ll_mc_stats', [{
+        channelId: guildId, userId, date, nick, count,
+      }], ['channelId', 'userId', 'date'])
+      if (config.verbose) logger.info(`[ll-mc] ${guildId} ${userId} +1 (${count})`)
+    }
+    catch (e) {
+      logger.warn('[ll-mc] 消息统计失败:', e?.message)
+    }
+    refreshGroupName(session).catch(() => {})
+  })
+  function todayStr() {
+    return dateStr(new Date())
+  }
+
+  // ===== 聚合 =====
+  async function aggregateStats(range, groupBy) {
+    const cond = {}
+    if (range.start) cond.date = { $gte: range.start }
+    if (range.end) cond.date = { ...(cond.date || {}), $lte: range.end }
+    const rows = await ctx.database.get('ll_mc_stats', cond)
+    const map = new Map()
+    for (const row of rows) {
+      const key = groupBy === 'user' ? `${row.channelId}:${row.userId}` : row.channelId
+      const item = map.get(key) || { count: 0, nick: row.nick }
+      item.count += row.count || 0
+      if (row.nick) item.nick = row.nick
+      map.set(key, item)
+    }
+    return [...map.entries()].map(([key, item]) => ({ key, ...item }))
+      .sort((a, b) => b.count - a.count)
+  }
+
+  // ===== 图片渲染（puppeteer，可选） =====
+  async function renderRankImage(title, subtitle, rows) {
+    try {
+      if (typeof ctx.puppeteer?.page !== 'function') return null
+      const page = await ctx.puppeteer.page()
+      const body = rows.map((r, i) => `
+        <div class="row">
+          <div class="no">${i + 1}</div>
+          <div class="name">${escapeHtml(r.name)}${r.mark ? ' <span class="star">★</span>' : ''}</div>
+          <div class="bar"><div class="fill" style="width:${r.percent}%"></div></div>
+          <div class="count">${r.count} 条</div>
+        </div>`).join('')
+      await page.setContent(`<!DOCTYPE html><html><head><meta charset="utf-8"><style>
+        body{margin:0;background:linear-gradient(135deg,#1a1a2e,#16213e);font-family:sans-serif;color:#fff;padding:24px;width:900px}
+        .title{font-size:28px;font-weight:bold;margin-bottom:4px}
+        .sub{font-size:14px;color:#8a94b8;margin-bottom:16px}
+        .row{display:flex;align-items:center;background:rgba(255,255,255,.06);border-radius:10px;padding:10px 14px;margin-bottom:8px}
+        .no{width:36px;font-size:18px;font-weight:bold;color:#ffd166;flex-shrink:0}
+        .name{width:220px;font-size:16px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;flex-shrink:0}
+        .star{color:#ffd166}
+        .bar{flex:1;height:10px;background:rgba(255,255,255,.12);border-radius:5px;margin:0 12px;overflow:hidden}
+        .fill{height:100%;background:linear-gradient(90deg,#06b6d4,#3b82f6);border-radius:5px}
+        .count{width:80px;text-align:right;font-size:15px;color:#a5f3fc;flex-shrink:0}
+      </style></head><body>
+        <div class="title">${escapeHtml(title)}</div>
+        <div class="sub">${escapeHtml(subtitle)}</div>
+        ${body}
+      </body></html>`, { waitUntil: 'networkidle0' })
+      await page.waitForSelector('.title')
+      const buf = await page.screenshot({ type: 'png' })
+      await page.close().catch(() => {})
+      return buf
+    }
+    catch (e) {
+      logger.warn('[ll-mc] 排行图片渲染失败，降级文字:', e?.message)
+      return null
+    }
+  }
+  function escapeHtml(s) {
+    return String(s == null ? '' : s).replace(/[&<>"']/g, c => ({
+      '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+    }[c]))
+  }
+
+  // ===== 命令：发言榜（成员） =====
+  async function memberRanking(session, period, limit) {
+    if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+    const range = parsePeriod(period)
+    if (!range) return '❌ 周期参数无效，可用：今日/昨日/本周/本月/本年/去年/总榜'
+    const gs = await getGroupSettings(session.guildId)
+    const n = Math.min(Math.max(limit || gs.rankLimit || config.rankLimit, 1), 100)
+    const list = await aggregateStats(range, 'user')
+    const inGroup = list.filter(x => x.key.startsWith(`${session.guildId}:`))
+    const mine = inGroup.find(x => x.key === `${session.guildId}:${session.userId}`)
+    const top = inGroup.slice(0, n)
+    const groupRows = await ctx.database.get('ll_mc_stats', { channelId: session.guildId })
+    const totalAll = groupRows.reduce((s, r) => s + (r.count || 0), 0)
+    const totalRange = inGroup.reduce((s, x) => s + x.count, 0)
+
+    const title = `${range.label}发言排行 TOP ${Math.min(n, inGroup.length)}`
+    const subtitle = `本群${range.label}共 ${totalRange} 条 · 历史累计 ${totalAll} 条`
+    const rows = top.map(x => {
+      const isMine = x.key === `${session.guildId}:${session.userId}`
+      return { name: x.nick || x.key.split(':')[1], count: x.count, percent: Math.max(top[0].count ? Math.round(x.count / top[0].count * 100) : 0, 2), mark: isMine }
+    })
+    const buf = await renderRankImage(title, subtitle, rows)
+    if (buf) return h.image(buf)
+    const lines = [`📊 ${title}`]
+    top.forEach((x, i) => {
+      const mark = x.key === `${session.guildId}:${session.userId}` ? ' ★' : ''
+      lines.push(`${i + 1}. ${x.nick || x.key.split(':')[1]} · ${x.count}条${mark}`)
+    })
+    lines.push(`—— ${subtitle}`)
+    if (mine) lines.push(`我的排名：第 ${inGroup.indexOf(mine) + 1} 名（${mine.count}条）`)
+    return lines.join('\n')
+  }
+
+  // ===== 命令：群发言榜（新增） =====
+  async function groupRanking(session, period, limit) {
+    const range = parsePeriod(period)
+    if (!range) return '❌ 周期参数无效，可用：今日/昨日/本周/本月/本年/去年/总榜'
+    const gs = session.guildId ? await getGroupSettings(session.guildId) : { rankLimit: config.rankLimit }
+    const n = Math.min(Math.max(limit || gs.rankLimit || config.rankLimit, 1), 100)
+    const list = await aggregateStats(range, 'group')
+    const top = list.slice(0, n)
+    const current = session.guildId
+    const rows = []
+    for (const x of top) {
+      const name = await getGroupName(x.key)
+      rows.push({ name, count: x.count, percent: Math.max(top[0].count ? Math.round(x.count / top[0].count * 100) : 0, 2), mark: x.key === current })
+    }
+    const title = `群${range.label}发言排行 TOP ${Math.min(n, top.length)}`
+    const subtitle = '跨群排行 · 群名来自 getGuild（需"获取群信息"权限）或 groupNameMap'
+    const buf = await renderRankImage(title, subtitle, rows)
+    if (buf) return h.image(buf)
+    const lines = [`🏆 ${title}`]
+    for (let i = 0; i < top.length; i++) {
+      const x = top[i]
+      const name = await getGroupName(x.key)
+      const mark = x.key === current ? ' ★当前群' : ''
+      lines.push(`${i + 1}. ${name} · ${x.count}条${mark}`)
+    }
+    lines.push(`—— ${subtitle}`)
+    return lines.join('\n')
+  }
+
+  // ===== 命令：我的发言 =====
+  async function myStats(session) {
+    if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+    const guildId = session.guildId
+    const userId = session.userId
+    const labels = [['day', '今日'], ['yesterday', '昨日'], ['week', '本周'], ['month', '本月'], ['year', '本年'], ['all', '总榜']]
+    const lines = ['👤 我的发言统计（本群）']
+    for (const [key, label] of labels) {
+      const range = parsePeriod(label === '总榜' ? '' : label)
+      const cond = { channelId: guildId, userId }
+      if (range.start) cond.date = { $gte: range.start }
+      if (range.end) cond.date = { ...(cond.date || {}), $lte: range.end }
+      const rows = await ctx.database.get('ll_mc_stats', cond)
+      lines.push(`${label}：${rows.reduce((s, r) => s + (r.count || 0), 0)} 条`)
+    }
+    return lines.join('\n')
+  }
+
+  // ===== 命令：定时推送 =====
+  async function pushRanking(period) {
+    const range = parsePeriod(period || (config.timerType === 'week' ? '本周' : config.timerType === 'month' ? '本月' : '昨日'))
+    if (!range) return '❌ 周期参数无效'
+    const list = await aggregateStats(range, 'group')
+    const targets = config.timerGroups && config.timerGroups.length
+      ? config.timerGroups
+      : list.map(x => x.key)
+    let sent = 0
+    const failed = []
+    for (const guildId of targets) {
+      try {
+        const botSid = await getGroupBotSid(guildId)
+        const bot = botSid ? (ctx.bots || []).find(b => b.sid === botSid) : (ctx.bots || []).find(b => b.online)
+        if (!bot || typeof bot.sendMessage !== 'function') {
+          failed.push(guildId)
+          continue
+        }
+        const gs = await getGroupSettings(guildId)
+        const n = gs.rankLimit || config.rankLimit
+        const rows = await ctx.database.get('ll_mc_stats', {
+          channelId: guildId,
+          ...(range.start ? { date: { $gte: range.start } } : {}),
+          ...(range.end ? { date: { $lte: range.end } } : {}),
+        })
+        const perUser = new Map()
+        for (const r of rows) {
+          const item = perUser.get(r.userId) || { count: 0, nick: r.nick }
+          item.count += r.count || 0
+          if (r.nick) item.nick = r.nick
+          perUser.set(r.userId, item)
+        }
+        const sorted = [...perUser.entries()].map(([uid, item]) => ({ uid, ...item }))
+          .sort((a, b) => b.count - a.count)
+          .slice(0, n)
+        const name = await getGroupName(guildId)
+        const lines = [`📊 ${name} ${range.label}发言榜 TOP ${Math.min(n, sorted.length)}`]
+        sorted.forEach((x, i) => lines.push(`${i + 1}. ${x.nick || x.uid} · ${x.count}条`))
+        await bot.sendMessage(guildId, lines.join('\n'))
+        sent++
+      }
+      catch (e) {
+        logger.warn(`[ll-mc] 推送 ${guildId} 失败: ${e?.message}`)
+        failed.push(guildId)
+      }
+    }
+    return `✅ 定时推送完成：成功 ${sent} 群${failed.length ? `，失败 ${failed.length} 群` : ''}`
+  }
+  const timer = setInterval(async () => {
+    const hm = nowHM()
+    if (!config.timerEnabled || config.timerTime !== hm) return
+    const today = todayStr()
+    if (firedTimer.date === today) return
+    firedTimer.date = today
+    logger.info(`[ll-mc] 定时推送触发 @ ${hm}`)
+    await pushRanking('')
+  }, 30000)
+  ctx.on('dispose', () => clearInterval(timer))
+
+  // ===== 命令注册 =====
+  function parseArgs(text) {
+    const parts = String(text || '').trim().split(/\s+/).filter(Boolean)
+    let period = ''
+    let limit = 0
+    for (const part of parts) {
+      if (/^\d+$/.test(part)) limit = parseInt(part, 10)
+      else period = part
+    }
+    return { period, limit }
+  }
+
+  ctx.command('发言榜 [args:text]', '本群成员发言排行（今日/昨日/本周/本月/本年/去年/总榜）')
+    .alias('水群榜', '发言排行', 'mc.排行')
+    .action(async ({ session }, args) => {
+      const { period, limit } = parseArgs(args)
+      return await memberRanking(session, period, limit)
+    })
+  ctx.command('群发言榜 [args:text]', '所有群的发言排行（群名正确）')
+    .alias('群排行', 'mc.群排行')
+    .action(async ({ session }, args) => {
+      const { period, limit } = parseArgs(args)
+      return await groupRanking(session, period, limit)
+    })
+  for (const [kw, period] of [['今日发言榜', '今日'], ['本周发言榜', '本周'], ['本月发言榜', '本月']]) {
+    ctx.command(kw, `查看${period}发言排行`).alias(`mc.${kw}`)
+      .action(async ({ session }) => memberRanking(session, period, 0))
+  }
+  ctx.command('我的发言', '我的发言统计').alias('查看发言', 'mc.我的')
+    .action(async ({ session }) => myStats(session))
+  ctx.command('发言榜帮助', '查看帮助').alias('发言帮助', '发言榜菜单')
+    .action(() => exports.usage.replace(/^`|`$/g, ''))
+  ctx.command('设置发言榜数量 <limit:number>', '设置本群排行显示人数')
+    .action(async ({ session }, limit) => {
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      const n = Math.min(Math.max(limit || config.rankLimit, 1), 100)
+      await setGroupSettings(session.guildId, { rankLimit: n })
+      return `✅ 本群排行显示人数已设为 ${n}`
+    })
+  ctx.command('设置发言榜图片 <mode:text>', '设置本群排行显示模式（auto/文字/图片）')
+    .action(async ({ session }, mode) => {
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      const m = /图|image/i.test(mode) ? 'image' : /文|text/i.test(mode) ? 'text' : 'auto'
+      await setGroupSettings(session.guildId, { imageMode: m })
+      return `✅ 本群排行模式已设为 ${m}（auto=有图片服务用图片）`
+    })
+  ctx.command('清除发言榜单', '清空本群统计')
+    .action(async ({ session }) => {
+      if (session.isDirect || !session.guildId) return '❌ 请在群聊中使用'
+      await ctx.database.remove('ll_mc_stats', { channelId: session.guildId })
+      return '✅ 本群发言统计已清空'
+    })
+  ctx.command('手动推送发言榜 [period:text]', '立即向定时目标群推送排行')
+    .action(async ({ session }, period) => {
+      return await pushRanking(period || '')
+    })
+  ctx.command('发言榜定时状态', '查看定时推送配置')
+    .action(() => {
+      const t = config.timerType === 'week' ? '本周' : config.timerType === 'month' ? '本月' : '昨日'
+      return `⏰ 定时推送：${config.timerEnabled ? '已启用' : '未启用'}\n时间：${config.timerTime}\n内容：${t}发言榜\n目标群：${config.timerGroups.length ? config.timerGroups.join(', ') : '所有有数据的群'}`
+    })
+
+  logger.info('[ll-mc] 已启动：发言榜 / 群发言榜 / 我的发言 / 定时推送')
+}
+
+exports.apply = apply

package/package.json

@@ -1,45 +1,26 @@
-{
-    "name":  "koishi-plugin-ll-mc",
-    "description":  "消息统计插件（克隆自 message-counter），支持排除指定群聊",
-    "version":  "1.0.7",
-    "main":  "lib/index.js",
-    "typings":  "lib/index.d.ts",
-    "files":  [
-                  "lib",
-                  "assets"
-              ],
-    "koishi":  {
-                   "description":  {
-                                       "zh":  "消息统计插件：发言排行榜、群排行榜，支持排除指定群聊"
-                                   },
-                   "service":  {
-                                   "required":  [
-                                                    "database",
-                                                    "cron"
-                                                ],
-                                   "optional":  [
-                                                    "markdownToImage",
-                                                    "puppeteer",
-                                                    "canvas"
-                                                ]
-                               }
-               },
-    "author":  "lee",
-    "license":  "MIT",
-    "keywords":  [
-                     "koishi",
-                     "koishi-plugin",
-                     "message-counter",
-                     "rank"
-                 ],
-    "peerDependencies":  {
-                             "koishi":  "^4.18.9"
-                         },
-    "devDependencies":  {
-                            "koishi":  "^4.18.11",
-                            "koishi-plugin-cron":  "^3.1.0",
-                            "koishi-plugin-markdown-to-image-service":  "^1.3.6",
-                            "koishi-plugin-puppeteer":  "^3.9.0",
-                            "typescript":  "^5.4.0"
-                        }
-}
+{
+  "name": "koishi-plugin-ll-mc",
+  "description": "消息统计插件（重做版）：群成员发言排行 + 跨群发言排行，官方QQ机器人原生适配",
+  "version": "2.1.0",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "koishi": {
+    "description": {
+      "zh": "消息统计插件：群成员发言排行 + 跨群发言排行（群名正确），官机原生适配，纯文本无需图片依赖"
+    }
+  },
+  "author": "lee",
+  "license": "MIT",
+  "keywords": [
+    "koishi",
+    "koishi-plugin",
+    "message-counter",
+    "rank",
+    "stats"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.0"
+  }
+}