@zhin.js/plugin-group-suite 1.0.1 → 1.1.0

package/src/index.ts

@@ -1,33 +1,47 @@
-/**
- * @zhin.js/plugin-group-suite
- *
- * ```yaml
- * plugins:
- *   - "@zhin.js/plugin-group-suite"
- * inbox:
- *   enabled: true
- * groupSuite:
- *   noticeAdapters: [icqq]
- *   autoAnalysisEnabled: true
- * ```
- */
-import { formatCompact, usePlugin } from "zhin.js";
-import { groupSuiteSchema } from "./config.js";
-import { registerAdmin } from "./admin.js";
-import { registerCheckin } from "./checkin.js";
-import { registerDailyAnalysis } from "./daily-analysis.js";
-import { registerStats } from "./stats.js";
-import { registerTeach } from "./teach.js";
-
-const plugin = usePlugin();
-const { logger, declareConfig } = plugin;
-
-const cfg = declareConfig("groupSuite", groupSuiteSchema);
-
-registerAdmin(plugin, cfg);
-registerCheckin(plugin, cfg);
-registerStats(plugin, cfg);
-registerDailyAnalysis(plugin, cfg);
-registerTeach(plugin, cfg);
-
-logger.info(formatCompact({ 模块: "群组套件", 状态: "已加载" }));
+export {
+  DEFAULT_GROUP_SUITE_CONFIG,
+  resolveGroupSuiteConfig,
+} from './config.js';
+export type { GroupSuiteConfig } from './config.js';
+export { doCheckin, myPoints, pointsRank } from './checkin-lib.js';
+export {
+  addKeyword,
+  listKeywords,
+  matchKeyword,
+  removeKeyword,
+  resetKeywords,
+} from './keyword-store.js';
+export {
+  ensureGroupSuiteMemoryDb,
+  getCheckinModel,
+  getGroupSuiteDb,
+  getStatsModel,
+  getTeachModel,
+  resetGroupSuiteDb,
+  registerGroupSuiteDb,
+  setGroupSuiteDb,
+} from './db-store.js';
+export {
+  createGroupSuiteRuntime,
+  groupSuiteRuntimeToken,
+  resolveGroupSuiteRuntime,
+} from './runtime-state.js';
+export type { GroupSuiteRuntime, PendingStatsIncrement } from './runtime-state.js';
+export {
+  parseTeachPair,
+  resetTeachCooldown,
+  teachAdd,
+  teachForget,
+  teachList,
+  tryTeachReply,
+} from './teach-lib.js';
+export {
+  flushStatsBuffer,
+  monthStartStr,
+  myStatsText,
+  queryStats,
+  recordMessage,
+  resetStatsBuffer,
+  statsRankText,
+  weekStartStr,
+} from './stats-lib.js';

package/src/keyword-store.ts

@@ -0,0 +1,24 @@
+const keywords = new Map<string, string>();
+
+export function addKeyword(keyword: string, reply: string, store = keywords): void {
+  store.set(keyword, reply);
+}
+
+export function removeKeyword(keyword: string, store = keywords): boolean {
+  return store.delete(keyword);
+}
+
+export function listKeywords(store = keywords): Array<[string, string]> {
+  return Array.from(store.entries());
+}
+
+export function matchKeyword(text: string, store = keywords): string | null {
+  for (const [keyword, reply] of store) {
+    if (text.includes(keyword)) return reply;
+  }
+  return null;
+}
+
+export function resetKeywords(): void {
+  keywords.clear();
+}

package/src/memory-store.ts

