koishi-plugin-best-cave 1.3.4 → 1.3.5

package/lib/index.js

@@ -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}`);
-      }
-      await this.saveHashes();
-    } catch (error) {
-      logger3.error(`Failed to update hash (cave ${caveId}): ${error.message}`);
-    }
-  }
-  /**
-   * 更新所有回声洞的哈希值
-   * @param isInitialBuild 是否为初始构建
-   */
-  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);
+      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();
-      logger3.success(`Update completed. Processed ${processedCount}/${totalImages} images`);
     } catch (error) {
-      logger3.error(`Full update failed: ${error.message}`);
-      throw error;
+      logger3.error(`Failed to update ${type} hash for cave ${caveId}: ${error.message}`);
     }
   }
   /**
-   * 查找重复的图片
-   * @param imgBuffers 待查找的图片buffer数组
-   * @param threshold 相似度阈值
-   * @returns 匹配结果数组，包含索引、回声洞ID和相似度
+   * 查找重复项
+   * @param type - 查找类型（图像或文本）
+   * @param hashes - 要查找的哈希值数组
+   * @param threshold - 相似度阈值，默认为1
+   * @returns 匹配结果数组
    */
-  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
@@ -1025,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);
@@ -1054,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();
@@ -1063,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);
       }
@@ -1098,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
       };
@@ -1109,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);
@@ -1137,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}`);
@@ -1503,7 +1438,7 @@ async function saveMedia(urls, fileNames, resourceDir, caveId, mediaType, config
         if (config.enableDuplicate) {
           const hashStorage2 = new HashStorage(path4.join(ctx.baseDir, "data", "cave"));
           await hashStorage2.initialize();
-          const result = await hashStorage2.findDuplicates([buffer], config.duplicateThreshold);
+          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;
@@ -1528,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.4",
+  "version": "1.3.5",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],