koishi-plugin-best-cave 2.2.2 → 2.2.4

package/lib/HashManager.d.ts

@@ -1,9 +1,18 @@
 import { Context, Logger } from 'koishi';
-import { Config } from './index';
+import { Config, CaveObject } from './index';
 import { FileManager } from './FileManager';
+/**
+ * @description 数据库 `cave_hash` 表的完整对象模型。
+ */
+export interface CaveHashObject {
+    cave: number;
+    hash: string;
+    type: 'simhash' | 'phash_color' | 'dhash_gray' | 'sub_phash_q1' | 'sub_phash_q2' | 'sub_phash_q3' | 'sub_phash_q4';
+}
 /**
  * @class HashManager
  * @description 封装了所有与文本和图片哈希生成、相似度比较、以及相关命令的功能。
+ * 实现了高精度的混合策略查重方案。
  */
 export declare class HashManager {
     private ctx;
@@ -29,40 +38,73 @@ export declare class HashManager {
      */
     generateHashesForHistoricalCaves(): Promise<string>;
     /**
-     * @description 对所有已存在哈希的回声洞进行相似度检查。
+     * @description 为单个回声洞对象生成所有类型的哈希。
+     * @param cave - 回声洞对象。
+     * @returns {Promise<CaveHashObject[]>} 生成的哈希对象数组。
+     */
+    generateAllHashesForCave(cave: Pick<CaveObject, 'id' | 'elements'>): Promise<CaveHashObject[]>;
+    /**
+     * @description 为单个图片Buffer生成所有类型的哈希。
+     * @param imageBuffer - 图片的Buffer数据。
+     * @returns {Promise<object>} 包含所有图片哈希的对象。
+     */
+    generateAllImageHashes(imageBuffer: Buffer): Promise<{
+        colorPHash: string;
+        dHash: string;
+        subHashes: {
+            q1: string;
+            q2: string;
+            q3: string;
+            q4: string;
+        };
+    }>;
+    /**
+     * @description 对回声洞进行混合策略的相似度与重复内容检查。
      * @returns {Promise<string>} 一个包含操作结果的报告字符串。
      */
     checkForSimilarCaves(): Promise<string>;
+    private _generateSingleChannelPHash;
     /**
-     * @description 将图片切割为4个象限并为每个象限生成pHash。
+     * @description 生成768位颜色感知哈希（Color pHash）。
      * @param imageBuffer - 图片的 Buffer 数据。
-     * @returns {Promise<Set<string>>} 一个包含最多4个唯一哈希值的集合。
+     * @returns {Promise<string>} 768位二进制哈希对应的192位十六进制字符串。
      */
-    generateImageSubHashes(imageBuffer: Buffer): Promise<Set<string>>;
+    generateColorPHash(imageBuffer: Buffer): Promise<string>;
     /**
-     * @description 根据感知哈希（pHash）算法为图片生成哈希。
-     * @param imageBuffer 图片的 Buffer 数据。
-     * @returns 64位二进制哈希字符串。
+     * @description 生成256位差异哈希（dHash）。
+     * @param imageBuffer - 图片的 Buffer 数据。
+     * @returns {Promise<string>} 256位二进制哈希对应的64位十六进制字符串。
+     */
+    generateDHash(imageBuffer: Buffer): Promise<string>;
+    /**
+     * @description 将图片切割为4个象限并为每个象限生成Color pHash。
+     * @param imageBuffer - 图片的 Buffer 数据。
+     * @returns {Promise<object>} 包含四个象限哈希的对象。
      */
-    generateImagePHash(imageBuffer: Buffer): Promise<string>;
+    generateImageSubHashes(imageBuffer: Buffer): Promise<{
+        q1: string;
+        q2: string;
+        q3: string;
+        q4: string;
+    }>;
     /**
-     * @description 计算两个哈希字符串之间的汉明距离（不同字符的数量）。
-     * @param hash1 - 第一个哈希字符串。
-     * @param hash2 - 第二个哈希字符串。
+     * @description 计算两个十六进制哈希字符串之间的汉明距离。
+     * @param hex1 - 第一个十六进制哈希字符串。
+     * @param hex2 - 第二个十六进制哈希字符串。
      * @returns {number} 两个哈希之间的距离。
      */
-    calculateHammingDistance(hash1: string, hash2: string): number;
+    calculateHammingDistance(hex1: string, hex2: string): number;
     /**
      * @description 根据汉明距离计算图片或文本哈希的相似度。
-     * @param hash1 - 第一个哈希字符串。
-     * @param hash2 - 第二个哈希字符串。
+     * @param hex1 - 第一个十六进制哈希字符串。
+     * @param hex2 - 第二个十六进制哈希字符串。
      * @returns {number} 范围在0到1之间的相似度得分。
      */
-    calculateSimilarity(hash1: string, hash2: string): number;
+    calculateSimilarity(hex1: string, hex2: string): number;
     /**
      * @description 为文本生成基于 Simhash 算法的哈希字符串。
      * @param text - 需要处理的文本。
-     * @returns {string} 64位二进制 Simhash 字符串。
+     * @returns {string} 64位二进制 Simhash 对应的16位十六进制字符串。
      */
     generateTextSimhash(text: string): string;
 }

package/lib/Utils.d.ts

@@ -0,0 +1,71 @@
+import { Context, h, Logger, Session } from 'koishi';
+import { CaveObject, Config, StoredElement } from './index';
+import { FileManager } from './FileManager';
+import { HashManager, CaveHashObject } from './HashManager';
+import { ReviewManager } from './ReviewManager';
+/**
+ * @description 将数据库存储的 StoredElement[] 转换为 Koishi 的 h() 元素数组。
+ * @param elements 从数据库读取的元素数组。
+ * @returns 转换后的 h() 元素数组。
+ */
+export declare function storedFormatToHElements(elements: StoredElement[]): h[];
+/**
+ * @description 构建一条用于发送的完整回声洞消息，处理不同存储后端的资源链接。
+ * @param cave 回声洞对象。
+ * @param config 插件配置。
+ * @param fileManager 文件管理器实例。
+ * @param logger 日志记录器实例。
+ * @returns 包含 h() 元素和字符串的消息数组。
+ */
+export declare function buildCaveMessage(cave: CaveObject, config: Config, fileManager: FileManager, logger: Logger): Promise<(string | h)[]>;
+/**
+ * @description 清理数据库中标记为 'delete' 状态的回声洞及其关联文件和哈希。
+ * @param ctx Koishi 上下文。
+ * @param fileManager 文件管理器实例。
+ * @param logger 日志记录器实例。
+ * @param reusableIds 可复用 ID 的内存缓存。
+ */
+export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
+/**
+ * @description 根据配置和会话，生成数据库查询的范围条件。
+ * @param session 当前会话。
+ * @param config 插件配置。
+ * @param includeStatus 是否包含 status: 'active' 条件，默认为 true。
+ * @returns 数据库查询条件对象。
+ */
+export declare function getScopeQuery(session: Session, config: Config, includeStatus?: boolean): object;
+/**
+ * @description 获取下一个可用的回声洞 ID，采用“回收ID > 扫描空缺 > 最大ID+1”策略。
+ * @param ctx Koishi 上下文。
+ * @param query 查询范围条件。
+ * @param reusableIds 可复用 ID 的内存缓存。
+ * @returns 可用的新 ID。
+ */
+export declare function getNextCaveId(ctx: Context, query: object, reusableIds: Set<number>): Promise<number>;
+/**
+ * @description 检查用户是否处于指令冷却中。
+ * @returns 若在冷却中则提示字符串，否则 null。
+ */
+export declare function checkCooldown(session: Session, config: Config, lastUsed: Map<string, number>): string | null;
+/**
+ * @description 更新指定频道的指令使用时间戳。
+ */
+export declare function updateCooldownTimestamp(session: Session, config: Config, lastUsed: Map<string, number>): void;
+/**
+ * @description 解析消息元素，分离出文本和待下载的媒体文件。
+ * @param sourceElements 原始的 Koishi 消息元素数组。
+ * @param newId 这条回声洞的新 ID。
+ * @param session 触发操作的会话。
+ * @returns 包含数据库元素和待保存媒体列表的对象。
+ */
+export declare function processMessageElements(sourceElements: h[], newId: number, session: Session): Promise<{
+    finalElementsForDb: StoredElement[];
+    mediaToSave: {
+        sourceUrl: string;
+        fileName: string;
+    }[];
+}>;
+export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: ReviewManager, cave: CaveObject, mediaToToSave: {
+    sourceUrl: string;
+    fileName: string;
+}[], reusableIds: Set<number>, session: Session, hashManager: HashManager, textHashesToStore: Omit<CaveHashObject, 'cave'>[]): Promise<void>;

