koishi-plugin-smmcat-yeyechat 0.0.1

package/lib/config.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'koishi';
+import { EmotionMap } from './types';
+export interface Config {
+    baseUrl: string;
+    token: string;
+    model: string;
+    persona: string;
+    shortMemoryLimit: number;
+    longMemoryLimit: number;
+    enableByDefault: boolean;
+    groupManagerAuthority: number;
+    timeZone: string;
+    randomReplyRate: number;
+    passiveReplyCooldown: number;
+    triggerKeywords: string[];
+    emojiMap: EmotionMap;
+}
+export declare const Config: Schema<Config>;

package/lib/emoji.d.ts

@@ -0,0 +1,2 @@
+import { EmotionMap } from './types';
+export declare function renderEmojis(text: string, emojiMap: EmotionMap): string | any[];

package/lib/index.d.ts

@@ -0,0 +1,51 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "smmcat-yeyechat";
+export declare const inject: string[];
+export type ChatRole = 'system' | 'user' | 'assistant';
+export interface ChatInfo {
+    role: ChatRole;
+    content: string;
+}
+export type EmotionMap = Record<string, string[]>;
+export interface UserDetailInfo {
+    userId?: string;
+    nickname: string;
+    likes: string[];
+    favorability: number;
+    localChat: ChatInfo[];
+    longMemory: string[];
+    isBan: boolean;
+}
+export interface GroupChatConfig {
+    id: string;
+    enabled: boolean;
+}
+export interface IncomingMessage {
+    text: string;
+    images: string[];
+    atMe: boolean;
+}
+export interface Config {
+    baseUrl: string;
+    token: string;
+    model: string;
+    persona: string;
+    shortMemoryLimit: number;
+    longMemoryLimit: number;
+    enableByDefault: boolean;
+    groupManagerAuthority: number;
+    timeZone: string;
+    randomReplyRate: number;
+    passiveReplyCooldown: number;
+    triggerKeywords: string[];
+    emojiMap: EmotionMap;
+    collectWindow: number;
+    queueLimit: number;
+    queueSweepInterval: number;
+    queueExpireAfter: number;
+    replyLeadDelay: number;
+    replyCharDelay: number;
+    replyMaxSegmentLength: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,572 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "smmcat-yeyechat";
+var inject = ["database"];
+var Config = import_koishi.Schema.object({
+  baseUrl: import_koishi.Schema.string().default("").description("接口基础地址"),
+  token: import_koishi.Schema.string().default("").description("接口令牌"),
+  model: import_koishi.Schema.string().default("").description("模型名称"),
+  persona: import_koishi.Schema.string().default("你叫夜夜酱，是一个活跃在群聊里的拟人化聊天角色。你说话自然、真诚、带一点点情绪起伏，但不要夸张。你会认真接住别人的话，并且像真人一样分成几行回复。不要一次写成很长的段落。").description("人物设定"),
+  shortMemoryLimit: import_koishi.Schema.natural().default(15).description("短期记忆条数"),
+  longMemoryLimit: import_koishi.Schema.natural().default(30).description("长期记忆条数"),
+  enableByDefault: import_koishi.Schema.boolean().default(false).description("新群是否默认开启"),
+  groupManagerAuthority: import_koishi.Schema.natural().default(3).description("开关群聊对话权限"),
+  timeZone: import_koishi.Schema.string().default("").description("本地时区"),
+  randomReplyRate: import_koishi.Schema.number().default(0.02).min(0).max(1).description("无触发时的随机发言概率"),
+  passiveReplyCooldown: import_koishi.Schema.natural().default(300).description("随机发言冷却秒数"),
+  triggerKeywords: import_koishi.Schema.array(String).default(["夜夜酱", "yeye", "在吗", "帮我"]).description("触发关键词"),
+  emojiMap: import_koishi.Schema.dict(import_koishi.Schema.array(String)).default({ 开心: [], 难过: [] }).description("表情映射"),
+  collectWindow: import_koishi.Schema.natural().default(6e3).description("收集窗口毫秒数"),
+  queueLimit: import_koishi.Schema.natural().default(24).description("单群最大排队数"),
+  queueSweepInterval: import_koishi.Schema.natural().default(1200).description("排队扫描间隔毫秒数"),
+  queueExpireAfter: import_koishi.Schema.natural().default(15 * 60 * 1e3).description("队列过期毫秒数"),
+  replyLeadDelay: import_koishi.Schema.natural().default(500).description("首段发送前延迟毫秒数"),
+  replyCharDelay: import_koishi.Schema.natural().default(45).description("按字数增加的发送间隔"),
+  replyMaxSegmentLength: import_koishi.Schema.natural().default(24).description("单段最大字数")
+});
+var favorabilityDict = {
+  0: "陌生",
+  20: "认识",
+  30: "熟悉",
+  50: "朋友",
+  60: "好感",
+  100: "亲近",
+  130: "挚友"
+};
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+__name(normalizeText, "normalizeText");
+function collectKeywords(text, keywords) {
+  const normalized = text.toLowerCase();
+  return keywords.some((keyword) => normalized.includes(keyword.toLowerCase()));
+}
+__name(collectKeywords, "collectKeywords");
+function extractMessage(session) {
+  const text = import_koishi.h.select(session.elements, "text").map((node) => node.attrs.content).join("").trim();
+  const images = import_koishi.h.select(session.elements, "img").map((node) => node.attrs.src).filter(Boolean);
+  const atNodes = import_koishi.h.select(session.elements, "at");
+  const selfId = String(session.selfId ?? "");
+  const atMe = atNodes.some((node) => {
+    const attrs = node.attrs || {};
+    const target = String(attrs.id ?? attrs.qq ?? attrs.userId ?? attrs.qqId ?? "");
+    return target === selfId;
+  });
+  return { text, images, atMe };
+}
+__name(extractMessage, "extractMessage");
+function buildUserContent(message) {
+  const text = normalizeText(message.text);
+  const imageText = message.images.length ? message.images.map((url) => `[图片] ${url}`).join("\n") : "";
+  return [text, imageText].filter(Boolean).join("\n").trim();
+}
+__name(buildUserContent, "buildUserContent");
+function renderEmojis(text, emojiMap) {
+  const children = [];
+  const pattern = /%([^%\s]{1,20})%/g;
+  let lastIndex = 0;
+  let hasImage = false;
+  text.replace(pattern, (match, key, index) => {
+    if (index > lastIndex) children.push(text.slice(lastIndex, index));
+    const candidates = emojiMap[key];
+    if (candidates?.length) {
+      hasImage = true;
+      const url = candidates[Math.floor(Math.random() * candidates.length)];
+      children.push(import_koishi.h.image(url));
+    }
+    lastIndex = index + match.length;
+    return match;
+  });
+  if (lastIndex < text.length) children.push(text.slice(lastIndex));
+  if (!hasImage) return children.join("");
+  return children;
+}
+__name(renderEmojis, "renderEmojis");
+function splitReplySegments(text, maxLength) {
+  const normalized = text.replace(/\r/g, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (!normalized) return [];
+  const paragraphs = normalized.split(/\n+/).map((line) => line.trim()).filter(Boolean);
+  const segments = [];
+  const sentencePattern = /([^。！？!?；;…]+[。！？!?；;…]?)/g;
+  for (const paragraph of paragraphs) {
+    const pieces = paragraph.match(sentencePattern) || [paragraph];
+    let buffer = "";
+    for (const rawPiece of pieces) {
+      const piece = rawPiece.trim();
+      if (!piece) continue;
+      if (!buffer) {
+        buffer = piece;
+        continue;
+      }
+      if (buffer.length + piece.length <= maxLength) {
+        buffer += piece;
+        continue;
+      }
+      segments.push(buffer);
+      buffer = piece;
+    }
+    if (buffer) segments.push(buffer);
+  }
+  if (!segments.length) return [normalized];
+  const output = [];
+  for (const segment of segments) {
+    if (segment.length <= maxLength) {
+      output.push(segment);
+      continue;
+    }
+    for (let index = 0; index < segment.length; index += maxLength) {
+      output.push(segment.slice(index, index + maxLength));
+    }
+  }
+  return output.filter(Boolean);
+}
+__name(splitReplySegments, "splitReplySegments");
+function parseAttributeBlock(text) {
+  const result = {};
+  const regex = /%\[([^\]]+)\]:([^%\n]+)%?/g;
+  let match;
+  let cleanedText = text;
+  while ((match = regex.exec(text)) !== null) {
+    const key = match[1].trim();
+    let value = match[2].trim();
+    if (value.endsWith("%")) value = value.slice(0, -1);
+    try {
+      if (value.startsWith('"') || value === "true" || value === "false" || value === "null" || !Number.isNaN(Number(value)) || value.startsWith("{") || value.startsWith("[")) {
+        result[key] = JSON.parse(value);
+      } else {
+        result[key] = value;
+      }
+    } catch {
+      result[key] = value;
+    }
+    cleanedText = cleanedText.replace(match[0], "");
+  }
+  return { attributes: result, cleanedText: cleanedText.trim() };
+}
+__name(parseAttributeBlock, "parseAttributeBlock");
+function applyAttributeBlock(data, attributes) {
+  for (const [key, value] of Object.entries(attributes)) {
+    if (key === "nickname" && typeof value === "string") {
+      data.nickname = value.slice(0, 30);
+    }
+    if (key === "favorability") {
+      const next = Number(value);
+      if (Number.isFinite(next)) data.favorability = Math.max(0, Math.min(150, Math.round(next)));
+    }
+    if (key === "likes") {
+      const values = Array.isArray(value) ? value : String(value).split(/[、,，\s]+/);
+      data.likes = Array.from(/* @__PURE__ */ new Set([
+        ...data.likes,
+        ...values.map((item) => String(item).trim()).filter(Boolean)
+      ])).slice(0, 30);
+    }
+    if (key === "longMemory") {
+      const values = Array.isArray(value) ? value : [value];
+      data.longMemory = Array.from(/* @__PURE__ */ new Set([
+        ...data.longMemory,
+        ...values.map((item) => String(item).trim()).filter(Boolean)
+      ])).slice(0, 30);
+    }
+  }
+}
+__name(applyAttributeBlock, "applyAttributeBlock");
+function buildSystemPrompt(config) {
+  const emojiKeys = Object.keys(config.emojiMap || {}).map((key) => `%${key}%`).join("、") || "无";
+  return [
+    { role: "system", content: config.persona },
+    { role: "system", content: "回复要像真人群友，不要过长，不要一次性写成一整大段。尽量按思路自然分行，每行短一点，口语化一点。" },
+    { role: "system", content: '如果需要记录用户状态，可以只在正文末尾加属性块，例如 %[favorability]:23% 或 %[likes]:["奶茶"]%。属性块不会直接发给用户。' },
+    { role: "system", content: "优先根据上下文、长期记忆、短期记忆、好感度和本地时间来回复，不要编造当前日期。" },
+    { role: "system", content: `可用的表情关键字：${emojiKeys}。` }
+  ];
+}
+__name(buildSystemPrompt, "buildSystemPrompt");
+function buildLocalTime(config) {
+  const options = {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false,
+    weekday: "long"
+  };
+  if (config.timeZone) options.timeZone = config.timeZone;
+  return {
+    role: "system",
+    content: `【本地时间】${new Intl.DateTimeFormat("zh-CN", options).format(/* @__PURE__ */ new Date())}`
+  };
+}
+__name(buildLocalTime, "buildLocalTime");
+function buildUserDetail(data) {
+  const favorabilityLabel = Object.keys(favorabilityDict).reverse().find((value) => data.favorability >= Number(value)) || "0";
+  return {
+    role: "system",
+    content: [
+      "【用户信息】",
+      `与你的关系：${data.favorability}(${favorabilityDict[Number(favorabilityLabel)]})`,
+      `对方称呼：${data.nickname || "你"}`,
+      `对方偏好：${data.likes.length ? data.likes.join("、") : "无"}`,
+      `长期记忆：${data.longMemory.length ? data.longMemory.join("；") : "无"}`
+    ].join("\n")
+  };
+}
+__name(buildUserDetail, "buildUserDetail");
+function buildRequestMessages(config, data) {
+  return [
+    ...buildSystemPrompt(config),
+    buildLocalTime(config),
+    buildUserDetail(data),
+    ...data.localChat
+  ];
+}
+__name(buildRequestMessages, "buildRequestMessages");
+function createStorage(ctx, config) {
+  const shortMemoryLimit = Math.max(1, config.shortMemoryLimit || 15);
+  const longMemoryLimit = Math.max(1, config.longMemoryLimit || 30);
+  ctx.database.extend("smm_ai_chat_data", {
+    userId: "string",
+    nickname: "string",
+    likes: "array",
+    favorability: "integer",
+    localChat: "json",
+    longMemory: "json",
+    isBan: "boolean"
+  }, {
+    primary: "userId",
+    autoInc: false
+  });
+  ctx.database.extend("smm_ai_chat_group_config", {
+    id: "string",
+    enabled: "boolean"
+  }, {
+    primary: "id",
+    autoInc: false
+  });
+  const clampMemory = /* @__PURE__ */ __name((data) => {
+    while (data.localChat.length > shortMemoryLimit) data.localChat.shift();
+    while (data.longMemory.length > longMemoryLimit) data.longMemory.shift();
+  }, "clampMemory");
+  return {
+    clampMemory,
+    async getUser(userId) {
+      const [data] = await ctx.database.get("smm_ai_chat_data", { userId });
+      if (!data) {
+        const init = {
+          userId,
+          nickname: "",
+          likes: [],
+          favorability: 20,
+          localChat: [],
+          longMemory: [],
+          isBan: false
+        };
+        await ctx.database.create("smm_ai_chat_data", init);
+        return init;
+      }
+      data.likes ||= [];
+      data.localChat ||= [];
+      data.longMemory ||= [];
+      clampMemory(data);
+      return data;
+    },
+    async saveUser(data) {
+      const { userId } = data;
+      const next = { ...data };
+      delete next.userId;
+      await ctx.database.set("smm_ai_chat_data", { userId }, next);
+    },
+    async getGroup(groupId) {
+      const [data] = await ctx.database.get("smm_ai_chat_group_config", { id: groupId });
+      return data;
+    },
+    async setGroupEnabled(groupId, enabled) {
+      const [data] = await ctx.database.get("smm_ai_chat_group_config", { id: groupId });
+      if (data) await ctx.database.set("smm_ai_chat_group_config", { id: groupId }, { enabled });
+      else await ctx.database.create("smm_ai_chat_group_config", { id: groupId, enabled });
+    }
+  };
+}
+__name(createStorage, "createStorage");
+function createTriggerController(config) {
+  const state = /* @__PURE__ */ new Map();
+  const key = /* @__PURE__ */ __name((session) => {
+    const targetId = session.guildId || session.channelId;
+    return targetId ? `${session.platform}:${targetId}` : "";
+  }, "key");
+  const getState = /* @__PURE__ */ __name((session) => {
+    const id = key(session);
+    if (!id) return null;
+    if (!state.has(id)) state.set(id, { lastPassiveReplyAt: 0 });
+    return state.get(id) || null;
+  }, "getState");
+  const shouldPassivelyReply = /* @__PURE__ */ __name((session) => {
+    const current = getState(session);
+    if (!current) return false;
+    const now = Date.now();
+    if (now - current.lastPassiveReplyAt < config.passiveReplyCooldown * 1e3) return false;
+    if (Math.random() > config.randomReplyRate) return false;
+    current.lastPassiveReplyAt = now;
+    return true;
+  }, "shouldPassivelyReply");
+  const shouldOpenConversation = /* @__PURE__ */ __name((session, text, atMe) => {
+    if (!session.guildId && !session.channelId) return true;
+    if (atMe) return true;
+    if (collectKeywords(text, config.triggerKeywords || [])) return true;
+    return shouldPassivelyReply(session);
+  }, "shouldOpenConversation");
+  return { key, shouldOpenConversation };
+}
+__name(createTriggerController, "createTriggerController");
+function createReplyEngine(ctx, config, storage) {
+  const authHeader = config.token.startsWith("Bearer ") ? config.token : `Bearer ${config.token}`;
+  const composeReply = /* @__PURE__ */ __name(async (item, data, text) => {
+    data.localChat.push({ role: "user", content: text });
+    storage.clampMemory(data);
+    try {
+      const result = await ctx.http.post(config.baseUrl + "/v1/chat/completions", {
+        model: config.model,
+        messages: buildRequestMessages(config, data),
+        max_tokens: 2048,
+        stream: false
+      }, {
+        headers: { Authorization: authHeader }
+      });
+      const content = result?.choices?.[0]?.message?.content || result?.choices?.[0]?.text || "";
+      if (!content) return null;
+      const parsed = parseAttributeBlock(String(content));
+      applyAttributeBlock(data, parsed.attributes);
+      data.localChat.push({ role: "assistant", content: parsed.cleanedText });
+      storage.clampMemory(data);
+      return {
+        text: parsed.cleanedText,
+        segments: splitReplySegments(parsed.cleanedText, config.replyMaxSegmentLength)
+      };
+    } catch (error) {
+      console.log(error);
+      return null;
+    }
+  }, "composeReply");
+  const sendReply = /* @__PURE__ */ __name(async (session, plan) => {
+    const segments = plan.segments.length ? plan.segments : [plan.text];
+    if (!segments.length) return;
+    const firstDelay = Math.max(config.replyLeadDelay, Math.min(2e3, 350 + segments[0].length * config.replyCharDelay));
+    await session.cancelQueued(firstDelay);
+    for (let index = 0; index < segments.length; index += 1) {
+      const segment = segments[index];
+      const delay = index < segments.length - 1 ? Math.max(160, Math.min(1400, 180 + segment.length * config.replyCharDelay)) : 0;
+      await session.sendQueued(renderEmojis(segment, config.emojiMap), delay);
+    }
+  }, "sendReply");
+  return { composeReply, sendReply };
+}
+__name(createReplyEngine, "createReplyEngine");
+function createConversationQueue(ctx, config, storage, trigger, replyEngine) {
+  const groups = /* @__PURE__ */ new Map();
+  const groupKey = /* @__PURE__ */ __name((session) => trigger.key(session), "groupKey");
+  const itemKey = /* @__PURE__ */ __name((session) => `${groupKey(session)}:${session.userId}`, "itemKey");
+  const ensureGroup = /* @__PURE__ */ __name((key) => {
+    if (!groups.has(key)) groups.set(key, { active: false, items: /* @__PURE__ */ new Map() });
+    return groups.get(key);
+  }, "ensureGroup");
+  const scoreItem = /* @__PURE__ */ __name((item, now = Date.now()) => {
+    const ageScore = Math.min(90, Math.floor((now - item.updatedAt) / 1e3));
+    const waitScore = Math.min(60, Math.floor((now - item.createdAt) / 2e3));
+    return item.priority + ageScore + waitScore;
+  }, "scoreItem");
+  const pruneGroup = /* @__PURE__ */ __name((state) => {
+    const limit = Math.max(1, config.queueLimit || 24);
+    while (state.items.size > limit) {
+      const victim = [...state.items.values()].filter((item) => !item.lockedAt).sort((a, b) => scoreItem(a) - scoreItem(b) || a.updatedAt - b.updatedAt)[0];
+      if (!victim) break;
+      state.items.delete(victim.id);
+    }
+  }, "pruneGroup");
+  const queueMessage = /* @__PURE__ */ __name(async (session, message, force = false) => {
+    const gKey = groupKey(session);
+    if (!gKey) return false;
+    const group = ensureGroup(gKey);
+    const key = itemKey(session);
+    const now = Date.now();
+    const content = buildUserContent(message);
+    const existing = group.items.get(key);
+    const user = await storage.getUser(session.userId);
+    if (user.isBan) return false;
+    if (existing) {
+      existing.updatedAt = now;
+      existing.dirty = true;
+      existing.turns += 1;
+      if (content) existing.textParts.push(content);
+      if (message.images.length) existing.imageParts.push(...message.images);
+      existing.priority = Math.max(existing.priority, buildPriority(session, message, existing.turns, user.favorability));
+      pruneGroup(group);
+      return true;
+    }
+    if (!force && !trigger.shouldOpenConversation(session, message.text, message.atMe)) return false;
+    const created = {
+      id: key,
+      groupKey: gKey,
+      userId: session.userId,
+      session,
+      createdAt: now,
+      updatedAt: now,
+      lockedAt: 0,
+      priority: buildPriority(session, message, 1, user.favorability),
+      dirty: false,
+      turns: 1,
+      textParts: content ? [content] : [],
+      imageParts: [...message.images]
+    };
+    group.items.set(key, created);
+    pruneGroup(group);
+    return true;
+  }, "queueMessage");
+  const buildPriority = /* @__PURE__ */ __name((session, message, turns, favorability = 20) => {
+    const base = message.atMe ? 120 : 0;
+    const keyword = collectKeywords(message.text, config.triggerKeywords || []) ? 80 : 0;
+    const favorabilityBonus = Math.min(260, Math.max(0, favorability) * 2);
+    const turnBonus = Math.min(25, turns * 3);
+    const randomBias = Math.floor(Math.random() * 5);
+    return base + keyword + favorabilityBonus + turnBonus + randomBias;
+  }, "buildPriority");
+  const takeNext = /* @__PURE__ */ __name((state) => {
+    const now = Date.now();
+    const readyItems = [...state.items.values()].filter((item) => !item.lockedAt).filter((item) => now - item.updatedAt >= config.collectWindow).sort((a, b) => scoreItem(b, now) - scoreItem(a, now) || a.updatedAt - b.updatedAt);
+    return readyItems[0] || null;
+  }, "takeNext");
+  const finishItem = /* @__PURE__ */ __name((state, item, snapshot) => {
+    if (item.updatedAt > item.lockedAt) {
+      item.textParts = item.textParts.slice(snapshot.textCount);
+      item.imageParts = item.imageParts.slice(snapshot.imageCount);
+      item.lockedAt = 0;
+      item.dirty = false;
+      return;
+    }
+    state.items.delete(item.id);
+  }, "finishItem");
+  const turn = /* @__PURE__ */ __name(async (state, item) => {
+    state.active = true;
+    item.lockedAt = Date.now();
+    const snapshot = { textCount: item.textParts.length, imageCount: item.imageParts.length };
+    try {
+      const data = await storage.getUser(item.userId);
+      if (!data || data.isBan) {
+        state.items.delete(item.id);
+        return;
+      }
+      const userText = item.textParts.join("\n").trim();
+      if (!userText) {
+        state.items.delete(item.id);
+        return;
+      }
+      const plan = await replyEngine.composeReply(item, data, userText);
+      if (!plan?.text) {
+        state.items.delete(item.id);
+        await storage.saveUser(data);
+        return;
+      }
+      await replyEngine.sendReply(item.session, plan);
+      await storage.saveUser(data);
+      finishItem(state, item, snapshot);
+    } catch (error) {
+      console.log(error);
+      item.lockedAt = 0;
+    } finally {
+      state.active = false;
+    }
+  }, "turn");
+  const tick = /* @__PURE__ */ __name(async () => {
+    for (const state of groups.values()) {
+      if (state.active) continue;
+      for (const item of [...state.items.values()]) {
+        if (!item.lockedAt && Date.now() - item.updatedAt > config.queueExpireAfter) {
+          state.items.delete(item.id);
+        }
+      }
+      const next = takeNext(state);
+      if (next) {
+        void turn(state, next).catch((error) => {
+          console.log(error);
+          state.active = false;
+          next.lockedAt = 0;
+        });
+      }
+    }
+  }, "tick");
+  const timer = setInterval(() => {
+    void tick();
+  }, Math.max(500, config.queueSweepInterval || 1200));
+  ctx.on("dispose", () => clearInterval(timer));
+  return {
+    queueMessage,
+    groupKey,
+    isEnabled: /* @__PURE__ */ __name(async (session) => {
+      const key = groupKey(session);
+      if (!key) return true;
+      const data = await storage.getGroup(key);
+      return data?.enabled ?? config.enableByDefault;
+    }, "isEnabled")
+  };
+}
+__name(createConversationQueue, "createConversationQueue");
+function apply(ctx, config) {
+  const storage = createStorage(ctx, config);
+  const trigger = createTriggerController(config);
+  const replyEngine = createReplyEngine(ctx, config, storage);
+  const queue = createConversationQueue(ctx, config, storage, trigger, replyEngine);
+  const setGroupSpeaking = /* @__PURE__ */ __name(async (session, enabled) => {
+    if (!session) return;
+    const id = queue.groupKey(session);
+    if (!id) return "这里只能在群聊或频道里设置对话开关。";
+    await storage.setGroupEnabled(id, enabled);
+    return enabled ? "好，我开始在本群说话。" : "好，我先闭嘴啦。";
+  }, "setGroupSpeaking");
+  ctx.command("夜夜说话", "开启夜夜酱在本群的对话", { authority: config.groupManagerAuthority }).action(async ({ session }) => setGroupSpeaking(session, true));
+  ctx.command("夜夜闭嘴", "关闭夜夜酱在本群的对话", { authority: config.groupManagerAuthority }).action(async ({ session }) => setGroupSpeaking(session, false));
+  ctx.middleware(async (session, next) => {
+    if (session.userId === session.selfId) return next();
+    const message = extractMessage(session);
+    if (!message.text && !message.images.length && !message.atMe) return next();
+    const enabled = await queue.isEnabled(session);
+    if (!enabled) return next();
+    const accepted = await queue.queueMessage(session, message);
+    if (!accepted) return next();
+    return next();
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/lib/message.d.ts

@@ -0,0 +1,4 @@
+import { Session } from 'koishi';
+import { IncomingMessage } from './types';
+export declare function extractMessage(session: Session): IncomingMessage;
+export declare function collectKeywords(text: string, keywords: string[]): boolean;

package/lib/prompt.d.ts

@@ -0,0 +1,11 @@
+import { Config } from './config';
+import { ChatInfo, UserDetailInfo } from './types';
+export declare function buildSystemPrompt(config: Config): ChatInfo[];
+export declare function buildLocalTime(config: Config): ChatInfo;
+export declare function buildUserDetail(data: UserDetailInfo): ChatInfo;
+export declare function buildRequestMessages(config: Config, data: UserDetailInfo): ChatInfo[];
+export declare function parseAttributeBlock(text: string): {
+    attributes: Record<string, any>;
+    cleanedText: string;
+};
+export declare function applyAttributeBlock(data: UserDetailInfo, attributes: Record<string, any>): void;

package/lib/service.d.ts

@@ -0,0 +1,15 @@
+import { Context, Session } from 'koishi';
+import { Config } from './config';
+import { UserDetailInfo } from './types';
+export declare function createService(ctx: Context, config: Config): {
+    storage: {
+        clampMemory: (data: UserDetailInfo) => void;
+        getUser(userId: string): Promise<UserDetailInfo>;
+        saveUser(data: UserDetailInfo): Promise<void>;
+        getGroup(groupId: string): Promise<import("./types").GroupChatConfig>;
+        setGroupEnabled(groupId: string, enabled: boolean): Promise<void>;
+    };
+    getGroupKey: (session: Session) => string;
+    isGroupAllowed: (session: Session) => Promise<boolean>;
+    getWebMsgApi: (session: Session, fn?: (err: string) => Promise<void> | void) => Promise<string | any[]>;
+};

package/lib/storage.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'koishi';
+import { Config } from './config';
+import { GroupChatConfig, UserDetailInfo } from './types';
+export declare function createStorage(ctx: Context, config: Config): {
+    clampMemory: (data: UserDetailInfo) => void;
+    getUser(userId: string): Promise<UserDetailInfo>;
+    saveUser(data: UserDetailInfo): Promise<void>;
+    getGroup(groupId: string): Promise<GroupChatConfig>;
+    setGroupEnabled(groupId: string, enabled: boolean): Promise<void>;
+};

package/lib/trigger.d.ts

@@ -0,0 +1,9 @@
+import { Session } from 'koishi';
+import { Config } from './config';
+export type GroupTriggerState = {
+    lastPassiveReplyAt: number;
+};
+export declare function createTriggerController(config: Config): {
+    shouldReply: (session: Session, text: string, atMe: boolean) => boolean;
+    key: (session: Session) => string;
+};

package/lib/types.d.ts

@@ -0,0 +1,30 @@
+export type ChatRole = 'system' | 'user' | 'assistant';
+export type ChatInfo = {
+    role: ChatRole;
+    content: string;
+};
+export type EmotionMap = Record<string, string[]>;
+export type UserDetailInfo = {
+    userId?: string;
+    nickname: string;
+    likes: string[];
+    favorability: number;
+    localChat: ChatInfo[];
+    longMemory: string[];
+    isBan: boolean;
+};
+export type GroupChatConfig = {
+    id: string;
+    enabled: boolean;
+};
+export type IncomingMessage = {
+    text: string;
+    images: string[];
+    atMe: boolean;
+};
+declare module 'koishi' {
+    interface Tables {
+        smm_ai_chat_data: UserDetailInfo;
+        smm_ai_chat_group_config: GroupChatConfig;
+    }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "koishi-plugin-smmcat-yeyechat",
+  "description": "名为【夜夜酱】的聊天系统",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-smmcat-yeyechat
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-smmcat-yeyechat?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-smmcat-yeyechat)
+
+名为【夜夜酱】的聊天系统