@@ -0,0 +1,90 @@
+/**
+ * In-memory group-suite models (slice-2) until Plugin Runtime DatabaseFeature Resource lands.
+ *
+ * 模型表面与 `@zhin.js/plugin-runtime` 的 DatabaseHostModel 结构兼容
+ * （where 返回 PromiseLike，host 侧是链式 Selection），
+ * plugin.ts 可把 PluginDatabaseHost 直接当 GroupSuiteMemoryDb 用。
+ */
+
+export type GroupSuiteRow = Record<string, unknown>;
+
+export interface GroupSuiteModel {
+  select: (...fields: string[]) => {
+    where: (query: Record<string, unknown>) => PromiseLike<GroupSuiteRow[]>;
+    then: <TResult1 = GroupSuiteRow[], TResult2 = never>(
+      onfulfilled?: ((value: GroupSuiteRow[]) => TResult1 | PromiseLike<TResult1>) | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+    ) => Promise<TResult1 | TResult2>;
+  };
+  insert: (row: Record<string, unknown>) => Promise<unknown>;
+  delete: () => { where: (query: Record<string, unknown>) => Promise<unknown> };
+  update: (patch: Record<string, unknown>) => {
+    where: (query: Record<string, unknown>) => Promise<unknown>;
+  };
+}
+
+function createMemoryModel(): GroupSuiteModel {
+  const rows: GroupSuiteRow[] = [];
+  let nextId = 1;
+
+  function matches(row: Record<string, unknown>, query: Record<string, unknown>): boolean {
+    return Object.entries(query).every(([key, value]) => row[key] === value);
+  }
+
+  function all(): GroupSuiteRow[] {
+    return rows.map((row) => ({ ...row }));
+  }
+
+  return {
+    select: () => {
+      const promise = Promise.resolve(all());
+      return {
+        where: async (query: Record<string, unknown>) =>
+          rows.filter((row) => matches(row, query)).map((row) => ({ ...row })),
+        then: (onfulfilled, onrejected) => promise.then(onfulfilled, onrejected),
+      };
+    },
+    insert: async (row: Record<string, unknown>) => {
+      const withId: GroupSuiteRow = { id: String(nextId++), ...row };
+      rows.push(withId);
+      return { ...withId };
+    },
+    delete: () => ({
+      where: async (query: Record<string, unknown>) => {
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+          if (matches(rows[i]!, query)) rows.splice(i, 1);
+        }
+      },
+    }),
+    update: (patch: Record<string, unknown>) => ({
+      where: async (query: Record<string, unknown>) => {
+        for (const row of rows) {
+          if (matches(row, query)) Object.assign(row, patch);
+        }
+      },
+    }),
+  };
+}
+
+export interface GroupSuiteMemoryDb {
+  models: {
+    get: (name: string) => GroupSuiteModel | undefined;
+  };
+}
+
+export const CHECKIN_TABLE = 'checkin_records';
+export const TEACH_TABLE = 'teach_qa';
+export const STATS_TABLE = 'message_stats';
+
+export function createInMemoryGroupSuiteDb(): GroupSuiteMemoryDb {
+  const models = new Map<string, GroupSuiteModel>([
+    [CHECKIN_TABLE, createMemoryModel()],
+    [TEACH_TABLE, createMemoryModel()],
+    [STATS_TABLE, createMemoryModel()],
+  ]);
+  return {
+    models: {
+      get: (name: string) => models.get(name),
+    },
+  };
+}

package/src/runtime-state.ts

@@ -0,0 +1,44 @@
+import { createToken, type Token } from 'zhin.js';
+import type { GroupSuiteMemoryDb } from './memory-store.js';
+
+export interface PendingStatsIncrement {
+  user_id: string;
+  user_name: string;
+  group_id: string;
+  date: string;
+  count: number;
+}
+
+/** All mutable state owned by one group-suite plugin instance. */
+export interface GroupSuiteRuntime {
+  readonly db: GroupSuiteMemoryDb;
+  readonly keywords: Map<string, string>;
+  readonly teachCooldowns: Map<string, number>;
+  readonly statsBuffer: Map<string, PendingStatsIncrement>;
+}
+
+export const groupSuiteRuntimeToken = createToken<GroupSuiteRuntime>(
+  'zhin.group-suite.runtime',
+  'Owner-scoped Group Suite database and ephemeral state',
+);
+
+export function createGroupSuiteRuntime(db: GroupSuiteMemoryDb): GroupSuiteRuntime {
+  return {
+    db,
+    keywords: new Map(),
+    teachCooldowns: new Map(),
+    statsBuffer: new Map(),
+  };
+}
+
+export function resolveGroupSuiteRuntime(context: {
+  owner?: { id?: unknown };
+  use<T>(token: Token<T>): T;
+}): GroupSuiteRuntime | undefined {
+  try {
+    return context.use(groupSuiteRuntimeToken);
+  } catch (error) {
+    if (context.owner?.id) throw error;
+    return undefined;
+  }
+}

package/src/shared-runtime.ts

