koishi-plugin-best-cave 2.2.9 → 2.3.1

package/lib/HashManager.d.ts

@@ -45,9 +45,13 @@ export declare class HashManager {
     generateAllHashesForCave(cave: Pick<CaveObject, 'id' | 'elements'>): Promise<CaveHashObject[]>;
     /**
      * @description 对数据库中所有哈希进行两两比较，找出相似度过高的内容。
+     * @param options 包含临时阈值的可选对象。
      * @returns 一个包含检查结果的报告字符串。
      */
-    checkForSimilarCaves(): Promise<string>;
+    checkForSimilarCaves(options?: {
+        textThreshold?: number;
+        imageThreshold?: number;
+    }): Promise<string>;
     /**
      * @description 为单个图片Buffer生成全局pHash和四个象限的局部pHash。
      * @param imageBuffer - 图片的Buffer数据。

package/lib/NameManager.d.ts

@@ -0,0 +1,45 @@
+import { Context } from 'koishi';
+/** 数据库 `cave_user` 表的结构。 */
+export interface UserName {
+    userId: string;
+    nickname: string;
+}
+declare module 'koishi' {
+    interface Tables {
+        cave_user: UserName;
+    }
+}
+/**
+ * @class NameManager
+ * @description 负责管理用户在回声洞中的自定义昵称。
+ */
+export declare class NameManager {
+    private ctx;
+    /**
+     * @constructor
+     * @param ctx - Koishi 上下文，用于初始化数据库模型。
+     */
+    constructor(ctx: Context);
+    /**
+     * @description 注册 `.name` 子命令，用于管理用户昵称。
+     * @param cave - 主 `cave` 命令实例。
+     */
+    registerCommands(cave: any): void;
+    /**
+     * @description 设置或更新指定用户的昵称。
+     * @param userId - 目标用户的 ID。
+     * @param nickname - 要设置的新昵称。
+     */
+    setNickname(userId: string, nickname: string): Promise<void>;
+    /**
+     * @description 获取指定用户的昵称。
+     * @param userId - 目标用户的 ID。
+     * @returns 用户的昵称字符串或 null。
+     */
+    getNickname(userId: string): Promise<string | null>;
+    /**
+     * @description 清除指定用户的昵称设置。
+     * @param userId - 目标用户的 ID。
+     */
+    clearNickname(userId: string): Promise<void>;
+}

package/lib/PendManager.d.ts

@@ -0,0 +1,32 @@
+import { Context, Logger } from 'koishi';
+import { CaveObject, Config } from './index';
+import { FileManager } from './FileManager';
+/**
+ * @class PendManager
+ * @description 负责处理回声洞的审核流程，处理新洞的提交、审核通知和审核操作。
+ */
+export declare class PendManager {
+    private ctx;
+    private config;
+    private fileManager;
+    private logger;
+    private reusableIds;
+    /**
+     * @param ctx Koishi 上下文。
+     * @param config 插件配置。
+     * @param fileManager 文件管理器实例。
+     * @param logger 日志记录器实例。
+     * @param reusableIds 可复用 ID 的内存缓存。
+     */
+    constructor(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reusableIds: Set<number>);
+    /**
+     * @description 注册与审核相关的子命令。
+     * @param cave - 主 `cave` 命令实例。
+     */
+    registerCommands(cave: any): void;
+    /**
+     * @description 将新回声洞提交到管理群组以供审核。
+     * @param cave 新创建的、状态为 'pending' 的回声洞对象。
+     */
+    sendForPend(cave: CaveObject): Promise<void>;
+}

package/lib/Utils.d.ts

@@ -2,7 +2,7 @@ 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';
+import { PendManager } from './PendManager';
 /**
  * @description 将数据库存储的 StoredElement[] 转换为 Koishi 的 h() 元素数组。
  * @param elements 从数据库读取的元素数组。
@@ -65,7 +65,7 @@ export declare function processMessageElements(sourceElements: h[], newId: numbe
         fileName: string;
     }[];
 }>;
-export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: ReviewManager, cave: CaveObject, mediaToToSave: {
+export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: PendManager, 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

@@ -33,13 +33,13 @@ export interface Config {
     coolDown: number;
     perChannel: boolean;
     adminChannel: string;
-    enableProfile: boolean;
+    enableName: boolean;
     enableIO: boolean;
-    enableReview: boolean;
+    enablePend: boolean;
     caveFormat: string;
     enableSimilarity: boolean;
     textThreshold: number;
-    imageWholeThreshold: number;
+    imageThreshold: number;
     localPath?: string;
     enableS3: boolean;
     endpoint?: string;

package/lib/index.js

@@ -149,8 +149,8 @@ var FileManager = class {
   }
 };
 
-// src/ProfileManager.ts
-var ProfileManager = class {
+// src/NameManager.ts
+var NameManager = class {
   /**
    * @constructor
    * @param ctx - Koishi 上下文，用于初始化数据库模型。
@@ -165,14 +165,14 @@ var ProfileManager = class {
     });
   }
   static {
-    __name(this, "ProfileManager");
+    __name(this, "NameManager");
   }
   /**
-   * @description 注册 `.profile` 子命令，用于管理用户昵称。
+   * @description 注册 `.name` 子命令，用于管理用户昵称。
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
+    cave.subcommand(".name [nickname:text]", "设置显示昵称").usage("设置在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
       const trimmedNickname = nickname?.trim();
       if (trimmedNickname) {
         await this.setNickname(session.userId, trimmedNickname);
@@ -196,8 +196,8 @@ var ProfileManager = class {
    * @returns 用户的昵称字符串或 null。
    */
   async getNickname(userId) {
-    const [profile] = await this.ctx.database.get("cave_user", { userId });
-    return profile?.nickname ?? null;
+    const [name2] = await this.ctx.database.get("cave_user", { userId });
+    return name2?.nickname ?? null;
   }
   /**
    * @description 清除指定用户的昵称设置。
@@ -287,7 +287,7 @@ var DataManager = class {
   }
 };
 
-// src/ReviewManager.ts
+// src/PendManager.ts
 var import_koishi2 = require("koishi");
 
 // src/Utils.ts
@@ -379,6 +379,10 @@ async function getNextCaveId(ctx, query = {}, reusableIds) {
 }
 __name(getNextCaveId, "getNextCaveId");
 function checkCooldown(session, config, lastUsed) {
+  const adminChannelId = config.adminChannel?.split(":")[1];
+  if (adminChannelId && session.channelId === adminChannelId) {
+    return null;
+  }
   if (config.coolDown <= 0 || !session.channelId) return null;
   const lastTime = lastUsed.get(session.channelId) || 0;
   const remainingTime = lastTime + config.coolDown * 1e3 - Date.now();
@@ -441,8 +445,8 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
         const { globalHash, quadrantHashes } = await hashManager.generateAllImageHashes(buffer);
         for (const existing of existingGlobalHashes) {
           const similarity = hashManager.calculateSimilarity(globalHash, existing.hash);
-          if (similarity >= config.imageWholeThreshold) {
-            await session.send(`图片与回声洞（${existing.cave}）的相似度为 ${similarity.toFixed(2)}%，超过阈值`);
+          if (similarity >= config.imageThreshold) {
+            await session.send(`图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值`);
             await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
             cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
             return;
@@ -453,7 +457,7 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
           for (const existing of existingQuadrantHashes) {
             if (notifiedPartialCaves.has(existing.cave)) continue;
             if (newSubHash === existing.hash) {
-              await session.send(`图片局部与回声洞（${existing.cave}）存在完全相同的区块`);
+              await session.send(`图片与回声洞（${existing.cave}）局部相同`);
               notifiedPartialCaves.add(existing.cave);
             }
           }
@@ -466,7 +470,7 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
       }
     }
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
-    const finalStatus = config.enableReview ? "pending" : "active";
+    const finalStatus = config.enablePend ? "pending" : "active";
     await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
     if (hashManager) {
       const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: cave.id }));
@@ -476,7 +480,7 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
     }
     if (finalStatus === "pending" && reviewManager) {
       const [finalCave] = await ctx.database.get("cave", { id: cave.id });
-      if (finalCave) reviewManager.sendForReview(finalCave);
+      if (finalCave) reviewManager.sendForPend(finalCave);
     }
   } catch (fileProcessingError) {
     logger2.error(`回声洞（${cave.id}）文件处理失败:`, fileProcessingError);
@@ -486,8 +490,8 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
 }
 __name(handleFileUploads, "handleFileUploads");
 
-// src/ReviewManager.ts
-var ReviewManager = class {
+// src/PendManager.ts
+var PendManager = class {
   /**
    * @param ctx Koishi 上下文。
    * @param config 插件配置。
@@ -503,7 +507,7 @@ var ReviewManager = class {
     this.reusableIds = reusableIds;
   }
   static {
-    __name(this, "ReviewManager");
+    __name(this, "PendManager");
   }
   /**
    * @description 注册与审核相关的子命令。
@@ -516,7 +520,7 @@ var ReviewManager = class {
       }
       return null;
     }, "requireAdmin");
-    const review = cave.subcommand(".review [id:posint]", "审核回声洞").action(async ({ session }, id) => {
+    const pend = cave.subcommand(".pend [id:posint]", "审核回声洞").action(async ({ session }, id) => {
       const adminError = requireAdmin(session);
       if (adminError) return adminError;
       if (id) {
@@ -530,7 +534,7 @@ var ReviewManager = class {
       return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
 ${pendingCaves.map((c) => c.id).join("|")}`;
     });
-    const createReviewAction = /* @__PURE__ */ __name((actionType) => async ({ session }, id) => {
+    const createPendAction = /* @__PURE__ */ __name((actionType) => async ({ session }, id) => {
       const adminError = requireAdmin(session);
       if (adminError) return adminError;
       try {
@@ -552,23 +556,23 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
         this.logger.error(`审核操作失败:`, error);
         return `操作失败: ${error.message}`;
       }
-    }, "createReviewAction");
-    review.subcommand(".Y [id:posint]", "通过审核").action(createReviewAction("approve"));
-    review.subcommand(".N [id:posint]", "拒绝审核").action(createReviewAction("reject"));
+    }, "createPendAction");
+    pend.subcommand(".Y [id:posint]", "通过审核").action(createPendAction("approve"));
+    pend.subcommand(".N [id:posint]", "拒绝审核").action(createPendAction("reject"));
   }
   /**
    * @description 将新回声洞提交到管理群组以供审核。
    * @param cave 新创建的、状态为 'pending' 的回声洞对象。
    */
