koishi-plugin-best-cave 1.3.3 → 1.3.5

package/lib/index.d.ts

@@ -25,4 +25,5 @@ export interface Config {
     itemsPerPage: number;
     duplicateThreshold: number;
     enableDuplicate: boolean;
+    enableMD5: boolean;
 }

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）", enableDuplicate: "启用图片查重", duplicateThreshold: "图片相似度阈值（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: "启用审核", 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}文件大小超过限制" } } } };
   }
 });
 
 // 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)", enableDuplicate: "Enable image duplicate check", duplicateThreshold: "Image 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", 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" } } } };
   }
 });
 
@@ -293,7 +293,6 @@ var IdManager = class {
       );
       await this.saveStatus();
       this.initialized = true;
-      logger2.success("ID Manager initialized");
     } catch (error) {
       this.initialized = false;
       logger2.error(`ID Manager initialization failed: ${error.message}`);
@@ -593,253 +592,131 @@ var ImageHasher = class {
 };
 
 // src/utils/HashStorage.ts
-var import_util = require("util");
+var import_crypto = __toESM(require("crypto"));
 var logger3 = new import_koishi3.Logger("HashStorage");
-var readFileAsync = (0, import_util.promisify)(fs3.readFile);
 var HashStorage = class _HashStorage {
   /**
-   * 初始化HashStorage实例
-   * @param caveDir 回声洞数据目录路径
+   * 创建哈希存储实例
+   * @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");
   }
-  // 哈希数据文件名
-  static HASH_FILE = "hash.json";
-  // 回声洞数据文件名
-  static CAVE_FILE = "cave.json";
-  // 批处理大小
-  static BATCH_SIZE = 50;
-  // 存储回声洞ID到图片哈希值的映射
-  hashes = /* @__PURE__ */ new Map();
-  // 初始化状态标志
+  filePath;
+  resourceDir;
+  caveFilePath;
+  imageHashes = /* @__PURE__ */ new Map();
+  textHashes = /* @__PURE__ */ new Map();
   initialized = false;
-  get filePath() {
-    return path3.join(this.caveDir, _HashStorage.HASH_FILE);
-  }
-  get resourceDir() {
-    return path3.join(this.caveDir, "resources");
-  }
-  get caveFilePath() {
-    return path3.join(this.caveDir, _HashStorage.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?.hashes || Object.keys(hashData.hashes).length === 0) {
-        this.hashes.clear();
+      if (!hashData?.imageHashes) {
         await this.buildInitialHashes();
       } else {
-        this.hashes = new Map(
-          Object.entries(hashData.hashes).map(([k, v]) => [Number(k), v])
-        );
+        this.loadHashData(hashData);
         await this.updateMissingHashes();
       }
       this.initialized = true;
     } catch (error) {
-      logger3.error(`Initialization failed: ${error.message}`);
-      this.initialized = false;
+      logger3.error(`Hash storage initialization failed: ${error.message}`);
       throw error;
     }
   }
   /**
-   * 获取当前哈希存储状态
-   * @returns 包含最后更新时间和所有条目的状态对象
+   * 加载哈希数据
+   * @param data - 要加载的哈希数据
+   * @private
    */
-  async getStatus() {
-    if (!this.initialized) await this.initialize();
-    return {
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      entries: Array.from(this.hashes.entries()).map(([caveId, hashes]) => ({
-        caveId,
-        hashes
-      }))
-    };
+  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]));
   }
   /**
-   * 更新指定回声洞的图片哈希值
-   * @param caveId 回声洞ID
-   * @param imgBuffers 图片buffer数组
+   * 更新指定回声洞的哈希值
+   * @param caveId - 回声洞ID
+   * @param type - 哈希类型（图像或文本）
+   * @param content - 要计算哈希的内容
    */