@@ -0,0 +1,44 @@
+export function todayStr(): string {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function yesterdayStr(): string {
+  const d = new Date();
+  d.setDate(d.getDate() - 1);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function ts(): string {
+  return new Date().toISOString();
+}
+
+export function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/** Runtime Message → group/global context */
+export function resolveContextKey(input: {
+  conversation?: { readonly kind?: string; readonly id?: string };
+  metadata?: Readonly<Record<string, unknown>>;
+}): { type: string; id: string } {
+  const meta = input.metadata ?? {};
+  const channelType = String(meta.type ?? meta.channelType ?? '');
+  if (channelType === 'group' || channelType === 'guild' || channelType === 'channel') {
+    return { type: 'group', id: String(meta.channelId ?? input.conversation?.id ?? '') };
+  }
+  if (input.conversation && channelType !== 'private') {
+    return { type: 'group', id: String(input.conversation.id ?? '') };
+  }
+  return { type: 'global', id: '' };
+}
+
+export function resolveSender(input: {
+  sender?: { readonly id: string; readonly name?: string };
+  metadata?: Readonly<Record<string, unknown>>;
+}): { id: string; name: string } {
+  const meta = input.metadata ?? {};
+  const id = input.sender?.id ?? String(meta.senderId ?? '');
+  const name = input.sender?.name ?? String(meta.senderName ?? meta.name ?? '用户');
+  return { id, name };
+}

package/src/stats-lib.ts

@@ -0,0 +1,205 @@
+import type { GroupSuiteConfig } from './config.js';
+import { getStatsModel } from './db-store.js';
+import {
+  resolveSender,
+  todayStr,
+  ts,
+} from './shared-runtime.js';
+import {
+  buildStatsRankReportData,
+  formatMyStatsText,
+  formatRankText,
+  type MyStatsReportData,
+} from './stats-data.js';
+import type { GroupSuiteRuntime, PendingStatsIncrement } from './runtime-state.js';
+
+export function weekStartStr(): string {
+  const d = new Date();
+  const day = d.getDay() || 7;
+  d.setDate(d.getDate() - day + 1);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function monthStartStr(): string {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-01`;
+}
+
+const buffer = new Map<string, PendingStatsIncrement>();
+
+function bufferKey(userId: string, groupId: string, date: string): string {
+  return `${userId}:${groupId}:${date}`;
+}
+
+export function resolveGroupId(input: {
+  conversation?: { readonly kind?: string; readonly id?: string };
+  metadata?: Readonly<Record<string, unknown>>;
+}): string {
+  const meta = input.metadata ?? {};
+  const channelType = String(meta.type ?? meta.channelType ?? '');
+  if (channelType === 'group' || channelType === 'guild' || channelType === 'channel') {
+    return String(meta.channelId ?? input.conversation?.id ?? '');
+  }
+  if (input.conversation && channelType !== 'private') {
+    return String(input.conversation.id ?? '');
+  }
+  return '';
+}
+
+export function recordMessage(input: {
+  sender?: { readonly id: string; readonly name?: string };
+  conversation?: { readonly kind?: string; readonly id?: string };
+  metadata?: Readonly<Record<string, unknown>>;
+}, runtime?: GroupSuiteRuntime): void {
+  const targetBuffer = runtime?.statsBuffer ?? buffer;
+  const { id: userId, name: userName } = resolveSender(input);
+  if (!userId) return;
+  const groupId = resolveGroupId(input);
+  const key = bufferKey(userId, groupId, todayStr());
+  const pending = targetBuffer.get(key);
+  if (pending) {
+    pending.count++;
+    pending.user_name = userName;
+  } else {
+    targetBuffer.set(key, {
+      user_id: userId,
+      user_name: userName,
+      group_id: groupId,
+      date: todayStr(),
+      count: 1,
+    });
+  }
+}
+
+export async function flushStatsBuffer(runtime?: GroupSuiteRuntime): Promise<void> {
+  const targetBuffer = runtime?.statsBuffer ?? buffer;
+  const M = getStatsModel(runtime?.db);
+  if (!M || targetBuffer.size === 0) return;
+  for (const [key, entry] of [...targetBuffer.entries()]) {
+    // 快照本次要落库的计数；flush 期间新累计的部分留在缓冲
+    const countSnapshot = entry.count;
+    try {
+      const existing = (await M.select().where({
+        user_id: entry.user_id,
+        group_id: entry.group_id,
+        date: entry.date,
+      })) as Record<string, unknown>[];
+      if (existing.length > 0) {
+        await M.update({
+          count: Number(existing[0]!.count || 0) + countSnapshot,
+          user_name: entry.user_name,
+          updated_at: ts(),
+        }).where({
+          user_id: entry.user_id,
+          group_id: entry.group_id,
+          date: entry.date,
+        });
+      } else {
+        await M.insert({
+          user_id: entry.user_id,
+          user_name: entry.user_name,
+          group_id: entry.group_id,
+          date: entry.date,
+          count: countSnapshot,
+          updated_at: ts(),
+        });
+      }
+      // 只移除写入成功的部分；失败的 key 留在缓冲等下一轮重试
+      entry.count -= countSnapshot;
+      if (entry.count <= 0 && targetBuffer.get(key) === entry) targetBuffer.delete(key);
+    } catch {
+      /* single row failure: keep entry in buffer for next flush */
+    }
+  }
+}
+
+export async function queryStats(
+  groupId: string,
+  fromDate: string,
+  runtime?: GroupSuiteRuntime,
+): Promise<Map<string, { name: string; count: number }>> {
+  const M = getStatsModel(runtime?.db);
+  if (!M) return new Map();
+  const all = (groupId
+    ? await M.select().where({ group_id: groupId })
+    : await M.select()) as Record<string, unknown>[];
+  const result = new Map<string, { name: string; count: number }>();
+  for (const row of all) {
+    if (String(row.date) < fromDate) continue;
+    const userId = String(row.user_id);
+    const existing = result.get(userId);
+    if (existing) {
+      existing.count += Number(row.count || 0);
+      if (row.user_name) existing.name = String(row.user_name);
+    } else {
+      result.set(userId, {
+        name: String(row.user_name || row.user_id),
+        count: Number(row.count || 0),
+      });
+    }
+  }
+  return result;
+}
+
+type MessageInput = {
+  sender?: { readonly id: string; readonly name?: string };
+  target?: string;
+  metadata?: Readonly<Record<string, unknown>>;
+};
+
+export async function statsRankText(
+  input: MessageInput,
+  cfg: GroupSuiteConfig,
+  fromDate: string,
+  title: string,
+  runtime?: GroupSuiteRuntime,
+): Promise<string> {
+  await flushStatsBuffer(runtime);
+  const groupId = resolveGroupId(input);
+  const stats = await queryStats(groupId, fromDate, runtime);
+  const { id: userId } = resolveSender(input);
+  const data = buildStatsRankReportData(stats, title, cfg.rankSize, userId);
+  return formatRankText(data);
+}
+
+export async function myStatsText(input: MessageInput, runtime?: GroupSuiteRuntime): Promise<string> {
+  await flushStatsBuffer(runtime);
+  const M = getStatsModel(runtime?.db);
+  if (!M) return '统计数据库尚未就绪';
+  const { id: userId, name: userName } = resolveSender(input);
+  if (!userId) return '无法获取用户信息';
+  const groupId = resolveGroupId(input);
+  const rows = (groupId
+    ? await M.select().where({ user_id: userId, group_id: groupId })
+    : await M.select().where({ user_id: userId })) as Record<string, unknown>[];
+  if (rows.length === 0) return '暂无你的消息记录';
+  const today = todayStr();
+  const weekStart = weekStartStr();
+  const monthStart = monthStartStr();
+  let todayCount = 0;
+  let weekCount = 0;
+  let monthCount = 0;
+  let totalCount = 0;
+  for (const row of rows) {
+    const c = Number(row.count || 0);
+    totalCount += c;
+    if (String(row.date) >= monthStart) monthCount += c;
+    if (String(row.date) >= weekStart) weekCount += c;
+    if (row.date === today) todayCount += c;
+  }
+  const data: MyStatsReportData = {
+    userName: userName || '你',
+    scope: groupId ? '本群' : '全局',
+    todayCount,
+    weekCount,
+    monthCount,
+    totalCount,
+    activeDays: rows.length,
+  };
+  return formatMyStatsText(data);
+}
+
+/** Test helper */
+export function resetStatsBuffer(): void {
+  buffer.clear();
+}

package/src/tables.ts

@@ -0,0 +1,46 @@
+/**
+ * Group-suite table schemas for DatabaseHost / legacy DatabaseFeature.
+ */
+import {
+  CHECKIN_TABLE,
+  TEACH_TABLE,
+  STATS_TABLE,
+} from './memory-store.js';
+
+export function defineGroupSuiteTables(
+  db: { define: (name: string, schema: Record<string, unknown>) => void },
+): void {
+  db.define(CHECKIN_TABLE, {
+    user_id: { type: 'text', nullable: false },
+    user_name: { type: 'text', default: '' },
+    points: { type: 'integer', default: 0 },
+    total_checkins: { type: 'integer', default: 0 },
+    streak: { type: 'integer', default: 0 },
+    max_streak: { type: 'integer', default: 0 },
+    last_checkin: { type: 'text', default: '' },
+    context_type: { type: 'text', default: 'global' },
+    context_id: { type: 'text', default: '' },
+    created_at: { type: 'text', default: '' },
+    updated_at: { type: 'text', default: '' },
+  });
+  db.define(TEACH_TABLE, {
+    question: { type: 'text', nullable: false },
+    answer: { type: 'text', nullable: false },
+    is_regex: { type: 'integer', default: 0 },
+    context_type: { type: 'text', default: 'global' },
+    context_id: { type: 'text', default: '' },
+    creator_id: { type: 'text', default: '' },
+    creator_name: { type: 'text', default: '' },
+    hit_count: { type: 'integer', default: 0 },
+    created_at: { type: 'text', default: '' },
+    updated_at: { type: 'text', default: '' },
+  });
+  db.define(STATS_TABLE, {
+    user_id: { type: 'text', nullable: false },
+    user_name: { type: 'text', default: '' },
+    group_id: { type: 'text', default: '' },
+    date: { type: 'text', nullable: false },
+    count: { type: 'integer', default: 0 },
+    updated_at: { type: 'text', default: '' },
+  });
+}