koishi-plugin-best-cave 1.4.0 → 1.5.0

package/lib/index.js

@@ -33,14 +33,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/locales/zh-CN.yml
 var require_zh_CN = __commonJS({
   "src/locales/zh-CN.yml"(exports2, module2) {
-    module2.exports = { _config: { manager: "管理员", number: "冷却时间（秒）", enableAudit: "启用审核", imageMaxSize: "图片最大大小（MB）", enableMD5: "启用MD5查重", enableDuplicate: "启用pHash查重", duplicateThreshold: "pHash相似度阈值（0-1）", allowVideo: "允许视频上传", videoMaxSize: "视频最大大小（MB）", enablePagination: "启用统计分页", itemsPerPage: "每页显示数目", blacklist: "黑名单（用户）", whitelist: "审核白名单（用户/群组/频道）" }, commands: { cave: { description: "回声洞", usage: "支持添加、抽取、查看、管理回声洞", examples: "使用 cave 随机抽取回声洞\n使用 -a 直接添加或引用添加\n使用 -g 查看指定回声洞\n使用 -r 删除指定回声洞", options: { a: "添加回声洞", g: "查看回声洞", r: "删除回声洞", p: "通过审核（批量）", d: "拒绝审核（批量）", l: "查询投稿统计" }, add: { noContent: "请在一分钟内发送内容", operationTimeout: "操作超时，添加取消", videoDisabled: "不允许上传视频", submitPending: "提交成功，序号为（{0}）", addSuccess: "添加成功，序号为（{0}）", mediaSizeExceeded: "{0}文件大小超过限制", localFileNotAllowed: "检测到本地文件路径，无法保存" }, remove: { noPermission: "你无权删除他人添加的回声洞", deletePending: "删除（待审核）", deleted: "已删除" }, list: { pageInfo: "第 {0} / {1} 页", header: "当前共有 {0} 项回声洞：", totalItems: "用户 {0} 共计投稿 {1} 项：", idsLine: "{0}" }, audit: { noPending: "暂无待审核回声洞", pendingNotFound: "未找到待审核回声洞", pendingResult: "{0}，剩余 {1} 个待审核回声洞：[{2}]", auditPassed: "已通过", auditRejected: "已拒绝", batchAuditResult: "已{0} {1}/{2} 项回声洞", title: "待审核回声洞：", from: "投稿人：", sendFailed: "发送审核消息失败，无法联系管理员 {0}" }, error: { noContent: "回声洞内容为空", getCave: "获取回声洞失败", noCave: "没有回声洞", invalidId: "请输入有效的回声洞ID", notFound: "未找到该回声洞", exactDuplicateFound: "发现完全相同的", similarDuplicateFound: "发现相似度为 {0}% 的" }, message: { blacklisted: "你已被列入黑名单", managerOnly: "此操作仅限管理员可用", cooldown: "群聊冷却中...请在 {0} 秒后重试", caveTitle: "回声洞 —— （{0}）", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0}文件大小超过限制" } } } };
+    module2.exports = { _config: { manager: "管理员", number: "冷却时间（秒）", enableAudit: "启用审核", enableTextDuplicate: "启用文本查重", textDuplicateThreshold: "文本相似度阈值（0-1）", enableImageDuplicate: "启用图片查重", imageDuplicateThreshold: "图片相似度阈值（0-1）", imageMaxSize: "图片最大大小（MB）", allowVideo: "允许视频上传", videoMaxSize: "视频最大大小（MB）", enablePagination: "启用统计分页", itemsPerPage: "每页显示数目", blacklist: "黑名单（用户）", whitelist: "审核白名单（用户/群组/频道）" }, commands: { cave: { description: "回声洞", usage: "支持添加、抽取、查看、管理回声洞", examples: "使用 cave 随机抽取回声洞\n使用 -a 直接添加或引用添加\n使用 -g 查看指定回声洞\n使用 -r 删除指定回声洞", options: { a: "添加回声洞", g: "查看回声洞", r: "删除回声洞", p: "通过审核（批量）", d: "拒绝审核（批量）", l: "查询投稿统计" }, add: { noContent: "请在一分钟内发送内容", operationTimeout: "操作超时，添加取消", videoDisabled: "不允许上传视频", submitPending: "提交成功，序号为（{0}）", addSuccess: "添加成功，序号为（{0}）", mediaSizeExceeded: "{0}文件大小超过限制", localFileNotAllowed: "检测到本地文件路径，无法保存" }, remove: { noPermission: "你无权删除他人添加的回声洞", deletePending: "删除（待审核）", deleted: "已删除" }, list: { pageInfo: "第 {0} / {1} 页", header: "当前共有 {0} 项回声洞：", totalItems: "用户 {0} 共计投稿 {1} 项：", idsLine: "{0}" }, audit: { noPending: "暂无待审核回声洞", pendingNotFound: "未找到待审核回声洞", pendingResult: "{0}，剩余 {1} 个待审核回声洞：[{2}]", auditPassed: "已通过", auditRejected: "已拒绝", batchAuditResult: "已{0} {1}/{2} 项回声洞", title: "待审核回声洞：", from: "投稿人：", sendFailed: "发送审核消息失败，无法联系管理员 {0}" }, error: { noContent: "回声洞内容为空", getCave: "获取回声洞失败", noCave: "没有回声洞", invalidId: "请输入有效的回声洞ID", notFound: "未找到该回声洞", exactDuplicateFound: "发现完全相同的", similarDuplicateFound: "发现相似度为 {0}% 的", addFailed: "添加失败，请稍后重试。" }, message: { blacklisted: "你已被列入黑名单", managerOnly: "此操作仅限管理员可用", cooldown: "群聊冷却中...请在 {0} 秒后重试", caveTitle: "回声洞 —— （{0}）", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0}文件大小超过限制" } } } };
   }
 });
 
 // src/locales/en-US.yml
 var require_en_US = __commonJS({
   "src/locales/en-US.yml"(exports2, module2) {
-    module2.exports = { _config: { manager: "Administrator", number: "Cooldown time (seconds)", enableAudit: "Enable moderation", imageMaxSize: "Maximum image size (MB)", enableMD5: "Enable MD5 duplicate check", enableDuplicate: "Enable pHash duplicate check", duplicateThreshold: "pHash similarity threshold (0-1)", allowVideo: "Allow video upload", videoMaxSize: "Maximum video size (MB)", enablePagination: "Enable statistics pagination", itemsPerPage: "Items per page", blacklist: "Blacklist (users)", whitelist: "Moderation whitelist (users/groups/channels)" }, commands: { cave: { description: "Echo Cave", usage: "Support adding, drawing, viewing, and managing echo caves", examples: "Use cave to randomly draw an echo\nUse -a to add directly or add by reference\nUse -g to view specific echo\nUse -r to delete specific echo", options: { a: "Add echo", g: "View echo", r: "Delete echo", p: "Approve moderation (batch)", d: "Reject moderation (batch)", l: "Query submission statistics" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timeout, addition cancelled", videoDisabled: "Video upload not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Added successfully, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You don't have permission to delete others' echos", deletePending: "Delete (pending review)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "Currently there are {0} echos:", totalItems: "User {0} has submitted {1} items:", idsLine: "{0}" }, audit: { noPending: "No pending echos for review", pendingNotFound: "Pending echo not found", pendingResult: "{0}, {1} pending echos remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "{0} {1}/{2} echos", title: "Pending echos:", from: "Submitted by:", sendFailed: "Failed to send moderation message, cannot contact administrator {0}" }, error: { noContent: "Echo content is empty", getCave: "Failed to get echo", noCave: "No echos available", invalidId: "Please enter a valid echo ID", notFound: "Echo not found", exactDuplicateFound: "Found exactly identical", similarDuplicateFound: "Found {0}% similar" }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is limited to administrators only", cooldown: "Group chat cooling down... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
+    module2.exports = { _config: { manager: "Administrator", number: "Cooldown time (seconds)", enableAudit: "Enable moderation", enableTextDuplicate: "Enable text duplicate check", textDuplicateThreshold: "Text similarity threshold (0-1)", enableImageDuplicate: "Enable image duplicate check", imageDuplicateThreshold: "Image similarity threshold (0-1)", imageMaxSize: "Maximum image size (MB)", allowVideo: "Allow video upload", videoMaxSize: "Maximum video size (MB)", enablePagination: "Enable statistics pagination", itemsPerPage: "Items per page", blacklist: "Blacklist (users)", whitelist: "Moderation whitelist (users/groups/channels)" }, commands: { cave: { description: "Echo Cave", usage: "Support adding, drawing, viewing, and managing echo caves", examples: "Use cave to randomly draw an echo\nUse -a to add directly or add by reference\nUse -g to view specific echo\nUse -r to delete specific echo", options: { a: "Add echo", g: "View echo", r: "Delete echo", p: "Approve moderation (batch)", d: "Reject moderation (batch)", l: "Query submission statistics" }, add: { noContent: "Please send content within one minute", operationTimeout: "Operation timeout, addition cancelled", videoDisabled: "Video upload not allowed", submitPending: "Submission successful, ID is ({0})", addSuccess: "Added successfully, ID is ({0})", mediaSizeExceeded: "{0} file size exceeds limit", localFileNotAllowed: "Local file path detected, cannot save" }, remove: { noPermission: "You don't have permission to delete others' echos", deletePending: "Delete (pending review)", deleted: "Deleted" }, list: { pageInfo: "Page {0} / {1}", header: "Currently there are {0} echos:", totalItems: "User {0} has submitted {1} items:", idsLine: "{0}" }, audit: { noPending: "No pending echos for review", pendingNotFound: "Pending echo not found", pendingResult: "{0}, {1} pending echos remaining: [{2}]", auditPassed: "Approved", auditRejected: "Rejected", batchAuditResult: "{0} {1}/{2} echos", title: "Pending echos:", from: "Submitted by:", sendFailed: "Failed to send moderation message, cannot contact administrator {0}" }, error: { noContent: "Echo content is empty", getCave: "Failed to get echo", noCave: "No echos available", invalidId: "Please enter a valid echo ID", notFound: "Echo not found", exactDuplicateFound: "Found exactly identical", similarDuplicateFound: "Found {0}% similar", addFailed: "Add failed, please try again later." }, message: { blacklisted: "You have been blacklisted", managerOnly: "This operation is limited to administrators only", cooldown: "Group chat cooling down... Please try again in {0} seconds", caveTitle: "Echo Cave —— ({0})", contributorSuffix: "—— {0}", mediaSizeExceeded: "{0} file size exceeds limit" } } } };
   }
 });
 
@@ -53,11 +53,11 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi4 = require("koishi");
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var import_koishi5 = require("koishi");
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 
-// src/utils/fileHandler.ts
+// src/utils/FileHandle.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_koishi = require("koishi");
@@ -216,11 +216,11 @@ var FileHandler = class {
   }
 };
 
-// src/utils/idManager.ts
+// src/utils/IdManage.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var import_koishi2 = require("koishi");
-var logger2 = new import_koishi2.Logger("idManager");
+var logger2 = new import_koishi2.Logger("IdManager");
 var IdManager = class {
   static {
     __name(this, "IdManager");
@@ -288,11 +288,15 @@ var IdManager = class {
         ...status.deletedIds || [],
         0
       );
-      this.deletedIds = new Set(
-        status.deletedIds?.filter((id) => !this.usedIds.has(id)) || []
-      );
+      this.deletedIds = new Set(status.deletedIds || []);
+      for (let i = 1; i <= this.maxId; i++) {
+        if (!this.usedIds.has(i)) {
+          this.deletedIds.add(i);
+        }
+      }
       await this.saveStatus();
       this.initialized = true;
+      logger2.success(`Cave ID Manager initialized with ${this.maxId}(-${this.deletedIds.size}) IDs`);
     } catch (error) {
       this.initialized = false;
       logger2.error(`ID Manager initialization failed: ${error.message}`);
@@ -430,16 +434,16 @@ var IdManager = class {
   }
 };
 
-// src/utils/HashStorage.ts
+// src/utils/HashManage.ts
 var import_koishi3 = require("koishi");
 var fs3 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 
-// src/utils/ImageHasher.ts
+// src/utils/ContentHash.ts
 var import_sharp = __toESM(require("sharp"));
-var ImageHasher = class {
+var ContentHasher = class {
   static {
-    __name(this, "ImageHasher");
+    __name(this, "ContentHasher");
   }
   /**
    * 计算图片的感知哈希值
@@ -580,6 +584,21 @@ var ImageHasher = class {
     const distance = this.calculateDistance(hash1, hash2);
     return (64 - distance) / 64;
   }
+  /**
+   * 计算文本的哈希值
+   * @param text - 输入文本
+   * @returns 文本的哈希值(36进制字符串)
+   */
+  static calculateTextHash(text) {
+    const normalizedText = text.toLowerCase().trim().replace(/\s+/g, " ");
+    let hash = 0;
+    for (let i = 0; i < normalizedText.length; i++) {
+      const char = normalizedText.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
   /**
    * 批量比较一个新哈希值与多个已存在哈希值的相似度
    * @param newHash - 新的哈希值
@@ -591,93 +610,199 @@ var ImageHasher = class {
   }
 };
 
-// src/utils/HashStorage.ts
-var import_crypto = __toESM(require("crypto"));
-var logger3 = new import_koishi3.Logger("HashStorage");
-var HashStorage = class _HashStorage {
+// src/utils/HashManage.ts
+var import_util = require("util");
+var logger3 = new import_koishi3.Logger("HashManager");
+var readFileAsync = (0, import_util.promisify)(fs3.readFile);
+var ContentHashManager = class _ContentHashManager {
   /**
-   * 创建哈希存储实例
-   * @param caveDir - 回声洞数据目录路径
+   * 初始化HashManager实例
+   * @param caveDir 回声洞数据目录路径
    */
   constructor(caveDir) {
     this.caveDir = caveDir;
-    this.filePath = path3.join(caveDir, "hash.json");
-    this.resourceDir = path3.join(caveDir, "resources");
-    this.caveFilePath = path3.join(caveDir, "cave.json");
   }
   static {
-    __name(this, "HashStorage");
+    __name(this, "ContentHashManager");
   }
-  filePath;
-  resourceDir;
-  caveFilePath;
+  // 哈希数据文件名
+  static HASH_FILE = "hash.json";
+  // 回声洞数据文件名
+  static CAVE_FILE = "cave.json";
+  // 批处理大小
+  static BATCH_SIZE = 50;
+  // 存储回声洞ID到图片哈希值的映射
   imageHashes = /* @__PURE__ */ new Map();
   textHashes = /* @__PURE__ */ new Map();
+  // 初始化状态标志
   initialized = false;
+  get filePath() {
+    return path3.join(this.caveDir, _ContentHashManager.HASH_FILE);
+  }
+  get resourceDir() {
+    return path3.join(this.caveDir, "resources");
+  }
+  get caveFilePath() {
+    return path3.join(this.caveDir, _ContentHashManager.CAVE_FILE);
+  }
   /**
    * 初始化哈希存储
+   * 读取现有哈希数据或重新构建哈希值
    * @throws 初始化失败时抛出错误
    */
   async initialize() {
     if (this.initialized) return;
     try {
       const hashData = await FileHandler.readJsonData(this.filePath).then((data) => data[0]).catch(() => null);
-      if (!hashData?.imageHashes) {
+      if (!hashData?.imageHashes || !hashData?.textHashes || Object.keys(hashData.imageHashes).length === 0) {
+        this.imageHashes.clear();
+        this.textHashes.clear();
         await this.buildInitialHashes();
       } else {
-        this.loadHashData(hashData);
+        this.imageHashes = new Map(
+          Object.entries(hashData.imageHashes).map(([k, v]) => [Number(k), v])
+        );
+        this.textHashes = new Map(
+          Object.entries(hashData.textHashes).map(([k, v]) => [Number(k), v])
+        );
         await this.updateMissingHashes();
       }
+      const totalCaves = (/* @__PURE__ */ new Set([...this.imageHashes.keys(), ...this.textHashes.keys()])).size;
       this.initialized = true;
+      logger3.success(`Cave Hash Manager initialized with ${totalCaves} hashes`);
     } catch (error) {
-      logger3.error(`Hash storage initialization failed: ${error.message}`);
+      logger3.error(`Initialization failed: ${error.message}`);
+      this.initialized = false;
       throw error;
     }
   }
   /**
-   * 加载哈希数据
-   * @param data - 要加载的哈希数据
-   * @private
+   * 获取当前哈希存储状态
+   * @returns 包含最后更新时间和所有条目的状态对象
    */
-  loadHashData(data) {
-    this.imageHashes = new Map(Object.entries(data.imageHashes).map(([k, v]) => [Number(k), v]));
-    this.textHashes = new Map(Object.entries(data.textHashes || {}).map(([k, v]) => [Number(k), v]));
+  async getStatus() {
+    if (!this.initialized) await this.initialize();
+    return {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: Array.from(this.imageHashes.entries()).map(([caveId, imgHashes]) => ({
+        caveId,
+        imageHashes: imgHashes,
+        textHashes: this.textHashes.get(caveId) || []
+      }))
+    };
   }
   /**
-   * 更新指定回声洞的哈希值
-   * @param caveId - 回声洞ID
-   * @param type - 哈希类型（图像或文本）
-   * @param content - 要计算哈希的内容
+   * 更新指定回声洞的图片哈希值
+   * @param caveId 回声洞ID
+   * @param content 图片buffer数组
    */
-  async updateHash(caveId, type, content) {
+  async updateCaveContent(caveId, content) {
     if (!this.initialized) await this.initialize();
     try {
-      const hash = type === "image" ? await ImageHasher.calculateHash(content) : _HashStorage.hashText(content);
-      const hashMap = type === "image" ? this.imageHashes : this.textHashes;
-      const existingHashes = hashMap.get(caveId) || [];
-      hashMap.set(caveId, [...existingHashes, hash]);
-      await this.saveHashes();
+      if (content.images?.length) {
+        const imageHashes = await Promise.all(
+          content.images.map((buffer) => ContentHasher.calculateHash(buffer))
+        );
+        this.imageHashes.set(caveId, imageHashes);
+      }
+      if (content.texts?.length) {
+        const textHashes = content.texts.map((text) => ContentHasher.calculateTextHash(text));
+        this.textHashes.set(caveId, textHashes);
+      }
+      if (!content.images && !content.texts) {
+        this.imageHashes.delete(caveId);
+        this.textHashes.delete(caveId);
+      }
+      await this.saveContentHashes();
     } catch (error) {
-      logger3.error(`Failed to update ${type} hash for cave ${caveId}: ${error.message}`);
+      logger3.error(`Failed to update content hashes (cave ${caveId}): ${error.message}`);
     }
   }
   /**
-   * 查找重复项
-   * @param type - 查找类型（图像或文本）
-   * @param hashes - 要查找的哈希值数组
-   * @param threshold - 相似度阈值，默认为1
-   * @returns 匹配结果数组
+   * 更新所有回声洞的哈希值
+   * @param isInitialBuild 是否为初始构建
    */
-  async findDuplicates(type, hashes, threshold = 1) {
+  async updateAllCaves(isInitialBuild = false) {
+    if (!this.initialized && !isInitialBuild) {
+      await this.initialize();
+      return;
+    }
+    try {
+      logger3.info("Starting full hash update...");
+      const caveData = await this.loadCaveData();
+      const cavesWithImages = caveData.filter(
+        (cave) => cave.elements?.some((el) => el.type === "img" && el.file)
+      );
+      this.imageHashes.clear();
+      let processedCount = 0;
+      const totalImages = cavesWithImages.length;
+      const processCave = /* @__PURE__ */ __name(async (cave) => {
+        const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+        if (imgElements.length === 0) return;
+        try {
+          const hashes = await Promise.all(
+            imgElements.map(async (imgElement) => {
+              const filePath = path3.join(this.resourceDir, imgElement.file);
+              if (!fs3.existsSync(filePath)) {
+                logger3.warn(`Image file not found: ${filePath}`);
+                return null;
+              }
+              const imgBuffer = await readFileAsync(filePath);
+              return await ContentHasher.calculateHash(imgBuffer);
+            })
+          );
+          const validHashes = hashes.filter((hash) => hash !== null);
+          if (validHashes.length > 0) {
+            this.imageHashes.set(cave.cave_id, validHashes);
+            processedCount++;
+            if (processedCount % 100 === 0) {
+              logger3.info(`Progress: ${processedCount}/${totalImages}`);
+            }
+          }
+        } catch (error) {
+          logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+        }
+      }, "processCave");
+      await this.processBatch(cavesWithImages, processCave);
+      await this.saveContentHashes();
+      logger3.success(`Update completed. Processed ${processedCount}/${totalImages} images`);
+    } catch (error) {
+      logger3.error(`Full update failed: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 查找重复的图片
+   * @param content 待查找的图片buffer数组
+   * @param thresholds 相似度阈值
+   * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+   */
+  async findDuplicates(content, thresholds) {
     if (!this.initialized) await this.initialize();
-    const hashMap = type === "image" ? this.imageHashes : this.textHashes;
-    const calculateSimilarity = type === "image" ? ImageHasher.calculateSimilarity : (a, b) => a === b ? 1 : 0;
-    return hashes.map((hash, index) => {
+    const results = [];
+    if (content.images?.length) {
+      const imageResults = await this.findImageDuplicates(content.images, thresholds.image);
+      results.push(...imageResults.map(
+        (result) => result ? { ...result, type: "image" } : null
+      ));
+    }
+    if (content.texts?.length) {
+      const textResults = await this.findTextDuplicates(content.texts, thresholds.text);
+      results.push(...textResults.map(
+        (result) => result ? { ...result, type: "text" } : null
+      ));
+    }
+    return results;
+  }
+  async findTextDuplicates(texts, threshold) {
+    const inputHashes = texts.map((text) => ContentHasher.calculateTextHash(text));
+    const existingHashes = Array.from(this.textHashes.entries());
+    return inputHashes.map((hash, index) => {
       let maxSimilarity = 0;
       let matchedCaveId = null;
-      for (const [caveId, existingHashes] of hashMap.entries()) {
-        for (const existingHash of existingHashes) {
-          const similarity = calculateSimilarity(hash, existingHash);
+      for (const [caveId, hashes] of existingHashes) {
+        for (const existingHash of hashes) {
+          const similarity = this.calculateTextSimilarity(hash, existingHash);
           if (similarity >= threshold && similarity > maxSimilarity) {
             maxSimilarity = similarity;
             matchedCaveId = caveId;
@@ -686,37 +811,122 @@ var HashStorage = class _HashStorage {
         }
         if (maxSimilarity === 1) break;
       }
-      return matchedCaveId ? { index, caveId: matchedCaveId, similarity: maxSimilarity } : null;
+      return matchedCaveId ? {
+        index,
+        caveId: matchedCaveId,
+        similarity: maxSimilarity
+      } : null;
     });
   }
+  calculateTextSimilarity(hash1, hash2) {
+    if (hash1 === hash2) return 1;
+    const length = Math.max(hash1.length, hash2.length);
+    let matches = 0;
+    for (let i = 0; i < length; i++) {
+      if (hash1[i] === hash2[i]) matches++;
+    }
+    return matches / length;
+  }
+  // 重命名原有的图片哈希相关方法
+  async findImageDuplicates(images, threshold) {
+    if (!this.initialized) await this.initialize();
+    const inputHashes = await Promise.all(
+      images.map((buffer) => ContentHasher.calculateHash(buffer))
+    );
+    const existingHashes = Array.from(this.imageHashes.entries());
+    return Promise.all(
+      inputHashes.map(async (hash, index) => {
+        try {
+          let maxSimilarity = 0;
+          let matchedCaveId = null;
+          for (const [caveId, hashes] of existingHashes) {
+            for (const existingHash of hashes) {
+              const similarity = ContentHasher.calculateSimilarity(hash, existingHash);
+              if (similarity >= threshold && similarity > maxSimilarity) {
+                maxSimilarity = similarity;
+                matchedCaveId = caveId;
+                if (Math.abs(similarity - 1) < Number.EPSILON) break;
+              }
+            }
+            if (Math.abs(maxSimilarity - 1) < Number.EPSILON) break;
+          }
+          return matchedCaveId ? {
+            index,
+            caveId: matchedCaveId,
+            similarity: maxSimilarity
+          } : null;
+        } catch (error) {
+          logger3.warn(`处理图片 ${index} 失败: ${error.message}`);
+          return null;
+        }
+      })
+    );
+  }
   /**
-   * 清除指定回声洞的所有哈希值
-   * @param caveId - 回声洞ID
+   * 加载回声洞数据
+   * @returns 回声洞数据数组
+   * @private
    */
-  async clearHashes(caveId) {
-    if (!this.initialized) await this.initialize();
-    this.imageHashes.delete(caveId);
-    this.textHashes.delete(caveId);
-    await this.saveHashes();
+  async loadCaveData() {
+    const data = await FileHandler.readJsonData(this.caveFilePath);
+    return Array.isArray(data) ? data.flat() : [];
+  }
+  /**
+   * 保存哈希数据到文件
+   * @private
+   */
+  async saveContentHashes() {
+    const data = {
+      imageHashes: Object.fromEntries(this.imageHashes),
+      textHashes: Object.fromEntries(this.textHashes),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await FileHandler.writeJsonData(this.filePath, [data]);
   }
   /**
-   * 构建初始哈希值
+   * 构建初始哈希数据
    * @private
    */
   async buildInitialHashes() {
     const caveData = await this.loadCaveData();
     let processedCount = 0;
-    const total = caveData.length;
+    const totalCaves = caveData.length;
+    logger3.info(`Building hash data for ${totalCaves} caves...`);
     for (const cave of caveData) {
-      await this.processCaveHashes(cave);
-      await this.processCaveTextHashes(cave);
-      processedCount++;
-      if (processedCount % 100 === 0 || processedCount === total) {
-        logger3.info(`Processing caves: ${processedCount}/${total} (${Math.floor(processedCount / total * 100)}%)`);
+      try {
+        const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+        if (imgElements.length > 0) {
+          const hashes = await Promise.all(
+            imgElements.map(async (imgElement) => {
+              const filePath = path3.join(this.resourceDir, imgElement.file);
+              if (!fs3.existsSync(filePath)) {
+                logger3.warn(`Image not found: ${filePath}`);
+                return null;
+              }
+              const imgBuffer = await fs3.promises.readFile(filePath);
+              return await ContentHasher.calculateHash(imgBuffer);
+            })
+          );
+          const validHashes = hashes.filter((hash) => hash !== null);
+          if (validHashes.length > 0) {
+            this.imageHashes.set(cave.cave_id, validHashes);
+          }
+        }
+        const textElements = cave.elements?.filter((el) => el.type === "text" && el.content) || [];
+        if (textElements.length > 0) {
+          const textHashes = textElements.map((el) => ContentHasher.calculateTextHash(el.content));
+          this.textHashes.set(cave.cave_id, textHashes);
+        }
+        processedCount++;
+        if (processedCount % 100 === 0) {
+          logger3.info(`Progress: ${processedCount}/${totalCaves} caves`);
+        }
+      } catch (error) {
+        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
       }
     }
-    await this.saveHashes();
-    logger3.info(`Processed ${processedCount} caves with ${this.imageHashes.size} images and ${this.textHashes.size} texts`);
+    await this.saveContentHashes();
+    logger3.success(`Build completed. Processed ${processedCount}/${totalCaves} caves`);
   }
   /**
    * 更新缺失的哈希值
@@ -724,128 +934,285 @@ var HashStorage = class _HashStorage {
    */
   async updateMissingHashes() {
     const caveData = await this.loadCaveData();
-    const missingImageCaves = caveData.filter((cave) => !this.imageHashes.has(cave.cave_id));
-    const missingTextCaves = caveData.filter((cave) => !this.textHashes.has(cave.cave_id));
-    const total = missingImageCaves.length + missingTextCaves.length;
-    if (total > 0) {
-      let processedCount = 0;
-      for (const cave of missingImageCaves) {
-        await this.processCaveHashes(cave);
-        processedCount++;
-        if (processedCount % 100 === 0 || processedCount === total) {
-          logger3.info(`Updating missing hashes: ${processedCount}/${total} (${Math.floor(processedCount / total * 100)}%)`);
-        }
-      }
-      for (const cave of missingTextCaves) {
-        await this.processCaveTextHashes(cave);
-        processedCount++;
-        if (processedCount % 100 === 0 || processedCount === total) {
-          logger3.info(`Updating missing hashes: ${processedCount}/${total} (${Math.floor(processedCount / total * 100)}%)`);
+    let updatedCount = 0;
+    for (const cave of caveData) {
+      if (this.imageHashes.has(cave.cave_id)) continue;
+      const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
+      if (imgElements.length === 0) continue;
+      try {
+        const hashes = await Promise.all(
+          imgElements.map(async (imgElement) => {
+            const filePath = path3.join(this.resourceDir, imgElement.file);
+            if (!fs3.existsSync(filePath)) {
+              return null;
+            }
+            const imgBuffer = await fs3.promises.readFile(filePath);
+            return ContentHasher.calculateHash(imgBuffer);
+          })
+        );
+        const validHashes = hashes.filter((hash) => hash !== null);
+        if (validHashes.length > 0) {
+          this.imageHashes.set(cave.cave_id, validHashes);
+          updatedCount++;
         }
+      } catch (error) {
+        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
       }
-      await this.saveHashes();
-      logger3.info(`Updated ${missingImageCaves.length} missing images and ${missingTextCaves.length} missing texts`);
     }
   }
   /**
-   * 处理单个回声洞的哈希值
-   * @param cave - 回声洞数据
+   * 批量处理数组项
+   * @param items 待处理项数组
+   * @param processor 处理函数
+   * @param batchSize 批处理大小
    * @private
    */
-  async processCaveHashes(cave) {
-    const imgElements = cave.elements?.filter((el) => el.type === "img" && el.file) || [];
-    if (imgElements.length === 0) return;
-    try {
-      const hashes = await Promise.all(imgElements.map(async (el) => {
-        const filePath = path3.join(this.resourceDir, el.file);
-        return fs3.existsSync(filePath) ? ImageHasher.calculateHash(await fs3.promises.readFile(filePath)) : null;
-      }));
-      const validHashes = hashes.filter(Boolean);
-      if (validHashes.length) {
-        this.imageHashes.set(cave.cave_id, validHashes);
-        await this.saveHashes();
+  async processBatch(items, processor, batchSize = _ContentHashManager.BATCH_SIZE) {
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (item) => {
+          try {
+            await processor(item);
+          } catch (error) {
+            logger3.error(`Batch processing error: ${error.message}`);
+          }
+        })
+      );
+    }
+  }
+};
+
+// src/utils/AuditManage.ts
+var import_koishi4 = require("koishi");
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var AuditManager = class {
+  constructor(ctx, config, caveDir, idManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.caveDir = caveDir;
+    this.idManager = idManager;
+  }
+  static {
+    __name(this, "AuditManager");
+  }
+  logger = new import_koishi4.Logger("AuditManager");
+  async processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
+    if (pendingData.length === 0) {
+      return this.sendMessage(session, "commands.cave.audit.noPending", [], true);
+    }
+    if (typeof targetId === "number") {
+      return await this.handleSingleAudit(
+        pendingData,
+        isApprove,
+        caveFilePath,
+        resourceDir,
+        pendingFilePath,
+        targetId,
+        session
+      );
+    }
+    return await this.handleBatchAudit(
+      pendingData,
+      isApprove,
+      caveFilePath,
+      resourceDir,
+      pendingFilePath,
+      session
+    );
+  }
+  async handleSingleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, targetId, session) {
+    const targetCave = pendingData.find((item) => item.cave_id === targetId);
+    if (!targetCave) {
+      return this.sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
+    }
+    const newPendingData = pendingData.filter((item) => item.cave_id !== targetId);
+    if (isApprove) {
+      const oldCaveData = await FileHandler.readJsonData(caveFilePath);
+      const newCaveData = [...oldCaveData, {
+        ...targetCave,
+        cave_id: targetId,
+        elements: this.cleanElementsForSave(targetCave.elements, false)
+      }];
+      await FileHandler.withTransaction([
+        {
+          filePath: caveFilePath,
+          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, newCaveData), "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldCaveData), "rollback")
+        },
+        {
+          filePath: pendingFilePath,
+          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, newPendingData), "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
+        }
+      ]);
+      await this.idManager.addStat(targetCave.contributor_number, targetId);
+    } else {
+      await FileHandler.writeJsonData(pendingFilePath, newPendingData);
+      await this.idManager.markDeleted(targetId);
+      await this.deleteMediaFiles(targetCave, resourceDir);
+    }
+    const remainingCount = newPendingData.length;
+    if (remainingCount > 0) {
+      const remainingIds = newPendingData.map((c) => c.cave_id).join(", ");
+      const action = isApprove ? "auditPassed" : "auditRejected";
+      return this.sendMessage(session, "commands.cave.audit.pendingResult", [
+        session.text(`commands.cave.audit.${action}`),
+        remainingCount,
+        remainingIds
+      ], false);
+    }
+    return this.sendMessage(
+      session,
+      isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
+      [],
+      false
+    );
+  }
+  async handleBatchAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session) {
+    const data = isApprove ? await FileHandler.readJsonData(caveFilePath) : null;
+    let processedCount = 0;
+    if (isApprove && data) {
+      const oldData = [...data];
+      const newData = [...data];
+      await FileHandler.withTransaction([
+        {
+          filePath: caveFilePath,
+          operation: /* @__PURE__ */ __name(async () => {
+            for (const cave of pendingData) {
+              newData.push({
+                ...cave,
+                cave_id: cave.cave_id,
+                elements: this.cleanElementsForSave(cave.elements, false)
+              });
+              processedCount++;
+              await this.idManager.addStat(cave.contributor_number, cave.cave_id);
+            }
+            return FileHandler.writeJsonData(caveFilePath, newData);
+          }, "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldData), "rollback")
+        },
+        {
+          filePath: pendingFilePath,
+          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, []), "operation"),
+          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
+        }
+      ]);
+    } else {
+      for (const cave of pendingData) {
+        await this.idManager.markDeleted(cave.cave_id);
+        await this.deleteMediaFiles(cave, resourceDir);
+        processedCount++;
       }
-    } catch (error) {
-      logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+      await FileHandler.writeJsonData(pendingFilePath, []);
     }
+    return this.sendMessage(session, "commands.cave.audit.batchAuditResult", [
+      isApprove ? "通过" : "拒绝",
+      processedCount,
+      pendingData.length
+    ], false);
   }
-  async processCaveTextHashes(cave) {
-    const textElements = cave.elements?.filter((el) => el.type === "text" && el.content) || [];
-    if (textElements.length === 0) return;
-    try {
-      const hashes = textElements.map((el) => _HashStorage.hashText(el.content));
-      if (hashes.length) {
-        this.textHashes.set(cave.cave_id, hashes);
+  async sendAuditMessage(cave, content, session) {
+    const auditMessage = `${session.text("commands.cave.audit.title")}
+${content}
+${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
+    for (const managerId of this.config.manager) {
+      const bot = this.ctx.bots[0];
+      if (bot) {
+        try {
+          await bot.sendPrivateMessage(managerId, auditMessage);
+        } catch (error) {
+          this.logger.error(session.text("commands.cave.audit.sendFailed", [managerId]));
+        }
       }
-    } catch (error) {
-      logger3.error(`Failed to process text hashes for cave ${cave.cave_id}: ${error.message}`);
     }
   }
-  /**
-   * 保存哈希数据到文件
-   * @private
-   */
-  async saveHashes() {
-    try {
-      const data = {
-        imageHashes: Object.fromEntries(this.imageHashes),
-        textHashes: Object.fromEntries(this.textHashes),
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await FileHandler.writeJsonData(this.filePath, [data]);
-    } catch (error) {
-      logger3.error(`Failed to save hash data: ${error.message}`);
-      throw error;
+  async deleteMediaFiles(cave, resourceDir) {
+    if (cave.elements) {
+      for (const element of cave.elements) {
+        if ((element.type === "img" || element.type === "video") && element.file) {
+          const fullPath = path4.join(resourceDir, element.file);
+          if (fs4.existsSync(fullPath)) {
+            await fs4.promises.unlink(fullPath);
+          }
+        }
+      }
     }
   }
-  /**
-   * 加载回声洞数据
-   * @returns 回声洞数据数组
-   * @private
-   */
-  async loadCaveData() {
-    const data = await FileHandler.readJsonData(this.caveFilePath);
-    return Array.isArray(data) ? data.flat() : [];
+  cleanElementsForSave(elements, keepIndex = false) {
+    if (!elements?.length) return [];
+    const cleanedElements = elements.map((element) => {
+      if (element.type === "text") {
+        const cleanedElement = {
+          type: "text",
+          content: element.content
+        };
+        if (keepIndex) cleanedElement.index = element.index;
+        return cleanedElement;
+      } else if (element.type === "img" || element.type === "video") {
+        const mediaElement = element;
+        const cleanedElement = {
+          type: mediaElement.type
+        };
+        if (mediaElement.file) cleanedElement.file = mediaElement.file;
+        if (keepIndex) cleanedElement.index = element.index;
+        return cleanedElement;
+      }
+      return element;
+    });
+    return keepIndex ? cleanedElements.sort((a, b) => (a.index || 0) - (b.index || 0)) : cleanedElements;
   }
-  /**
-   * 计算文本的哈希值
-   * @param text - 要计算哈希的文本
-   * @returns MD5哈希值
-   */
-  static hashText(text) {
-    return import_crypto.default.createHash("md5").update(text).digest("hex");
+  async sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
+    try {
+      const msg = await session.send(session.text(key, params));
+      if (isTemp && msg) {
+        setTimeout(async () => {
+          try {
+            await session.bot.deleteMessage(session.channelId, msg);
+          } catch (error) {
+            this.logger.debug(`Failed to delete temporary message: ${error.message}`);
+          }
+        }, timeout);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to send message: ${error.message}`);
+    }
+    return "";
   }
 };
 
 // src/index.ts
 var name = "best-cave";
 var inject = ["database"];
-var Config = import_koishi4.Schema.object({
-  manager: import_koishi4.Schema.array(import_koishi4.Schema.string()).required(),
+var Config = import_koishi5.Schema.object({
+  manager: import_koishi5.Schema.array(import_koishi5.Schema.string()).required(),
   // 管理员用户ID
-  number: import_koishi4.Schema.number().default(60),
+  number: import_koishi5.Schema.number().default(60),
   // 冷却时间(秒)
-  enableAudit: import_koishi4.Schema.boolean().default(false),
+  enableAudit: import_koishi5.Schema.boolean().default(false),
   // 启用审核
-  imageMaxSize: import_koishi4.Schema.number().default(4),
+  enableTextDuplicate: import_koishi5.Schema.boolean().default(true),
+  // 启用文本查重
+  textDuplicateThreshold: import_koishi5.Schema.number().default(0.9),
+  // 文本查重阈值
+  enableImageDuplicate: import_koishi5.Schema.boolean().default(true),
+  // 开启图片查重
+  imageDuplicateThreshold: import_koishi5.Schema.number().default(0.8),
+  // 图片查重阈值
+  imageMaxSize: import_koishi5.Schema.number().default(4),
   // 图片大小限制(MB)
-  enableMD5: import_koishi4.Schema.boolean().default(true),
-  // 启用MD5查重
-  enableDuplicate: import_koishi4.Schema.boolean().default(true),
-  // 启用相似度查重
-  duplicateThreshold: import_koishi4.Schema.number().default(0.8),
-  // 相似度查重阈值(0-1)
-  allowVideo: import_koishi4.Schema.boolean().default(true),
+  allowVideo: import_koishi5.Schema.boolean().default(true),
   // 允许视频
-  videoMaxSize: import_koishi4.Schema.number().default(16),
+  videoMaxSize: import_koishi5.Schema.number().default(16),
   // 视频大小限制(MB)
-  enablePagination: import_koishi4.Schema.boolean().default(false),
+  enablePagination: import_koishi5.Schema.boolean().default(false),
   // 启用分页
-  itemsPerPage: import_koishi4.Schema.number().default(10),
+  itemsPerPage: import_koishi5.Schema.number().default(10),
   // 每页条数
-  blacklist: import_koishi4.Schema.array(import_koishi4.Schema.string()).default([]),
+  blacklist: import_koishi5.Schema.array(import_koishi5.Schema.string()).default([]),
   // 黑名单
-  whitelist: import_koishi4.Schema.array(import_koishi4.Schema.string()).default([])
+  whitelist: import_koishi5.Schema.array(import_koishi5.Schema.string()).default([])
   // 白名单
 }).i18n({
   "zh-CN": require_zh_CN()._config,
@@ -854,19 +1221,20 @@ var Config = import_koishi4.Schema.object({
 async function apply(ctx, config) {
   ctx.i18n.define("zh-CN", require_zh_CN());
   ctx.i18n.define("en-US", require_en_US());
-  const dataDir = path4.join(ctx.baseDir, "data");
-  const caveDir = path4.join(dataDir, "cave");
+  const dataDir = path5.join(ctx.baseDir, "data");
+  const caveDir = path5.join(dataDir, "cave");
   await FileHandler.ensureDirectory(dataDir);
   await FileHandler.ensureDirectory(caveDir);
-  await FileHandler.ensureDirectory(path4.join(caveDir, "resources"));
-  await FileHandler.ensureJsonFile(path4.join(caveDir, "cave.json"));
-  await FileHandler.ensureJsonFile(path4.join(caveDir, "pending.json"));
-  await FileHandler.ensureJsonFile(path4.join(caveDir, "hash.json"));
+  await FileHandler.ensureDirectory(path5.join(caveDir, "resources"));
+  await FileHandler.ensureJsonFile(path5.join(caveDir, "cave.json"));
+  await FileHandler.ensureJsonFile(path5.join(caveDir, "pending.json"));
+  await FileHandler.ensureJsonFile(path5.join(caveDir, "hash.json"));
   const idManager = new IdManager(ctx.baseDir);
-  const hashStorage = new HashStorage(caveDir);
+  const contentHashManager = new ContentHashManager(caveDir);
+  const auditManager = new AuditManager(ctx, config, caveDir, idManager);
   await Promise.all([
-    idManager.initialize(path4.join(caveDir, "cave.json"), path4.join(caveDir, "pending.json")),
-    hashStorage.initialize()
+    idManager.initialize(path5.join(caveDir, "cave.json"), path5.join(caveDir, "pending.json")),
+    contentHashManager.initialize()
   ]);
   const lastUsed = /* @__PURE__ */ new Map();
   async function processList(session, config2, userId, pageNum = 1) {
@@ -895,13 +1263,13 @@ async function apply(ctx, config) {
     const pendingData = await FileHandler.readJsonData(pendingFilePath);
     const isApprove = Boolean(options.p);
     if (options.p === true && content[0] === "all" || options.d === true && content[0] === "all") {
-      return await handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session);
+      return await auditManager.processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session);
     }
     const id = parseInt(content[0] || (typeof options.p === "string" ? options.p : "") || (typeof options.d === "string" ? options.d : ""));
     if (isNaN(id)) {
       return sendMessage(session, "commands.cave.error.invalidId", [], true);
     }
-    return sendMessage(session, await handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, id), [], true);
+    return await auditManager.processAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, id);
   }
   __name(processAudit, "processAudit");
   async function processView(caveFilePath, resourceDir, session, options, content) {
@@ -944,14 +1312,15 @@ async function apply(ctx, config) {
     }
     const caveContent = await buildMessage(targetCave, resourceDir, session);
     if (targetCave.elements) {
-      const hashStorage2 = new HashStorage(caveDir);
-      await hashStorage2.initialize();
-      await hashStorage2.clearHashes(caveId);
+      await contentHashManager.updateCaveContent(caveId, {
+        images: void 0,
+        texts: void 0
+      });
       for (const element of targetCave.elements) {
         if ((element.type === "img" || element.type === "video") && element.file) {
-          const fullPath = path4.join(resourceDir, element.file);
-          if (fs4.existsSync(fullPath)) {
-            await fs4.promises.unlink(fullPath);
+          const fullPath = path5.join(resourceDir, element.file);
+          if (fs5.existsSync(fullPath)) {
+            await fs5.promises.unlink(fullPath);
           }
         }
       }
@@ -971,36 +1340,24 @@ async function apply(ctx, config) {
   }
   __name(processDelete, "processDelete");
   async function processAdd(ctx2, config2, caveFilePath, resourceDir, pendingFilePath, session, content) {
+    let caveId;
     try {
       const inputContent = content.length > 0 ? content.join("\n") : await (async () => {
         await sendMessage(session, "commands.cave.add.noContent", [], true);
         const reply = await session.prompt({ timeout: 6e4 });
-        if (!reply) session.text("commands.cave.add.operationTimeout");
+        if (!reply) throw new Error(session.text("commands.cave.add.operationTimeout"));
         return reply;
       })();
-      const caveId = await idManager.getNextId();
+      caveId = await idManager.getNextId();
       if (inputContent.includes("/app/.config/QQ/")) {
         return sendMessage(session, "commands.cave.add.localFileNotAllowed", [], true);
       }
       const bypassAudit = config2.whitelist.includes(session.userId) || config2.whitelist.includes(session.guildId) || config2.whitelist.includes(session.channelId);
       const { imageUrls, imageElements, videoUrls, videoElements, textParts } = await extractMediaContent(inputContent, config2, session);
-      const pureText = textParts.filter((tp) => tp.type === "text").map((tp) => tp.content.trim()).join("\n").trim();
-      if (config2.enableMD5 && pureText) {
-        const textHash = HashStorage.hashText(pureText);
-        const textDuplicates = await hashStorage.findDuplicates("text", [textHash]);
-        if (textDuplicates[0]) {
-          const data2 = await FileHandler.readJsonData(caveFilePath);
-          const duplicateCave = data2.find((item) => item.cave_id === textDuplicates[0].caveId);
-          if (duplicateCave) {
-            const message = session.text("commands.cave.error.exactDuplicateFound");
-            await session.send(message + await buildMessage(duplicateCave, resourceDir, session));
-            throw new Error("duplicate_found");
-          }
-        }
-      }
       if (videoUrls.length > 0 && !config2.allowVideo) {
         return sendMessage(session, "commands.cave.add.videoDisabled", [], true);
       }
+      const imageBuffers = [];
       const [savedImages, savedVideos] = await Promise.all([
         imageUrls.length > 0 ? saveMedia(
           imageUrls,
@@ -1010,7 +1367,9 @@ async function apply(ctx, config) {
           "img",
           config2,
           ctx2,
-          session
+          session,
+          imageBuffers
+          // 添加参数用于收集buffer
         ) : [],
         videoUrls.length > 0 ? saveMedia(
           videoUrls,
@@ -1033,7 +1392,7 @@ async function apply(ctx, config) {
             // 保持原始文本和图片的相对位置
             index: el.index
           }))
-        ].sort((a) => a.index - a.index),
+        ].sort((a, b) => a.index - a.index),
         contributor_number: session.userId,
         contributor_name: session.username
       };
@@ -1044,19 +1403,24 @@ async function apply(ctx, config) {
           index: Number.MAX_SAFE_INTEGER
         });
       }
-      const existingData = await FileHandler.readJsonData(caveFilePath);
-      const hasImages = existingData.some(
-        (cave) => cave.elements?.some((element) => element.type === "img" && element.file)
-      );
-      if (hasImages) {
-        await hashStorage.initialize();
+      const hashStorage = new ContentHashManager(path5.join(ctx2.baseDir, "data", "cave"));
+      await hashStorage.initialize();
+      const hashStatus = await hashStorage.getStatus();
+      if (!hashStatus.lastUpdated || hashStatus.entries.length === 0) {
+        const existingData = await FileHandler.readJsonData(caveFilePath);
+        const hasImages = existingData.some(
+          (cave) => cave.elements?.some((element) => element.type === "img" && element.file)
+        );
+        if (hasImages) {
+          await hashStorage.updateAllCaves(true);
+        }
       }
       if (config2.enableAudit && !bypassAudit) {
         const pendingData = await FileHandler.readJsonData(pendingFilePath);
         pendingData.push(newCave);
         await Promise.all([
           FileHandler.writeJsonData(pendingFilePath, pendingData),
-          sendAuditMessage(ctx2, config2, newCave, await buildMessage(newCave, resourceDir, session), session)
+          auditManager.sendAuditMessage(newCave, await buildMessage(newCave, resourceDir, session), session)
         ]);
         return sendMessage(session, "commands.cave.add.submitPending", [caveId], false);
       }
@@ -1065,137 +1429,58 @@ async function apply(ctx, config) {
         ...newCave,
         elements: cleanElementsForSave(newCave.elements, false)
       });
+      if (config2.enableImageDuplicate || config2.enableTextDuplicate) {
+        try {
+          const duplicateResults = await contentHashManager.findDuplicates({
+            images: config2.enableImageDuplicate ? imageBuffers : void 0,
+            texts: config2.enableTextDuplicate ? textParts.filter((p) => p.type === "text").map((p) => p.content) : void 0
+          }, {
+            image: config2.imageDuplicateThreshold,
+            text: config2.textDuplicateThreshold
+          });
+          for (const result of duplicateResults) {
+            if (!result) continue;
+            const originalCave = data.find((item) => item.cave_id === result.caveId);
+            if (!originalCave) continue;
+            await idManager.markDeleted(caveId);
+            const duplicateMessage = session.text(
+              "commands.cave.error.similarDuplicateFound",
+              [(result.similarity * 100).toFixed(1)]
+            );
+            await session.send(duplicateMessage + await buildMessage(originalCave, resourceDir, session));
+            throw new Error("duplicate_found");
+          }
+        } catch (error) {
+          if (error.message !== "duplicate_found") {
+            await idManager.markDeleted(caveId);
+          }
+          if (error.message === "duplicate_found") {
+            return "";
+          }
+          return sendMessage(session, "commands.cave.error.addFailed", [], true);
+        }
+      }
       await Promise.all([
         FileHandler.writeJsonData(caveFilePath, data),
-        pureText && config2.enableMD5 ? hashStorage.updateHash(caveId, "text", pureText) : Promise.resolve(),
-        savedImages?.length ? Promise.all(savedImages.map((buffer) => hashStorage.updateHash(caveId, "image", buffer))) : Promise.resolve()
+        contentHashManager.updateCaveContent(caveId, {
+          images: savedImages.length > 0 ? await Promise.all(savedImages.map((file) => fs5.promises.readFile(path5.join(resourceDir, file)))) : void 0,
+          texts: textParts.filter((p) => p.type === "text").map((p) => p.content)
+        })
       ]);
       await idManager.addStat(session.userId, caveId);
-      if (config2.enableMD5 && pureText) {
-        const textHash = HashStorage.hashText(pureText);
-        await hashStorage.updateHash(caveId, "text", textHash);
-      }
       return sendMessage(session, "commands.cave.add.addSuccess", [caveId], false);
     } catch (error) {
-      logger4.error(`Failed to process add command: ${error.message}`);
-    }
-  }
-  __name(processAdd, "processAdd");
-  async function handleAudit(pendingData, isApprove, caveFilePath, resourceDir, pendingFilePath, session, targetId) {
-    if (pendingData.length === 0) {
-      return sendMessage(session, "commands.cave.audit.noPending", [], true);
-    }
-    if (typeof targetId === "number") {
-      const targetCave = pendingData.find((item) => item.cave_id === targetId);
-      if (!targetCave) {
-        return sendMessage(session, "commands.cave.audit.pendingNotFound", [], true);
+      if (error.message !== "duplicate_found") {
+        await idManager.markDeleted(caveId);
       }
-      const newPendingData = pendingData.filter((item) => item.cave_id !== targetId);
-      if (isApprove) {
-        const oldCaveData = await FileHandler.readJsonData(caveFilePath);
-        const newCaveData = [...oldCaveData, {
-          ...targetCave,
-          cave_id: targetId,
-          elements: cleanElementsForSave(targetCave.elements, false)
-        }];
-        await FileHandler.withTransaction([
-          {
-            filePath: caveFilePath,
-            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, newCaveData), "operation"),
-            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldCaveData), "rollback")
-          },
-          {
-            filePath: pendingFilePath,
-            operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, newPendingData), "operation"),
-            rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
-          }
-        ]);
-        await idManager.addStat(targetCave.contributor_number, targetId);
-      } else {
-        await FileHandler.writeJsonData(pendingFilePath, newPendingData);
-        await idManager.markDeleted(targetId);
-        if (targetCave.elements) {
-          for (const element of targetCave.elements) {
-            if ((element.type === "img" || element.type === "video") && element.file) {
-              const fullPath = path4.join(resourceDir, element.file);
-              if (fs4.existsSync(fullPath)) {
-                await fs4.promises.unlink(fullPath);
-              }
-            }
-          }
-        }
-      }
-      const remainingCount = newPendingData.length;
-      if (remainingCount > 0) {
-        const remainingIds = newPendingData.map((c) => c.cave_id).join(", ");
-        const action = isApprove ? "auditPassed" : "auditRejected";
-        return sendMessage(session, "commands.cave.audit.pendingResult", [
-          session.text(`commands.cave.audit.${action}`),
-          remainingCount,
-          remainingIds
-        ], false);
-      }
-      return sendMessage(
-        session,
-        isApprove ? "commands.cave.audit.auditPassed" : "commands.cave.audit.auditRejected",
-        [],
-        false
-      );
-    }
-    const data = isApprove ? await FileHandler.readJsonData(caveFilePath) : null;
-    let processedCount = 0;
-    if (isApprove && data) {
-      const oldData = [...data];
-      const newData = [...data];
-      await FileHandler.withTransaction([
-        {
-          filePath: caveFilePath,
-          operation: /* @__PURE__ */ __name(async () => {
-            for (const cave of pendingData) {
-              newData.push({
-                ...cave,
-                cave_id: cave.cave_id,
-                elements: cleanElementsForSave(cave.elements, false)
-              });
-              processedCount++;
-              await idManager.addStat(cave.contributor_number, cave.cave_id);
-            }
-            return FileHandler.writeJsonData(caveFilePath, newData);
-          }, "operation"),
-          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(caveFilePath, oldData), "rollback")
-        },
-        {
-          filePath: pendingFilePath,
-          operation: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, []), "operation"),
-          rollback: /* @__PURE__ */ __name(async () => FileHandler.writeJsonData(pendingFilePath, pendingData), "rollback")
-        }
-      ]);
-    } else {
-      for (const cave of pendingData) {
-        await idManager.markDeleted(cave.cave_id);
-      }
-      await FileHandler.writeJsonData(pendingFilePath, []);
-      for (const cave of pendingData) {
-        if (cave.elements) {
-          for (const element of cave.elements) {
-            if ((element.type === "img" || element.type === "video") && element.file) {
-              const fullPath = path4.join(resourceDir, element.file);
-              if (fs4.existsSync(fullPath)) {
-                await fs4.promises.unlink(fullPath);
-              }
-            }
-          }
-        }
-        processedCount++;
+      if (error.message === "duplicate_found") {
+        return "";
       }
+      logger4.error(`Failed to process add command: ${error.message}`);
+      return sendMessage(session, "commands.cave.error.addFailed", [], true);
     }
-    return sendMessage(session, "commands.cave.audit.batchAuditResult", [
-      isApprove ? "通过" : "拒绝",
-      processedCount,
-      pendingData.length
-    ], false);
   }
-  __name(handleAudit, "handleAudit");
+  __name(processAdd, "processAdd");
   ctx.command("cave [message]").option("a", "添加回声洞").option("g", "查看回声洞", { type: "string" }).option("r", "删除回声洞", { type: "string" }).option("p", "通过审核", { type: "string" }).option("d", "拒绝审核", { type: "string" }).option("l", "查询投稿统计", { type: "string" }).before(async ({ session, options }) => {
     if (config.blacklist.includes(session.userId)) {
       return sendMessage(session, "commands.cave.message.blacklisted", [], true);
@@ -1204,11 +1489,11 @@ async function apply(ctx, config) {
       return sendMessage(session, "commands.cave.message.managerOnly", [], true);
     }
   }).action(async ({ session, options }, ...content) => {
-    const dataDir2 = path4.join(ctx.baseDir, "data");
-    const caveDir2 = path4.join(dataDir2, "cave");
-    const caveFilePath = path4.join(caveDir2, "cave.json");
-    const resourceDir = path4.join(caveDir2, "resources");
-    const pendingFilePath = path4.join(caveDir2, "pending.json");
+    const dataDir2 = path5.join(ctx.baseDir, "data");
+    const caveDir2 = path5.join(dataDir2, "cave");
+    const caveFilePath = path5.join(caveDir2, "cave.json");
+    const resourceDir = path5.join(caveDir2, "resources");
+    const pendingFilePath = path5.join(caveDir2, "pending.json");
     const needsCooldown = !options.l && !options.a && !options.p && !options.d;
     if (needsCooldown) {
       const guildId = session.guildId;
@@ -1255,7 +1540,7 @@ async function apply(ctx, config) {
   });
 }
 __name(apply, "apply");
-var logger4 = new import_koishi4.Logger("cave");
+var logger4 = new import_koishi5.Logger("cave");
 async function sendMessage(session, key, params = [], isTemp = true, timeout = 1e4) {
   try {
     const msg = await session.send(session.text(key, params));
@@ -1274,22 +1559,6 @@ async function sendMessage(session, key, params = [], isTemp = true, timeout = 1
   return "";
 }
 __name(sendMessage, "sendMessage");
-async function sendAuditMessage(ctx, config, cave, content, session) {
-  const auditMessage = `${session.text("commands.cave.audit.title")}
-${content}
-${session.text("commands.cave.audit.from")}${cave.contributor_number}`;
-  for (const managerId of config.manager) {
-    const bot = ctx.bots[0];
-    if (bot) {
-      try {
-        await bot.sendPrivateMessage(managerId, auditMessage);
-      } catch (error) {
-        logger4.error(session.text("commands.cave.audit.sendFailed", [managerId]));
-      }
-    }
-  }
-}
-__name(sendAuditMessage, "sendAuditMessage");
 function cleanElementsForSave(elements, keepIndex = false) {
   if (!elements?.length) return [];
   const cleanedElements = elements.map((element) => {
@@ -1315,7 +1584,7 @@ function cleanElementsForSave(elements, keepIndex = false) {
 }
 __name(cleanElementsForSave, "cleanElementsForSave");
 async function processMediaFile(filePath, type) {
-  const data = await fs4.promises.readFile(filePath).catch(() => null);
+  const data = await fs5.promises.readFile(filePath).catch(() => null);
   if (!data) return null;
   return `data:${type}/${type === "image" ? "png" : "mp4"};base64,${data.toString("base64")}`;
 }
@@ -1332,10 +1601,10 @@ async function buildMessage(cave, resourceDir, session) {
       session.text("commands.cave.message.contributorSuffix", [cave.contributor_name])
     ].join("\n");
     await session?.send(basicInfo);
-    const filePath = path4.join(resourceDir, videoElement.file);
+    const filePath = path5.join(resourceDir, videoElement.file);
     const base64Data = await processMediaFile(filePath, "video");
     if (base64Data && session) {
-      await session.send((0, import_koishi4.h)("video", { src: base64Data }));
+      await session.send((0, import_koishi5.h)("video", { src: base64Data }));
     }
     return "";
   }
@@ -1344,10 +1613,10 @@ async function buildMessage(cave, resourceDir, session) {
     if (element.type === "text") {
       lines.push(element.content);
     } else if (element.type === "img" && element.file) {
-      const filePath = path4.join(resourceDir, element.file);
+      const filePath = path5.join(resourceDir, element.file);
       const base64Data = await processMediaFile(filePath, "image");
       if (base64Data) {
-        lines.push((0, import_koishi4.h)("image", { src: base64Data }));
+        lines.push((0, import_koishi5.h)("image", { src: base64Data }));
       }
     }
   }
@@ -1396,13 +1665,13 @@ async function extractMediaContent(originalContent, config, session) {
   return { imageUrls, imageElements, videoUrls, videoElements, textParts };
 }
 __name(extractMediaContent, "extractMediaContent");
-async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session) {
+async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config, ctx, session, buffers) {
   const accept = mediaType === "img" ? "image/*" : "video/*";
-  const hashStorage = new HashStorage(path4.join(ctx.baseDir, "data", "cave"));
+  const hashStorage = new ContentHashManager(path5.join(ctx.baseDir, "data", "cave"));
   await hashStorage.initialize();
   const downloadTasks = urls.map(async (url, i) => {
     const fileName = fileNames[i];
-    const ext = path4.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
+    const ext = path5.extname(fileName || url) || (mediaType === "img" ? ".png" : ".mp4");
     try {
       const response = await ctx.http(decodeURIComponent(url).replace(/&amp;/g, "&"), {
         method: "GET",
@@ -1416,75 +1685,58 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config
       });
       if (!response.data) throw new Error("empty_response");
       const buffer = Buffer.from(response.data);
-      if (mediaType === "img") {
-        const baseName = path4.basename(fileName || "md5", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-        if (config.enableMD5) {
-          const files = await fs4.promises.readdir(resourceDir);
-          const duplicateFile = files.find((file) => file.startsWith(baseName + "_"));
-          if (duplicateFile) {
-            const duplicateCaveId = parseInt(duplicateFile.split("_")[1]);
-            if (!isNaN(duplicateCaveId)) {
-              const caveFilePath = path4.join(ctx.baseDir, "data", "cave", "cave.json");
-              const data = await FileHandler.readJsonData(caveFilePath);
-              const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
-              if (originalCave) {
-                const message = session.text("commands.cave.error.exactDuplicateFound");
-                await session.send(message + await buildMessage(originalCave, resourceDir, session));
-                throw new Error("duplicate_found");
-              }
-            }
+      if (buffers && mediaType === "img") {
+        buffers.push(buffer);
+      }
+      const md5 = path5.basename(fileName || `${mediaType}`, ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+      const files = await fs5.promises.readdir(resourceDir);
+      const duplicateFile = files.find((file) => {
+        const match = file.match(/^\d+_([^.]+)/);
+        return match && match[1] === md5;
+      });
+      if (duplicateFile) {
+        const duplicateCaveId = parseInt(duplicateFile.split("_")[0]);
+        if (!isNaN(duplicateCaveId)) {
+          const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
+          const data = await FileHandler.readJsonData(caveFilePath);
+          const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
+          if (originalCave) {
+            const message = session.text("commands.cave.error.exactDuplicateFound");
+            await session.send(message + await buildMessage(originalCave, resourceDir, session));
+            throw new Error("duplicate_found");
           }
         }
-        if (config.enableDuplicate) {
-          const hashStorage2 = new HashStorage(path4.join(ctx.baseDir, "data", "cave"));
-          await hashStorage2.initialize();
-          const result = await hashStorage2.findDuplicates("image", [buffer.toString("base64")], config.duplicateThreshold);
-          if (result.length > 0 && result[0] !== null) {
-            const duplicate = result[0];
-            const similarity = duplicate.similarity;
-            if (similarity >= config.duplicateThreshold) {
-              const caveFilePath = path4.join(ctx.baseDir, "data", "cave", "cave.json");
-              const data = await FileHandler.readJsonData(caveFilePath);
-              const originalCave = data.find((item) => item.cave_id === duplicate.caveId);
-              if (originalCave) {
-                const message = session.text(
-                  "commands.cave.error.similarDuplicateFound",
-                  [(similarity * 100).toFixed(1)]
-                );
-                await session.send(message + await buildMessage(originalCave, resourceDir, session));
-                throw new Error("duplicate_found");
-              }
-            }
+      }
+      if (mediaType === "img" && config.enableImageDuplicate) {
+        const result = await hashStorage.findDuplicates(
+          { images: [buffer] },
+          {
+            image: config.imageDuplicateThreshold,
+            text: config.textDuplicateThreshold
           }
-        }
-        const finalFileName = `${caveId}_${baseName}${ext}`;
-        const filePath = path4.join(resourceDir, finalFileName);
-        await FileHandler.saveMediaFile(filePath, buffer);
-        return finalFileName;
-      } else {
-        const baseName = path4.basename(fileName || "video", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-        if (config.enableMD5) {
-          const files = await fs4.promises.readdir(resourceDir);
-          const duplicateFile = files.find((file) => file.startsWith(baseName + "_"));
-          if (duplicateFile) {
-            const duplicateCaveId = parseInt(duplicateFile.split("_")[1]);
-            if (!isNaN(duplicateCaveId)) {
-              const caveFilePath = path4.join(ctx.baseDir, "data", "cave", "cave.json");
-              const data = await FileHandler.readJsonData(caveFilePath);
-              const originalCave = data.find((item) => item.cave_id === duplicateCaveId);
-              if (originalCave) {
-                const message = session.text("commands.cave.error.exactDuplicateFound");
-                await session.send(message + await buildMessage(originalCave, resourceDir, session));
-                throw new Error("duplicate_found");
-              }
+        );
+        if (result.length > 0 && result[0] !== null) {
+          const duplicate = result[0];
+          const similarity = duplicate.similarity;
+          if (similarity >= config.imageDuplicateThreshold) {
+            const caveFilePath = path5.join(ctx.baseDir, "data", "cave", "cave.json");
+            const data = await FileHandler.readJsonData(caveFilePath);
+            const originalCave = data.find((item) => item.cave_id === duplicate.caveId);
+            if (originalCave) {
+              const message = session.text(
+                "commands.cave.error.similarDuplicateFound",
+                [(similarity * 100).toFixed(1)]
+              );
+              await session.send(message + await buildMessage(originalCave, resourceDir, session));
+              throw new Error("duplicate_found");
             }
           }
         }
-        const finalFileName = `${caveId}_${baseName}${ext}`;
-        const filePath = path4.join(resourceDir, finalFileName);
-        await FileHandler.saveMediaFile(filePath, buffer);
-        return finalFileName;
       }
+      const finalFileName = `${caveId}_${md5}${ext}`;
+      const filePath = path5.join(resourceDir, finalFileName);
+      await FileHandler.saveMediaFile(filePath, buffer);
+      return finalFileName;
     } catch (error) {
       if (error.message === "duplicate_found") {
         throw error;