-  async updateCaveHash(caveId, imgBuffers) {
+  async updateHash(caveId, type, content) {
     if (!this.initialized) await this.initialize();
     try {
-      if (imgBuffers?.length) {
-        const hashes = await Promise.all(
-          imgBuffers.map((buffer) => ImageHasher.calculateHash(buffer))
-        );
-        this.hashes.set(caveId, hashes);
-        logger3.info(`Added ${hashes.length} hashes for cave ${caveId}`);
-      } else {
-        this.hashes.delete(caveId);
-        logger3.info(`Deleted hashes for cave ${caveId}`);
-      }
+      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();
     } catch (error) {
-      logger3.error(`Failed to update hash (cave ${caveId}): ${error.message}`);
+      logger3.error(`Failed to update ${type} hash for cave ${caveId}: ${error.message}`);
     }
   }
   /**
-   * 更新所有回声洞的哈希值
-   * @param isInitialBuild 是否为初始构建
+   * 查找重复项
+   * @param type - 查找类型（图像或文本）
+   * @param hashes - 要查找的哈希值数组
+   * @param threshold - 相似度阈值，默认为1
+   * @returns 匹配结果数组
    */
-  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.hashes.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 ImageHasher.calculateHash(imgBuffer);
-            })
-          );
-          const validHashes = hashes.filter((hash) => hash !== null);
-          if (validHashes.length > 0) {
-            this.hashes.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.saveHashes();
-      logger3.success(`Update completed. Processed ${processedCount}/${totalImages} images`);
-    } catch (error) {
-      logger3.error(`Full update failed: ${error.message}`);
-      throw error;
-    }
-  }
-  /**
-   * 查找重复的图片
-   * @param imgBuffers 待查找的图片buffer数组
-   * @param threshold 相似度阈值
-   * @returns 匹配结果数组，包含索引、回声洞ID和相似度
-   */
-  async findDuplicates(imgBuffers, threshold) {
+  async findDuplicates(type, hashes, threshold = 1) {
     if (!this.initialized) await this.initialize();
-    const inputHashes = await Promise.all(
-      imgBuffers.map((buffer) => ImageHasher.calculateHash(buffer))
-    );
-    const existingHashes = Array.from(this.hashes.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 = ImageHasher.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;
+    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) => {
+      let maxSimilarity = 0;
+      let matchedCaveId = null;
+      for (const [caveId, existingHashes] of hashMap.entries()) {
+        for (const existingHash of existingHashes) {
+          const similarity = calculateSimilarity(hash, existingHash);
+          if (similarity >= threshold && similarity > maxSimilarity) {
+            maxSimilarity = similarity;
+            matchedCaveId = caveId;
+            if (similarity === 1) break;
           }
-          return matchedCaveId ? {
-            index,
-            caveId: matchedCaveId,
-            similarity: maxSimilarity
-          } : null;
-        } catch (error) {
-          logger3.warn(`处理图片 ${index} 失败: ${error.message}`);
-          return null;
         }
-      })
-    );
-  }
-  /**
-   * 加载回声洞数据
-   * @returns 回声洞数据数组
-   * @private
-   */
-  async loadCaveData() {
-    const data = await FileHandler.readJsonData(this.caveFilePath);
-    return Array.isArray(data) ? data.flat() : [];
+        if (maxSimilarity === 1) break;
+      }
+      return matchedCaveId ? { index, caveId: matchedCaveId, similarity: maxSimilarity } : null;
+    });
   }
   /**
-   * 保存哈希数据到文件
-   * @private
+   * 清除指定回声洞的所有哈希值
+   * @param caveId - 回声洞ID
    */
-  async saveHashes() {
-    const data = {
-      hashes: Object.fromEntries(this.hashes),
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await FileHandler.writeJsonData(this.filePath, [data]);
+  async clearHashes(caveId) {
+    if (!this.initialized) await this.initialize();
+    this.imageHashes.delete(caveId);
+    this.textHashes.delete(caveId);
+    await this.saveHashes();
   }
   /**
-   * 构建初始哈希数据
+   * 构建初始哈希值
    * @private
    */
   async buildInitialHashes() {
     const caveData = await this.loadCaveData();
-    let processedImageCount = 0;
-    const totalImages = caveData.reduce((sum, cave) => sum + (cave.elements?.filter((el) => el.type === "img" && el.file).length || 0), 0);
-    logger3.info(`Building hash data for ${totalImages} images...`);
+    let processedCount = 0;
+    const total = caveData.length;
     for (const cave of caveData) {
-      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)) {
-              logger3.warn(`Image not found: ${filePath}`);
-              return null;
-            }
-            const imgBuffer = await fs3.promises.readFile(filePath);
-            const hash = await ImageHasher.calculateHash(imgBuffer);
-            processedImageCount++;
-            if (processedImageCount % 100 === 0) {
-              logger3.info(`Progress: ${processedImageCount}/${totalImages} images`);
-            }
-            return hash;
-          })
-        );
-        const validHashes = hashes.filter((hash) => hash !== null);
-        if (validHashes.length > 0) {
-          this.hashes.set(cave.cave_id, validHashes);
-        }
-      } catch (error) {
-        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+      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)}%)`);
       }
     }
     await this.saveHashes();
-    logger3.success(`Build completed. Processed ${processedImageCount}/${totalImages} images`);
+    logger3.info(`Processed ${processedCount} caves with ${this.imageHashes.size} images and ${this.textHashes.size} texts`);
   }
   /**
    * 更新缺失的哈希值
@@ -847,53 +724,97 @@ var HashStorage = class _HashStorage {
    */
   async updateMissingHashes() {
     const caveData = await this.loadCaveData();
-    let updatedCount = 0;
-    for (const cave of caveData) {
-      if (this.hashes.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 ImageHasher.calculateHash(imgBuffer);
-          })
-        );
-        const validHashes = hashes.filter((hash) => hash !== null);
-        if (validHashes.length > 0) {
-          this.hashes.set(cave.cave_id, validHashes);
-          updatedCount++;
+    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)}%)`);
         }