-  async sendForReview(cave) {
+  async sendForPend(cave) {
     if (!this.config.adminChannel?.includes(":")) {
       this.logger.warn(`管理群组配置无效，已自动通过回声洞（${cave.id}）`);
       await this.ctx.database.upsert("cave", [{ id: cave.id, status: "active" }]);
       return;
     }
     try {
-      const reviewMessage = [`待审核`, ...await buildCaveMessage(cave, this.config, this.fileManager, this.logger)];
-      await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(reviewMessage));
+      const pendMessage = [`待审核`, ...await buildCaveMessage(cave, this.config, this.fileManager, this.logger)];
+      await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(pendMessage));
     } catch (error) {
       this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
     }
@@ -624,12 +628,12 @@ var HashManager = class {
         return `操作失败: ${error.message}`;
       }
     });
-    cave.subcommand(".check", "检查相似度").usage("检查所有回声洞，找出相似度过高的内容。").action(async (argv) => {
+    cave.subcommand(".check", "检查相似度").usage("检查所有回声洞，找出相似度过高的内容。").option("textThreshold", "-t <threshold:number> 文本相似度阈值 (%)").option("imageThreshold", "-i <threshold:number> 图片相似度阈值 (%)").action(async (argv) => {
       const checkResult = adminCheck(argv);
       if (checkResult) return checkResult;
       await argv.session.send("正在检查，请稍候...");
       try {
-        return await this.checkForSimilarCaves();
+        return await this.checkForSimilarCaves(argv.options);
       } catch (error) {
         this.logger.error("检查相似度失败:", error);
         return `检查失败: ${error.message}`;
@@ -716,28 +720,33 @@ var HashManager = class {
   }
   /**
    * @description 对数据库中所有哈希进行两两比较，找出相似度过高的内容。
+   * @param options 包含临时阈值的可选对象。
    * @returns 一个包含检查结果的报告字符串。
    */
-  async checkForSimilarCaves() {
+  async checkForSimilarCaves(options = {}) {
+    const textThreshold = options.textThreshold ?? this.config.textThreshold;
+    const imageThreshold = options.imageThreshold ?? this.config.imageThreshold;
     const allHashes = await this.ctx.database.get("cave_hash", {});
     const allCaveIds = [...new Set(allHashes.map((h4) => h4.cave))];
     const textHashes = /* @__PURE__ */ new Map();
     const globalHashes = /* @__PURE__ */ new Map();
-    const quadrantHashes = /* @__PURE__ */ new Map();
+    const quadrantHashesByCave = /* @__PURE__ */ new Map();
+    const partialHashToCaves = /* @__PURE__ */ new Map();
     for (const hash of allHashes) {
       if (hash.type === "simhash") {
         textHashes.set(hash.cave, hash.hash);
       } else if (hash.type === "phash_g") {
         globalHashes.set(hash.cave, hash.hash);
       } else if (hash.type.startsWith("phash_q")) {
-        if (!quadrantHashes.has(hash.cave)) quadrantHashes.set(hash.cave, /* @__PURE__ */ new Set());
-        quadrantHashes.get(hash.cave).add(hash.hash);
+        if (!quadrantHashesByCave.has(hash.cave)) quadrantHashesByCave.set(hash.cave, /* @__PURE__ */ new Set());
+        quadrantHashesByCave.get(hash.cave).add(hash.hash);
+        if (!partialHashToCaves.has(hash.hash)) partialHashToCaves.set(hash.hash, /* @__PURE__ */ new Set());
+        partialHashToCaves.get(hash.hash).add(hash.cave);
       }
     }
     const similarPairs = {
       text: /* @__PURE__ */ new Set(),
-      global: /* @__PURE__ */ new Set(),
-      partial: /* @__PURE__ */ new Set()
+      global: /* @__PURE__ */ new Set()
     };
     for (let i = 0; i < allCaveIds.length; i++) {
       for (let j = i + 1; j < allCaveIds.length; j++) {
@@ -748,7 +757,7 @@ var HashManager = class {
         const text2 = textHashes.get(id2);
         if (text1 && text2) {
           const similarity = this.calculateSimilarity(text1, text2);
-          if (similarity >= this.config.textThreshold) {
+          if (similarity >= textThreshold) {
             similarPairs.text.add(`${pair} = ${similarity.toFixed(2)}%`);
           }
         }
@@ -756,32 +765,46 @@ var HashManager = class {
         const global2 = globalHashes.get(id2);
         if (global1 && global2) {
           const similarity = this.calculateSimilarity(global1, global2);
-          if (similarity >= this.config.imageWholeThreshold) {
+          if (similarity >= imageThreshold) {
             similarPairs.global.add(`${pair} = ${similarity.toFixed(2)}%`);
           }
         }
-        const quads1 = quadrantHashes.get(id1);
-        const quads2 = quadrantHashes.get(id2);
-        if (quads1 && quads2 && quads1.size > 0 && quads2.size > 0) {
-          let matchFound = false;
-          for (const h1 of quads1) {
-            if (quads2.has(h1)) {
-              matchFound = true;
-              break;
-            }
-          }
-          if (matchFound) {
-            similarPairs.partial.add(pair);
-          }
-        }
       }
     }
-    const totalFindings = similarPairs.text.size + similarPairs.global.size + similarPairs.partial.size;
+    const allPartialCaveIds = Array.from(quadrantHashesByCave.keys());
+    const parent = /* @__PURE__ */ new Map();
+    const find = /* @__PURE__ */ __name((i) => {
+      if (parent.get(i) === i) return i;
+      parent.set(i, find(parent.get(i)));
+      return parent.get(i);
+    }, "find");
+    const union = /* @__PURE__ */ __name((i, j) => {
+      const rootI = find(i);
+      const rootJ = find(j);
+      if (rootI !== rootJ) parent.set(rootI, rootJ);
+    }, "union");
+    allPartialCaveIds.forEach((id) => parent.set(id, id));
+    for (const caveIds of partialHashToCaves.values()) {
+      if (caveIds.size <= 1) continue;
+      const ids = Array.from(caveIds);
+      for (let i = 1; i < ids.length; i++) union(ids[0], ids[i]);
+    }
+    const components = /* @__PURE__ */ new Map();
+    for (const id of allPartialCaveIds) {
+      const root = find(id);
+      if (!components.has(root)) components.set(root, /* @__PURE__ */ new Set());
+      components.get(root).add(id);
+    }
+    const partialGroups = [];
+    for (const component of components.values()) {
+      if (component.size > 1) partialGroups.push(Array.from(component).sort((a, b) => a - b).join(" & "));
+    }
+    const totalFindings = similarPairs.text.size + similarPairs.global.size + partialGroups.length;
     if (totalFindings === 0) return "未发现高相似度的内容";
     let report = `已发现 ${totalFindings} 组高相似度的内容:`;
     if (similarPairs.text.size > 0) report += "\n文本内容相似:\n" + [...similarPairs.text].join("\n");
     if (similarPairs.global.size > 0) report += "\n图片整体相似:\n" + [...similarPairs.global].join("\n");
-    if (similarPairs.partial.size > 0) report += "\n图片局部相同:\n" + [...similarPairs.partial].join("\n");
+    if (partialGroups.length > 0) report += "\n图片局部相同:\n" + partialGroups.join("\n");
     return report.trim();
   }
   /**
@@ -949,16 +972,16 @@ var Config = import_koishi3.Schema.intersect([
   import_koishi3.Schema.object({
     coolDown: import_koishi3.Schema.number().default(10).description("冷却时间（秒）"),
     perChannel: import_koishi3.Schema.boolean().default(false).description("启用分群模式"),
-    enableProfile: import_koishi3.Schema.boolean().default(false).description("启用自定义昵称"),
+    enableName: import_koishi3.Schema.boolean().default(false).description("启用自定义昵称"),
     enableIO: import_koishi3.Schema.boolean().default(false).description("启用导入导出"),
     adminChannel: import_koishi3.Schema.string().default("onebot:").description("管理群组 ID"),
     caveFormat: import_koishi3.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本")
   }).description("基础配置"),
   import_koishi3.Schema.object({
-    enableReview: import_koishi3.Schema.boolean().default(false).description("启用审核"),
+    enablePend: import_koishi3.Schema.boolean().default(false).description("启用审核"),
     enableSimilarity: import_koishi3.Schema.boolean().default(false).description("启用查重"),
     textThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("文本相似度阈值 (%)"),
-    imageWholeThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("图片相似度阈值 (%)")
+    imageThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(95).description("图片相似度阈值 (%)")
   }).description("复核配置"),
   import_koishi3.Schema.object({
     localPath: import_koishi3.Schema.string().description("文件映射路径"),
@@ -984,8 +1007,8 @@ function apply(ctx, config) {
   const fileManager = new FileManager(ctx.baseDir, config, logger);
   const lastUsed = /* @__PURE__ */ new Map();
   const reusableIds = /* @__PURE__ */ new Set();
-  const profileManager = config.enableProfile ? new ProfileManager(ctx) : null;
-  const reviewManager = config.enableReview ? new ReviewManager(ctx, config, fileManager, logger, reusableIds) : null;
+  const profileManager = config.enableName ? new NameManager(ctx) : null;
+  const reviewManager = config.enablePend ? new PendManager(ctx, config, fileManager, logger, reusableIds) : null;
   const hashManager = config.enableSimilarity ? new HashManager(ctx, config, logger, fileManager) : null;
   const dataManager = config.enableIO ? new DataManager(ctx, config, fileManager, logger, hashManager) : null;
   const cave = ctx.command("cave", "回声洞").option("add", "-a <content:text> 添加回声洞").option("view", "-g <id:posint> 查看指定回声洞").option("delete", "-r <id:posint> 删除指定回声洞").option("list", "-l 查询投稿统计").usage("随机抽取一条已添加的回声洞。").action(async ({ session, options }) => {
@@ -1035,16 +1058,16 @@ function apply(ctx, config) {
             for (const existing of existingTextHashes) {
               const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
               if (similarity >= config.textThreshold) {
-                return `文本与回声洞（${existing.cave}）的相似度为 ${similarity.toFixed(2)}%，超过阈值`;
+                return `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值`;
               }
             }
             textHashesToStore.push({ hash: newSimhash, type: "simhash" });
           }
         }
       }
-      const userName = (config.enableProfile ? await profileManager.getNickname(session.userId) : null) || session.username;
+      const userName = (config.enableName ? await profileManager.getNickname(session.userId) : null) || session.username;
       const hasMedia = mediaToSave.length > 0;
-      const initialStatus = hasMedia ? "preload" : config.enableReview ? "pending" : "active";
+      const initialStatus = hasMedia ? "preload" : config.enablePend ? "pending" : "active";
       const newCave = await ctx.database.create("cave", {
         id: newId,
         elements: finalElementsForDb,
@@ -1061,10 +1084,10 @@ function apply(ctx, config) {
           await ctx.database.upsert("cave_hash", textHashesToStore.map((h4) => ({ ...h4, cave: newCave.id })));
         }
         if (initialStatus === "pending") {
-          reviewManager.sendForReview(newCave);
+          reviewManager.sendForPend(newCave);
         }
       }
-      return initialStatus === "pending" || initialStatus === "preload" && config.enableReview ? `提交成功，序号为（${newCave.id}）` : `添加成功，序号为（${newCave.id}）`;
+      return initialStatus === "pending" || initialStatus === "preload" && config.enablePend ? `提交成功，序号为（${newCave.id}）` : `添加成功，序号为（${newCave.id}）`;
     } catch (error) {
       logger.error("添加回声洞失败:", error);
       return "添加失败，请稍后再试";
@@ -1101,17 +1124,47 @@ function apply(ctx, config) {
       return "删除失败，请稍后再试";
     }
   });
-  cave.subcommand(".list", "查询我的投稿").action(async ({ session }) => {
-    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("|");
-      return `你已投稿 ${userCaves.length} 条回声洞，序号为：
-${caveIds}`;
-    } catch (error) {
-      logger.error("查询投稿列表失败:", error);
-      return "查询失败，请稍后再试";
+  cave.subcommand(".list", "查询投稿统计").option("user", "-u <user:user> 指定用户").option("all", "-a 查看排行").action(async ({ session, options }) => {
+    if (options.all) {
+      const adminChannelId = config.adminChannel?.split(":")[1];
+      if (session.channelId !== adminChannelId) {
+        return "此指令仅限在管理群组中使用";
+      }
+      try {
+        const allCaves = await ctx.database.get("cave", { status: "active" });
+        if (!allCaves.length) return "目前没有任何回声洞投稿。";
+        const userStats = /* @__PURE__ */ new Map();
+        for (const cave2 of allCaves) {
+          const { userId, userName: userName2 } = cave2;
+          const stat = userStats.get(userId);
+          if (stat) {
+            stat.count++;
+            stat.userName = userName2;
+          } else {
+            userStats.set(userId, { userName: userName2, count: 1 });
+          }
+        }
+        const sortedStats = Array.from(userStats.values()).sort((a, b) => b.count - a.count);
+        let report = "回声洞投稿数量排行：\n";
+        sortedStats.forEach((stat, index) => {
+          report += `${index + 1}. ${stat.userName}: ${stat.count} 条
+`;
+        });
+        return report.trim();
+      } catch (error) {
+        logger.error("查询排行失败:", error);
+        return "查询失败，请稍后再试";
+      }
     }
+    const targetUserId = options.user || session.userId;
+    const isQueryingSelf = !options.user;
+    const query = { ...getScopeQuery(session, config), userId: targetUserId };
+    const userCaves = await ctx.database.get("cave", query);
+    if (!userCaves.length) return isQueryingSelf ? "你还没有投稿过回声洞" : `用户 ${targetUserId} 还没有投稿过回声洞`;
+    const caveIds = userCaves.map((c) => c.id).sort((a, b) => a - b).join("|");
+    const userName = userCaves.sort((a, b) => b.time.getTime() - a.time.getTime())[0].userName;
+    return `${isQueryingSelf ? "你" : userName}已投稿 ${userCaves.length} 条回声洞，序号为：
+${caveIds}`;
   });
   if (profileManager) profileManager.registerCommands(cave);
   if (dataManager) dataManager.registerCommands(cave);

package/package.json

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

package/readme.md

@@ -8,13 +8,14 @@
 
 - **丰富的内容形式**：不止于文本，轻松发布包含图片、视频、音频甚至文件的混合内容。插件能自动解析回复或引用的消息，并将其完整存入回声洞。
 - **灵活的存储后端**：媒体文件可存储在 **本地服务器** (`data/cave` 目录)，或配置使用 **AWS S3** 兼容的云端对象存储。支持通过公共URL、本地文件路径或Base64三种方式发送媒体。
-- **内容相似度检查**：(可选) 启用后，插件会在添加时自动计算文本（Simhash）和图片（pHash）的哈希值，拒绝与现有内容相似度过高的投稿，有效防止重复。
+- **高级内容查重**：(可选) 启用后，插件会在添加时自动计算文本（Simhash）和图片（pHash，包括整体及分块哈希）的哈希值，拒绝与现有内容相似度过高的投稿，并能对局部相似的图片进行提示，有效防止重复。
 - **完善的审核机制**：(可选) 启用后，所有新投稿都将进入待审核状态，并通知管理群组。只有管理员审核通过后，内容才会对用户可见，确保内容质量。
 - **精细的作用域**：通过 `perChannel` 配置，可设定回声洞是在所有群聊中共享（全局模式），还是在每个群聊中独立（分群模式）。
 - **专属用户昵称**：(可选) 用户可以为自己在回声洞中的发言设置一个专属昵称，增加趣味性。
 - **便捷的数据管理**：(可选) 管理员可通过指令轻松地将所有回声洞数据导出为 `JSON` 文件备份，或从文件中恢复数据，迁移无忧。
-- **强大的维护工具**：管理员可以通过 `cave.hash` 指令为历史数据批量生成哈希值，并获取一份所有内容的相似度报告。
+- **强大的维护工具**：管理员可以通过 `cave.hash` 指令为历史数据批量生成哈希值，并通过 `cave.check` 获取一份所有内容的相似度报告。
 - **权限分离**：普通用户可删除自己的投稿。审核、数据管理等高级操作则仅限在指定的 **管理群组** 内由管理员执行。
+- **智能ID管理**：采用ID回收和空缺扫描机制，确保回声洞序号紧凑，并能高效处理大量删除和添加操作。
 
 ## 📖 指令说明
 
@@ -23,7 +24,7 @@
 | 指令 | 别名/选项 | 说明 |
 | :--- | :--- | :--- |
 | `cave` | | 随机查看一条回声洞。 |
-| `cave.add [内容]` | `cave -a [内容]` | 添加一条新的回声洞。可直接跟内容，也可回复/引用消息，或等待机器人提示后发送。 |
+| `cave.add [内容]` | `cave -a [内容]` | 添加一条新的回声洞。可直接跟内容，也可回复/引用消息，或等待机器人提示后在一分钟内发送。 |
 | `cave.view <序号>` | `cave -g <序号>` | 查看指定序号的回声洞。 |
 | `cave.del <序号>` | `cave -r <序号>` | 删除指定序号的回声洞。仅投稿人或在管理群组内的管理员可操作。 |
 | `cave.list` | `cave -l` | 查询并列出自己投稿过的所有回声洞序号及总数。 |
@@ -41,7 +42,8 @@
 | `cave.review.N [序号]` | `enableReview: true` | **(仅限管理群组)** 拒绝审核。若不提供序号，则拒绝所有待审核内容。 |
 | `cave.export` | `enableIO: true` | **(仅限管理群组)** 将所有`active`状态的回声洞导出到 `cave_export.json`。 |
 | `cave.import` | `enableIO: true` | **(仅限管理群组)** 从 `cave_import.json` 文件中导入数据。 |
-| `cave.hash` | `enableSimilarity: true` | **(仅限管理群组)** 校验所有历史数据，补全哈希并检查内容相似度。 |
+| `cave.hash` | `enableSimilarity: true` | **(仅限管理群组)** 校验所有历史数据，为缺失哈希的回声洞补全记录。 |
+| `cave.check` | `enableSimilarity: true` | **(仅限管理群组)** 检查所有回声洞的哈希，生成一份关于文本和图片相似度的报告。 |
 
 ## ⚙️ 配置说明
 
@@ -60,10 +62,10 @@
 
 | 配置项 | 类型 | 默认值 | 说明 |
 | :--- | :--- | :--- | :--- |
-| `enableReview` | `boolean` | `false` | 是否启用审核机制。 |
+| `enableReview` | `boolean` | `false` | 是否启用审核机制。启用后，新投稿将进入`pending`状态。 |
 | `enableSimilarity` | `boolean` | `false` | 是否启用内容相似度检查（查重）。 |
-| `textThreshold` | `number` | `0.9` | 文本相似度阈值 (0-1)。超过此值将被拒绝。 |
-| `imageThreshold` | `number` | `0.9` | 图片相似度阈值 (0-1)。超过此值将被拒绝。 |
+| `textThreshold` | `number` | `95` | **文本**相似度阈值 (0-100)。基于Simhash汉明距离计算，超过此值将被拒绝。 |
+| `imageWholeThreshold` | `number` | `95` | **图片整体**相似度阈值 (0-100)。基于pHash汉明距离计算，超过此值将被拒绝。 |
 
 ### 存储配置
 
@@ -83,7 +85,8 @@
 1. **媒体发送方式**：插件会按以下优先级决定如何发送图片、视频等媒体文件：
     1. **S3 公共URL**：如果 `enableS3` 和 `publicUrl` 已配置。
     2. **本地文件路径**：如果 `localPath` 已配置。
-    3. **Base64 编码**：如果以上两项均未配置，将文件转为 Base64 发送（可能受平台大小限制）。
-2. **文件存储权限**：若使用本地存储，请确保 Koishi 拥有对 `data/cave` 目录的读写权限。若使用 S3，请确保 Access Key 权限和存储桶策略配置正确。
+    3. **Base64 编码**：如果以上两项均未配置，将文件转为 Base64 发送（可能受平台大小限制或支持问题）。
+2. **文件存储权限**：若使用本地存储，请确保 Koishi 拥有对 `data/cave` 目录的读写权限。若使用 S3，请确保 Access Key 权限和存储桶策略（如ACL设为`public-read`）配置正确。
 3. **异步删除**：删除操作（`cave.del` 或审核拒绝）会将内容状态标记为 `delete`，然后由后台任务异步清理关联的文件和数据库条目，以避免阻塞当前指令。
-4. **数据迁移**：导入功能会读取插件数据目录下的 `cave_import.json`。导出功能则会生成 `cave_export.json`。请在操作前放置或备份好相应文件。
+4. **数据迁移**：导入功能会读取插件数据目录下的 `cave_import.json`。导出功能则会生成 `cave_export.json`。请在操作前放置或备份好相应文件。导入时，ID会从现有最大ID开始自增，不会覆盖或修改老数据。
+5. **查重机制**：图片查重不仅比较整图，还会比较图片的四个象限。如果象限完全一致，会发送提示但不会直接拒绝，为识别拼接图、裁剪图等提供了依据。