koishi-plugin-best-cave 2.2.0 → 2.2.2

package/lib/HashManager.d.ts

@@ -24,10 +24,15 @@ export declare class HashManager {
      */
     registerCommands(cave: any): void;
     /**
-     * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希，并在此之后对所有内容进行相似度检查。
+     * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希。
      * @returns {Promise<string>} 一个包含操作结果的报告字符串。
      */
-    validateAllCaves(): Promise<string>;
+    generateHashesForHistoricalCaves(): Promise<string>;
+    /**
+     * @description 对所有已存在哈希的回声洞进行相似度检查。
+     * @returns {Promise<string>} 一个包含操作结果的报告字符串。
+     */
+    checkForSimilarCaves(): Promise<string>;
     /**
      * @description 将图片切割为4个象限并为每个象限生成pHash。
      * @param imageBuffer - 图片的 Buffer 数据。

package/lib/index.js

@@ -597,25 +597,40 @@ var HashManager = class {
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".hash", "校验回声洞").usage("校验所有回声洞，为历史数据生成哈希，并检查现有内容的相似度。").action(async ({ session }) => {
+    const adminCheck = /* @__PURE__ */ __name(({ session }) => {
       const adminChannelId = this.config.adminChannel?.split(":")[1];
       if (session.channelId !== adminChannelId) {
         return "此指令仅限在管理群组中使用";
       }
-      await session.send("正在处理，请稍候...");
+    }, "adminCheck");
+    cave.subcommand(".hash", "校验回声洞").usage("校验所有回声洞，补全所有哈希记录。").action(async (argv) => {
+      const checkResult = adminCheck(argv);
+      if (checkResult) return checkResult;
+      await argv.session.send("正在处理，请稍候...");
       try {
-        return await this.validateAllCaves();
+        return await this.generateHashesForHistoricalCaves();
       } catch (error) {
-        this.logger.error("校验哈希失败:", error);
-        return `校验失败: ${error.message}`;
+        this.logger.error("生成历史哈希失败:", error);
+        return `操作失败: ${error.message}`;
+      }
+    });
+    cave.subcommand(".check", "检查回声洞").usage("检查所有已存在哈希的回声洞的相似度。").action(async (argv) => {
+      const checkResult = adminCheck(argv);
+      if (checkResult) return checkResult;
+      await argv.session.send("正在检查，请稍候...");
+      try {
+        return await this.checkForSimilarCaves();
+      } catch (error) {
+        this.logger.error("检查相似度失败:", error);
+        return `检查失败: ${error.message}`;
       }
     });
   }
   /**
-   * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希，并在此之后对所有内容进行相似度检查。
+   * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希。
    * @returns {Promise<string>} 一个包含操作结果的报告字符串。
    */