-      } catch (error) {
-        logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
       }
+      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)}%)`);
+        }
+      }
+      await this.saveHashes();
+      logger3.info(`Updated ${missingImageCaves.length} missing images and ${missingTextCaves.length} missing texts`);
     }
   }
   /**
-   * 批量处理数组项
-   * @param items 待处理项数组
-   * @param processor 处理函数
-   * @param batchSize 批处理大小
+   * 处理单个回声洞的哈希值
+   * @param cave - 回声洞数据
    * @private
    */
-  async processBatch(items, processor, batchSize = _HashStorage.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}`);
-          }
-        })
-      );
+  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();
+      }
+    } catch (error) {
+      logger3.error(`Failed to process cave ${cave.cave_id}: ${error.message}`);
+    }
+  }
+  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);
+      }
+    } 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;
+    }
+  }
+  /**
+   * 加载回声洞数据
+   * @returns 回声洞数据数组
+   * @private
+   */
+  async loadCaveData() {
+    const data = await FileHandler.readJsonData(this.caveFilePath);
+    return Array.isArray(data) ? data.flat() : [];
+  }
+  /**
+   * 计算文本的哈希值
+   * @param text - 要计算哈希的文本
+   * @returns MD5哈希值
+   */
+  static hashText(text) {
+    return import_crypto.default.createHash("md5").update(text).digest("hex");
+  }
 };
 
 // src/index.ts
@@ -908,10 +829,12 @@ var Config = import_koishi4.Schema.object({
   // 启用审核
   imageMaxSize: import_koishi4.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)
+  // 相似度查重阈值(0-1)
   allowVideo: import_koishi4.Schema.boolean().default(true),
   // 允许视频
   videoMaxSize: import_koishi4.Schema.number().default(16),
@@ -1023,7 +946,7 @@ async function apply(ctx, config) {
     if (targetCave.elements) {
       const hashStorage2 = new HashStorage(caveDir);
       await hashStorage2.initialize();
-      await hashStorage2.updateCaveHash(caveId);
+      await hashStorage2.clearHashes(caveId);
       for (const element of targetCave.elements) {
         if ((element.type === "img" || element.type === "video") && element.file) {
           const fullPath = path4.join(resourceDir, element.file);
@@ -1052,7 +975,7 @@ async function apply(ctx, config) {
       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) throw new Error(session.text("commands.cave.add.operationTimeout"));
+        if (!reply) session.text("commands.cave.add.operationTimeout");
         return reply;
       })();
       const caveId = await idManager.getNextId();
@@ -1061,6 +984,20 @@ async function apply(ctx, config) {
       }
       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);
       }
@@ -1096,7 +1033,7 @@ async function apply(ctx, config) {
             // 保持原始文本和图片的相对位置
             index: el.index
           }))
-        ].sort((a, b) => a.index - a.index),
+        ].sort((a) => a.index - a.index),
         contributor_number: session.userId,
         contributor_name: session.username
       };
@@ -1107,17 +1044,12 @@ async function apply(ctx, config) {
           index: Number.MAX_SAFE_INTEGER
         });
       }
