koishi-plugin-best-cave 2.2.1 → 2.2.3

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/Utils.d.ts

@@ -0,0 +1,85 @@
+import { Context, h, Logger, Session } from 'koishi';
+import { CaveObject, Config, StoredElement, CaveHashObject } from './index';
+import { FileManager } from './FileManager';
+import { HashManager } 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;
+    }[];
+}>;
+/**
+ * @description 异步处理文件上传、查重和状态更新的后台任务。
+ * @param ctx - Koishi 上下文。
+ * @param config - 插件配置。
+ * @param fileManager - FileManager 实例，用于保存文件。
+ * @param logger - 日志记录器实例。
+ * @param reviewManager - ReviewManager 实例，用于提交审核。
+ * @param cave - 刚刚在数据库中创建的 `preload` 状态的回声洞对象。
+ * @param mediaToSave - 需要下载和处理的媒体文件列表。
+ * @param reusableIds - 可复用 ID 的内存缓存。
+ * @param session - 触发此操作的用户会话，用于发送反馈。
+ * @param hashManager - HashManager 实例，如果启用则用于哈希计算和比较。
+ * @param textHashesToStore - 已预先计算好的、待存入数据库的文本哈希对象数组。
+ */
+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.js

@@ -427,32 +427,39 @@ 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 existingPHashes = hashManager ? await ctx.database.get("cave_hash", { type: "phash" }) : [];
+    const existingSubHashes = hashManager ? await ctx.database.get("cave_hash", { type: "sub" }) : [];
+    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);
+        for (const existing of existingPHashes) {
+          const similarity = hashManager.calculateSimilarity(pHash, 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;
+          }
+        }
+        const pHashEntry = { hash: pHash, type: "phash" };
+        imageHashesToStore.push(pHashEntry);
         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);
+        for (const newSubHash of subHashes) {
+          for (const existing of existingSubHashes) {
+            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)}%`);
             }
           }
         }
-        const pHashEntry = { hash: pHash, type: "phash" };
         const subHashEntries = [...subHashes].map((sh) => ({ hash: sh, type: "sub" }));
-        imageHashesToStore.push(pHashEntry, ...subHashEntries);
+        imageHashesToStore.push(...subHashEntries);
       }
     }
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
@@ -597,25 +604,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.generateHashesForHistoricalCaves();
+      } catch (error) {
+        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.validateAllCaves();
+        return await this.checkForSimilarCaves();
       } catch (error) {
-        this.logger.error("校验哈希失败:", error);
-        return `校验失败: ${error.message}`;
+        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 = [];
@@ -664,51 +686,84 @@ var HashManager = class {
       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();
+    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);
+      switch (hash.type) {
+        case "sim":
+          caveTextHashes.set(hash.cave, hash.hash);
+          break;
+        case "phash":
+          if (!caveImagePHashes.has(hash.cave)) caveImagePHashes.set(hash.cave, []);
+          caveImagePHashes.get(hash.cave).push(hash.hash);
+          break;
+        case "sub":
+          if (!subHashToCaves.has(hash.hash)) subHashToCaves.set(hash.hash, /* @__PURE__ */ new Set());
+          subHashToCaves.get(hash.hash).add(hash.cave);
+          break;
       }
     }
-    const caveIds = allCaves.map((c) => c.id);
-    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 subHashDuplicates = [];
+    subHashToCaves.forEach((caves, hash) => {
+      if (caves.size > 1) {
+        const sortedCaves = [...caves].sort((a, b) => a - b).join(", ");
+        subHashDuplicates.push(`[${sortedCaves}]`);
+      }
+    });
+    const textSimilarPairs = [];
+    const imageSimilarPairs = [];
+    const allCaveIds = Array.from(/* @__PURE__ */ new Set([...caveTextHashes.keys(), ...caveImagePHashes.keys()]));
+    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 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)}%`);
+            textSimilarPairs.push(`${id1} & ${id2} = ${(textSim * 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 pHashes1 = caveImagePHashes.get(id1) || [];
+        const pHashes2 = caveImagePHashes.get(id2) || [];
+        if (pHashes1.length > 0 && pHashes2.length > 0) {
+          for (const imgHash1 of pHashes1) {
+            for (const imgHash2 of pHashes2) {
               const imgSim = this.calculateSimilarity(imgHash1, imgHash2);
               if (imgSim >= this.config.imageThreshold) {
-                similarPairs.add(`图片:（${id1}，${id2}），相似度：${(imgSim * 100).toFixed(2)}%`);
+                imageSimilarPairs.push(`${id1} & ${id2} = ${(imgSim * 100).toFixed(2)}%`);
               }
             }
           }
         }
       }
     }
-    const similarityReport = similarPairs.size > 0 ? `发现 ${similarPairs.size} 对高相似度内容:
-` + [...similarPairs].join("\n") : "未发现高相似度内容";
-    return `校验完成:
-${generationReport}${similarityReport}`;
+    const totalFindings = textSimilarPairs.length + imageSimilarPairs.length + subHashDuplicates.length;
+    if (totalFindings === 0) {
+      return "未发现高相似度的内容";
+    }
+    let report = `已发现 ${totalFindings} 组高相似度的内容:
+`;
+    if (textSimilarPairs.length > 0) {
+      report += "文本相似度过高:\n" + [...new Set(textSimilarPairs)].join("\n");
+    }
+    if (imageSimilarPairs.length > 0) {
+      report += "图片相似度过高:\n" + [...new Set(imageSimilarPairs)].join("\n");
+    }
+    if (subHashDuplicates.length > 0) {
+      report += "子图完全重复:\n" + subHashDuplicates.join("\n");
+    }
+    return report.trim();
   }
   /**
    * @description 将图片切割为4个象限并为每个象限生成pHash。
@@ -898,7 +953,7 @@ function apply(ctx, config) {
           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" });
@@ -967,7 +1022,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.1",
+  "version": "2.2.3",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],