-  async validateAllCaves() {
+  async generateHashesForHistoricalCaves() {
     const allCaves = await this.ctx.database.get("cave", { status: "active" });
     const existingHashedCaveIds = new Set((await this.ctx.database.get("cave_hash", {}, { fields: ["cave"] })).map((h4) => h4.cave));
     let hashesToInsert = [];
@@ -625,8 +640,12 @@ var HashManager = class {
     const flushHashes = /* @__PURE__ */ __name(async () => {
       if (hashesToInsert.length > 0) {
         this.logger.info(`补全第 ${batchStartCaveCount + 1} 到 ${historicalCount} 条回声洞哈希中...`);
-        await this.ctx.database.upsert("cave_hash", hashesToInsert);
-        totalHashesGenerated += hashesToInsert.length;
+        try {
+          await this.ctx.database.upsert("cave_hash", hashesToInsert);
+          totalHashesGenerated += hashesToInsert.length;
+        } catch (error) {
+          this.logger.error(`导入哈希失败: ${error.message}`);
+        }
         hashesToInsert = [];
         batchStartCaveCount = historicalCount;
       }
@@ -634,26 +653,39 @@ var HashManager = class {
     for (const cave of allCaves) {
       if (existingHashedCaveIds.has(cave.id)) continue;
       historicalCount++;
+      const newHashesForCave = [];
       const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
-      if (combinedText) {
-        hashesToInsert.push({ cave: cave.id, hash: this.generateTextSimhash(combinedText), type: "sim" });
+      const textHash = this.generateTextSimhash(combinedText);
+      if (textHash) {
+        newHashesForCave.push({ cave: cave.id, hash: textHash, type: "sim" });
       }
       for (const el of cave.elements.filter((el2) => el2.type === "image" && el2.file)) {
         try {
           const imageBuffer = await this.fileManager.readFile(el.file);
           const pHash = await this.generateImagePHash(imageBuffer);
-          hashesToInsert.push({ cave: cave.id, hash: pHash, type: "phash" });
+          newHashesForCave.push({ cave: cave.id, hash: pHash, type: "phash" });
           const subHashes = await this.generateImageSubHashes(imageBuffer);
-          subHashes.forEach((subHash) => hashesToInsert.push({ cave: cave.id, hash: subHash, type: "sub" }));
+          subHashes.forEach((subHash) => newHashesForCave.push({ cave: cave.id, hash: subHash, type: "sub" }));
         } catch (e) {
           this.logger.warn(`无法为回声洞（${cave.id}）的内容（${el.file}）生成哈希:`, e);
         }
       }
+      const uniqueHashesMap = /* @__PURE__ */ new Map();
+      newHashesForCave.forEach((h4) => {
+        const uniqueKey = `${h4.type}-${h4.hash}`;
+        uniqueHashesMap.set(uniqueKey, h4);
+      });
+      hashesToInsert.push(...uniqueHashesMap.values());
       if (hashesToInsert.length >= 100) await flushHashes();
     }
     await flushHashes();
-    const generationReport = totalHashesGenerated > 0 ? `已补全 ${historicalCount} 个回声洞的 ${totalHashesGenerated} 条哈希
-` : "无需补全回声洞的哈希\n";
+    return totalHashesGenerated > 0 ? `已补全 ${historicalCount} 个回声洞的 ${totalHashesGenerated} 条哈希` : "无需补全回声洞哈希";
+  }
+  /**
+   * @description 对所有已存在哈希的回声洞进行相似度检查。
+   * @returns {Promise<string>} 一个包含操作结果的报告字符串。
+   */
+  async checkForSimilarCaves() {
     const allHashes = await this.ctx.database.get("cave_hash", {});
     const caveTextHashes = /* @__PURE__ */ new Map();
     const caveImagePHashes = /* @__PURE__ */ new Map();
@@ -665,7 +697,7 @@ var HashManager = class {
         caveImagePHashes.get(hash.cave).push(hash.hash);
       }
     }
-    const caveIds = allCaves.map((c) => c.id);
+    const caveIds = Array.from(/* @__PURE__ */ new Set([...caveTextHashes.keys(), ...caveImagePHashes.keys()]));
     const similarPairs = /* @__PURE__ */ new Set();
     for (let i = 0; i < caveIds.length; i++) {
       for (let j = i + 1; j < caveIds.length; j++) {
@@ -676,7 +708,7 @@ var HashManager = class {
         if (textHash1 && textHash2) {
           const textSim = this.calculateSimilarity(textHash1, textHash2);
           if (textSim >= this.config.textThreshold) {
-            similarPairs.add(`文本:（${id1}，${id2}），相似度：${(textSim * 100).toFixed(2)}%`);
+            similarPairs.add(`文本${id1}&${id2}=${(textSim * 100).toFixed(2)}%`);
           }
         }
         const imageHashes1 = caveImagePHashes.get(id1) || [];
@@ -686,17 +718,15 @@ var HashManager = class {
             for (const imgHash2 of imageHashes2) {
               const imgSim = this.calculateSimilarity(imgHash1, imgHash2);
               if (imgSim >= this.config.imageThreshold) {
-                similarPairs.add(`图片:（${id1}，${id2}），相似度：${(imgSim * 100).toFixed(2)}%`);
+                similarPairs.add(`图片${id1}&${id2}=${(imgSim * 100).toFixed(2)}%`);
               }
             }
           }
         }
       }
     }
-    const similarityReport = similarPairs.size > 0 ? `发现 ${similarPairs.size} 对高相似度内容:
+    return similarPairs.size > 0 ? `已发现 ${similarPairs.size} 对高相似度内容:
 ` + [...similarPairs].join("\n") : "未发现高相似度内容";
-    return `校验完成:
-${generationReport}${similarityReport}`;
   }
   /**
    * @description 将图片切割为4个象限并为每个象限生成pHash。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "功能强大、高度可定制的回声洞。支持丰富的媒体类型、内容查重、人工审核、用户昵称、数据迁移以及本地/S3 双重文件存储后端。",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],