-      const hashStorage2 = new HashStorage(path4.join(ctx2.baseDir, "data", "cave"));
-      await hashStorage2.initialize();
-      const hashStatus = await hashStorage2.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 hashStorage2.updateAllCaves(true);
-        }
+      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();
       }
       if (config2.enableAudit && !bypassAudit) {
         const pendingData = await FileHandler.readJsonData(pendingFilePath);
@@ -1135,9 +1067,14 @@ async function apply(ctx, config) {
       });
       await Promise.all([
         FileHandler.writeJsonData(caveFilePath, data),
-        hashStorage2.updateCaveHash(caveId)
+        pureText && config2.enableMD5 ? hashStorage.updateHash(caveId, "text", pureText) : Promise.resolve(),
+        savedImages?.length ? Promise.all(savedImages.map((buffer) => hashStorage.updateHash(caveId, "image", buffer))) : Promise.resolve()
       ]);
       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}`);
@@ -1481,23 +1418,27 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config
       const buffer = Buffer.from(response.data);
       if (mediaType === "img") {
         const baseName = path4.basename(fileName || "md5", ext).replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-        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 (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 (config.enableDuplicate) {
-          const result = await hashStorage.findDuplicates([buffer], config.duplicateThreshold);
+          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;
@@ -1522,6 +1463,23 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config
         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");
+              }
+            }
+          }
+        }
         const finalFileName = `${caveId}_${baseName}${ext}`;
         const filePath = path4.join(resourceDir, finalFileName);
         await FileHandler.saveMediaFile(filePath, buffer);

package/lib/utils/HashStorage.d.ts

@@ -1,95 +1,87 @@
 /**
- * 哈希存储状态信息
- */
-interface HashStatus {
-    /** 最后更新时间戳 */
-    lastUpdated: string;
-    /** 所有回声洞的哈希值条目 */
-    entries: Array<{
-        caveId: number;
-        hashes: string[];
-    }>;
-}
-/**
- * 图片哈希值存储管理类
- * 负责管理和维护回声洞图片的哈希值
+ * 哈希存储管理类
+ * @class HashStorage
  */
 export declare class HashStorage {
     private readonly caveDir;
-    private static readonly HASH_FILE;
-    private static readonly CAVE_FILE;
-    private static readonly BATCH_SIZE;
-    private hashes;
+    private readonly filePath;
+    private readonly resourceDir;
+    private readonly caveFilePath;
+    private imageHashes;
+    private textHashes;
     private initialized;
     /**
-     * 初始化HashStorage实例
-     * @param caveDir 回声洞数据目录路径
+     * 创建哈希存储实例
+     * @param caveDir - 回声洞数据目录路径
      */
     constructor(caveDir: string);
-    private get filePath();
-    private get resourceDir();
-    private get caveFilePath();
     /**
      * 初始化哈希存储
-     * 读取现有哈希数据或重新构建哈希值
      * @throws 初始化失败时抛出错误
      */
     initialize(): Promise<void>;
     /**
-     * 获取当前哈希存储状态
-     * @returns 包含最后更新时间和所有条目的状态对象
-     */
-    getStatus(): Promise<HashStatus>;
-    /**
-     * 更新指定回声洞的图片哈希值
-     * @param caveId 回声洞ID
-     * @param imgBuffers 图片buffer数组
+     * 加载哈希数据
+     * @param data - 要加载的哈希数据
+     * @private
      */
-    updateCaveHash(caveId: number, imgBuffers?: Buffer[]): Promise<void>;
+    private loadHashData;
     /**
-     * 更新所有回声洞的哈希值
-     * @param isInitialBuild 是否为初始构建
+     * 更新指定回声洞的哈希值
+     * @param caveId - 回声洞ID
+     * @param type - 哈希类型（图像或文本）
+     * @param content - 要计算哈希的内容
      */
-    updateAllCaves(isInitialBuild?: boolean): Promise<void>;
+    updateHash(caveId: number, type: 'image' | 'text', content: Buffer | string): Promise<void>;
     /**
-     * 查找重复的图片
-     * @param imgBuffers 待查找的图片buffer数组
-     * @param threshold 相似度阈值
-     * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+     * 查找重复项
+     * @param type - 查找类型（图像或文本）
+     * @param hashes - 要查找的哈希值数组
+     * @param threshold - 相似度阈值，默认为1
+     * @returns 匹配结果数组
      */
-    findDuplicates(imgBuffers: Buffer[], threshold: number): Promise<Array<{
+    findDuplicates(type: 'image' | 'text', hashes: string[], threshold?: number): Promise<Array<{
         index: number;
         caveId: number;
         similarity: number;
     } | null>>;
     /**
-     * 加载回声洞数据
-     * @returns 回声洞数据数组
+     * 清除指定回声洞的所有哈希值
+     * @param caveId - 回声洞ID
+     */
+    clearHashes(caveId: number): Promise<void>;
+    /**
+     * 构建初始哈希值
      * @private
      */
-    private loadCaveData;
+    private buildInitialHashes;
     /**
-     * 保存哈希数据到文件
+     * 更新缺失的哈希值
      * @private
      */
-    private saveHashes;
+    private updateMissingHashes;
     /**
-     * 构建初始哈希数据
+     * 处理单个回声洞的哈希值
+     * @param cave - 回声洞数据
      * @private
      */
-    private buildInitialHashes;
+    private processCaveHashes;
+    private processCaveTextHashes;
     /**
-     * 更新缺失的哈希值
+     * 保存哈希数据到文件
      * @private
      */
-    private updateMissingHashes;
+    private saveHashes;
     /**
-     * 批量处理数组项
-     * @param items 待处理项数组
-     * @param processor 处理函数
-     * @param batchSize 批处理大小
+     * 加载回声洞数据
+     * @returns 回声洞数据数组
      * @private
      */
-    private processBatch;
+    private loadCaveData;
+    /**
+     * 计算文本的哈希值
+     * @param text - 要计算哈希的文本
+     * @returns MD5哈希值
+     */
+    static hashText(text: string): string;
 }
-export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最好的 cave 插件，可开关的审核系统，可引用添加，支持图文混合内容，可查阅投稿列表，完美复刻你的 .cave 体验！",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],

package/readme.md

@@ -8,15 +8,36 @@
 
 ### 核心功能
 
-- 支持文字与图片混合保存
-- 智能处理各类图片与视频链接
-- 内容智能排序，保持原始布局
-- 完整的权限管理系统
-- 可选的内容审核流程
-- 群组调用冷却机制
-- 重复内容智能检测
-- 黑白名单系统
-- 分页显示支持
+- **内容管理**
+  - 支持文字与图片混合保存，自动保持布局顺序
+  - 视频内容单独发送，支持多种格式
+  - 自动文本格式化与排版
+  - 引用消息自动解析和保存
+  - 支持引用已有内容的布局
+
+- **审核机制**
+  - 可配置的审核开关与多级权限
+  - 完整的黑白名单系统（支持用户/群组/频道）
+  - 白名单用户自动跳过审核
+  - 支持单条和批量审核操作
+  - 拒绝审核时自动清理媒体文件
+  - 审核消息自动通知管理员
+
+- **媒体处理**
+  - 智能处理多种类型媒体链接
+  - 支持本地图片上传和URL引用
+  - 自动文件大小检查与限制
+  - 基于感知哈希的图片查重
+  - 可配置的相似度阈值检测
+  - MD5文件名重复检查
+
+- **使用体验**
+  - 基于群组的调用冷却机制
+  - 管理员操作不受冷却限制
+  - 支持按页浏览投稿记录
+  - 支持按用户ID查询统计
+  - 临时消息自动清理
+  - 错误提示自动消失
 
 ### 指令
 
@@ -54,9 +75,14 @@
 ### 注意事项
 
 1. 图片和视频会自动保存到本地，请确保存储空间充足
-2. 管理员不受群组冷却时间限制
-3. 开启审核模式后，白名单内的用户可直接投稿
-4. 引用消息添加时会保留原消息的格式与布局
-5. 支持自动检测重复图片内容，可通过阈值调整严格程度
+2. 管理员不受群组冷却时间限制且可查看所有用户统计
+3. 开启审核模式后，白名单内的用户/群组/频道可直接投稿
+4. 引用消息添加时会保留原消息的格式与布局顺序
+5. 支持两种重复检测机制：
+   - 基于MD5的精确查重
+   - 基于感知哈希的相似度查重
 6. 黑名单中的用户无法使用任何功能
-7. 支持按页码查看投稿统计，提升大量数据的浏览体验
+7. 支持按页码和用户ID查看投稿统计
+8. 临时消息（如错误提示）会在10秒后自动消失
+9. 视频内容会单独发送以保证正常显示
+10. 支持自动清理被拒绝或删除的媒体文件