package/lib/index.d.ts

@@ -0,0 +1,53 @@
+import { Context, Schema } from 'koishi';
+import { CaveHashObject } from './HashManager';
+export declare const name = "best-cave";
+export declare const inject: string[];
+export declare const usage = "\n<div style=\"border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);\">\n  <h2 style=\"margin-top: 0; color: #4a6ee0;\">\uD83D\uDCCC \u63D2\u4EF6\u8BF4\u660E</h2>\n  <p>\uD83D\uDCD6 <strong>\u4F7F\u7528\u6587\u6863</strong>\uFF1A\u8BF7\u70B9\u51FB\u5DE6\u4E0A\u89D2\u7684 <strong>\u63D2\u4EF6\u4E3B\u9875</strong> \u67E5\u770B\u63D2\u4EF6\u4F7F\u7528\u6587\u6863</p>\n  <p>\uD83D\uDD0D <strong>\u66F4\u591A\u63D2\u4EF6</strong>\uFF1A\u53EF\u8BBF\u95EE <a href=\"https://github.com/YisRime\" style=\"color:#4a6ee0;text-decoration:none;\">\u82E1\u6DDE\u7684 GitHub</a> \u67E5\u770B\u672C\u4EBA\u7684\u6240\u6709\u63D2\u4EF6</p>\n</div>\n<div style=\"border-radius: 10px; border: 1px solid #ddd; padding: 16px; margin-bottom: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);\">\n  <h2 style=\"margin-top: 0; color: #e0574a;\">\u2764\uFE0F \u652F\u6301\u4E0E\u53CD\u9988</h2>\n  <p>\uD83C\uDF1F \u559C\u6B22\u8FD9\u4E2A\u63D2\u4EF6\uFF1F\u8BF7\u5728 <a href=\"https://github.com/YisRime\" style=\"color:#e0574a;text-decoration:none;\">GitHub</a> \u4E0A\u7ED9\u6211\u4E00\u4E2A Star\uFF01</p>\n  <p>\uD83D\uDC1B \u9047\u5230\u95EE\u9898\uFF1F\u8BF7\u901A\u8FC7 <strong>Issues</strong> \u63D0\u4EA4\u53CD\u9988\uFF0C\u6216\u52A0\u5165 QQ \u7FA4 <a href=\"https://qm.qq.com/q/PdLMx9Jowq\" style=\"color:#e0574a;text-decoration:none;\"><strong>855571375</strong></a> \u8FDB\u884C\u4EA4\u6D41</p>\n</div>\n";
+/**
+ * @description 存储在数据库中的单个消息元素。
+ */
+export interface StoredElement {
+    type: 'text' | 'image' | 'video' | 'audio' | 'file';
+    content?: string;
+    file?: string;
+}
+/**
+ * @description 数据库 `cave` 表的完整对象模型。
+ */
+export interface CaveObject {
+    id: number;
+    elements: StoredElement[];
+    channelId: string;
+    userId: string;
+    userName: string;
+    status: 'active' | 'delete' | 'pending' | 'preload';
+    time: Date;
+}
+declare module 'koishi' {
+    interface Tables {
+        cave: CaveObject;
+        cave_hash: CaveHashObject;
+    }
+}
+export interface Config {
+    coolDown: number;
+    perChannel: boolean;
+    adminChannel: string;
+    enableProfile: boolean;
+    enableIO: boolean;
+    enableReview: boolean;
+    caveFormat: string;
+    enableSimilarity: boolean;
+    textThreshold: number;
+    imageThreshold: number;
+    localPath?: string;
+    enableS3: boolean;
+    endpoint?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    bucket?: string;
+    publicUrl?: string;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -427,32 +427,66 @@ async function processMessageElements(sourceElements, newId, session) {
   return { finalElementsForDb, mediaToSave };
 }
 __name(processMessageElements, "processMessageElements");
-async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, mediaToSave, reusableIds, session, hashManager, textHashesToStore) {
+async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, mediaToToSave, reusableIds, session, hashManager, textHashesToStore) {
   try {
     const downloadedMedia = [];
     const imageHashesToStore = [];
-    for (const media of mediaToSave) {
+    const existingHashes = hashManager ? await ctx.database.get("cave_hash", { type: { $ne: "simhash" } }) : [];
+    const existingColorPHashes = existingHashes.filter((h4) => h4.type === "phash_color");
+    const existingDHashes = existingHashes.filter((h4) => h4.type === "dhash_gray");
+    const existingSubHashObjects = existingHashes.filter((h4) => h4.type.startsWith("sub_phash_"));
+    for (const media of mediaToToSave) {
       const buffer = Buffer.from(await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 3e4 }));
       downloadedMedia.push({ fileName: media.fileName, buffer });
       if (hashManager && [".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
-        const pHash = await hashManager.generateImagePHash(buffer);
-        const subHashes = await hashManager.generateImageSubHashes(buffer);
-        const allNewImageHashes = [pHash, ...subHashes];
-        const existingImageHashes = await ctx.database.get("cave_hash", { type: /^image_/ });
-        for (const newHash of allNewImageHashes) {
-          for (const existing of existingImageHashes) {
-            const similarity = hashManager.calculateSimilarity(newHash, existing.hash);
+        const { colorPHash, dHash, subHashes } = await hashManager.generateAllImageHashes(buffer);
+        let caveToDelete = null;
+        let highestCombinedSimilarity = 0;
+        const similarityScores = /* @__PURE__ */ new Map();
+        for (const existing of existingColorPHashes) {
+          const similarity = hashManager.calculateSimilarity(colorPHash, existing.hash);
+          if (similarity >= config.imageThreshold) {
+            if (!similarityScores.has(existing.cave)) similarityScores.set(existing.cave, {});
+            similarityScores.get(existing.cave).colorSim = similarity;
+          }
+        }
+        for (const existing of existingDHashes) {
+          const similarity = hashManager.calculateSimilarity(dHash, existing.hash);
+          if (similarity >= config.imageThreshold) {
+            if (!similarityScores.has(existing.cave)) similarityScores.set(existing.cave, {});
+            similarityScores.get(existing.cave).dSim = similarity;
+          }
+        }
+        for (const [caveId, scores] of similarityScores.entries()) {
+          if (scores.colorSim && scores.dSim) {
+            caveToDelete = caveId;
+            highestCombinedSimilarity = scores.colorSim;
+            break;
+          }
+        }
+        if (caveToDelete) {
+          await session.send(`图片与回声洞（${caveToDelete}）的相似度为 ${(highestCombinedSimilarity * 100).toFixed(2)}%，超过阈值`);
+          await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
+          cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
+          return;
+        }
+        const notifiedPartialCaves = /* @__PURE__ */ new Set();
+        for (const newSubHash of Object.values(subHashes)) {
+          for (const existing of existingSubHashObjects) {
+            if (notifiedPartialCaves.has(existing.cave)) continue;
+            const similarity = hashManager.calculateSimilarity(newSubHash, existing.hash);
             if (similarity >= config.imageThreshold) {
-              await session.send(`图片与回声洞（${existing.cave}）的相似度（${(similarity * 100).toFixed(2)}%）过高`);
-              await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
-              reusableIds.add(cave.id);
-              return;
+              await session.send(`图片局部与回声洞（${existing.cave}）的相似度为 ${(similarity * 100).toFixed(2)}%`);
+              notifiedPartialCaves.add(existing.cave);
             }
           }
         }
-        const pHashEntry = { hash: pHash, type: "phash" };
-        const subHashEntries = [...subHashes].map((sh) => ({ hash: sh, type: "sub" }));
-        imageHashesToStore.push(pHashEntry, ...subHashEntries);
+        imageHashesToStore.push({ hash: colorPHash, type: "phash_color" });
+        imageHashesToStore.push({ hash: dHash, type: "dhash_gray" });
+        imageHashesToStore.push({ hash: subHashes.q1, type: "sub_phash_q1" });
+        imageHashesToStore.push({ hash: subHashes.q2, type: "sub_phash_q2" });
+        imageHashesToStore.push({ hash: subHashes.q3, type: "sub_phash_q3" });
+        imageHashesToStore.push({ hash: subHashes.q4, type: "sub_phash_q4" });
       }
     }
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
@@ -636,165 +670,247 @@ var HashManager = class {
     let hashesToInsert = [];
     let historicalCount = 0;
     let totalHashesGenerated = 0;
-    let batchStartCaveCount = 0;
-    const flushHashes = /* @__PURE__ */ __name(async () => {
-      if (hashesToInsert.length > 0) {
-        this.logger.info(`补全第 ${batchStartCaveCount + 1} 到 ${historicalCount} 条回声洞哈希中...`);
-        try {
-          await this.ctx.database.upsert("cave_hash", hashesToInsert);
-          totalHashesGenerated += hashesToInsert.length;
-        } catch (error) {
-          this.logger.error(`导入哈希失败: ${error.message}`);
-        }
-        hashesToInsert = [];
-        batchStartCaveCount = historicalCount;
-      }
-    }, "flushHashes");
     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(" ");
-      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);
-          newHashesForCave.push({ cave: cave.id, hash: pHash, type: "phash" });
-          const subHashes = await this.generateImageSubHashes(imageBuffer);
-          subHashes.forEach((subHash) => newHashesForCave.push({ cave: cave.id, hash: subHash, type: "sub" }));
-        } catch (e) {
-          this.logger.warn(`无法为回声洞（${cave.id}）的内容（${el.file}）生成哈希:`, e);
-        }
+      const newHashesForCave = await this.generateAllHashesForCave(cave);
+      hashesToInsert.push(...newHashesForCave);
+      if (hashesToInsert.length >= 100) {
+        await this.ctx.database.upsert("cave_hash", hashesToInsert);
+        totalHashesGenerated += hashesToInsert.length;
+        hashesToInsert = [];
       }
-      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();
+    if (hashesToInsert.length > 0) {
+      await this.ctx.database.upsert("cave_hash", hashesToInsert);
+      totalHashesGenerated += hashesToInsert.length;
+    }
     return totalHashesGenerated > 0 ? `已补全 ${historicalCount} 个回声洞的 ${totalHashesGenerated} 条哈希` : "无需补全回声洞哈希";
   }
   /**
-   * @description 对所有已存在哈希的回声洞进行相似度检查。
+   * @description 为单个回声洞对象生成所有类型的哈希。
+   * @param cave - 回声洞对象。
+   * @returns {Promise<CaveHashObject[]>} 生成的哈希对象数组。
+   */
+  async generateAllHashesForCave(cave) {
+    const allHashes = [];
+    const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
+    if (combinedText) {
+      const textHash = this.generateTextSimhash(combinedText);
+      allHashes.push({ cave: cave.id, hash: textHash, type: "simhash" });
+    }
+    for (const el of cave.elements.filter((el2) => el2.type === "image" && el2.file)) {
+      try {
+        const imageBuffer = await this.fileManager.readFile(el.file);
+        const imageHashes = await this.generateAllImageHashes(imageBuffer);
+        allHashes.push({ cave: cave.id, hash: imageHashes.colorPHash, type: "phash_color" });
+        allHashes.push({ cave: cave.id, hash: imageHashes.dHash, type: "dhash_gray" });
+        allHashes.push({ cave: cave.id, hash: imageHashes.subHashes.q1, type: "sub_phash_q1" });
+        allHashes.push({ cave: cave.id, hash: imageHashes.subHashes.q2, type: "sub_phash_q2" });
+        allHashes.push({ cave: cave.id, hash: imageHashes.subHashes.q3, type: "sub_phash_q3" });
+        allHashes.push({ cave: cave.id, hash: imageHashes.subHashes.q4, type: "sub_phash_q4" });
+      } catch (e) {
+        this.logger.warn(`无法为回声洞（${cave.id}）的内容（${el.file}）生成哈希:`, e);
+      }
+    }
+    return allHashes;
+  }
+  /**
+   * @description 为单个图片Buffer生成所有类型的哈希。
+   * @param imageBuffer - 图片的Buffer数据。
+   * @returns {Promise<object>} 包含所有图片哈希的对象。
+   */
+  async generateAllImageHashes(imageBuffer) {
+    const [colorPHash, dHash, subHashes] = await Promise.all([
+      this.generateColorPHash(imageBuffer),
+      this.generateDHash(imageBuffer),
+      this.generateImageSubHashes(imageBuffer)
+    ]);
+    return { colorPHash, dHash, subHashes };
+  }
+  /**
+   * @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();
+    const caves = await this.ctx.database.get("cave", { status: "active" }, { fields: ["id"] });
+    const allCaveIds = caves.map((c) => c.id);
+    const hashGroups = {
+      simhash: /* @__PURE__ */ new Map(),
+      phash_color: /* @__PURE__ */ new Map(),
+      dhash_gray: /* @__PURE__ */ new Map()
+    };
+    const subHashToCaves = /* @__PURE__ */ new Map();
     for (const hash of allHashes) {
-      if (hash.type === "sim") {
-        caveTextHashes.set(hash.cave, hash.hash);
-      } else if (hash.type === "phash") {
-        if (!caveImagePHashes.has(hash.cave)) caveImagePHashes.set(hash.cave, []);
-        caveImagePHashes.get(hash.cave).push(hash.hash);
+      if (hashGroups[hash.type]) {
+        if (!hashGroups[hash.type].has(hash.cave)) hashGroups[hash.type].set(hash.cave, []);
+        hashGroups[hash.type].get(hash.cave).push(hash.hash);
+      } else if (hash.type.startsWith("sub_phash_")) {
+        if (!subHashToCaves.has(hash.hash)) subHashToCaves.set(hash.hash, /* @__PURE__ */ new Set());
+        subHashToCaves.get(hash.hash).add(hash.cave);
       }
     }
-    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++) {
-        const id1 = caveIds[i];
-        const id2 = caveIds[j];
-        const textHash1 = caveTextHashes.get(id1);
-        const textHash2 = caveTextHashes.get(id2);
-        if (textHash1 && textHash2) {
-          const textSim = this.calculateSimilarity(textHash1, textHash2);
-          if (textSim >= this.config.textThreshold) {
-            similarPairs.add(`文本${id1}&${id2}=${(textSim * 100).toFixed(2)}%`);
+    const similarPairs = {
+      text: /* @__PURE__ */ new Set(),
+      image_color: /* @__PURE__ */ new Set(),
+      image_dhash: /* @__PURE__ */ new Set()
+    };
+    for (let i = 0; i < allCaveIds.length; i++) {
+      for (let j = i + 1; j < allCaveIds.length; j++) {
+        const id1 = allCaveIds[i];
+        const id2 = allCaveIds[j];
+        const simhash1 = hashGroups.simhash.get(id1)?.[0];
+        const simhash2 = hashGroups.simhash.get(id2)?.[0];
+        if (simhash1 && simhash2) {
+          const sim = this.calculateSimilarity(simhash1, simhash2);
+          if (sim >= this.config.textThreshold) {
+            similarPairs.text.add(`${id1} & ${id2} = ${(sim * 100).toFixed(2)}%`);
+          }
+        }
+        const colorHashes1 = hashGroups.phash_color.get(id1) || [];
+        const colorHashes2 = hashGroups.phash_color.get(id2) || [];
+        for (const h1 of colorHashes1) {
+          for (const h22 of colorHashes2) {
+            const sim = this.calculateSimilarity(h1, h22);
+            if (sim >= this.config.imageThreshold) {
+              similarPairs.image_color.add(`${id1} & ${id2} = ${(sim * 100).toFixed(2)}%`);
+            }
           }
         }
-        const imageHashes1 = caveImagePHashes.get(id1) || [];
-        const imageHashes2 = caveImagePHashes.get(id2) || [];
-        if (imageHashes1.length > 0 && imageHashes2.length > 0) {
-          for (const imgHash1 of imageHashes1) {
-            for (const imgHash2 of imageHashes2) {
-              const imgSim = this.calculateSimilarity(imgHash1, imgHash2);
-              if (imgSim >= this.config.imageThreshold) {
-                similarPairs.add(`图片${id1}&${id2}=${(imgSim * 100).toFixed(2)}%`);
-              }
+        const dHashes1 = hashGroups.dhash_gray.get(id1) || [];
+        const dHashes2 = hashGroups.dhash_gray.get(id2) || [];
+        for (const h1 of dHashes1) {
+          for (const h22 of dHashes2) {
+            const sim = this.calculateSimilarity(h1, h22);
+            if (sim >= this.config.imageThreshold) {
+              similarPairs.image_dhash.add(`${id1} & ${id2} = ${(sim * 100).toFixed(2)}%`);
             }
           }
         }
       }
     }
-    return similarPairs.size > 0 ? `已发现 ${similarPairs.size} 对高相似度内容:
-` + [...similarPairs].join("\n") : "未发现高相似度内容";
+    const subHashDuplicates = [];
+    subHashToCaves.forEach((caves2) => {
+      if (caves2.size > 1) {
+        const sortedCaves = [...caves2].sort((a, b) => a - b).join(", ");
+        subHashDuplicates.push(`[${sortedCaves}]`);
+      }
+    });
+    const totalFindings = similarPairs.text.size + similarPairs.image_color.size + similarPairs.image_dhash.size + subHashDuplicates.length;
+    if (totalFindings === 0) return "未发现高相似度的内容";
+    let report = `已发现 ${totalFindings} 组高相似度或重复的内容:`;
+    if (similarPairs.text.size > 0) report += "\n文本近似:\n" + [...similarPairs.text].join("\n");
+    if (similarPairs.image_color.size > 0) report += "\n图片整体相似:\n" + [...similarPairs.image_color].join("\n");
+    if (similarPairs.image_dhash.size > 0) report += "\n图片结构相似:\n" + [...similarPairs.image_dhash].join("\n");
+    if (subHashDuplicates.length > 0) report += "\n图片局部重复:\n" + [...new Set(subHashDuplicates)].join("\n");
+    return report.trim();
+  }
+  async _generateSingleChannelPHash(channelBuffer, size) {
+    const pixelData = await (0, import_sharp.default)(channelBuffer).resize(size, size, { fit: "fill" }).raw().toBuffer();
+    const totalLuminance = pixelData.reduce((acc, val) => acc + val, 0);
+    const avgLuminance = totalLuminance / (size * size);
+    return Array.from(pixelData).map((lum) => lum > avgLuminance ? "1" : "0").join("");
   }
   /**
-   * @description 将图片切割为4个象限并为每个象限生成pHash。
+   * @description 生成768位颜色感知哈希（Color pHash）。
    * @param imageBuffer - 图片的 Buffer 数据。
-   * @returns {Promise<Set<string>>} 一个包含最多4个唯一哈希值的集合。
+   * @returns {Promise<string>} 768位二进制哈希对应的192位十六进制字符串。
    */
-  async generateImageSubHashes(imageBuffer) {
-    const hashes = /* @__PURE__ */ new Set();
-    try {
-      const metadata = await (0, import_sharp.default)(imageBuffer).metadata();
-      const { width, height } = metadata;
-      if (!width || !height || width < 16 || height < 16) return hashes;
-      const regions = [
-        { left: 0, top: 0, width: Math.floor(width / 2), height: Math.floor(height / 2) },
-        { left: Math.floor(width / 2), top: 0, width: Math.ceil(width / 2), height: Math.floor(height / 2) },
-        { left: 0, top: Math.floor(height / 2), width: Math.floor(width / 2), height: Math.ceil(height / 2) },
-        { left: Math.floor(width / 2), top: Math.floor(height / 2), width: Math.ceil(width / 2), height: Math.ceil(height / 2) }
-      ];
-      for (const region of regions) {
-        if (region.width < 8 || region.height < 8) continue;
-        const quadrantBuffer = await (0, import_sharp.default)(imageBuffer).extract(region).toBuffer();
-        hashes.add(await this.generateImagePHash(quadrantBuffer));
+  async generateColorPHash(imageBuffer) {
+    const { data, info } = await (0, import_sharp.default)(imageBuffer).resize(16, 16, { fit: "fill" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    const { channels } = info;
+    const r = [], g = [], b = [];
+    for (let i = 0; i < data.length; i += channels) {
+      r.push(data[i]);
+      g.push(data[i + 1]);
+      b.push(data[i + 2]);
+    }
+    const [rHash, gHash, bHash] = await Promise.all([
+      this._generateSingleChannelPHash(Buffer.from(r), 16),
+      this._generateSingleChannelPHash(Buffer.from(g), 16),
+      this._generateSingleChannelPHash(Buffer.from(b), 16)
+    ]);
+    const combinedHash = rHash + gHash + bHash;
+    let hex = "";
+    for (let i = 0; i < combinedHash.length; i += 4) {
+      hex += parseInt(combinedHash.substring(i, i + 4), 2).toString(16);
+    }
+    return hex.padStart(192, "0");
+  }
+  /**
+   * @description 生成256位差异哈希（dHash）。
+   * @param imageBuffer - 图片的 Buffer 数据。
+   * @returns {Promise<string>} 256位二进制哈希对应的64位十六进制字符串。
+   */
+  async generateDHash(imageBuffer) {
+    const pixels = await (0, import_sharp.default)(imageBuffer).grayscale().resize(17, 16, { fit: "fill" }).raw().toBuffer();
+    let hash = "";
+    for (let y = 0; y < 16; y++) {
+      for (let x = 0; x < 16; x++) {
+        const i = y * 17 + x;
+        hash += pixels[i] > pixels[i + 1] ? "1" : "0";
       }
-    } catch (e) {
-      this.logger.warn(`生成子哈希失败:`, e);
     }
-    return hashes;
+    return BigInt("0b" + hash).toString(16).padStart(64, "0");
   }
   /**
-   * @description 根据感知哈希（pHash）算法为图片生成哈希。
-   * @param imageBuffer 图片的 Buffer 数据。
-   * @returns 64位二进制哈希字符串。
+   * @description 将图片切割为4个象限并为每个象限生成Color pHash。
+   * @param imageBuffer - 图片的 Buffer 数据。
+   * @returns {Promise<object>} 包含四个象限哈希的对象。
    */
-  async generateImagePHash(imageBuffer) {
-    const smallImage = await (0, import_sharp.default)(imageBuffer).grayscale().resize(8, 8, { fit: "fill" }).raw().toBuffer();
-    const totalLuminance = smallImage.reduce((acc, val) => acc + val, 0);
-    const avgLuminance = totalLuminance / 64;
-    return Array.from(smallImage).map((lum) => lum > avgLuminance ? "1" : "0").join("");
+  async generateImageSubHashes(imageBuffer) {
+    const { width, height } = await (0, import_sharp.default)(imageBuffer).metadata();
+    if (!width || !height || width < 16 || height < 16) {
+      const fallbackHash = await this.generateColorPHash(imageBuffer);
+      return { q1: fallbackHash, q2: fallbackHash, q3: fallbackHash, q4: fallbackHash };
+    }
+    const w2 = Math.floor(width / 2), h22 = Math.floor(height / 2);
+    const regions = [
+      { left: 0, top: 0, width: w2, height: h22 },
+      { left: w2, top: 0, width: width - w2, height: h22 },
+      { left: 0, top: h22, width: w2, height: height - h22 },
+      { left: w2, top: h22, width: width - w2, height: height - h22 }
+    ];
+    const [q1, q2, q3, q4] = await Promise.all(
+      regions.map((region) => {
+        if (region.width < 8 || region.height < 8) return this.generateColorPHash(imageBuffer);
+        return (0, import_sharp.default)(imageBuffer).extract(region).toBuffer().then((b) => this.generateColorPHash(b));
+      })
+    );
+    return { q1, q2, q3, q4 };
   }
   /**
-   * @description 计算两个哈希字符串之间的汉明距离（不同字符的数量）。
-   * @param hash1 - 第一个哈希字符串。
-   * @param hash2 - 第二个哈希字符串。
+   * @description 计算两个十六进制哈希字符串之间的汉明距离。
+   * @param hex1 - 第一个十六进制哈希字符串。
+   * @param hex2 - 第二个十六进制哈希字符串。
    * @returns {number} 两个哈希之间的距离。
    */
-  calculateHammingDistance(hash1, hash2) {
+  calculateHammingDistance(hex1, hex2) {
     let distance = 0;
-    const len = Math.min(hash1.length, hash2.length);
+    const bin1 = hexToBinary(hex1);
+    const bin2 = hexToBinary(hex2);
+    const len = Math.min(bin1.length, bin2.length);
     for (let i = 0; i < len; i++) {
-      if (hash1[i] !== hash2[i]) distance++;
+      if (bin1[i] !== bin2[i]) distance++;
     }
     return distance;
   }
   /**
    * @description 根据汉明距离计算图片或文本哈希的相似度。
-   * @param hash1 - 第一个哈希字符串。
-   * @param hash2 - 第二个哈希字符串。
+   * @param hex1 - 第一个十六进制哈希字符串。
+   * @param hex2 - 第二个十六进制哈希字符串。
    * @returns {number} 范围在0到1之间的相似度得分。
    */
-  calculateSimilarity(hash1, hash2) {
-    const distance = this.calculateHammingDistance(hash1, hash2);
-    const hashLength = Math.max(hash1.length, hash2.length);
+  calculateSimilarity(hex1, hex2) {
+    const distance = this.calculateHammingDistance(hex1, hex2);
+    const hashLength = Math.max(hex1.length, hex2.length) * 4;
     return hashLength === 0 ? 1 : 1 - distance / hashLength;
   }
   /**
    * @description 为文本生成基于 Simhash 算法的哈希字符串。
    * @param text - 需要处理的文本。
-   * @returns {string} 64位二进制 Simhash 字符串。
+   * @returns {string} 64位二进制 Simhash 对应的16位十六进制字符串。
    */
   generateTextSimhash(text) {
     if (!text?.trim()) return "";
@@ -807,9 +923,18 @@ var HashManager = class {
         vector[i] += hash[Math.floor(i / 8)] >> i % 8 & 1 ? 1 : -1;
       }
     });
-    return vector.map((v) => v > 0 ? "1" : "0").join("");
+    const binaryHash = vector.map((v) => v > 0 ? "1" : "0").join("");
+    return BigInt("0b" + binaryHash).toString(16).padStart(16, "0");
   }
 };
+function hexToBinary(hex) {
+  let bin = "";
+  for (let i = 0; i < hex.length; i++) {
+    bin += parseInt(hex[i], 16).toString(2).padStart(4, "0");
+  }
+  return bin;
+}
+__name(hexToBinary, "hexToBinary");
 
 // src/index.ts
 var name = "best-cave";
@@ -912,14 +1037,14 @@ function apply(ctx, config) {
         const combinedText = finalElementsForDb.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
         if (combinedText) {
           const newSimhash = hashManager.generateTextSimhash(combinedText);
-          const existingTextHashes = await ctx.database.get("cave_hash", { type: "sim" });
+          const existingTextHashes = await ctx.database.get("cave_hash", { type: "simhash" });
           for (const existing of existingTextHashes) {
             const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
             if (similarity >= config.textThreshold) {
-              return `内容与回声洞（${existing.cave}）的相似度（${(similarity * 100).toFixed(2)}%）过高`;
+              return `文本与回声洞（${existing.cave}）的相似度为 ${(similarity * 100).toFixed(2)}%，超过阈值`;
             }
           }
-          textHashesToStore.push({ hash: newSimhash, type: "sim" });
+          textHashesToStore.push({ hash: newSimhash, type: "simhash" });
         }
       }
       const userName = (config.enableProfile ? await profileManager.getNickname(session.userId) : null) || session.username;
@@ -985,7 +1110,7 @@ function apply(ctx, config) {
     try {
       const userCaves = await ctx.database.get("cave", { ...getScopeQuery(session, config), userId: session.userId });
       if (!userCaves.length) return "你还没有投稿过回声洞";
-      const caveIds = userCaves.map((c) => c.id).sort((a, b) => a - b).join(", ");
+      const caveIds = userCaves.map((c) => c.id).sort((a, b) => a - b).join("|");
       return `你已投稿 ${userCaves.length} 条回声洞，序号为：
 ${caveIds}`;
     } catch (error) {

package/package.json

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