@forgetmelody/koishi-plugin-best-cave 0.0.0-stage → 1.0.0

package/lib/index.js

@@ -0,0 +1,1981 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi3 = require("koishi");
+
+// src/FileManager.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var fs = __toESM(require("fs/promises"));
+var path = __toESM(require("path"));
+var FileManager = class {
+  /**
+   * @constructor
+   * @param baseDir Koishi 应用的基础数据目录 (ctx.baseDir)。
+   * @param config 插件的配置对象。
+   * @param logger 日志记录器实例。
+   */
+  constructor(baseDir, config, logger2) {
+    this.logger = logger2;
+    this.resourceDir = path.join(baseDir, "data", "cave");
+    if (config.enableS3 && config.endpoint && config.bucket && config.accessKeyId && config.secretAccessKey) {
+      this.s3Client = new import_client_s3.S3Client({
+        endpoint: config.endpoint,
+        region: config.region,
+        credentials: {
+          accessKeyId: config.accessKeyId,
+          secretAccessKey: config.secretAccessKey
+        }
+      });
+      this.s3Bucket = config.bucket;
+    }
+  }
+  static {
+    __name(this, "FileManager");
+  }
+  resourceDir;
+  locks = /* @__PURE__ */ new Map();
+  s3Client;
+  s3Bucket;
+  /**
+   * @description 使用文件锁安全地执行异步文件操作，防止并发读写冲突。
+   * @template T 异步操作的返回类型。
+   * @param fullPath 需要加锁的文件的完整路径。
+   * @param operation 要执行的异步函数。
+   * @returns 异步操作的结果。
+   */
+  async withLock(fullPath, operation) {
+    while (this.locks.has(fullPath)) await this.locks.get(fullPath);
+    const promise = operation().finally(() => {
+      this.locks.delete(fullPath);
+    });
+    this.locks.set(fullPath, promise);
+    return promise;
+  }
+  /**
+   * @description 保存文件，自动选择 S3 或本地存储。
+   * @param fileName 用作 S3 Key 或本地文件名。
+   * @param data 要写入的 Buffer 数据。
+   * @returns 保存时使用的文件名。
+   */
+  async saveFile(fileName, data) {
+    if (this.s3Client) {
+      const command = new import_client_s3.PutObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: fileName,
+        Body: data,
+        ACL: "public-read"
+      });
+      await this.s3Client.send(command);
+    } else {
+      await fs.mkdir(this.resourceDir, { recursive: true }).catch((error) => {
+        this.logger.error(`创建资源目录失败 ${this.resourceDir}:`, error);
+        throw error;
+      });
+      const filePath = path.join(this.resourceDir, fileName);
+      await this.withLock(filePath, () => fs.writeFile(filePath, data));
+    }
+    return fileName;
+  }
+  /**
+   * @description 读取文件，自动从 S3 或本地存储读取。
+   * @param fileName 要读取的文件名/标识符。
+   * @returns 文件的 Buffer 数据。
+   */
+  async readFile(fileName) {
+    if (this.s3Client) {
+      const command = new import_client_s3.GetObjectCommand({ Bucket: this.s3Bucket, Key: fileName });
+      const response = await this.s3Client.send(command);
+      return Buffer.from(await response.Body.transformToByteArray());
+    } else {
+      const filePath = path.join(this.resourceDir, fileName);
+      return this.withLock(filePath, () => fs.readFile(filePath));
+    }
+  }
+  /**
+   * @description 删除文件，自动从 S3 或本地删除。
+   * @param fileIdentifier 要删除的文件名/标识符。
+   */
+  async deleteFile(fileIdentifier) {
+    try {
+      if (this.s3Client) {
+        await this.s3Client.send(new import_client_s3.DeleteObjectCommand({ Bucket: this.s3Bucket, Key: fileIdentifier }));
+      } else {
+        const filePath = path.join(this.resourceDir, fileIdentifier);
+        await this.withLock(filePath, () => fs.unlink(filePath));
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+        this.logger.warn(`删除文件 ${fileIdentifier} 失败:`, error);
+      }
+    }
+  }
+};
+
+// src/NameManager.ts
+var NameManager = class {
+  /**
+   * @constructor
+   * @param ctx - Koishi 上下文，用于初始化数据库模型。
+   */
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ctx.model.extend("cave_user", {
+      userId: "string",
+      nickname: "string"
+    }, {
+      primary: "userId"
+    });
+  }
+  static {
+    __name(this, "NameManager");
+  }
+  /**
+   * @description 注册 `.name` 子命令，用于管理用户昵称。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    cave.subcommand(".name [nickname:text]", "设置显示昵称").usage("设置在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
+      const trimmedNickname = nickname?.trim();
+      if (trimmedNickname) {
+        await this.setNickname(session.userId, trimmedNickname);
+        return `昵称已更新为：${trimmedNickname}`;
+      }
+      await this.clearNickname(session.userId);
+      return "昵称已清除";
+    });
+  }
+  /**
+   * @description 设置或更新指定用户的昵称。
+   * @param userId - 目标用户的 ID。
+   * @param nickname - 要设置的新昵称。
+   */
+  async setNickname(userId, nickname) {
+    await this.ctx.database.upsert("cave_user", [{ userId, nickname }]);
+  }
+  /**
+   * @description 获取指定用户的昵称。
+   * @param userId - 目标用户的 ID。
+   * @returns 用户的昵称字符串或 null。
+   */
+  async getNickname(userId) {
+    const [name2] = await this.ctx.database.get("cave_user", { userId });
+    return name2?.nickname ?? null;
+  }
+  /**
+   * @description 清除指定用户的昵称设置。
+   * @param userId - 目标用户的 ID。
+   */
+  async clearNickname(userId) {
+    await this.ctx.database.remove("cave_user", { userId });
+  }
+};
+
+// src/DataManager.ts
+var DataManager = class {
+  /**
+   * @constructor
+   * @param ctx Koishi 上下文，用于数据库操作。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
+   */
+  constructor(ctx, config, fileManager, logger2) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = logger2;
+  }
+  static {
+    __name(this, "DataManager");
+  }
+  /**
+   * @description 注册 `.export` 和 `.import` 子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    const commandAction = /* @__PURE__ */ __name((action) => async ({ session }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      try {
+        await session.send("正在处理，请稍候...");
+        return await action();
+      } catch (error) {
+        this.logger.error("数据操作时发生错误:", error);
+        return `操作失败: ${error.message}`;
+      }
+    }, "commandAction");
+    cave.subcommand(".export", "导出回声洞数据", { hidden: true, authority: 4 }).usage("将所有回声洞数据导出到 cave.json 中。").action(commandAction(() => this.exportData()));
+    cave.subcommand(".import", "导入回声洞数据", { hidden: true, authority: 4 }).usage("从 cave.json 中导入回声洞数据。").action(commandAction(() => this.importData()));
+  }
+  /**
+   * @description 导出所有 'active' 状态的回声洞数据到 `cave.json`。
+   * @returns 描述导出结果的消息字符串。
+   */
+  async exportData() {
+    const fileName = "cave.json";
+    const cavesToExport = await this.ctx.database.get("cave", { status: "active" });
+    await this.fileManager.saveFile(fileName, Buffer.from(JSON.stringify(cavesToExport, null, 2)));
+    return `成功导出 ${cavesToExport.length} 条数据`;
+  }
+  /**
+   * @description 从 `cave.json` 文件导入回声洞数据。
+   * @returns 描述导入结果的消息字符串。
+   */
+  async importData() {
+    const fileName = "cave.json";
+    let importedCaves;
+    try {
+      const fileContent = await this.fileManager.readFile(fileName);
+      importedCaves = JSON.parse(fileContent.toString("utf-8"));
+      if (!Array.isArray(importedCaves) || !importedCaves.length) throw new Error("导入文件格式无效或为空");
+    } catch (error) {
+      throw new Error(`读取导入文件失败: ${error.message}`);
+    }
+    const allDbCaves = await this.ctx.database.get("cave", {}, { fields: ["id"] });
+    const existingIds = new Set(allDbCaves.map((c) => c.id));
+    let maxId = allDbCaves.length > 0 ? Math.max(...allDbCaves.map((c) => c.id)) : 0;
+    const nonConflictingCaves = [];
+    const conflictingCaves = [];
+    let invalidCount = 0;
+    for (const importedCave of importedCaves) {
+      if (typeof importedCave.id !== "number" || !Array.isArray(importedCave.elements)) {
+        this.logger.warn(`回声洞（${importedCave.id}）无效: ${JSON.stringify(importedCave)}`);
+        invalidCount++;
+        continue;
+      }
+      if (existingIds.has(importedCave.id)) {
+        conflictingCaves.push(importedCave);
+      } else {
+        nonConflictingCaves.push({ ...importedCave, status: "active" });
+        existingIds.add(importedCave.id);
+        maxId = Math.max(maxId, importedCave.id);
+      }
+    }
+    const newCavesFromConflicts = conflictingCaves.map((cave) => {
+      maxId++;
+      this.logger.info(`回声洞（${cave.id}）已转移至（${maxId}）`);
+      return { ...cave, id: maxId, status: "active" };
+    });
+    const finalCavesToUpsert = [...nonConflictingCaves, ...newCavesFromConflicts];
+    if (finalCavesToUpsert.length > 0) await this.ctx.database.upsert("cave", finalCavesToUpsert);
+    return `成功导入 ${finalCavesToUpsert.length} 条数据`;
+  }
+};
+
+// src/PendManager.ts
+var import_koishi2 = require("koishi");
+
+// src/Utils.ts
+var import_koishi = require("koishi");
+var path2 = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var import_jimp = __toESM(require("jimp"));
+var mimeTypeMap = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".mp4": "video/mp4", ".mp3": "audio/mpeg", ".webp": "image/webp" };
+function resolveCaveHeaderFooter(cave, config, prefix) {
+  const data = {
+    id: cave.id.toString(),
+    name: cave.userName,
+    user: cave.userId,
+    channel: cave.channelId,
+    time: cave.time.toLocaleString()
+  };
+  const placeholderRegex = /\{([^}]+)\}/g;
+  const replacer = /* @__PURE__ */ __name((match, rawContent) => {
+    const isReviewMode = !!prefix;
+    const [normalPart, reviewPart] = rawContent.split("/", 2);
+    const contentToProcess = isReviewMode ? reviewPart !== void 0 ? reviewPart : normalPart : normalPart;
+    if (!contentToProcess?.trim()) return "";
+    const useMask = contentToProcess.startsWith("*");
+    const key = (useMask ? contentToProcess.substring(1) : contentToProcess).trim();
+    if (!key) return "";
+    const originalValue = data[key];
+    if (originalValue === void 0 || originalValue === null) return match;
+    const valueStr = String(originalValue);
+    if (!useMask) return valueStr;
+    const len = valueStr.length;
+    if (len <= 5) return valueStr;
+    let keep = 0;
+    if (len <= 7) keep = 2;
+    else keep = 3;
+    return `${valueStr.substring(0, keep)}***${valueStr.substring(len - keep)}`;
+  }, "replacer");
+  const [rawHeader, rawFooter] = config.caveFormat.split("|", 2);
+  let header = rawHeader ? rawHeader.replace(placeholderRegex, replacer).trim() : "";
+  if (prefix) header = `${prefix}${header}`;
+  const footer = rawFooter ? rawFooter.replace(placeholderRegex, replacer).trim() : "";
+  return { header, footer };
+}
+__name(resolveCaveHeaderFooter, "resolveCaveHeaderFooter");
+async function buildCaveMessage(cave, config, fileManager, logger2, platform, prefix) {
+  async function transformToH(elements) {
+    return Promise.all(elements.map(async (el) => {
+      if (el.type === "text") return import_koishi.h.text(el.content);
+      if (el.type === "at") return (0, import_koishi.h)("at", { id: el.content });
+      if (el.type === "reply") return (0, import_koishi.h)("reply", { id: el.content });
+      if (el.type === "face") return (0, import_koishi.h)("face", { id: el.content });
+      if (el.type === "forward") {
+        try {
+          const forwardNodes = Array.isArray(el.content) ? el.content : [];
+          const messageNodes = await Promise.all(forwardNodes.map(async (node) => {
+            const author = (0, import_koishi.h)("author", { id: node.userId, name: node.userName });
+            const contentElements = await transformToH(node.elements);
+            const unwrappedContent = [];
+            const nestedMessageNodes = [];
+            for (const contentEl of contentElements) {
+              if (contentEl.type === "message" && contentEl.attrs.forward) {
+                nestedMessageNodes.push(...contentEl.children);
+              } else {
+                unwrappedContent.push(contentEl);
+              }
+            }
+            const resultNodes = [];
+            if (unwrappedContent.length > 0) resultNodes.push((0, import_koishi.h)("message", {}, [author, ...unwrappedContent]));
+            resultNodes.push(...nestedMessageNodes);
+            return resultNodes;
+          }));
+          return (0, import_koishi.h)("message", { forward: true }, messageNodes.flat());
+        } catch (error) {
+          logger2.warn(`解析回声洞（${cave.id}）合并转发内容失败:`, error);
+          return import_koishi.h.text("[合并转发]");
+        }
+      }
+      if (["image", "video", "audio", "file"].includes(el.type)) {
+        const fileName = el.file;
+        if (!fileName) return (0, import_koishi.h)("p", {}, `[${el.type}]`);
+        if (config.enableS3 && config.publicUrl) return (0, import_koishi.h)(el.type, { ...el, src: new URL(fileName, config.publicUrl).href });
+        if (config.localPath) return (0, import_koishi.h)(el.type, { ...el, src: `file://${path2.join(config.localPath, fileName)}` });
+        try {
+          const data = await fileManager.readFile(fileName);
+          const mimeType = mimeTypeMap[path2.extname(fileName).toLowerCase()] || "application/octet-stream";
+          return (0, import_koishi.h)(el.type, { ...el, src: `data:${mimeType};base64,${data.toString("base64")}` });
+        } catch (error) {
+          logger2.warn(`转换文件 ${fileName} 为 Base64 失败:`, error);
+          return (0, import_koishi.h)("p", {}, `[${el.type}]`);
+        }
+      }
+      return null;
+    })).then((hElements) => hElements.flat().filter(Boolean));
+  }
+  __name(transformToH, "transformToH");
+  const caveHElements = await transformToH(cave.elements);
+  const { header, footer } = resolveCaveHeaderFooter(cave, config, prefix);
+  const problematicTypes = ["video", "audio", "file", "forward"];
+  const placeholderMap = { video: "[视频]", audio: "[音频]", file: "[文件]", forward: "[合并转发]" };
+  const containsProblematic = platform === "onebot" && caveHElements.some((el) => problematicTypes.includes(el.type) || el.type === "message" && el.attrs.forward);
+  if (!containsProblematic) {
+    const finalMessage = [];
+    if (header) finalMessage.push(header + "\n");
+    finalMessage.push(...caveHElements);
+    if (footer) finalMessage.push("\n" + footer);
+    return [finalMessage.length > 0 ? finalMessage : []];
+  }
+  const initialMessageContent = [];
+  const followUpMessages = [];
+  for (const el of caveHElements) {
+    if (problematicTypes.includes(el.type) || el.type === "message" && el.attrs.forward) {
+      const placeholderKey = el.type === "message" && el.attrs.forward ? "forward" : el.type;
+      initialMessageContent.push(import_koishi.h.text(placeholderMap[placeholderKey]));
+      followUpMessages.push([el]);
+    } else {
+      initialMessageContent.push(el);
+    }
+  }
+  const finalInitialMessage = [];
+  if (header) finalInitialMessage.push(header + "\n");
+  finalInitialMessage.push(...initialMessageContent);
+  if (footer) finalInitialMessage.push("\n" + footer);
+  return [finalInitialMessage, ...followUpMessages].filter((msg) => msg.length > 0);
+}
+__name(buildCaveMessage, "buildCaveMessage");
+var qqImageCache = /* @__PURE__ */ new Map();
+var qqImageTypes = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
+async function uploadQQImage(session, buffer, fileName) {
+  const contentType = qqImageTypes[path2.extname(fileName).toLowerCase()];
+  if (!contentType || buffer.length > 10 * 1024 * 1024) return null;
+  const cached = qqImageCache.get(`${session.bot.selfId}:${fileName}`);
+  if (cached) return cached;
+  const bot = session.bot;
+  const request = bot.internal.http();
+  const md5 = crypto.createHash("md5").update(buffer).digest("hex");
+  const sha1 = crypto.createHash("sha1").update(buffer).digest("hex");
+  const prepared = await request("/v2/media-images/prepare", {
+    method: "POST",
+    data: { file_name: fileName, file_size: buffer.length, content_type: contentType, md5, sha1 }
+  });
+  await bot.ctx.http.put(prepared.presigned_url, buffer, { headers: { "Content-Type": contentType } });
+  const completed = await request("/v2/media-images/complete", {
+    method: "POST",
+    data: { upload_id: prepared.upload_id, md5 }
+  });
+  if (!completed?.url) return null;
+  qqImageCache.set(`${session.bot.selfId}:${fileName}`, completed.url);
+  return completed.url;
+}
+__name(uploadQQImage, "uploadQQImage");
+async function getImageSize(buffer) {
+  try {
+    const image = await import_jimp.default.read(buffer);
+    return { width: image.bitmap.width, height: image.bitmap.height };
+  } catch {
+    return null;
+  }
+}
+__name(getImageSize, "getImageSize");
+async function buildQQCaveMarkdown(cave, config, fileManager, logger2, session, prefix) {
+  const { header, footer } = resolveCaveHeaderFooter(cave, config, prefix);
+  const lines = [];
+  if (header) lines.push(header);
+  for (const el of cave.elements) {
+    if (el.type === "text") {
+      if (el.content) lines.push(el.content);
+    } else if (el.type === "at") {
+      if (!session.isDirect && el.content) lines.push(`<qqbot-at-user id="${el.content}" />`);
+    } else if (el.type === "image") {
+      const fileName = el.file;
+      if (!fileName) {
+        lines.push("[图片]");
+        continue;
+      }
+      let buffer;
+      try {
+        buffer = await fileManager.readFile(fileName);
+      } catch (error) {
+        logger2.warn(`读取图片 ${fileName} 失败:`, error);
+      }
+      let url = null;
+      if (config.enableS3 && config.publicUrl) {
+        url = new URL(fileName, config.publicUrl).href;
+      } else if (buffer) {
+        try {
+          url = await uploadQQImage(session, buffer, fileName);
+        } catch (error) {
+          logger2.warn(`上传图片 ${fileName} 到 QQ 素材库失败:`, error);
+        }
+      }
+      if (!url) {
+        lines.push("[图片]");
+        continue;
+      }
+      const size = buffer ? await getImageSize(buffer) : null;
+      lines.push(size ? `![img #${size.width}px #${size.height}px](${url})` : `![img](${url})`);
+    } else if (el.type === "video") {
+      lines.push("[视频]");
+    } else if (el.type === "audio") {
+      lines.push("[音频]");
+    } else if (el.type === "file") {
+      lines.push("[文件]");
+    } else if (el.type === "forward") {
+      lines.push("[合并转发]");
+    } else if (el.type === "face") {
+      lines.push("[表情]");
+    }
+  }
+  if (footer) lines.push(footer);
+  return lines.join("\n");
+}
+__name(buildQQCaveMarkdown, "buildQQCaveMarkdown");
+async function sendQQCaveMarkdown(session, content) {
+  const bot = session.bot;
+  const s = session;
+  const data = {
+    msg_type: 2,
+    markdown: { content: content || " " },
+    keyboard: {
+      content: {
+        rows: [{
+          buttons: [{
+            render_data: { label: "再来一个cave", style: 1 },
+            action: { type: 2, permission: { type: 2 }, data: "cave", enter: true }
+          }]
+        }]
+      }
+    }
+  };
+  const passive = Date.now() - s.timestamp < 5 * 60 * 1e3;
+  if (passive && s.messageId) {
+    s.seq = (s.seq || 0) + 1;
+    data.msg_id = s.messageId;
+    data.msg_seq = s.seq;
+  } else if (passive && s.qq?.id) {
+    data.event_id = s.qq.id;
+  }
+  if (s.isDirect) {
+    await bot.internal.sendPrivateMessage(s.channelId, data);
+  } else {
+    await bot.internal.sendMessage(s.channelId, data);
+  }
+}
+__name(sendQQCaveMarkdown, "sendQQCaveMarkdown");
+async function sendCave(session, cave, config, fileManager, logger2, prefix) {
+  if (session.platform === "qq") {
+    try {
+      const content = await buildQQCaveMarkdown(cave, config, fileManager, logger2, session, prefix);
+      await sendQQCaveMarkdown(session, content);
+      return;
+    } catch (error) {
+      logger2.warn(`以 QQ Markdown 发送回声洞（${cave.id}）失败，回退到普通消息:`, error);
+    }
+  }
+  const messages = await buildCaveMessage(cave, config, fileManager, logger2, session.platform, prefix);
+  for (const message of messages) if (message.length > 0) await session.send(import_koishi.h.normalize(message));
+}
+__name(sendCave, "sendCave");
+function parseCaveIds(inputs) {
+  const tokens = inputs.flatMap((item) => `${item}`.split(/[|\s,，、]+/)).filter(Boolean);
+  const ids = tokens.filter((token) => /^[1-9]\d*$/.test(token)).map(Number);
+  const invalid = tokens.filter((token) => !/^[1-9]\d*$/.test(token));
+  return { ids: [...new Set(ids)], invalid };
+}
+__name(parseCaveIds, "parseCaveIds");
+async function getNextCaveId(ctx, reusableIds) {
+  for (const id of reusableIds) {
+    if (id > 0) {
+      reusableIds.delete(id);
+      return id;
+    }
+  }
+  if (reusableIds.has(0)) {
+    reusableIds.delete(0);
+    const [lastCave] = await ctx.database.get("cave", {}, { sort: { id: "desc" }, limit: 1 });
+    const newId2 = (lastCave?.id || 0) + 1;
+    reusableIds.add(0);
+    return newId2;
+  }
+  const allCaveIds = (await ctx.database.get("cave", {}, { fields: ["id"] })).map((c) => c.id);
+  const existingIds = new Set(allCaveIds);
+  let newId = 1;
+  while (existingIds.has(newId)) newId++;
+  if (existingIds.size === (allCaveIds.length > 0 ? Math.max(...allCaveIds) : 0)) reusableIds.add(0);
+  return newId;
+}
+__name(getNextCaveId, "getNextCaveId");
+async function processMessageElements(sourceElements, newId, session, creationTime) {
+  const mediaToSave = [];
+  const urlToFileMap = /* @__PURE__ */ new Map();
+  let mediaIndex = 0;
+  const typeMap = { "img": "image", "image": "image", "video": "video", "audio": "audio", "file": "file", "text": "text", "at": "at", "forward": "forward", "reply": "reply", "face": "face" };
+  const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
+  async function transform(elements) {
+    const result = [];
+    async function processForwardContent(segments) {
+      const innerResult = [];
+      for (const segment of segments) {
+        const sType = typeMap[segment.type];
+        if (!sType) continue;
+        if (sType === "text" && segment.data?.text?.trim()) {
+          innerResult.push({ type: "text", content: segment.data.text.trim() });
+        } else if (sType === "at" && (segment.data?.id || segment.data?.qq)) {
+          innerResult.push({ type: "at", content: segment.data.id || segment.data.qq });
+        } else if (sType === "reply" && segment.data?.id) {
+          innerResult.push({ type: "reply", content: segment.data.id });
+        } else if (["image", "video", "audio", "file"].includes(sType) && (segment.data?.src || segment.data?.url)) {
+          let fileIdentifier = segment.data.src || segment.data.url;
+          if (fileIdentifier.startsWith("http")) {
+            if (urlToFileMap.has(fileIdentifier)) {
+              fileIdentifier = urlToFileMap.get(fileIdentifier);
+            } else {
+              const ext = path2.extname(segment.data.file || "") || defaultExtMap[sType];
+              const currentMediaIndex = ++mediaIndex;
+              const newFileName = `${newId}_${currentMediaIndex}_${session.channelId || session.guildId}_${session.userId}_${creationTime.getTime()}${ext}`;
+              mediaToSave.push({ sourceUrl: fileIdentifier, fileName: newFileName });
+              urlToFileMap.set(fileIdentifier, newFileName);
+              fileIdentifier = newFileName;
+            }
+          }
+          innerResult.push({ type: sType, file: fileIdentifier });
+        } else if (sType === "forward" && Array.isArray(segment.data?.content)) {
+          const nestedForwardNodes = [];
+          for (const nestedNode of segment.data.content) {
+            if (!nestedNode.message || !Array.isArray(nestedNode.message)) continue;
+            const nestedContentElements = await processForwardContent(nestedNode.message);
+            if (nestedContentElements.length > 0) {
+              nestedForwardNodes.push({ userId: nestedNode.sender?.user_id, userName: nestedNode.sender?.nickname, elements: nestedContentElements });
+            }
+          }
+          if (nestedForwardNodes.length > 0) innerResult.push({ type: "forward", content: nestedForwardNodes });
+        }
+      }
+      return innerResult;
+    }
+    __name(processForwardContent, "processForwardContent");
+    for (const el of elements) {
+      const type = typeMap[el.type];
+      if (!type) {
+        if (el.children) result.push(...await transform(el.children));
+        continue;
+      }
+      if (type === "text" && el.attrs.content?.trim()) {
+        result.push({ type: "text", content: el.attrs.content.trim() });
+      } else if (type === "at" && el.attrs.id) {
+        result.push({ type: "at", content: el.attrs.id });
+      } else if (type === "reply" && el.attrs.id) {
+        result.push({ type: "reply", content: el.attrs.id });
+      } else if (type === "forward" && Array.isArray(el.attrs.content)) {
+        const forwardNodes = [];
+        for (const node of el.attrs.content) {
+          if (!node.message || !Array.isArray(node.message)) continue;
+          const contentElements = await processForwardContent(node.message);
+          if (contentElements.length > 0) {
+            forwardNodes.push({ userId: node.sender?.user_id, userName: node.sender?.nickname, elements: contentElements });
+          }
+        }
+        if (forwardNodes.length > 0) result.push({ type: "forward", content: forwardNodes });
+      } else if (["image", "video", "audio", "file"].includes(type) && el.attrs.src) {
+        let fileIdentifier = el.attrs.src;
+        if (fileIdentifier.startsWith("http")) {
+          if (urlToFileMap.has(fileIdentifier)) {
+            fileIdentifier = urlToFileMap.get(fileIdentifier);
+          } else {
+            const ext = path2.extname(el.attrs.file || "") || defaultExtMap[type];
+            const currentMediaIndex = ++mediaIndex;
+            const newFileName = `${newId}-${currentMediaIndex}_${session.channelId}-${session.userId}_${creationTime.getTime()}${ext}`;
+            mediaToSave.push({ sourceUrl: fileIdentifier, fileName: newFileName });
+            urlToFileMap.set(fileIdentifier, newFileName);
+            fileIdentifier = newFileName;
+          }
+        }
+        result.push({ type, file: fileIdentifier });
+      } else if (type === "face" && el.attrs.id) {
+        result.push({ type: "face", content: el.attrs.id });
+      }
+    }
+    return result;
+  }
+  __name(transform, "transform");
+  const finalElementsForDb = await transform(sourceElements);
+  return { finalElementsForDb, mediaToSave };
+}
+__name(processMessageElements, "processMessageElements");
+function clusterItemsFromPairs(pairs) {
+  const parent = /* @__PURE__ */ new Map();
+  const allIds = /* @__PURE__ */ new Set();
+  const find = /* @__PURE__ */ __name((i) => {
+    if (!parent.has(i)) {
+      parent.set(i, i);
+      return i;
+    }
+    if (parent.get(i) === i) return i;
+    const root = find(parent.get(i));
+    parent.set(i, root);
+    return root;
+  }, "find");
+  const union = /* @__PURE__ */ __name((i, j) => {
+    const rootI = find(i);
+    const rootJ = find(j);
+    if (rootI !== rootJ) parent.set(rootI, rootJ);
+  }, "union");
+  for (const [id1, id2] of pairs) {
+    union(id1, id2);
+    allIds.add(id1);
+    allIds.add(id2);
+  }
+  if (allIds.size === 0) return [];
+  const clusterMap = /* @__PURE__ */ new Map();
+  allIds.forEach((id) => {
+    const root = find(id);
+    if (!clusterMap.has(root)) clusterMap.set(root, []);
+    clusterMap.get(root).push(id);
+  });
+  return Array.from(clusterMap.values()).filter((c) => c.length > 1);
+}
+__name(clusterItemsFromPairs, "clusterItemsFromPairs");
+function generateFromLSH(items, getBucketInfo) {
+  const buckets = /* @__PURE__ */ new Map();
+  items.forEach((item) => {
+    const { id, keys } = getBucketInfo(item);
+    if (!id || !keys || keys.length === 0) return;
+    keys.forEach((key) => {
+      if (!buckets.has(key)) buckets.set(key, []);
+      buckets.get(key).push(id);
+    });
+  });
+  const candidatePairs = /* @__PURE__ */ new Set();
+  for (const ids of buckets.values()) {
+    if (ids.length < 2) continue;
+    const uniqueIds = [...new Set(ids)].sort((a, b) => a - b);
+    if (uniqueIds.length < 2) continue;
+    for (let i = 0; i < uniqueIds.length; i++) {
+      for (let j = i + 1; j < uniqueIds.length; j++) {
+        const pairKey = `${uniqueIds[i]}-${uniqueIds[j]}`;
+        candidatePairs.add(pairKey);
+      }
+    }
+  }
+  return candidatePairs;
+}
+__name(generateFromLSH, "generateFromLSH");
+async function processNewCave(ctx, config, fileManager, logger2, reusableIds, newCave, session, mediaToSave, hashManager, aiManager, reviewManager) {
+  const newId = newCave.id;
+  try {
+    const initialDownloads = [];
+    if (mediaToSave.length > 0) {
+      const downloadPromises = mediaToSave.map(async (media) => {
+        const buffer = Buffer.from(await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 6e4 }));
+        return { candidateFile: media.fileName, buffer };
+      });
+      initialDownloads.push(...await Promise.all(downloadPromises));
+    }
+    const mediaForProcessing = [];
+    const fileRemapping = /* @__PURE__ */ new Map();
+    const canonicalFilesToSave = /* @__PURE__ */ new Map();
+    if (hashManager) {
+      const hashToCanonicalFile = /* @__PURE__ */ new Map();
+      const hashableExtensions = [".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tiff", ".gif"];
+      const sanitizableExtensions = [".png", ".jpg", ".jpeg", ".webp", ".gif"];
+      for (const { candidateFile, buffer } of initialDownloads) {
+        const ext = path2.extname(candidateFile).toLowerCase();
+        let finalBuffer = buffer;
+        let hash;
+        if (hashableExtensions.includes(ext)) {
+          try {
+            hash = await hashManager.generatePHash(finalBuffer);
+          } catch {
+            if (sanitizableExtensions.includes(ext)) {
+              try {
+                const sanitized = hashManager.sanitizeImageBuffer(finalBuffer);
+                if (!sanitized.equals(finalBuffer)) {
+                  finalBuffer = sanitized;
+                  hash = await hashManager.generatePHash(finalBuffer);
+                }
+              } catch (e) {
+                logger2.warn(`图片修复失败 (${candidateFile}): ${e.message}`);
+              }
+            }
+          }
+        }
+        if (hash && hashToCanonicalFile.has(hash)) {
+          fileRemapping.set(candidateFile, hashToCanonicalFile.get(hash));
+          continue;
+        }
+        if (hash) hashToCanonicalFile.set(hash, candidateFile);
+        canonicalFilesToSave.set(candidateFile, finalBuffer);
+        fileRemapping.set(candidateFile, candidateFile);
+        mediaForProcessing.push({ fileName: candidateFile, buffer: finalBuffer, hash });
+      }
+      newCave.elements.forEach((el) => {
+        if (el.file && fileRemapping.has(el.file)) el.file = fileRemapping.get(el.file);
+      });
+    } else {
+      initialDownloads.forEach((d) => {
+        canonicalFilesToSave.set(d.candidateFile, d.buffer);
+        mediaForProcessing.push({ fileName: d.candidateFile, buffer: d.buffer });
+      });
+    }
+    let textHashesToStore = [];
+    let imageHashesToStore = [];
+    if (config.enableSimilarity && hashManager) {
+      try {
+        const combinedText = newCave.elements.filter((el) => el.type === "text" && typeof el.content === "string").map((el) => el.content).join(" ");
+        if (combinedText) {
+          const newSimhash = hashManager.generateTextSimhash(combinedText);
+          if (newSimhash) {
+            const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
+            for (const existing of existingTextHashes) {
+              const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
+              if (similarity >= config.textThreshold) {
+                await session.send(`回声洞（${newId}）添加失败：文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值`);
+                await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
+                return;
+              }
+            }
+            textHashesToStore.push({ hash: newSimhash, type: "text" });
+          }
+        }
+        const imagesWithHash = mediaForProcessing.filter((m) => m.hash !== void 0);
+        if (imagesWithHash.length > 0) {
+          const dbImageHashes = await ctx.database.get("cave_hash", { type: "image" });
+          const newImageHashes = /* @__PURE__ */ new Set();
+          for (const media of imagesWithHash) {
+            const imageHash = media.hash;
+            if (newImageHashes.has(imageHash)) continue;
+            for (const existing of dbImageHashes) {
+              const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
+              if (similarity >= config.imageThreshold) {
+                await session.send(`回声洞（${newId}）添加失败：图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值`);
+                await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
+                return;
+              }
+            }
+            newImageHashes.add(imageHash);
+          }
+          imageHashesToStore = Array.from(newImageHashes).map((hash) => ({ hash, type: "image" }));
+        }
+      } catch (error) {
+        logger2.warn("相似度比较失败:", error);
+      }
+    }
+    if (canonicalFilesToSave.size > 0) await Promise.all(Array.from(canonicalFilesToSave.entries()).map(([fileName, buffer]) => fileManager.saveFile(fileName, buffer)));
+    let analysisResult;
+    if (config.enableAI && aiManager) {
+      const analyses = await aiManager.analyze([newCave], mediaForProcessing);
+      if (analyses.length > 0) {
+        analysisResult = analyses[0];
+        await ctx.database.upsert("cave_meta", analyses);
+        const duplicateIds = await aiManager.checkForDuplicates(analysisResult, newCave);
+        if (duplicateIds?.length > 0) {
+          await session.send(`回声洞（${newId}）添加失败：内容与回声洞（${duplicateIds.join("|")}）重复`);
+          await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
+          return;
+        }
+      }
+    }
+    if (config.enableSimilarity && hashManager) {
+      const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: newCave.id }));
+      if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
+    }
+    let finalStatus = "active";
+    const needsManualReview = config.enablePend && session.cid !== config.adminChannel;
+    if (needsManualReview) {
+      if (config.enableAI && config.enableApprove && analysisResult) {
+        if (analysisResult.rating >= config.approveThreshold) {
+          finalStatus = "active";
+        } else if (config.onAIReviewFail) {
+          finalStatus = "pending";
+        } else {
+          await session.send(`回声洞（${newId}）添加失败：AI 审核未通过 (评分: ${analysisResult.rating})`);
+          await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
+          return;
+        }
+      } else {
+        finalStatus = "pending";
+      }
+    }
+    await ctx.database.upsert("cave", [{ id: newId, status: finalStatus, elements: newCave.elements }]);
+    if (finalStatus === "pending" && reviewManager) reviewManager.sendForPend({ ...newCave, status: finalStatus });
+  } catch (error) {
+    logger2.error(`回声洞（${newId}）处理失败:`, error);
+    await ctx.database.upsert("cave", [{ id: newId, status: "delete" }]);
+    await session.send(`回声洞（${newId}）处理失败: ${error.message}`);
+  }
+}
+__name(processNewCave, "processNewCave");
+
+// src/PendManager.ts
+var PendManager = class {
+  /**
+   * @param ctx Koishi 上下文。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
+   * @param reusableIds 可复用 ID 的内存缓存。
+   */
+  constructor(ctx, config, fileManager, logger2) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = logger2;
+  }
+  static {
+    __name(this, "PendManager");
+  }
+  /**
+   * @description 注册与审核相关的子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    const pend = cave.subcommand(".pend [id:posint]", "审核回声洞", { hidden: true }).usage("查询待审核的回声洞列表，或指定 ID 查看对应待审核的回声洞。").action(async ({ session }, id) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      if (id) {
+        const [targetCave] = await this.ctx.database.get("cave", { id });
+        if (!targetCave) return `回声洞（${id}）不存在`;
+        if (targetCave.status !== "pending") return `回声洞（${id}）无需审核`;
+        const caveMessages = await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger, session.platform, "待审核");
+        for (const message of caveMessages) if (message.length > 0) await session.send(import_koishi2.h.normalize(message));
+        return;
+      }
+      const pendingCaves = await this.ctx.database.get("cave", { status: "pending" }, { fields: ["id"] });
+      if (!pendingCaves.length) return "当前没有需要审核的回声洞";
+      return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
+${pendingCaves.map((c) => c.id).join("|")}`;
+    });
+    const createPendAction = /* @__PURE__ */ __name((actionType) => async ({ session }, ...args) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      const { ids, invalid } = parseCaveIds(args);
+      let idsToProcess = ids;
+      if (args.length === 0) {
+        const pendingCaves = await this.ctx.database.get("cave", { status: "pending" }, { fields: ["id"] });
+        if (!pendingCaves.length) return "当前没有需要审核的回声洞";
+        idsToProcess = pendingCaves.map((c) => c.id);
+      }
+      try {
+        const targetStatus = actionType === "approve" ? "active" : "delete";
+        const actionText = actionType === "approve" ? "通过" : "拒绝";
+        const cavesToProcess = idsToProcess.length === 0 ? [] : await this.ctx.database.get("cave", { id: { $in: idsToProcess }, status: "pending" });
+        if (cavesToProcess.length === 0) return `回声洞（${[...invalid, ...idsToProcess].join("|")}）无需审核或不存在`;
+        const processedIds = cavesToProcess.map((cave2) => cave2.id);
+        await this.ctx.database.upsert("cave", processedIds.map((id) => ({ id, status: targetStatus })));
+        return `已${actionText}回声洞（${processedIds.join("|")}）`;
+      } catch (error) {
+        this.logger.error(`审核操作失败:`, error);
+        return `操作失败: ${error.message}`;
+      }
+    }, "createPendAction");
+    pend.subcommand(".Y [...ids:string]", "通过审核").usage("通过一个或多个指定 ID 的回声洞审核，序号之间以空格或 | 分隔。若不指定 ID，则通过所有待审核的回声洞。").action(createPendAction("approve"));
+    pend.subcommand(".N [...ids:string]", "拒绝审核").usage("拒绝一个或多个指定 ID 的回声洞审核，序号之间以空格或 | 分隔。若不指定 ID，则拒绝所有待审核的回声洞。").action(createPendAction("reject"));
+    if (this.config.enableAI) {
+      pend.subcommand(".A <threshold:number>", "自动通过审核").usage("根据评分自动通过不小于指定阈值的回声洞。默认使用配置中的阈值。").action(async ({ session }, threshold) => {
+        if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+        const finalThreshold = threshold ?? this.config.approveThreshold;
+        try {
+          const pendingCaves = await this.ctx.database.get("cave", { status: "pending" });
+          if (pendingCaves.length === 0) return "当前没有需要审核的回声洞";
+          const pendingCaveIds = pendingCaves.map((c) => c.id);
+          const pendingMeta = await this.ctx.database.get("cave_meta", { cave: { $in: pendingCaveIds } });
+          const idsToApprove = pendingMeta.filter((meta) => meta.rating >= finalThreshold).map((meta) => meta.cave);
+          if (idsToApprove.length === 0) return `没有找到评分不小于 ${finalThreshold} 的待审核回声洞`;
+          await this.ctx.database.upsert("cave", idsToApprove.map((id) => ({ id, status: "active" })));
+          return `已自动通过回声洞（${idsToApprove.join("|")}）`;
+        } catch (error) {
+          this.logger.error("自动审核操作失败:", error);
+          return `操作失败: ${error.message}`;
+        }
+      });
+    }
+  }
+  /**
+   * @description 将新回声洞提交到管理群组以供审核。
+   * @param cave 新创建的、状态为 'pending' 的回声洞对象。
+   */
+  async sendForPend(cave) {
+    if (!this.config.adminChannel?.includes(":")) {
+      this.logger.warn(`管理群组配置无效，已自动通过回声洞（${cave.id}）`);
+      await this.ctx.database.upsert("cave", [{ id: cave.id, status: "active" }]);
+      return;
+    }
+    try {
+      const [platform] = this.config.adminChannel.split(":", 1);
+      const caveMessages = await buildCaveMessage(cave, this.config, this.fileManager, this.logger, platform, "待审核");
+      for (const message of caveMessages) if (message.length > 0) await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(message));
+    } catch (error) {
+      this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
+    }
+  }
+};
+
+// src/HashManager.ts
+var import_jimp2 = __toESM(require("jimp"));
+var crypto2 = __toESM(require("crypto"));
+var HashManager = class {
+  /**
+   * @constructor
+   * @param ctx - Koishi 上下文，用于数据库操作。
+   * @param config - 插件配置，用于获取相似度阈值等。
+   * @param logger - 日志记录器实例。
+   * @param fileManager - 文件管理器实例，用于读取图片文件。
+   */
+  constructor(ctx, config, logger2, fileManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.logger = logger2;
+    this.fileManager = fileManager;
+    this.ctx.model.extend("cave_hash", {
+      cave: "unsigned",
+      hash: "string",
+      type: "string"
+    }, {
+      primary: ["cave", "hash", "type"],
+      indexes: ["type"]
+    });
+  }
+  static {
+    __name(this, "HashManager");
+  }
+  /**
+   * @description 注册与哈希功能相关的子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    cave.subcommand(".hash", "校验回声洞", { hidden: true, authority: 3 }).usage("校验缺失哈希的回声洞，补全哈希记录。").action(async ({ session }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      try {
+        const allCaves = await this.ctx.database.get("cave", { status: "active" });
+        const existingHashes = await this.ctx.database.get("cave_hash", {}, { fields: ["cave"] });
+        const hashedCaveIds = new Set(existingHashes.map((h4) => h4.cave));
+        const cavesToProcess = allCaves.filter((cave2) => !hashedCaveIds.has(cave2.id));
+        if (cavesToProcess.length === 0) return "无需补全回声洞哈希";
+        await session.send(`开始补全 ${cavesToProcess.length} 个回声洞的哈希...`);
+        let hashesToInsert = [];
+        let processedCaveCount = 0;
+        let totalHashesGenerated = 0;
+        let errorCount = 0;
+        const flushBatch = /* @__PURE__ */ __name(async () => {
+          if (hashesToInsert.length === 0) return;
+          await this.ctx.database.upsert("cave_hash", hashesToInsert);
+          totalHashesGenerated += hashesToInsert.length;
+          this.logger.info(`[${processedCaveCount}/${cavesToProcess.length}] 正在导入 ${hashesToInsert.length} 条回声洞哈希...`);
+          hashesToInsert = [];
+        }, "flushBatch");
+        for (const cave2 of cavesToProcess) {
+          processedCaveCount++;
+          try {
+            const tempHashes = [];
+            const uniqueHashTracker = /* @__PURE__ */ new Set();
+            const addUniqueHash = /* @__PURE__ */ __name((hashObj) => {
+              const key = `${hashObj.hash}-${hashObj.type}`;
+              if (!uniqueHashTracker.has(key)) {
+                tempHashes.push(hashObj);
+                uniqueHashTracker.add(key);
+              }
+            }, "addUniqueHash");
+            const combinedText = cave2.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
+            if (combinedText) {
+              const textHash = this.generateTextSimhash(combinedText);
+              if (textHash) addUniqueHash({ cave: cave2.id, hash: textHash, type: "text" });
+            }
+            for (const el of cave2.elements.filter((el2) => el2.type === "image" && el2.file)) {
+              const imageBuffer = await this.fileManager.readFile(el.file);
+              const imageHash = await this.generatePHash(imageBuffer);
+              addUniqueHash({ cave: cave2.id, hash: imageHash, type: "image" });
+            }
+            const newHashesForCave = tempHashes;
+            if (newHashesForCave.length > 0) hashesToInsert.push(...newHashesForCave);
+            if (hashesToInsert.length >= 100) await flushBatch();
+          } catch (error) {
+            errorCount++;
+            this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error.message}`);
+          }
+        }
+        await flushBatch();
+        const successCount = processedCaveCount - errorCount;
+        return `已补全 ${successCount} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
+      } catch (error) {
+        this.logger.error("补全哈希失败:", error);
+        return `操作失败: ${error.message}`;
+      }
+    });
+    cave.subcommand(".check", "检查相似度", { hidden: true }).usage("检查所有回声洞，找出相似度过高的内容。").option("textThreshold", "-t <threshold:number> 文本相似度阈值 (%)").option("imageThreshold", "-i <threshold:number> 图片相似度阈值 (%)").action(async ({ session, options }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      await session.send("正在检查，请稍候...");
+      try {
+        const textThreshold = options.textThreshold ?? this.config.textThreshold;
+        const imageThreshold = options.imageThreshold ?? this.config.imageThreshold;
+        const allHashes = await this.ctx.database.get("cave_hash", {});
+        if (allHashes.length < 2) return "无可比较哈希";
+        const candidatePairs = generateFromLSH(allHashes, (hashObj) => {
+          const binHash = BigInt("0x" + hashObj.hash).toString(2).padStart(64, "0");
+          const keys = [];
+          for (let i = 0; i < 4; i++) {
+            const band = binHash.substring(i * 16, (i + 1) * 16);
+            keys.push(`${hashObj.type}:${i}:${band}`);
+          }
+          return { id: hashObj.cave, keys };
+        });
+        const hashLookup = /* @__PURE__ */ new Map();
+        allHashes.forEach((h4) => {
+          if (!hashLookup.has(h4.cave)) hashLookup.set(h4.cave, { text: [], image: [] });
+          const entry = hashLookup.get(h4.cave);
+          if (h4.type === "text") entry.text.push(h4.hash);
+          else if (h4.type === "image") entry.image.push(h4.hash);
+        });
+        const textPairs = [];
+        const imagePairs = [];
+        for (const pairKey of candidatePairs) {
+          const [id1, id2] = pairKey.split("-").map(Number);
+          const cave1Hashes = hashLookup.get(id1);
+          const cave2Hashes = hashLookup.get(id2);
+          if (cave1Hashes?.text.length && cave2Hashes?.text.length) {
+            for (const hash1 of cave1Hashes.text) {
+              for (const hash2 of cave2Hashes.text) {
+                const similarity = this.calculateSimilarity(hash1, hash2);
+                if (similarity >= textThreshold) textPairs.push({ id1, id2, similarity });
+              }
+            }
+          }
+          if (cave1Hashes?.image.length && cave2Hashes?.image.length) {
+            for (const hash1 of cave1Hashes.image) {
+              for (const hash2 of cave2Hashes.image) {
+                const similarity = this.calculateSimilarity(hash1, hash2);
+                if (similarity >= imageThreshold) imagePairs.push({ id1, id2, similarity });
+              }
+            }
+          }
+        }
+        if (textPairs.length === 0 && imagePairs.length === 0) return "未发现高相似度的内容";
+        const generateReportForType = /* @__PURE__ */ __name((pairs) => {
+          if (pairs.length === 0) return { reportLines: [], clusters: [] };
+          const numericPairs = pairs.map((p) => [p.id1, p.id2]);
+          const validClusters = clusterItemsFromPairs(numericPairs);
+          const reportLines = [];
+          validClusters.forEach((cluster) => {
+            const sortedCluster = cluster.sort((a, b) => a - b);
+            const clusterPairs = pairs.filter((p) => cluster.includes(p.id1) && cluster.includes(p.id2)).sort((a, b) => b.similarity - a.similarity);
+            const scores = clusterPairs.map((p) => `${p.similarity.toFixed(2)}%`).join("/");
+            reportLines.push(`- ${sortedCluster.join("|")} = ${scores}`);
+          });
+          return { reportLines, clusters: validClusters };
+        }, "generateReportForType");
+        const textResult = generateReportForType(textPairs);
+        const imageResult = generateReportForType(imagePairs);
+        const totalClusters = textResult.clusters.length + imageResult.clusters.length;
+        if (totalClusters === 0) return "未发现高相似度的内容";
+        let report = `共发现 ${totalClusters} 组高相似度的内容:`;
+        if (textResult.reportLines.length > 0) {
+          report += `
+[文本相似]`;
+          report += `
+${textResult.reportLines.join("\n")}`;
+        }
+        if (imageResult.reportLines.length > 0) {
+          report += `
+[图片相似]`;
+          report += `
+${imageResult.reportLines.join("\n")}`;
+        }
+        return report.trim();
+      } catch (error) {
+        this.logger.error("检查相似度失败:", error);
+        return `检查失败: ${error.message}`;
+      }
+    });
+    cave.subcommand(".fix [...ids:string]", "修复回声洞", { hidden: true, authority: 3 }).usage("扫描并修复回声洞中的图片，可指定一个或多个 ID，序号之间以空格或 | 分隔。").action(async ({ session }, ...args) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      const { ids } = parseCaveIds(args);
+      let cavesToProcess;
+      try {
+        await session.send("正在修复，请稍候...");
+        if (args.length === 0) {
+          cavesToProcess = await this.ctx.database.get("cave", { status: "active" });
+        } else {
+          cavesToProcess = ids.length === 0 ? [] : await this.ctx.database.get("cave", { id: { $in: ids }, status: "active" });
+        }
+        if (!cavesToProcess.length) return "无可修复的回声洞";
+        let fixedFiles = 0;
+        let errorCount = 0;
+        for (const cave2 of cavesToProcess) {
+          const imageElements = cave2.elements.filter((el) => el.type === "image" && el.file);
+          for (const element of imageElements) {
+            try {
+              const originalBuffer = await this.fileManager.readFile(element.file);
+              const sanitizedBuffer = this.sanitizeImageBuffer(originalBuffer);
+              if (!originalBuffer.equals(sanitizedBuffer)) {
+                await this.fileManager.saveFile(element.file, sanitizedBuffer);
+                fixedFiles++;
+              }
+            } catch (error) {
+              if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+                this.logger.warn(`无法修复回声洞（${cave2.id}）的图片（${element.file}）:`, error);
+                errorCount++;
+              }
+            }
+          }
+        }
+        return `已修复 ${cavesToProcess.length} 个回声洞的 ${fixedFiles} 张图片（失败 ${errorCount} 条）`;
+      } catch (error) {
+        this.logger.error("修复图像文件时发生严重错误:", error);
+        return `操作失败: ${error.message}`;
+      }
+    });
+  }
+  /**
+   * @description 扫描并修复单个图片 Buffer，移除文件结束符之后的多余数据。
+   * @param imageBuffer - 原始的图片 Buffer。
+   * @returns 修复后的图片 Buffer。如果无需修复，则返回原始 Buffer。
+   */
+  sanitizeImageBuffer(imageBuffer) {
+    const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const JPEG_SIGNATURE = Buffer.from([255, 216]);
+    const GIF_SIGNATURE = Buffer.from("GIF");
+    const WEBP_SIGNATURE = Buffer.from("WEBP");
+    let sanitizedBuffer = imageBuffer;
+    if (imageBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
+      const IEND_CHUNK = Buffer.from("IEND");
+      const iendIndex = imageBuffer.lastIndexOf(IEND_CHUNK);
+      if (iendIndex !== -1) {
+        const endOfPngData = iendIndex + 8;
+        if (imageBuffer.length > endOfPngData) sanitizedBuffer = imageBuffer.slice(0, endOfPngData);
+      }
+    } else if (imageBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
+      const EOI_MARKER = Buffer.from([255, 217]);
+      const eoiIndex = imageBuffer.lastIndexOf(EOI_MARKER);
+      if (eoiIndex !== -1) {
+        const endOfJpegData = eoiIndex + 2;
+        if (imageBuffer.length > endOfJpegData) sanitizedBuffer = imageBuffer.slice(0, endOfJpegData);
+      }
+    } else if (imageBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
+      const GIF_TERMINATOR = Buffer.from([59]);
+      const terminatorIndex = imageBuffer.lastIndexOf(GIF_TERMINATOR);
+      if (terminatorIndex !== -1) {
+        const endOfGifData = terminatorIndex + 1;
+        if (imageBuffer.length > endOfGifData) sanitizedBuffer = imageBuffer.slice(0, endOfGifData);
+      }
+    } else if (imageBuffer.slice(8, 12).equals(WEBP_SIGNATURE)) {
+      const fileSize = imageBuffer.readUInt32LE(4);
+      const expectedLength = fileSize + 8;
+      if (imageBuffer.length > expectedLength) sanitizedBuffer = imageBuffer.slice(0, expectedLength);
+    }
+    return sanitizedBuffer;
+  }
+  /**
+   * @description 执行一维离散余弦变换 (DCT-II) 的方法。
+   * @param input - 输入的数字数组。
+   * @returns DCT 变换后的数组。
+   */
+  dct1D(input) {
+    const N = input.length;
+    const output = new Array(N).fill(0);
+    const c0 = 1 / Math.sqrt(2);
+    for (let k = 0; k < N; k++) {
+      let sum = 0;
+      for (let n = 0; n < N; n++) sum += input[n] * Math.cos(Math.PI * (2 * n + 1) * k / (2 * N));
+      const ck = k === 0 ? c0 : 1;
+      output[k] = Math.sqrt(2 / N) * ck * sum;
+    }
+    return output;
+  }
+  /**
+   * @description 执行二维离散余弦变换 (DCT-II) 的方法。
+   * 通过对行和列分别应用一维 DCT 来实现。
+   * @param matrix - 输入的 N x N 像素亮度矩阵。
+   * @returns DCT 变换后的 N x N 系数矩阵。
+   */
+  dct2D(matrix) {
+    const N = matrix.length;
+    if (N === 0) return [];
+    const tempMatrix = matrix.map((row) => this.dct1D(row));
+    const transposed = tempMatrix.map((_, colIndex) => tempMatrix.map((row) => row[colIndex]));
+    const dctResultTransposed = transposed.map((row) => this.dct1D(row));
+    const dctResult = dctResultTransposed.map((_, colIndex) => dctResultTransposed.map((row) => row[colIndex]));
+    return dctResult;
+  }
+  /**
+   * @description pHash 算法核心实现，使用 Jimp 和自定义 DCT。
+   * @param imageBuffer - 图片的 Buffer。
+   * @returns 64位十六进制 pHash 字符串。
+   */
+  async generatePHash(imageBuffer) {
+    const image = await import_jimp2.default.read(imageBuffer);
+    image.resize(32, 32, import_jimp2.default.RESIZE_BILINEAR).greyscale();
+    const matrix = Array.from({ length: 32 }, () => new Array(32).fill(0));
+    image.scan(0, 0, 32, 32, (x, y, idx) => {
+      matrix[y][x] = image.bitmap.data[idx];
+    });
+    const dctMatrix = this.dct2D(matrix);
+    const coefficients = [];
+    for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) coefficients.push(dctMatrix[y][x]);
+    const acCoefficients = coefficients.slice(1);
+    const average = acCoefficients.reduce((sum, val) => sum + val, 0) / acCoefficients.length;
+    let binaryHash = "";
+    for (const val of coefficients) binaryHash += val > average ? "1" : "0";
+    return BigInt("0b" + binaryHash).toString(16).padStart(16, "0");
+  }
+  /**
+   * @description 根据汉明距离计算相似度百分比。
+   * @param hex1 - 第一个哈希。
+   * @param hex2 - 第二个哈希。
+   * @returns 相似度 (0-100)。
+   */
+  calculateSimilarity(hex1, hex2) {
+    let distance = 0;
+    let bin1 = "";
+    for (const char of hex1) bin1 += parseInt(char, 16).toString(2).padStart(4, "0");
+    let bin2 = "";
+    for (const char of hex2) bin2 += parseInt(char, 16).toString(2).padStart(4, "0");
+    const len = Math.min(bin1.length, bin2.length);
+    for (let i = 0; i < len; i++) if (bin1[i] !== bin2[i]) distance++;
+    const hashLength = Math.max(hex1.length, hex2.length) * 4;
+    return hashLength === 0 ? 100 : (1 - distance / hashLength) * 100;
+  }
+  /**
+   * @description 为文本生成 64 位 Simhash 字符串。
+   * @param text - 需要处理的文本。
+   * @returns 16位十六进制 Simhash 字符串。
+   */
+  generateTextSimhash(text) {
+    const cleanText = (text || "").toLowerCase().replace(/\s+/g, "");
+    if (!cleanText) return "";
+    const tokens = Array.from(cleanText);
+    const tokenArray = Array.from(new Set(tokens));
+    if (tokenArray.length === 0) return "";
+    const vector = new Array(64).fill(0);
+    tokenArray.forEach((token) => {
+      const hash = crypto2.createHash("md5").update(token).digest();
+      for (let i = 0; i < 64; i++) vector[i] += hash[Math.floor(i / 8)] >> i % 8 & 1 ? 1 : -1;
+    });
+    const binaryHash = vector.map((v) => v > 0 ? "1" : "0").join("");
+    return BigInt("0b" + binaryHash).toString(16).padStart(16, "0");
+  }
+};
+
+// src/AIManager.ts
+var path3 = __toESM(require("path"));
+var AIManager = class {
+  /**
+   * @constructor
+   * @description AIManager 的构造函数。
+   * @param {Context} ctx - Koishi 的上下文对象。
+   * @param {Config} config - 插件的配置对象。
+   * @param {Logger} logger - 日志记录器实例。
+   * @param {FileManager} fileManager - 文件管理器实例。
+   */
+  constructor(ctx, config, logger2, fileManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.logger = logger2;
+    this.fileManager = fileManager;
+    this.http = ctx.http;
+    this.ctx.model.extend("cave_meta", {
+      cave: "unsigned",
+      rating: "unsigned",
+      type: "string",
+      keywords: "json"
+    }, {
+      primary: "cave"
+    });
+  }
+  static {
+    __name(this, "AIManager");
+  }
+  http;
+  endpointIndex = 0;
+  retryTime = 0;
+  /**
+   * @description 用于分析的 AI 系统提示词。
+   */
+  ANALYSIS_SYSTEM_PROMPT = `你需要分析给定的内容，并按照以下规则进行评分和分类，并提取内容中的关键词，然后输出回复。
+你的回复必须且只能是一个JSON对象，严禁含有注释说明等其他文字，例: {"rating": 88,"type": "Game","keywords": ["Minecraft", "Nether"]}。`;
+  /**
+   * @description 用于查重的 AI 系统提示词。
+   */
+  DUPLICATE_SYSTEM_PROMPT = `你需要比较给定的“新内容”与“候选内容”，判断是否在核心主旨上近似，忽略非关键元素的差异。
+你的回复必须且只能是一个JSON数组，严禁含有注释说明等其他文字，只包含与新内容重复的候选内容的ID，例: [1, 2]或[]（若无重复）`;
+  /**
+   * @description 注册与 AI 功能相关的管理命令。
+   * @param {any} cave - \`cave\` 命令的实例，用于挂载子命令。
+   */
+  registerCommands(cave) {
+    cave.subcommand(".ai", "分析回声洞", { hidden: true, authority: 4 }).usage("分析尚未分析的回声洞，补全回声洞记录。").action(async ({ session }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      try {
+        const allCaves = await this.ctx.database.get("cave", { status: "active" });
+        const analyzedCaveIds = new Set((await this.ctx.database.get("cave_meta", {}, { fields: ["cave"] })).map((meta) => meta.cave));
+        const cavesToAnalyze = allCaves.filter((cave2) => !analyzedCaveIds.has(cave2.id));
+        if (cavesToAnalyze.length === 0) return "无需分析回声洞";
+        await session.send(`开始分析 ${cavesToAnalyze.length} 个回声洞...`);
+        let successCount = 0;
+        let failedCount = 0;
+        for (let i = 0; i < cavesToAnalyze.length; i += 20) {
+          const batch = cavesToAnalyze.slice(i, i + 20);
+          this.logger.info(`[${i + 1}/${cavesToAnalyze.length}] 正在分析 ${batch.length} 个回声洞...`);
+          const results = await Promise.allSettled(batch.map((cave2) => this.analyze([cave2])));
+          const successfulAnalyses = [];
+          for (let j = 0; j < results.length; j++) {
+            const result = results[j];
+            if (result.status === "fulfilled" && result.value.length > 0) {
+              successfulAnalyses.push(result.value[0]);
+            } else {
+              failedCount++;
+              if (result.status === "rejected") this.logger.error(`分析回声洞（${batch[j].id}）失败:`, result.reason);
+            }
+          }
+          if (successfulAnalyses.length > 0) {
+            await this.ctx.database.upsert("cave_meta", successfulAnalyses);
+            successCount += successfulAnalyses.length;
+          }
+        }
+        return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
+      } catch (error) {
+        this.logger.error("分析回声洞失败:", error);
+        return `操作失败: ${error.message}`;
+      }
+    });
+    cave.subcommand(".compare", "比较重复性", { hidden: true }).usage("检查回声洞，找出可能重复的内容。").action(async ({ session }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      await session.send("正在检查，请稍候...");
+      try {
+        const allMeta = await this.ctx.database.get("cave_meta", {});
+        if (allMeta.length < 2) return "无可比较数据";
+        const combinedTags = /* @__PURE__ */ __name((meta) => [meta.type, ...meta.keywords || []].filter(Boolean), "combinedTags");
+        const candidatePairs = generateFromLSH(allMeta, (meta) => ({ id: meta.cave, keys: combinedTags(meta) }));
+        if (candidatePairs.size === 0) return "未发现相似内容";
+        const metaMap = new Map(allMeta.map((meta) => [meta.cave, meta]));
+        const filteredPairs = /* @__PURE__ */ new Set();
+        for (const pairKey of candidatePairs) {
+          const [id1, id2] = pairKey.split("-").map(Number);
+          const meta1 = metaMap.get(id1);
+          const meta2 = metaMap.get(id2);
+          if (meta1 && meta2) {
+            const tags1 = combinedTags(meta1);
+            const tags2 = combinedTags(meta2);
+            const similarity = this.calculateSimilarity(tags1, tags2);
+            if (similarity >= 66) {
+              const sortedPairKey = [id1, id2].sort((a, b) => a - b).join("-");
+              filteredPairs.add(sortedPairKey);
+            }
+          }
+        }
+        if (filteredPairs.size === 0) return "未发现相似内容";
+        const groupedCandidates = /* @__PURE__ */ new Map();
+        const allCaveIds = /* @__PURE__ */ new Set();
+        filteredPairs.forEach((pairKey) => {
+          const [id1, id2] = pairKey.split("-").map(Number);
+          if (!groupedCandidates.has(id1)) groupedCandidates.set(id1, /* @__PURE__ */ new Set());
+          groupedCandidates.get(id1).add(id2);
+          allCaveIds.add(id1);
+          allCaveIds.add(id2);
+        });
+        let preliminaryReport = `共发现 ${groupedCandidates.size} 组可能相似的内容:`;
+        for (const [mainId, candidateIdsSet] of groupedCandidates.entries()) {
+          const cluster = [mainId, ...Array.from(candidateIdsSet)].sort((a, b) => a - b);
+          preliminaryReport += `
+- ${cluster.join("|")}`;
+        }
+        preliminaryReport += "\n正在分析，请稍候...";
+        await session.send(preliminaryReport);
+        const caveData = await this.ctx.database.get("cave", { id: { $in: Array.from(allCaveIds) }, status: "active" });
+        const allCaves = new Map(caveData.map((c) => [c.id, c]));
+        const duplicatePairs = [];
+        for (const [mainId, candidateIdsSet] of groupedCandidates.entries()) {
+          const mainCave = allCaves.get(mainId);
+          const candidateCaves = Array.from(candidateIdsSet).map((id) => allCaves.get(id)).filter((c) => !!c);
+          if (mainCave && candidateCaves.length > 0) {
+            const duplicateIds = await this.IsDuplicate(mainCave, candidateCaves);
+            if (duplicateIds && duplicateIds.length > 0) duplicateIds.forEach((candidateId) => duplicatePairs.push({ id1: mainId, id2: candidateId }));
+          }
+        }
+        if (duplicatePairs.length === 0) return "未发现高重复性的内容";
+        const numericPairs = duplicatePairs.map((p) => [p.id1, p.id2]);
+        const validClusters = clusterItemsFromPairs(numericPairs);
+        if (validClusters.length === 0) return "未发现高重复性的内容";
+        let report = `共发现 ${validClusters.length} 组高重复性的内容:`;
+        validClusters.forEach((cluster) => {
+          report += `
+- ${cluster.sort((a, b) => a - b).join("|")}`;
+        });
+        return report;
+      } catch (error) {
+        this.logger.error("检查重复性失败:", error);
+        return `检查失败: ${error.message}`;
+      }
+    });
+    cave.subcommand(".rank", "查询评分排行", { hidden: true }).option("count", "-n <limit:posint> 显示数量", { fallback: 30 }).option("greater", "-g <rating:number> 显示下限").option("less", "-l <rating:number> 显示上限").option("pending", "-p 查询待审核回声洞").action(async ({ session, options }) => {
+      if (session.cid !== this.config.adminChannel) return "此指令仅限在管理群组中使用";
+      try {
+        const statusToQuery = options.pending ? "pending" : "active";
+        const caves = await this.ctx.database.get("cave", { status: statusToQuery }, { fields: ["id"] });
+        const caveIds = caves.map((c) => c.id);
+        if (caveIds.length === 0) return `暂无${statusToQuery === "pending" ? "待审核" : "已通过"}的回声洞`;
+        const metaQuery = { cave: { $in: caveIds } };
+        if (options.greater !== void 0) metaQuery.rating = { ...metaQuery.rating, $gte: options.greater };
+        if (options.less !== void 0) metaQuery.rating = { ...metaQuery.rating, $lte: options.less };
+        const rankedMeta = await this.ctx.database.get("cave_meta", metaQuery);
+        if (rankedMeta.length === 0) return "暂无相符的评分记录";
+        const sortedMeta = rankedMeta.sort((a, b) => b.rating - a.rating);
+        const topMeta = sortedMeta.slice(0, options.count);
+        const formattedEntries = topMeta.map((meta) => `${meta.cave}(${meta.rating})`);
+        const reportChunks = [];
+        for (let i = 0; i < formattedEntries.length; i += 3) reportChunks.push(formattedEntries.slice(i, i + 3).join("|"));
+        let report = `${statusToQuery === "pending" ? "待审核" : ""}回声洞评分排行:
+`;
+        report += reportChunks.join("\n");
+        return report.trim();
+      } catch (error) {
+        this.logger.error("查询评分排行失败:", error);
+        return `查询失败: ${error.message}`;
+      }
+    });
+  }
+  /**
+   * @description 检查新内容是否与数据库中已存在的回声洞重复。
+   * @param {CaveMetaObject} newAnalysis - 新内容经过 AI 分析后的元数据。
+   * @param {CaveObject} newCave - 待检查的新回声洞的完整对象。
+   * @returns {Promise<number[]>} - 一个 Promise，解析为重复的回声洞 ID 数组。如果不重复或检查失败，则为空数组。
+   */
+  async checkForDuplicates(newAnalysis, newCave) {
+    try {
+      if (!newAnalysis || !newAnalysis.type) return [];
+      const allNewTags = [newAnalysis.type, ...newAnalysis.keywords || []];
+      if (allNewTags.length === 1 && !allNewTags[0]) return [];
+      const allMeta = await this.ctx.database.get("cave_meta", { type: newAnalysis.type }, { fields: ["cave", "type", "keywords"] });
+      const similarCaveIds = allMeta.filter((meta) => {
+        if (meta.cave === newCave.id) return false;
+        const existingTags = [meta.type, ...meta.keywords || []];
+        return this.calculateSimilarity(allNewTags, existingTags) >= 66;
+      }).map((meta) => meta.cave);
+      if (similarCaveIds.length === 0) return [];
+      const potentialDuplicates = await this.ctx.database.get("cave", { id: { $in: similarCaveIds } });
+      if (potentialDuplicates.length === 0) return [];
+      return await this.IsDuplicate(newCave, potentialDuplicates);
+    } catch (error) {
+      this.logger.error("查重回声洞出错:", error);
+      return [];
+    }
+  }
+  /**
+   * @description 对一个或多个回声洞内容进行 AI 分析。
+   * @param {CaveObject[]} caves - 需要分析的回声洞对象数组。
+   * @param {{ fileName: string; buffer: Buffer }[]} [mediaBuffers] - 可选的媒体文件缓存。
+   * @returns {Promise<CaveMetaObject[]>} - 一个 Promise，解析为分析结果（\`CaveMetaObject\`）的数组。
+   */
+  async analyze(caves, mediaBuffers) {
+    const analysisPromises = caves.map(async (cave) => {
+      try {
+        const contentForAI = await this.prepareContent(cave, mediaBuffers ? new Map(mediaBuffers.map((m) => [m.fileName, m.buffer])) : void 0);
+        if (!contentForAI) return null;
+        const userMessage = { role: "user", content: contentForAI };
+        const response = await this.requestAI([userMessage], `${this.ANALYSIS_SYSTEM_PROMPT}
+${this.config.systemPrompt}`);
+        if (response) {
+          return {
+            cave: cave.id,
+            rating: Math.max(0, Math.min(100, response.rating || 0)),
+            type: response.type || "",
+            keywords: response.keywords || []
+          };
+        }
+        return null;
+      } catch (error) {
+        this.logger.error(`分析回声洞（${cave.id}）失败:`, error);
+        return null;
+      }
+    });
+    const results = await Promise.all(analysisPromises);
+    return results.filter((result) => !!result);
+  }
+  /**
+   * @description 准备单个回声洞的内容（文本和图片）以供 AI 模型处理。
+   * @param {CaveObject} cave - 要处理的回声洞对象。
+   * @param {Map<string, Buffer>} [mediaMap] - 媒体文件的缓存 Map。
+   * @returns {Promise<any[] | null>} - 一个 Promise，解析为适合 AI 请求的 content 数组，如果回声洞为空则返回 null。
+   */
+  async prepareContent(cave, mediaMap) {
+    const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join("\n");
+    const imageElements = await Promise.all(
+      cave.elements.filter((el) => el.type === "image" && el.file).map(async (el) => {
+        try {
+          const buffer = mediaMap?.get(el.file) ?? await this.fileManager.readFile(el.file);
+          const mimeType = path3.extname(el.file).toLowerCase() === ".png" ? "image/png" : "image/jpeg";
+          return { type: "image_url", image_url: { url: `data:${mimeType};base64,${buffer.toString("base64")}` } };
+        } catch (error) {
+          this.logger.warn(`读取文件（${el.file}）失败:`, error);
+          return null;
+        }
+      })
+    );
+    const images = imageElements.filter(Boolean);
+    if (!combinedText.trim() && images.length === 0) return null;
+    const contentForAI = [];
+    if (combinedText.trim()) contentForAI.push({ type: "text", text: `${combinedText}` });
+    contentForAI.push(...images);
+    return contentForAI;
+  }
+  /**
+   * @description 使用 AI 批量判断一个主要回声洞是否与一组候选回声洞中的任何一个重复。
+   * @param {CaveObject} mainCave - 主要的回声洞。
+   * @param {CaveObject[]} candidateCaves - 用于比较的候选回声洞数组。
+   * @returns {Promise<number[]>} - 一个 Promise，解析为重复的回声洞 ID 数组。如果不重复或检查失败，则为空数组。
+   */
+  async IsDuplicate(mainCave, candidateCaves) {
+    try {
+      const formatContent = /* @__PURE__ */ __name((elements) => elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" "), "formatContent");
+      const newContentText = formatContent(mainCave.elements);
+      const candidatesText = candidateCaves.map((cave) => `{"id": ${cave.id}, "text": "${formatContent(cave.elements).replace(/"/g, '\\"')}"}`).join("\n");
+      const userMessageContent = `新内容:
+${newContentText}
+候选内容:
+${candidatesText}`;
+      const userMessage = { role: "user", content: JSON.stringify(userMessageContent) };
+      const response = await this.requestAI([userMessage], this.DUPLICATE_SYSTEM_PROMPT);
+      return response || [];
+    } catch (error) {
+      this.logger.error(`比较回声洞（${mainCave.id}）失败:`, error);
+      return [];
+    }
+  }
+  /**
+   * @description 计算两组关键词之间的相似度（Jaccard 相似系数）。
+   * @param {string[]} keywordsA - 第一组关键词。
+   * @param {string[]} keywordsB - 第二组关键词。
+   * @returns {number} - 返回 0 到 100 之间的相似度百分比。
+   */
+  calculateSimilarity(keywordsA, keywordsB) {
+    if (!keywordsA?.length || !keywordsB?.length) return 0;
+    const setA = new Set(keywordsA);
+    const setB = new Set(keywordsB);
+    const intersection = new Set([...setA].filter((x) => setB.has(x)));
+    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+    return union.size > 0 ? intersection.size / union.size * 100 : 0;
+  }
+  /**
+   * @description 向配置的 AI 服务端点发送请求的通用方法。
+   * @template T - 期望从 AI 响应中解析出的 JSON 对象的类型。
+   * @param {any[]} messages - 发送给 AI 的消息数组。
+   * @param {string} systemPrompt - 系统提示词。
+   * @returns {Promise<T>} - 一个 Promise，解析为从 AI 响应中解析出的 JSON 对象。
+   * @throws {Error} - 如果 AI 服务持续失败或响应无法解析，则抛出错误。
+   */
+  async requestAI(messages, systemPrompt) {
+    const now = Date.now();
+    if (now < this.retryTime) {
+      const waitTime = this.retryTime - now;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    const endpointConfig = this.config.endpoints[this.endpointIndex];
+    this.endpointIndex = (this.endpointIndex + 1) % this.config.endpoints.length;
+    const payload = { model: endpointConfig.model, messages: [{ role: "system", content: systemPrompt }, ...messages] };
+    const fullUrl = `${endpointConfig.url.replace(/\/$/, "")}/chat/completions`;
+    const headers = { "Content-Type": "application/json", "Authorization": `Bearer ${endpointConfig.key}` };
+    let response;
+    try {
+      response = await this.http.post(fullUrl, payload, { headers, timeout: 6e5 });
+    } catch (httpError) {
+      this.retryTime = Date.now() + 3e4;
+      throw httpError;
+    }
+    try {
+      const content = response?.choices?.[0]?.message?.content;
+      if (!content?.trim()) throw new Error();
+      const potentialStrings = /* @__PURE__ */ new Set();
+      const jsonBlockMatch = content.match(/```json\s*([\s\S]*?)\s*```/i);
+      if (jsonBlockMatch?.[1]) potentialStrings.add(jsonBlockMatch[1]);
+      const firstBrace = content.indexOf("{");
+      const lastBrace = content.lastIndexOf("}");
+      const firstBracket = content.indexOf("[");
+      const lastBracket = content.lastIndexOf("]");
+      if (firstBrace !== -1 && (firstBracket === -1 || firstBrace < firstBracket)) {
+        if (lastBrace > firstBrace) potentialStrings.add(content.substring(firstBrace, lastBrace + 1));
+      } else if (firstBracket !== -1) {
+        if (lastBracket > firstBracket) potentialStrings.add(content.substring(firstBracket, lastBracket + 1));
+      }
+      potentialStrings.add(content);
+      for (const jsonString of potentialStrings) {
+        try {
+          const result = JSON.parse(jsonString);
+          this.retryTime = 0;
+          return result;
+        } catch (e) {
+        }
+      }
+      throw new Error();
+    } catch (parsingError) {
+      this.logger.error("解析失败:", JSON.stringify(response, null, 2));
+      throw parsingError;
+    }
+  }
+};
+
+// src/index.ts
+var name = "best-cave";
+var inject = ["database"];
+var usage = `
+<div style="border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+  <h2 style="margin-top: 0; color: #4a6ee0;">📌 插件说明</h2>
+  <p>📖 <strong>使用文档</strong>：请点击左上角的 <strong>插件主页</strong> 查看插件使用文档</p>
+  <p>🔍 <strong>更多插件</strong>：可访问 <a href="https://github.com/YisRime" style="color:#4a6ee0;text-decoration:none;">苡淞的 GitHub</a> 查看本人的所有插件</p>
+</div>
+<div style="border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
+  <h2 style="margin-top: 0; color: #e0574a;">❤️ 支持与反馈</h2>
+  <p>🌟 喜欢这个插件？请在 <a href="https://github.com/YisRime" style="color:#e0574a;text-decoration:none;">GitHub</a> 上给我一个 Star！</p>
+  <p>🐛 遇到问题？请通过 <strong>Issues</strong> 提交反馈，或加入 QQ 群 <a href="https://qm.qq.com/q/PdLMx9Jowq" style="color:#e0574a;text-decoration:none;"><strong>855571375</strong></a> 进行交流</p>
+</div>
+`;
+var DEFAULT_PROMPT = `1."rating" (整数): 对内容进行公正客观的评分，以下为评分标准:
+从以下维度分别评分，每项0-10分，总分为各项之和，最高100分。
+  - 原创性: 评估内容的创意和独特性。
+    - 8-10分: 完全原创的梗或高质量的二次创作，展现出独特的巧思。
+    - 4-7分: 对现有梗或模板进行了巧妙的改造或融合，赋予了新的趣味。
+    - 0-3分: 简单套用常见模板，或是陈旧内容的再利用，甚至完全照搬。
+  - 内容价值: 评估内容所蕴含的幽默、情感或信息价值。
+    - 8-10分: 能引发强烈共鸣或深度思考，具有极高的娱乐性或启发性。
+    - 4-7分: 幽默感强，能让人会心一笑，或是在特定圈层中具有高度相关性。
+    - 0-3分: 内容平淡，笑点模糊，难以引起共鸣，甚至内容空洞、无意义。
+  - 视觉呈现: 评估图像的质量和元素的协调性。
+    - 8-10分: 构图、P图技术或截图时机堪称完美，视觉元素清晰且极具表现力。
+    - 4-7分: 图像清晰，元素搭配得当，能有效服务于主题表达，但存在轻微瑕疵。
+    - 0-3分: 图像模糊、分辨率低，或视觉元素严重影响观感，甚至完全无法辨认。
+  - 文本功底: 评估内容中的文字表达能力。不包含任何文本元素时，此项计为5分。
+    - 8-10分: 文字精炼、幽默且一语中的，与图片配合天衣无缝。
+    - 4-7分: 文字通顺，能准确表达核心笑点或信息，但可能略显啰嗦。
+    - 0-3分: 文字表达不清，存在语病，或与图片关联性不强。
+  - 传播潜力: 评估内容被二次创作、分享和讨论的可能性。
+    - 8-10分: “梗”感十足，极易引发模仿、分享和病毒式传播。
+    - 4-7分: 具有成为热点的潜质，易于在社交圈内传播和讨论。
+    - 0-3分: 内容过于小众，难以被大众理解，无法引发分享意愿。
+  - 娱乐效果: 评估内容的趣味性和吸引力。
+    - 8-10分: 极度搞笑或有趣，能立刻吸引用户注意力并带来愉悦感。
+    - 4-7分: 具有明显的笑点或趣味性，能有效调动观看者情绪。
+    - 0-3分: 趣味性较弱，难以引人发笑或产生兴趣，甚至枯燥乏味。
+  - 逻辑清晰: 评估内容的叙事或表达是否连贯易懂。
+    - 8-10分: 无论是笑话、故事还是玩梗，逻辑都非常清晰，核心意图一目了然。
+    - 4-7分: 内容主旨明确，大部分人都能轻松理解其意图，但存在细节上的模糊。
+    - 0-3分: 逻辑混乱，表达不知所云，需要费力猜测其含义，甚至完全没有逻辑。
+  - 制作完善: 评估内容的完整度和精良程度。
+    - 8-10分: 无论是P图还是对话截图，细节处理到位，内容完整精致。
+    - 4-7分: 内容主体完整，但在细节上（如裁剪、打码）存在瑕疵。
+    - 0-3分: 内容残缺不全，或制作粗糙，有明显的未完成感。
+  - 内容导向: 评估内容是否积极健康。
+    - 8-10分: 内容积极向上，或为中性、善意的幽默。
+    - 4-7分: 内容中性，不包含明显的价值观偏向。
+    - 0-3分: 包含有冒犯性的元素，甚至宣扬不良价值观。
+  - 内容合规: 评估内容是否符合规范。
+    - 10分: 内容符合法律法规和道德规范，适合大众阅读。
+    - 0分: 包含广告、引流、令人不适、争议性等NSFW内容。
+2."type" (字符串): 对内容进行准确且规范的分类，以下为分类规范:
+  - Game: 与电子游戏直接相关或源自于电子游戏的内容。
+  - ACG: 与动漫、漫画及广义二次元文化紧密相关的内容。
+  - Internet: 源于互联网的流行文化、迷因或社群现象。
+  - Reality: 取材于现实世界的日常经验和场景的内容。
+  - Creative: 具有原创性、艺术性或巧妙构思的内容。
+  - Other: 不适合归入以上任何一类的无关或小众内容。
+3."keywords" (字符串数组): 从内容中直接提取具体且全面的关键词，以下为提取准则:
+  - 必须源自可直接识别的文字与元素，仅在无可识别内容时才可使用描述性关键词说明。
+  - 要求需通过多维度准确定义内容，且必须规范、简短，禁止使用组合词与分类性词汇`;
+var logger = new import_koishi3.Logger("best-cave");
+var Config = import_koishi3.Schema.intersect([
+  import_koishi3.Schema.object({
+    perChannel: import_koishi3.Schema.boolean().default(false).description("启用分群模式"),
+    enableName: import_koishi3.Schema.boolean().default(false).description("启用自定义昵称"),
+    enableIO: import_koishi3.Schema.boolean().default(false).description("启用导入导出"),
+    adminChannel: import_koishi3.Schema.string().default("onebot:").description("管理群组 ID"),
+    caveFormat: import_koishi3.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本（参见 README）")
+  }).description("基础配置"),
+  import_koishi3.Schema.object({
+    enablePend: import_koishi3.Schema.boolean().default(false).description("启用审核"),
+    enableSimilarity: import_koishi3.Schema.boolean().default(false).description("启用查重"),
+    textThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("文本相似度阈值 (%)"),
+    imageThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("图片相似度阈值 (%)")
+  }).description("复核配置"),
+  import_koishi3.Schema.object({
+    enableAI: import_koishi3.Schema.boolean().default(false).description("启用 AI"),
+    enableApprove: import_koishi3.Schema.boolean().default(false).description("启用自动审核"),
+    onAIReviewFail: import_koishi3.Schema.boolean().default(true).description("拒绝时转人工"),
+    approveThreshold: import_koishi3.Schema.number().min(0).max(100).step(1).default(60).description("评分阈值"),
+    endpoints: import_koishi3.Schema.array(import_koishi3.Schema.object({
+      url: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link").required(),
+      key: import_koishi3.Schema.string().description("密钥 (API Key)").role("secret"),
+      model: import_koishi3.Schema.string().description("模型 (Model)").required()
+    })).description("端点列表").role("table"),
+    systemPrompt: import_koishi3.Schema.string().role("textarea").default(DEFAULT_PROMPT).description("系统提示词")
+  }).description("模型配置"),
+  import_koishi3.Schema.object({
+    localPath: import_koishi3.Schema.string().description("文件映射路径"),
+    enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
+    publicUrl: import_koishi3.Schema.string().description("公共访问 URL").role("link"),
+    endpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link"),
+    bucket: import_koishi3.Schema.string().description("存储桶 (Bucket)"),
+    region: import_koishi3.Schema.string().default("auto").description("区域 (Region)"),
+    accessKeyId: import_koishi3.Schema.string().description("Access Key ID").role("secret"),
+    secretAccessKey: import_koishi3.Schema.string().description("Secret Access Key").role("secret")
+  }).description("存储配置")
+]);
+async function cleanupCaves(ctx, fileManager, reusableIds, config, logger2, cavesToCleanup) {
+  if (cavesToCleanup.length === 0) return;
+  try {
+    const idsToDelete = cavesToCleanup.map((c) => c.id);
+    for (const cave of cavesToCleanup) await Promise.all(cave.elements.filter((el) => el.file).map((el) => fileManager.deleteFile(el.file)));
+    reusableIds.delete(0);
+    idsToDelete.forEach((id) => reusableIds.add(id));
+    await ctx.database.remove("cave", { id: { $in: idsToDelete } });
+    if (config.enableSimilarity) await ctx.database.remove("cave_hash", { cave: { $in: idsToDelete } });
+    if (config.enableAI) await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
+  } catch (error) {
+    logger2.error("清理回声洞出错:", error);
+  }
+}
+__name(cleanupCaves, "cleanupCaves");
+function apply(ctx, config) {
+  ctx.model.extend("cave", {
+    id: "unsigned",
+    elements: "json",
+    channelId: "string",
+    userId: "string",
+    userName: "string",
+    status: "string",
+    time: "timestamp"
+  }, {
+    primary: "id",
+    indexes: ["status", "channelId", "userId"]
+  });
+  const fileManager = new FileManager(ctx.baseDir, config, logger);
+  const reusableIds = /* @__PURE__ */ new Set();
+  const profileManager = config.enableName ? new NameManager(ctx) : null;
+  const reviewManager = config.enablePend ? new PendManager(ctx, config, fileManager, logger) : null;
+  const hashManager = config.enableSimilarity ? new HashManager(ctx, config, logger, fileManager) : null;
+  const dataManager = config.enableIO ? new DataManager(ctx, config, fileManager, logger) : null;
+  const aiManager = config.enableAI ? new AIManager(ctx, config, logger, fileManager) : null;
+  const cleanupInterval = ctx.setInterval(async () => {
+    const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
+    await cleanupCaves(ctx, fileManager, reusableIds, config, logger, cavesToDelete);
+  }, 60 * 60 * 1e3);
+  ctx.on("dispose", async () => {
+    cleanupInterval();
+    const cavesMarkedForDelete = await ctx.database.get("cave", { status: "delete" });
+    const stalePreloadCaves = await ctx.database.get("cave", { status: "preload" });
+    const allCavesToCleanup = [...cavesMarkedForDelete, ...stalePreloadCaves];
+    await cleanupCaves(ctx, fileManager, reusableIds, config, logger, allCavesToCleanup);
+  });
+  const cave = ctx.command("cave", "回声洞").option("add", "-a [content:text] 添加回声洞").option("view", "-g [id:posint] 查看指定回声洞").option("delete", "-r [ids:text] 删除指定回声洞").option("list", "-l 查询投稿统计").usage("随机抽取一条已添加的回声洞。").action(async ({ session, options }) => {
+    if (options.add) return session.execute(`cave.add ${options.add}`);
+    if (options.view) return session.execute(`cave.view ${options.view}`);
+    if (options.delete) return session.execute(`cave.del ${options.delete}`);
+    if (options.list) return session.execute("cave.list");
+    try {
+      const query = config.perChannel && session.channelId ? { status: "active", channelId: session.channelId } : { status: "active" };
+      const candidates = await ctx.database.get("cave", query, { fields: ["id"] });
+      if (!candidates.length) return `当前${config.perChannel && session.channelId ? "本群" : ""}还没有任何回声洞`;
+      const randomId = candidates[Math.floor(Math.random() * candidates.length)].id;
+      const [randomCave] = await ctx.database.get("cave", { ...query, id: randomId });
+      await sendCave(session, randomCave, config, fileManager, logger);
+    } catch (error) {
+      logger.error("随机获取回声洞失败:", error);
+      return "随机获取回声洞失败";
+    }
+  });
+  cave.subcommand(".add [content:text]", "添加回声洞").usage("添加一条回声洞。可直接发送内容，也可回复或引用消息。").action(async ({ session }, content) => {
+    let sourceElements;
+    if (session.quote?.elements) {
+      sourceElements = session.quote.elements;
+    } else if (content?.trim()) {
+      sourceElements = import_koishi3.h.parse(content);
+    } else {
+      await session.send("请在一分钟内发送你要添加的内容");
+      const reply = await session.prompt(6e4);
+      if (!reply) return "等待操作超时";
+      sourceElements = import_koishi3.h.parse(reply);
+    }
+    const newId = await getNextCaveId(ctx, reusableIds);
+    const creationTime = /* @__PURE__ */ new Date();
+    const { finalElementsForDb, mediaToSave } = await processMessageElements(sourceElements, newId, session, creationTime);
+    if (finalElementsForDb.length === 0) return "无可添加内容";
+    const userName = (config.enableName && profileManager ? await profileManager.getNickname(session.userId) : null) || session.username;
+    const newCave = { id: newId, elements: finalElementsForDb, channelId: session.channelId, userId: session.userId, userName, status: "preload", time: creationTime };
+    await ctx.database.create("cave", newCave);
+    const needsReviewImmediately = config.enablePend && session.cid !== config.adminChannel;
+    session.send(needsReviewImmediately ? `提交成功，序号为（${newCave.id}）` : `添加成功，序号为（${newCave.id}）`);
+    processNewCave(ctx, config, fileManager, logger, reusableIds, newCave, session, mediaToSave, hashManager, aiManager, reviewManager);
+  });
+  cave.subcommand(".view <id:posint>", "查看指定回声洞").action(async ({ session }, id) => {
+    if (!id) return "请输入要查看的回声洞序号";
+    try {
+      const scopeQuery = config.perChannel && session.channelId ? { status: "active", channelId: session.channelId } : { status: "active" };
+      const [targetCave] = await ctx.database.get("cave", { ...scopeQuery, id });
+      if (!targetCave) return `回声洞（${id}）不存在`;
+      await sendCave(session, targetCave, config, fileManager, logger);
+    } catch (error) {
+      logger.error(`查看回声洞（${id}）失败:`, error);
+      return "查看失败，请稍后再试";
+    }
+  });
+  cave.subcommand(".del [...ids:string]", "删除指定回声洞").usage("删除一个或多个指定序号的回声洞，序号之间以空格或 | 分隔。").action(async ({ session }, ...args) => {
+    const { ids, invalid } = parseCaveIds(args);
+    if (ids.length === 0 && invalid.length === 0) return "请输入要删除的回声洞序号";
+    try {
+      const isAdmin = session.cid === config.adminChannel;
+      const targetCaves = ids.length === 0 ? [] : await ctx.database.get("cave", { id: { $in: ids }, status: "active" });
+      const cavesToDelete = isAdmin ? targetCaves : targetCaves.filter((cave2) => cave2.userId === session.userId);
+      const deletableIds = new Set(cavesToDelete.map((cave2) => cave2.id));
+      const processedIds = ids.filter((id) => deletableIds.has(id));
+      if (processedIds.length === 0) return `回声洞（${[...invalid, ...ids].join("|")}）不存在`;
+      await ctx.database.upsert("cave", processedIds.map((id) => ({ id, status: "delete" })));
+      const notes = [];
+      const orderedCaves = processedIds.map((id) => cavesToDelete.find((cave2) => cave2.id === id));
+      if (orderedCaves.length === 1) {
+        await sendCave(session, orderedCaves[0], config, fileManager, logger, "已删除");
+      } else if (session.platform === "qq") {
+        for (const cave2 of orderedCaves) await sendCave(session, cave2, config, fileManager, logger, "已删除");
+      } else {
+        const groupedMessages = await Promise.all(orderedCaves.map(async (cave2) => {
+          const caveMessages = await buildCaveMessage(cave2, config, fileManager, logger, session.platform, "已删除");
+          const content = caveMessages.filter((message) => message.length > 0).flatMap((message) => import_koishi3.h.normalize(message));
+          if (content.length === 0) return null;
+          return (0, import_koishi3.h)("message", {}, [(0, import_koishi3.h)("author", { id: cave2.userId, name: cave2.userName }), ...content]);
+        }));
+        await session.send((0, import_koishi3.h)("message", { forward: true }, groupedMessages.filter(Boolean)));
+      }
+      const missedIds = [...invalid, ...ids.filter((id) => !processedIds.includes(id))];
+      if (missedIds.length > 0) notes.push(`回声洞（${missedIds.join("|")}）不存在`);
+      if (notes.length > 0) return notes.join("\n");
+    } catch (error) {
+      logger.error(`标记回声洞（${args.join("|")}）失败:`, error);
+      return "删除失败，请稍后再试";
+    }
+  });
+  cave.subcommand(".list", "查询投稿统计").usage("查询排行或指定用户的回声洞统计。").option("user", "-u <user:user> 指定用户").option("all", "-a 查看排行").action(async ({ session, options }) => {
+    if (options.all) {
+      if (session.cid !== config.adminChannel) return "此指令仅限在管理群组中使用";
+      try {
+        const aggregatedStats = await ctx.database.select("cave", { status: "active" }).groupBy(["userId", "userName"], { count: /* @__PURE__ */ __name((row) => import_koishi3.$.count(row.id), "count") }).execute();
+        if (!aggregatedStats.length) return "目前没有回声洞投稿";
+        const userStats = /* @__PURE__ */ new Map();
+        for (const stat of aggregatedStats) {
+          const existing = userStats.get(stat.userId);
+          if (existing) {
+            existing.count += stat.count;
+            const existingGroup = aggregatedStats.find((s) => s.userId === stat.userId && s.userName === existing.userName);
+            if (stat.count > (existingGroup?.count || 0)) existing.userName = stat.userName;
+          } else {
+            userStats.set(stat.userId, { userName: stat.userName, count: stat.count });
+          }
+        }
+        const sortedStats = Array.from(userStats.values()).sort((a, b) => b.count - a.count);
+        let report = "回声洞投稿数量排行：\n";
+        sortedStats.forEach((stat, index) => {
+          report += `${index + 1}. ${stat.userName}: ${stat.count} 条
+`;
+        });
+        return report.trim();
+      } catch (error) {
+        logger.error("查询排行失败:", error);
+        return "查询失败，请稍后再试";
+      }
+    }
+    const targetUserId = options.user || session.userId;
+    const isQueryingSelf = !options.user;
+    const scopeQuery = config.perChannel && session.channelId ? { status: "active", channelId: session.channelId } : { status: "active" };
+    const query = { ...scopeQuery, userId: targetUserId };
+    const userCaves = await ctx.database.get("cave", query);
+    if (!userCaves.length) return isQueryingSelf ? "你还没有投稿过回声洞" : `用户 ${targetUserId} 还没有投稿过回声洞`;
+    const caveIds = userCaves.map((c) => c.id).sort((a, b) => a - b).join("|");
+    const userName = userCaves.sort((a, b) => b.time.getTime() - a.time.getTime())[0].userName;
+    return `${isQueryingSelf ? "你" : userName}已投稿 ${userCaves.length} 条回声洞，序号为：
+${caveIds}`;
+  });
+  if (profileManager) profileManager.registerCommands(cave);
+  if (dataManager) dataManager.registerCommands(cave);
+  if (reviewManager) reviewManager.registerCommands(cave);
+  if (hashManager) hashManager.registerCommands(cave);
+  if (aiManager) aiManager.registerCommands(cave);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name,
+  usage
+});