koishi-plugin-best-cave 2.1.3 → 2.1.4

package/lib/DataManager.d.ts

@@ -1,5 +1,6 @@
 import { Context, Logger } from 'koishi';
 import { FileManager } from './FileManager';
+import { HashManager } from './HashManager';
 import { Config } from './index';
 /**
  * @class DataManager
@@ -10,16 +11,16 @@ export declare class DataManager {
     private config;
     private fileManager;
     private logger;
-    private reusableIds;
+    private hashManager;
     /**
      * @constructor
      * @param ctx Koishi 上下文，用于数据库操作。
      * @param config 插件配置。
      * @param fileManager 文件管理器实例。
      * @param logger 日志记录器实例。
-     * @param reusableIds 可复用 ID 的内存缓存。
+     * @param hashManager 哈希管理器实例，用于增量更新哈希。
      */
-    constructor(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reusableIds: Set<number>);
+    constructor(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, hashManager: HashManager | null);
     /**
      * @description 注册 `.export` 和 `.import` 子命令。
      * @param cave - 主 `cave` 命令实例。

package/lib/FileManager.d.ts

@@ -24,14 +24,14 @@ export declare class FileManager {
      * @template T 异步操作的返回类型。
      * @param fullPath 需要加锁的文件的完整路径。
      * @param operation 要执行的异步函数。
-     * @returns 返回异步操作的结果。
+     * @returns 异步操作的结果。
      */
     private withLock;
     /**
      * @description 保存文件，自动选择 S3 或本地存储。
      * @param fileName 用作 S3 Key 或本地文件名。
      * @param data 要写入的 Buffer 数据。
-     * @returns 返回保存时使用的文件名/标识符。
+     * @returns 保存时使用的文件名。
      */
     saveFile(fileName: string, data: Buffer): Promise<string>;
     /**

package/lib/HashManager.d.ts

@@ -10,6 +10,8 @@ export declare class HashManager {
     private config;
     private logger;
     private fileManager;
+    private static readonly HASH_BATCH_SIZE;
+    private static readonly SIMHASH_BITS;
     /**
      * @constructor
      * @param ctx - Koishi 上下文，用于数据库操作。
@@ -24,20 +26,20 @@ export declare class HashManager {
      */
     registerCommands(cave: any): void;
     /**
-     * @description 检查数据库中所有回声洞，并为没有哈希记录的历史数据生成哈希。
-     * @returns {Promise<string>} 返回一个包含操作结果的报告字符串。
+     * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希，并在此之后对所有内容进行相似度检查。
+     * @returns {Promise<string>} 一个包含操作结果的报告字符串。
      */
-    private validateAllCaves;
+    validateAllCaves(): Promise<string>;
     /**
      * @description 将图片切割为4个象限并为每个象限生成pHash。
      * @param imageBuffer - 图片的 Buffer 数据。
-     * @returns {Promise<Set<string>>} 返回一个包含最多4个唯一哈希值的集合。
+     * @returns {Promise<Set<string>>} 一个包含最多4个唯一哈希值的集合。
      */
     generateImageSubHashes(imageBuffer: Buffer): Promise<Set<string>>;
     /**
-     * @description 根据pHash（感知哈希）算法为图片生成哈希值。
-     * @param imageBuffer - 图片的 Buffer 数据。
-     * @returns {Promise<string>} 返回一个64位的二进制哈希字符串。
+     * @description 根据感知哈希（pHash）算法为图片生成哈希。
+     * @param imageBuffer 图片的 Buffer 数据。
+     * @returns 64位二进制哈希字符串。
      */
     generateImagePHash(imageBuffer: Buffer): Promise<string>;
     /**
@@ -48,30 +50,16 @@ export declare class HashManager {
      */
     calculateHammingDistance(hash1: string, hash2: string): number;
     /**
-     * @description 根据汉明距离计算图片pHash的相似度。
+     * @description 根据汉明距离计算图片或文本哈希的相似度。
      * @param hash1 - 第一个哈希字符串。
      * @param hash2 - 第二个哈希字符串。
      * @returns {number} 范围在0到1之间的相似度得分。
      */
-    calculateImageSimilarity(hash1: string, hash2: string): number;
-    /**
-     * @description 将文本分割成指定大小的“瓦片”(shingles)，用于Jaccard相似度计算。
-     * @param text - 输入的文本。
-     * @param size - 每个瓦片的大小，默认为2。
-     * @returns {Set<string>} 包含所有唯一瓦片的集合。
-     */
-    private getShingles;
+    calculateSimilarity(hash1: string, hash2: string): number;
     /**
-     * @description 为文本生成基于Shingling的哈希字符串。
+     * @description 为文本生成基于 Simhash 算法的哈希字符串。
      * @param text - 需要处理的文本。
-     * @returns {string} 由排序后的shingles组成的、用'|'分隔的哈希字符串。
-     */
-    generateTextHash(text: string): string;
-    /**
-     * @description 使用Jaccard相似度系数计算两个文本哈希的相似度。
-     * @param hash1 - 第一个文本哈希。
-     * @param hash2 - 第二个文本哈希。
-     * @returns {number} 范围在0到1之间的相似度得分。
+     * @returns {string} 64位二进制 Simhash 字符串。
      */
-    calculateTextSimilarity(hash1: string, hash2: string): number;
+    generateTextSimhash(text: string): string;
 }

package/lib/ProfileManager.d.ts

@@ -1,9 +1,5 @@
 import { Context } from 'koishi';
-/**
- * @description 数据库 `cave_user` 表的结构定义。
- * @property userId 用户唯一ID，作为主键。
- * @property nickname 用户自定义的昵称。
- */
+/** 数据库 `cave_user` 表的结构。 */
 export interface UserProfile {
     userId: string;
     nickname: string;
@@ -16,7 +12,6 @@ declare module 'koishi' {
 /**
  * @class ProfileManager
  * @description 负责管理用户在回声洞中的自定义昵称。
- * 当插件配置 `enableProfile` 为 true 时实例化。
  */
 export declare class ProfileManager {
     private ctx;
@@ -39,7 +34,7 @@ export declare class ProfileManager {
     /**
      * @description 获取指定用户的昵称。
      * @param userId - 目标用户的 ID。
-     * @returns 返回用户的昵称字符串，如果未设置则返回 null。
+     * @returns 用户的昵称字符串或 null。
      */
     getNickname(userId: string): Promise<string | null>;
     /**

package/lib/ReviewManager.d.ts

@@ -12,7 +12,6 @@ export declare class ReviewManager {
     private logger;
     private reusableIds;
     /**
-     * @constructor
      * @param ctx Koishi 上下文。
      * @param config 插件配置。
      * @param fileManager 文件管理器实例。
@@ -30,11 +29,4 @@ export declare class ReviewManager {
      * @param cave 新创建的、状态为 'pending' 的回声洞对象。
      */
     sendForReview(cave: CaveObject): Promise<void>;
-    /**
-     * @description 处理管理员的审核决定（通过或拒绝）。
-     * @param action 'approve' (通过) 或 'reject' (拒绝)。
-     * @param caveId 被审核的回声洞 ID。
-     * @returns 返回给操作者的确认消息。
-     */
-    processReview(action: 'approve' | 'reject', caveId: number): Promise<string>;
 }

package/lib/Utils.d.ts

@@ -2,6 +2,7 @@ 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 从数据库读取的元素数组。
@@ -9,42 +10,41 @@ import { HashManager } from './HashManager';
  */
 export declare function storedFormatToHElements(elements: StoredElement[]): h[];
 /**
- * @description 构建一条用于发送的完整回声洞消息。
- * 此函数会处理 S3 URL、文件映射路径或本地文件到 Base64 的转换。
- * @param cave 要展示的回声洞对象。
+ * @description 构建一条用于发送的完整回声洞消息，处理不同存储后端的资源链接。
+ * @param cave 回声洞对象。
  * @param config 插件配置。
- * @param fileManager FileManager 实例。
- * @param logger Logger 实例。
+ * @param fileManager 文件管理器实例。
+ * @param logger 日志记录器实例。
  * @returns 包含 h() 元素和字符串的消息数组。
  */
 export declare function buildCaveMessage(cave: CaveObject, config: Config, fileManager: FileManager, logger: Logger): Promise<(string | h)[]>;
 /**
- * @description 清理数据库中所有被标记为 'delete' 状态的回声洞及其关联文件。
+ * @description 清理数据库中标记为 'delete' 状态的回声洞及其关联文件和哈希。
  * @param ctx Koishi 上下文。
- * @param fileManager FileManager 实例。
- * @param logger Logger 实例。
+ * @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 当前会话对象。
+ * @description 根据配置和会话，生成数据库查询的范围条件。
+ * @param session 当前会话。
  * @param config 插件配置。
- * @returns 用于数据库查询的条件对象。
+ * @param includeStatus 是否包含 status: 'active' 条件，默认为 true。
+ * @returns 数据库查询条件对象。
  */
-export declare function getScopeQuery(session: Session, config: Config): object;
+export declare function getScopeQuery(session: Session, config: Config, includeStatus?: boolean): object;
 /**
- * @description 获取下一个可用的回声洞 ID。
- * 实现了三阶段逻辑：优先使用回收ID -> 扫描空闲ID -> 获取最大ID+1。
+ * @description 获取下一个可用的回声洞 ID，采用“回收ID > 扫描空缺 > 最大ID+1”策略。
  * @param ctx Koishi 上下文。
- * @param query 查询范围条件，用于分群模式。
+ * @param query 查询范围条件。
  * @param reusableIds 可复用 ID 的内存缓存。
  * @returns 可用的新 ID。
  */
 export declare function getNextCaveId(ctx: Context, query: object, reusableIds: Set<number>): Promise<number>;
 /**
  * @description 检查用户是否处于指令冷却中。
- * @returns 若在冷却中则返回提示字符串，否则返回 null。
+ * @returns 若在冷却中则提示字符串，否则 null。
  */
 export declare function checkCooldown(session: Session, config: Config, lastUsed: Map<string, number>): string | null;
 /**
@@ -53,13 +53,12 @@ export declare function checkCooldown(session: Session, config: Config, lastUsed
 export declare function updateCooldownTimestamp(session: Session, config: Config, lastUsed: Map<string, number>): void;
 /**
  * @description 解析消息元素，分离出文本和待下载的媒体文件。
- * @param sourceElements - 原始的 Koishi 消息元素数组。
- * @param newId - 这条回声洞的新 ID。
- * @param channelId - 频道 ID。
- * @param userId - 用户 ID。
- * @returns 一个包含数据库元素和待保存媒体列表的对象。
+ * @param sourceElements 原始的 Koishi 消息元素数组。
+ * @param newId 这条回声洞的新 ID。
+ * @param session 触发操作的会话。
+ * @returns 包含数据库元素和待保存媒体列表的对象。
  */
-export declare function processMessageElements(sourceElements: h[], newId: number, channelId: string, userId: string): Promise<{
+export declare function processMessageElements(sourceElements: h[], newId: number, session: Session): Promise<{
     finalElementsForDb: StoredElement[];
     mediaToSave: {
         sourceUrl: string;
@@ -80,7 +79,7 @@ export declare function processMessageElements(sourceElements: h[], newId: numbe
  * @param hashManager - HashManager 实例，如果启用则用于哈希计算和比较。
  * @param textHashesToStore - 已预先计算好的、待存入数据库的文本哈希对象数组。
  */
-export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: any, cave: CaveObject, mediaToSave: {
+export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reviewManager: ReviewManager, cave: CaveObject, mediaToSave: {
     sourceUrl: string;
     fileName: string;
-}[], reusableIds: Set<number>, session: Session, hashManager: HashManager | null, textHashesToStore: Omit<CaveHashObject, 'cave'>[]): Promise<void>;
+}[], reusableIds: Set<number>, session: Session, hashManager: HashManager, textHashesToStore: Omit<CaveHashObject, 'cave'>[]): Promise<void>;

package/lib/index.d.ts

@@ -28,8 +28,7 @@ export interface CaveObject {
 export interface CaveHashObject {
     cave: number;
     hash: string;
-    type: 'text' | 'image';
-    subType: 'shingle' | 'pHash' | 'subImage';
+    type: 'sim' | 'phash' | 'sub';
 }
 declare module 'koishi' {
     interface Tables {

package/lib/index.js

@@ -77,7 +77,7 @@ var FileManager = class {
    * @template T 异步操作的返回类型。
    * @param fullPath 需要加锁的文件的完整路径。
    * @param operation 要执行的异步函数。
-   * @returns 返回异步操作的结果。
+   * @returns 异步操作的结果。
    */
   async withLock(fullPath, operation) {
     while (this.locks.has(fullPath)) {
@@ -93,7 +93,7 @@ var FileManager = class {
    * @description 保存文件，自动选择 S3 或本地存储。
    * @param fileName 用作 S3 Key 或本地文件名。
    * @param data 要写入的 Buffer 数据。
-   * @returns 返回保存时使用的文件名/标识符。
+   * @returns 保存时使用的文件名。
    */
   async saveFile(fileName, data) {
     if (this.s3Client) {
@@ -136,8 +136,7 @@ var FileManager = class {
   async deleteFile(fileIdentifier) {
     try {
       if (this.s3Client) {
-        const command = new import_client_s3.DeleteObjectCommand({ Bucket: this.s3Bucket, Key: fileIdentifier });
-        await this.s3Client.send(command);
+        await this.s3Client.send(new import_client_s3.DeleteObjectCommand({ Bucket: this.s3Bucket, Key: fileIdentifier }));
       } else {
         const filePath = path.join(this.resourceDir, fileIdentifier);
         await this.withLock(filePath, () => fs.unlink(filePath));
@@ -160,12 +159,9 @@ var ProfileManager = class {
     this.ctx = ctx;
     this.ctx.model.extend("cave_user", {
       userId: "string",
-      // 用户 ID
       nickname: "string"
-      // 用户自定义昵称
     }, {
       primary: "userId"
-      // 保证每个用户只有一条昵称记录。
     });
   }
   static {
@@ -176,7 +172,7 @@ var ProfileManager = class {
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置你在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
+    cave.subcommand(".profile [nickname:text]", "设置显示昵称").usage("设置在回声洞中显示的昵称。若不提供昵称，则清除现有昵称。").action(async ({ session }, nickname) => {
       const trimmedNickname = nickname?.trim();
       if (trimmedNickname) {
         await this.setNickname(session.userId, trimmedNickname);
@@ -197,10 +193,10 @@ var ProfileManager = class {
   /**
    * @description 获取指定用户的昵称。
    * @param userId - 目标用户的 ID。
-   * @returns 返回用户的昵称字符串，如果未设置则返回 null。
+   * @returns 用户的昵称字符串或 null。
    */
   async getNickname(userId) {
-    const [profile] = await this.ctx.database.get("cave_user", { userId }, { fields: ["nickname"] });
+    const [profile] = await this.ctx.database.get("cave_user", { userId });
     return profile?.nickname ?? null;
   }
   /**
@@ -220,14 +216,14 @@ var DataManager = class {
    * @param config 插件配置。
    * @param fileManager 文件管理器实例。
    * @param logger 日志记录器实例。
-   * @param reusableIds 可复用 ID 的内存缓存。
+   * @param hashManager 哈希管理器实例，用于增量更新哈希。
    */
-  constructor(ctx, config, fileManager, logger2, reusableIds) {
+  constructor(ctx, config, fileManager, logger2, hashManager) {
     this.ctx = ctx;
     this.config = config;
     this.fileManager = fileManager;
     this.logger = logger2;
-    this.reusableIds = reusableIds;
+    this.hashManager = hashManager;
   }
   static {
     __name(this, "DataManager");
@@ -238,8 +234,9 @@ var DataManager = class {
    */
   registerCommands(cave) {
     const requireAdmin = /* @__PURE__ */ __name((action) => async ({ session }) => {
-      const adminChannelId = this.config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
+      if (session.channelId !== this.config.adminChannel?.split(":")[1]) {
+        return "此指令仅限在管理群组中使用";
+      }
       try {
         await session.send("正在处理，请稍候...");
         return await action();
@@ -248,8 +245,8 @@ var DataManager = class {
         return `操作失败: ${error.message}`;
       }
     }, "requireAdmin");
-    cave.subcommand(".export", "导出回声洞数据").usage("将所有回声洞数据导出到 cave_export.json。").action(requireAdmin(() => this.exportData()));
-    cave.subcommand(".import", "导入回声洞数据").usage("从 cave_import.json 中导入回声洞数据。").action(requireAdmin(() => this.importData()));
+    cave.subcommand(".export", "导出回声洞数据").action(requireAdmin(() => this.exportData()));
+    cave.subcommand(".import", "导入回声洞数据").action(requireAdmin(() => this.importData()));
   }
   /**
    * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
@@ -259,8 +256,7 @@ var DataManager = class {
     const fileName = "cave_export.json";
     const cavesToExport = await this.ctx.database.get("cave", { status: "active" });
     const portableCaves = cavesToExport.map(({ id, ...rest }) => rest);
-    const data = JSON.stringify(portableCaves, null, 2);
-    await this.fileManager.saveFile(fileName, Buffer.from(data));
+    await this.fileManager.saveFile(fileName, Buffer.from(JSON.stringify(portableCaves, null, 2)));
     return `成功导出 ${portableCaves.length} 条数据`;
   }
   /**
@@ -273,17 +269,13 @@ var DataManager = class {
     try {
       const fileContent = await this.fileManager.readFile(fileName);
       importedCaves = JSON.parse(fileContent.toString("utf-8"));
-      if (!Array.isArray(importedCaves)) throw new Error("文件格式无效");
-      if (!importedCaves.length) throw new Error("导入文件为空");
+      if (!Array.isArray(importedCaves) || !importedCaves.length) {
+        throw new Error("导入文件格式无效或为空");
+      }
     } catch (error) {
-      this.logger.error(`读取导入文件失败:`, error);
       throw new Error(`读取导入文件失败: ${error.message}`);
     }
-    const [lastCave] = await this.ctx.database.get("cave", {}, {
-      sort: { id: "desc" },
-      limit: 1,
-      fields: ["id"]
-    });
+    const [lastCave] = await this.ctx.database.get("cave", {}, { sort: { id: "desc" }, limit: 1 });
     let startId = (lastCave?.id || 0) + 1;
     const newCavesToInsert = importedCaves.map((cave, index) => ({
       ...cave,
@@ -291,8 +283,6 @@ var DataManager = class {
       status: "active"
     }));
     await this.ctx.database.upsert("cave", newCavesToInsert);
-    this.reusableIds.clear();
-    await this.ctx.database.remove("cave_hash", {});
     return `成功导入 ${newCavesToInsert.length} 条数据`;
   }
 };
@@ -320,8 +310,7 @@ async function buildCaveMessage(cave, config, fileManager, logger2) {
     const fileName = element.attrs.src;
     if (!isMedia || !fileName) return element;
     if (config.enableS3 && config.publicUrl) {
-      const fullUrl = new URL(fileName, config.publicUrl).href;
-      return (0, import_koishi.h)(element.type, { ...element.attrs, src: fullUrl });
+      return (0, import_koishi.h)(element.type, { ...element.attrs, src: new URL(fileName, config.publicUrl).href });
     }
     if (config.localPath) {
       return (0, import_koishi.h)(element.type, { ...element.attrs, src: `file://${path2.join(config.localPath, fileName)}` });
@@ -336,8 +325,7 @@ async function buildCaveMessage(cave, config, fileManager, logger2) {
     }
   }));
   const replacements = { id: cave.id.toString(), name: cave.userName };
-  const formatPart = /* @__PURE__ */ __name((part) => part.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]).trim(), "formatPart");
-  const [header, footer] = config.caveFormat.split("|", 2).map(formatPart);
+  const [header, footer] = config.caveFormat.split("|", 2).map((part) => part.replace(/\{id\}|\{name\}/g, (match) => replacements[match.slice(1, -1)]).trim());
   const finalMessage = [];
   if (header) finalMessage.push(header + "\n");
   finalMessage.push(...processedElements);
@@ -349,21 +337,21 @@ async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
   try {
     const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
     if (!cavesToDelete.length) return;
+    const idsToDelete = cavesToDelete.map((c) => c.id);
     for (const cave of cavesToDelete) {
-      const deletePromises = cave.elements.filter((el) => el.file).map((el) => fileManager.deleteFile(el.file));
-      await Promise.all(deletePromises);
-      reusableIds.add(cave.id);
-      reusableIds.delete(MAX_ID_FLAG);
-      await ctx.database.remove("cave", { id: cave.id });
-      await ctx.database.remove("cave_hash", { cave: cave.id });
+      await Promise.all(cave.elements.filter((el) => el.file).map((el) => fileManager.deleteFile(el.file)));
     }
+    reusableIds.delete(MAX_ID_FLAG);
+    idsToDelete.forEach((id) => reusableIds.add(id));
+    await ctx.database.remove("cave", { id: { $in: idsToDelete } });
+    await ctx.database.remove("cave_hash", { cave: { $in: idsToDelete } });
   } catch (error) {
     logger2.error("清理回声洞时发生错误:", error);
   }
 }
 __name(cleanupPendingDeletions, "cleanupPendingDeletions");
-function getScopeQuery(session, config) {
-  const baseQuery = { status: "active" };
+function getScopeQuery(session, config, includeStatus = true) {
+  const baseQuery = includeStatus ? { status: "active" } : {};
   return config.perChannel && session.channelId ? { ...baseQuery, channelId: session.channelId } : baseQuery;
 }
 __name(getScopeQuery, "getScopeQuery");
@@ -376,11 +364,7 @@ async function getNextCaveId(ctx, query = {}, reusableIds) {
   }
   if (reusableIds.has(MAX_ID_FLAG)) {
     reusableIds.delete(MAX_ID_FLAG);
-    const [lastCave] = await ctx.database.get("cave", query, {
-      fields: ["id"],
-      sort: { id: "desc" },
-      limit: 1
-    });
+    const [lastCave] = await ctx.database.get("cave", query, { sort: { id: "desc" }, limit: 1 });
     const newId2 = (lastCave?.id || 0) + 1;
     reusableIds.add(MAX_ID_FLAG);
     return newId2;
@@ -388,11 +372,8 @@ async function getNextCaveId(ctx, query = {}, reusableIds) {
   const allCaveIds = (await ctx.database.get("cave", query, { fields: ["id"] })).map((c) => c.id);
   const existingIds = new Set(allCaveIds);
   let newId = 1;
-  while (existingIds.has(newId)) {
-    newId++;
-  }
-  const maxIdInDb = allCaveIds.length > 0 ? Math.max(...allCaveIds) : 0;
-  if (existingIds.size === maxIdInDb) {
+  while (existingIds.has(newId)) newId++;
+  if (existingIds.size === (allCaveIds.length > 0 ? Math.max(...allCaveIds) : 0)) {
     reusableIds.add(MAX_ID_FLAG);
   }
   return newId;
@@ -414,35 +395,30 @@ function updateCooldownTimestamp(session, config, lastUsed) {
   }
 }
 __name(updateCooldownTimestamp, "updateCooldownTimestamp");
-async function processMessageElements(sourceElements, newId, channelId, userId) {
+async function processMessageElements(sourceElements, newId, session) {
   const finalElementsForDb = [];
   const mediaToSave = [];
   let mediaIndex = 0;
-  const typeMap = {
-    "img": "image",
-    "image": "image",
-    "video": "video",
-    "audio": "audio",
-    "file": "file",
-    "text": "text"
-  };
+  const typeMap = { "img": "image", "image": "image", "video": "video", "audio": "audio", "file": "file", "text": "text" };
   const defaultExtMap = { "image": ".jpg", "video": ".mp4", "audio": ".mp3", "file": ".dat" };
   async function traverse(elements) {
     for (const el of elements) {
-      const normalizedType = typeMap[el.type];
-      if (normalizedType) {
-        if (["image", "video", "audio", "file"].includes(normalizedType) && el.attrs.src) {
-          let fileIdentifier = el.attrs.src;
-          if (fileIdentifier.startsWith("http")) {
-            const ext = path2.extname(el.attrs.file || "") || defaultExtMap[normalizedType];
-            const fileName = `${newId}_${++mediaIndex}_${channelId || "private"}_${userId}${ext}`;
-            mediaToSave.push({ sourceUrl: fileIdentifier, fileName });
-            fileIdentifier = fileName;
-          }
-          finalElementsForDb.push({ type: normalizedType, file: fileIdentifier });
-        } else if (normalizedType === "text" && el.attrs.content?.trim()) {
-          finalElementsForDb.push({ type: "text", content: el.attrs.content.trim() });
+      const type = typeMap[el.type];
+      if (!type) {
+        if (el.children) await traverse(el.children);
+        continue;
+      }
+      if (type === "text" && el.attrs.content?.trim()) {
+        finalElementsForDb.push({ type: "text", content: el.attrs.content.trim() });
+      } else if (type !== "text" && el.attrs.src) {
+        let fileIdentifier = el.attrs.src;
+        if (fileIdentifier.startsWith("http")) {
+          const ext = path2.extname(el.attrs.file || "") || defaultExtMap[type];
+          const fileName = `${newId}_${++mediaIndex}_${session.channelId || "private"}_${session.userId}${ext}`;
+          mediaToSave.push({ sourceUrl: fileIdentifier, fileName });
+          fileIdentifier = fileName;
         }
+        finalElementsForDb.push({ type, file: fileIdentifier });
       }
       if (el.children) await traverse(el.children);
     }
@@ -456,49 +432,35 @@ async function handleFileUploads(ctx, config, fileManager, logger2, reviewManage
   try {
     const downloadedMedia = [];
     const imageHashesToStore = [];
-    let allNewImageHashes = [];
-    if (hashManager) {
-      for (const media of mediaToSave) {
-        const response = await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 3e4 });
-        const buffer = Buffer.from(response);
-        downloadedMedia.push({ fileName: media.fileName, buffer });
-        const isImage = [".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase());
-        if (isImage) {
-          const pHash = await hashManager.generateImagePHash(buffer);
-          const subHashes = [...await hashManager.generateImageSubHashes(buffer)];
-          allNewImageHashes.push(pHash, ...subHashes);
-          imageHashesToStore.push({ hash: pHash, type: "image", subType: "pHash" });
-          subHashes.forEach((sh) => imageHashesToStore.push({ hash: sh, type: "image", subType: "subImage" }));
-        }
-      }
-      if (allNewImageHashes.length > 0) {
-        const existingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
+    for (const media of mediaToSave) {
+      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.calculateImageSimilarity(newHash, existing.hash);
+            const similarity = hashManager.calculateSimilarity(newHash, 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" }]);
-              cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
+              reusableIds.add(cave.id);
               return;
             }
           }
         }
-      }
-    } else {
-      for (const media of mediaToSave) {
-        const response = await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 3e4 });
-        downloadedMedia.push({ fileName: media.fileName, buffer: Buffer.from(response) });
+        const pHashEntry = { hash: pHash, type: "phash" };
+        const subHashEntries = [...subHashes].map((sh) => ({ hash: sh, type: "sub" }));
+        imageHashesToStore.push(pHashEntry, ...subHashEntries);
       }
     }
     await Promise.all(downloadedMedia.map((item) => fileManager.saveFile(item.fileName, item.buffer)));
     const finalStatus = config.enableReview ? "pending" : "active";
     await ctx.database.upsert("cave", [{ id: cave.id, status: finalStatus }]);
     if (hashManager) {
-      const allHashesToInsert = [
-        ...textHashesToStore.map((h4) => ({ ...h4, cave: cave.id })),
-        ...imageHashesToStore.map((h4) => ({ ...h4, cave: cave.id }))
-      ];
+      const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: cave.id }));
       if (allHashesToInsert.length > 0) {
         await ctx.database.upsert("cave_hash", allHashesToInsert);
       }
@@ -518,7 +480,6 @@ __name(handleFileUploads, "handleFileUploads");
 // src/ReviewManager.ts
 var ReviewManager = class {
   /**
-   * @constructor
    * @param ctx Koishi 上下文。
    * @param config 插件配置。
    * @param fileManager 文件管理器实例。
@@ -541,50 +502,50 @@ var ReviewManager = class {
    */
   registerCommands(cave) {
     const requireAdmin = /* @__PURE__ */ __name((session) => {
-      const adminChannelId = this.config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) {
+      if (session.channelId !== this.config.adminChannel?.split(":")[1]) {
         return "此指令仅限在管理群组中使用";
       }
       return null;
     }, "requireAdmin");
-    const review = cave.subcommand(".review [id:posint]", "审核回声洞").usage("查看所有待审核回声洞，或查看指定待审核回声洞。").action(async ({ session }, id) => {
+    const review = cave.subcommand(".review [id:posint]", "审核回声洞").action(async ({ session }, id) => {
       const adminError = requireAdmin(session);
       if (adminError) return adminError;
-      if (!id) {
-        const pendingCaves = await this.ctx.database.get("cave", { status: "pending" }, { fields: ["id"] });
-        if (!pendingCaves.length) return "当前没有需要审核的回声洞";
-        return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
-${pendingCaves.map((c) => c.id).join("|")}`;
+      if (id) {
+        const [targetCave] = await this.ctx.database.get("cave", { id });
+        if (!targetCave) return `回声洞（${id}）不存在`;
+        if (targetCave.status !== "pending") return `回声洞（${id}）无需审核`;
+        return [`待审核`, ...await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger)];
       }
-      const [targetCave] = await this.ctx.database.get("cave", { id });
-      if (!targetCave) return `回声洞（${id}）不存在`;
-      if (targetCave.status !== "pending") return `回声洞（${id}）无需审核`;
-      return [`待审核`, ...await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger)];
+      const pendingCaves = await this.ctx.database.get("cave", { status: "pending" }, { fields: ["id"] });
+      if (!pendingCaves.length) return "当前没有需要审核的回声洞";
+      return `当前共有 ${pendingCaves.length} 条待审核回声洞，序号为：
+${pendingCaves.map((c) => c.id).join("|")}`;
     });
     const createReviewAction = /* @__PURE__ */ __name((actionType) => async ({ session }, id) => {
       const adminError = requireAdmin(session);
       if (adminError) return adminError;
       try {
+        const targetStatus = actionType === "approve" ? "active" : "delete";
+        const actionText = actionType === "approve" ? "通过" : "拒绝";
         if (!id) {
           const pendingCaves = await this.ctx.database.get("cave", { status: "pending" });
-          if (!pendingCaves.length) return `当前没有需要${actionType === "approve" ? "通过" : "拒绝"}的回声洞`;
-          if (actionType === "approve") {
-            await this.ctx.database.upsert("cave", pendingCaves.map((c) => ({ id: c.id, status: "active" })));
-            return `已通过 ${pendingCaves.length} 条回声洞`;
-          } else {
-            await this.ctx.database.upsert("cave", pendingCaves.map((c) => ({ id: c.id, status: "delete" })));
-            cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
-            return `已拒绝 ${pendingCaves.length} 条回声洞`;
-          }
+          if (!pendingCaves.length) return `当前没有需要${actionText}的回声洞`;
+          await this.ctx.database.upsert("cave", pendingCaves.map((c) => ({ id: c.id, status: targetStatus })));
+          if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
+          return `已批量${actionText} ${pendingCaves.length} 条回声洞`;
         }
-        return this.processReview(actionType, id);
+        const [cave2] = await this.ctx.database.get("cave", { id, status: "pending" });
+        if (!cave2) return `回声洞（${id}）无需审核`;
+        await this.ctx.database.upsert("cave", [{ id, status: targetStatus }]);
+        if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
+        return `回声洞（${id}）已${actionText}`;
       } catch (error) {
         this.logger.error(`审核操作失败:`, error);
         return `操作失败: ${error.message}`;
       }
     }, "createReviewAction");
-    review.subcommand(".Y [id:posint]", "通过审核").usage("通过回声洞审核，可批量操作。").action(createReviewAction("approve"));
-    review.subcommand(".N [id:posint]", "拒绝审核").usage("拒绝回声洞审核，可批量操作。").action(createReviewAction("reject"));
+    review.subcommand(".Y [id:posint]", "通过审核").action(createReviewAction("approve"));
+    review.subcommand(".N [id:posint]", "拒绝审核").action(createReviewAction("reject"));
   }
   /**
    * @description 将新回声洞提交到管理群组以供审核。
@@ -603,29 +564,12 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
       this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
     }
   }
-  /**
-   * @description 处理管理员的审核决定（通过或拒绝）。
-   * @param action 'approve' (通过) 或 'reject' (拒绝)。
-   * @param caveId 被审核的回声洞 ID。
-   * @returns 返回给操作者的确认消息。
-   */
-  async processReview(action, caveId) {
-    const [cave] = await this.ctx.database.get("cave", { id: caveId, status: "pending" });
-    if (!cave) return `回声洞（${caveId}）无需审核`;
-    if (action === "approve") {
-      await this.ctx.database.upsert("cave", [{ id: caveId, status: "active" }]);
-      return `回声洞（${caveId}）已通过`;
-    } else {
-      await this.ctx.database.upsert("cave", [{ id: caveId, status: "delete" }]);
-      cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
-      return `回声洞（${caveId}）已拒绝`;
-    }
-  }
 };
 
 // src/HashManager.ts
 var import_sharp = __toESM(require("sharp"));
-var HashManager = class {
+var crypto = __toESM(require("crypto"));
+var HashManager = class _HashManager {
   /**
    * @constructor
    * @param ctx - Koishi 上下文，用于数据库操作。
@@ -638,24 +582,32 @@ var HashManager = class {
     this.config = config;
     this.logger = logger2;
     this.fileManager = fileManager;
+    this.ctx.model.extend("cave_hash", {
+      cave: "unsigned",
+      hash: "string",
+      type: "string"
+    }, {
+      primary: ["cave", "hash", "type"]
+    });
   }
   static {
     __name(this, "HashManager");
   }
+  static HASH_BATCH_SIZE = 1e3;
+  static SIMHASH_BITS = 64;
   /**
    * @description 注册与哈希校验相关的子命令。
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".hash", "校验回声洞").usage("校验所有回声洞，为历史数据生成哈希。").action(async ({ session }) => {
+    cave.subcommand(".hash", "校验回声洞").usage("校验所有回声洞，为历史数据生成哈希，并检查现有内容的相似度。").action(async ({ session }) => {
       const adminChannelId = this.config.adminChannel?.split(":")[1];
       if (session.channelId !== adminChannelId) {
         return "此指令仅限在管理群组中使用";
       }
       await session.send("正在处理，请稍候...");
       try {
-        const report = await this.validateAllCaves();
-        return report;
+        return await this.validateAllCaves();
       } catch (error) {
         this.logger.error("校验哈希失败:", error);
         return `校验失败: ${error.message}`;
@@ -663,74 +615,111 @@ var HashManager = class {
     });
   }
   /**
-   * @description 检查数据库中所有回声洞，并为没有哈希记录的历史数据生成哈希。
-   * @returns {Promise<string>} 返回一个包含操作结果的报告字符串。
+   * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希，并在此之后对所有内容进行相似度检查。
+   * @returns {Promise<string>} 一个包含操作结果的报告字符串。
    */
   async validateAllCaves() {
     const allCaves = await this.ctx.database.get("cave", { status: "active" });
-    const existingHashes = await this.ctx.database.get("cave_hash", {});
-    const existingHashedCaveIds = new Set(existingHashes.map((h4) => h4.cave));
-    const hashesToInsert = [];
+    const existingHashedCaveIds = new Set((await this.ctx.database.get("cave_hash", {}, { fields: ["cave"] })).map((h4) => h4.cave));
+    let hashesToInsert = [];
     let historicalCount = 0;
+    let totalHashesGenerated = 0;
+    const flushHashes = /* @__PURE__ */ __name(async () => {
+      if (hashesToInsert.length > 0) {
+        await this.ctx.database.upsert("cave_hash", hashesToInsert);
+        totalHashesGenerated += hashesToInsert.length;
+        hashesToInsert = [];
+      }
+    }, "flushHashes");
     for (const cave of allCaves) {
       if (existingHashedCaveIds.has(cave.id)) continue;
       this.logger.info(`正在为回声洞（${cave.id}）生成哈希...`);
       historicalCount++;
-      const textElements = cave.elements.filter((el) => el.type === "text" && el.content);
-      for (const el of textElements) {
-        const textHash = this.generateTextHash(el.content);
-        hashesToInsert.push({ cave: cave.id, hash: textHash, type: "text", subType: "shingle" });
+      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 imageElements = cave.elements.filter((el) => el.type === "image" && el.file);
-      for (const el of imageElements) {
+      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: "image", subType: "pHash" });
+          hashesToInsert.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: "image", subType: "subImage" });
-          });
+          subHashes.forEach((subHash) => hashesToInsert.push({ cave: cave.id, hash: subHash, type: "sub" }));
         } catch (e) {
           this.logger.warn(`无法为回声洞（${cave.id}）的内容（${el.file}）生成哈希:`, e);
         }
       }
+      if (hashesToInsert.length >= _HashManager.HASH_BATCH_SIZE) await flushHashes();
     }
-    if (hashesToInsert.length > 0) {
-      await this.ctx.database.upsert("cave_hash", hashesToInsert);
-    } else {
-      this.logger.info("无需补全哈希");
+    await flushHashes();
+    const generationReport = totalHashesGenerated > 0 ? `已补全 ${historicalCount} 个回声洞的 ${totalHashesGenerated} 条哈希
+` : "无需补全回声洞的哈希\n";
+    const allHashes = await this.ctx.database.get("cave_hash", {});
+    const caveTextHashes = /* @__PURE__ */ new Map();
+    const caveImagePHashes = /* @__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);
+      }
+    }
+    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 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 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)}%`);
+              }
+            }
+          }
+        }
+      }
     }
-    return `校验完成，共补全 ${historicalCount} 个回声洞的 ${hashesToInsert.length} 条哈希`;
+    const similarityReport = similarPairs.size > 0 ? `发现 ${similarPairs.size} 对高相似度内容:
+` + [...similarPairs].join("\n") : "未发现高相似度内容";
+    return `校验完成:
+${generationReport}${similarityReport}`;
   }
   /**
    * @description 将图片切割为4个象限并为每个象限生成pHash。
    * @param imageBuffer - 图片的 Buffer 数据。
-   * @returns {Promise<Set<string>>} 返回一个包含最多4个唯一哈希值的集合。
+   * @returns {Promise<Set<string>>} 一个包含最多4个唯一哈希值的集合。
    */
   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;
-      }
+      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) },
-        // Top-left
         { left: Math.floor(width / 2), top: 0, width: Math.ceil(width / 2), height: Math.floor(height / 2) },
-        // Top-right
         { left: 0, top: Math.floor(height / 2), width: Math.floor(width / 2), height: Math.ceil(height / 2) },
-        // Bottom-left
         { left: Math.floor(width / 2), top: Math.floor(height / 2), width: Math.ceil(width / 2), height: Math.ceil(height / 2) }
-        // Bottom-right
       ];
       for (const region of regions) {
         if (region.width < 8 || region.height < 8) continue;
         const quadrantBuffer = await (0, import_sharp.default)(imageBuffer).extract(region).toBuffer();
-        const subHash = await this.generateImagePHash(quadrantBuffer);
-        hashes.add(subHash);
+        hashes.add(await this.generateImagePHash(quadrantBuffer));
       }
     } catch (e) {
       this.logger.warn(`生成子哈希失败:`, e);
@@ -738,22 +727,15 @@ var HashManager = class {
     return hashes;
   }
   /**
-   * @description 根据pHash（感知哈希）算法为图片生成哈希值。
-   * @param imageBuffer - 图片的 Buffer 数据。
-   * @returns {Promise<string>} 返回一个64位的二进制哈希字符串。
+   * @description 根据感知哈希（pHash）算法为图片生成哈希。
+   * @param imageBuffer 图片的 Buffer 数据。
+   * @returns 64位二进制哈希字符串。
    */
   async generateImagePHash(imageBuffer) {
     const smallImage = await (0, import_sharp.default)(imageBuffer).grayscale().resize(8, 8, { fit: "fill" }).raw().toBuffer();
-    let totalLuminance = 0;
-    for (let i = 0; i < 64; i++) {
-      totalLuminance += smallImage[i];
-    }
+    const totalLuminance = smallImage.reduce((acc, val) => acc + val, 0);
     const avgLuminance = totalLuminance / 64;
-    let hash = "";
-    for (let i = 0; i < 64; i++) {
-      hash += smallImage[i] > avgLuminance ? "1" : "0";
-    }
-    return hash;
+    return Array.from(smallImage).map((lum) => lum > avgLuminance ? "1" : "0").join("");
   }
   /**
    * @description 计算两个哈希字符串之间的汉明距离（不同字符的数量）。
@@ -763,61 +745,40 @@ var HashManager = class {
    */
   calculateHammingDistance(hash1, hash2) {
     let distance = 0;
-    for (let i = 0; i < Math.min(hash1.length, hash2.length); i++) {
-      if (hash1[i] !== hash2[i]) {
-        distance++;
-      }
+    const len = Math.min(hash1.length, hash2.length);
+    for (let i = 0; i < len; i++) {
+      if (hash1[i] !== hash2[i]) distance++;
     }
     return distance;
   }
   /**
-   * @description 根据汉明距离计算图片pHash的相似度。
+   * @description 根据汉明距离计算图片或文本哈希的相似度。
    * @param hash1 - 第一个哈希字符串。
    * @param hash2 - 第二个哈希字符串。
    * @returns {number} 范围在0到1之间的相似度得分。
    */
-  calculateImageSimilarity(hash1, hash2) {
+  calculateSimilarity(hash1, hash2) {
     const distance = this.calculateHammingDistance(hash1, hash2);
-    const hashLength = 64;
-    return 1 - distance / hashLength;
-  }
-  /**
-   * @description 将文本分割成指定大小的“瓦片”(shingles)，用于Jaccard相似度计算。
-   * @param text - 输入的文本。
-   * @param size - 每个瓦片的大小，默认为2。
-   * @returns {Set<string>} 包含所有唯一瓦片的集合。
-   */
-  getShingles(text, size = 2) {
-    const shingles = /* @__PURE__ */ new Set();
-    const cleanedText = text.replace(/\s+/g, "");
-    for (let i = 0; i <= cleanedText.length - size; i++) {
-      shingles.add(cleanedText.substring(i, i + size));
-    }
-    return shingles;
+    const hashLength = Math.max(hash1.length, hash2.length);
+    return hashLength === 0 ? 1 : 1 - distance / hashLength;
   }
   /**
-   * @description 为文本生成基于Shingling的哈希字符串。
+   * @description 为文本生成基于 Simhash 算法的哈希字符串。
    * @param text - 需要处理的文本。
-   * @returns {string} 由排序后的shingles组成的、用'|'分隔的哈希字符串。
-   */
-  generateTextHash(text) {
-    if (!text) return "";
-    const shingles = Array.from(this.getShingles(text));
-    return shingles.sort().join("|");
-  }
-  /**
-   * @description 使用Jaccard相似度系数计算两个文本哈希的相似度。
-   * @param hash1 - 第一个文本哈希。
-   * @param hash2 - 第二个文本哈希。
-   * @returns {number} 范围在0到1之间的相似度得分。
+   * @returns {string} 64位二进制 Simhash 字符串。
    */
-  calculateTextSimilarity(hash1, hash2) {
-    if (!hash1 || !hash2) return 0;
-    const set1 = new Set(hash1.split("|"));
-    const set2 = new Set(hash2.split("|"));
-    const intersection = new Set([...set1].filter((x) => set2.has(x)));
-    const union = /* @__PURE__ */ new Set([...set1, ...set2]);
-    return union.size === 0 ? 1 : intersection.size / union.size;
+  generateTextSimhash(text) {
+    if (!text?.trim()) return "";
+    const tokens = text.toLowerCase().split(/[^a-z0-9\u4e00-\u9fa5]+/).filter(Boolean);
+    if (tokens.length === 0) return "";
+    const vector = new Array(_HashManager.SIMHASH_BITS).fill(0);
+    tokens.forEach((token) => {
+      const hash = crypto.createHash("md5").update(token).digest();
+      for (let i = 0; i < _HashManager.SIMHASH_BITS; i++) {
+        vector[i] += hash[Math.floor(i / 8)] >> i % 8 & 1 ? 1 : -1;
+      }
+    });
+    return vector.map((v) => v > 0 ? "1" : "0").join("");
   }
 };
 
@@ -851,7 +812,7 @@ var Config = import_koishi3.Schema.intersect([
     enableSimilarity: import_koishi3.Schema.boolean().default(false).description("启用查重"),
     textThreshold: import_koishi3.Schema.number().min(0).max(1).step(0.01).default(0.9).description("文本相似度阈值"),
     imageThreshold: import_koishi3.Schema.number().min(0).max(1).step(0.01).default(0.9).description("图片相似度阈值")
-  }).description("审核与查重配置"),
+  }).description("复核配置"),
   import_koishi3.Schema.object({
     localPath: import_koishi3.Schema.string().description("文件映射路径"),
     enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
@@ -873,21 +834,13 @@ function apply(ctx, config) {
     status: "string",
     time: "timestamp"
   }, { primary: "id" });
-  ctx.model.extend("cave_hash", {
-    cave: "unsigned",
-    hash: "string",
-    type: "string",
-    subType: "string"
-  }, {
-    primary: ["cave", "hash", "subType"]
-  });
   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 dataManager = config.enableIO ? new DataManager(ctx, config, fileManager, logger, reusableIds) : null;
   const reviewManager = config.enableReview ? new ReviewManager(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 }) => {
     if (options.add) return session.execute(`cave.add ${options.add}`);
     if (options.view) return session.execute(`cave.view ${options.view}`);
@@ -910,7 +863,7 @@ function apply(ctx, config) {
       return "随机获取回声洞失败";
     }
   });
-  cave.subcommand(".add [content:text]", "添加回声洞").usage("添加一条回声洞。可以直接发送内容，也可以回复或引用一条消息。").action(async ({ session }, content) => {
+  cave.subcommand(".add [content:text]", "添加回声洞").usage("添加一条回声洞。可直接发送内容，也可回复或引用消息。").action(async ({ session }, content) => {
     try {
       let sourceElements = session.quote?.elements;
       if (!sourceElements && content?.trim()) {
@@ -922,39 +875,28 @@ function apply(ctx, config) {
         if (!reply) return "等待操作超时";
         sourceElements = import_koishi3.h.parse(reply);
       }
-      const idScopeQuery = config.perChannel && session.channelId ? { channelId: session.channelId } : {};
-      const newId = await getNextCaveId(ctx, idScopeQuery, reusableIds);
-      const { finalElementsForDb, mediaToSave } = await processMessageElements(
-        sourceElements,
-        newId,
-        session.channelId,
-        session.userId
-      );
-      if (finalElementsForDb.length === 0) {
-        return "无可添加内容";
-      }
-      let textHashesToStore = [];
+      const newId = await getNextCaveId(ctx, getScopeQuery(session, config, false), reusableIds);
+      const { finalElementsForDb, mediaToSave } = await processMessageElements(sourceElements, newId, session);
+      if (finalElementsForDb.length === 0) return "无可添加内容";
+      const textHashesToStore = [];
       if (hashManager) {
-        const textContents = finalElementsForDb.filter((el) => el.type === "text" && el.content).map((el) => el.content);
-        if (textContents.length > 0) {
-          const newTextHashes = textContents.map((text) => hashManager.generateTextHash(text));
-          textHashesToStore = newTextHashes.map((hash) => ({ hash, type: "text", subType: "shingle" }));
-          const existingTextHashes = await ctx.database.get("cave_hash", { type: "text", hash: { $in: newTextHashes } });
+        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" });
           for (const existing of existingTextHashes) {
-            const matchedNewHash = textHashesToStore.find((h4) => h4.hash === existing.hash);
-            if (matchedNewHash) {
-              const similarity = hashManager.calculateTextSimilarity(matchedNewHash.hash, existing.hash);
-              if (similarity >= config.textThreshold) {
-                return `内容与回声洞（${existing.cave}）的相似度（${(similarity * 100).toFixed(2)}%）过高`;
-              }
+            const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
+            if (similarity >= config.textThreshold) {
+              return `内容与回声洞（${existing.cave}）的相似度（${(similarity * 100).toFixed(2)}%）过高`;
             }
           }
+          textHashesToStore.push({ hash: newSimhash, type: "sim" });
         }
       }
       const userName = (config.enableProfile ? await profileManager.getNickname(session.userId) : null) || session.username;
       const hasMedia = mediaToSave.length > 0;
       const initialStatus = hasMedia ? "preload" : config.enableReview ? "pending" : "active";
-      const newCave = {
+      const newCave = await ctx.database.create("cave", {
         id: newId,
         elements: finalElementsForDb,
         channelId: session.channelId,
@@ -962,33 +904,29 @@ function apply(ctx, config) {
         userName,
         status: initialStatus,
         time: /* @__PURE__ */ new Date()
-      };
-      await ctx.database.create("cave", newCave);
+      });
       if (hasMedia) {
         handleFileUploads(ctx, config, fileManager, logger, reviewManager, newCave, mediaToSave, reusableIds, session, hashManager, textHashesToStore);
       } else {
         if (hashManager && textHashesToStore.length > 0) {
-          const hashObjectsToInsert = textHashesToStore.map((h4) => ({ ...h4, cave: newId }));
-          await ctx.database.upsert("cave_hash", hashObjectsToInsert);
+          await ctx.database.upsert("cave_hash", textHashesToStore.map((h4) => ({ ...h4, cave: newCave.id })));
         }
         if (initialStatus === "pending") {
           reviewManager.sendForReview(newCave);
         }
       }
-      const responseMessage = initialStatus === "pending" || initialStatus === "preload" && config.enableReview ? `提交成功，序号为（${newId}）` : `添加成功，序号为（${newId}）`;
-      return responseMessage;
+      return initialStatus === "pending" || initialStatus === "preload" && config.enableReview ? `提交成功，序号为（${newCave.id}）` : `添加成功，序号为（${newCave.id}）`;
     } catch (error) {
       logger.error("添加回声洞失败:", error);
       return "添加失败，请稍后再试";
     }
   });
-  cave.subcommand(".view <id:posint>", "查看指定回声洞").usage("通过序号查看对应的回声洞。").action(async ({ session }, id) => {
+  cave.subcommand(".view <id:posint>", "查看指定回声洞").action(async ({ session }, id) => {
     if (!id) return "请输入要查看的回声洞序号";
     const cdMessage = checkCooldown(session, config, lastUsed);
     if (cdMessage) return cdMessage;
     try {
-      const query = { ...getScopeQuery(session, config), id };
-      const [targetCave] = await ctx.database.get("cave", query);
+      const [targetCave] = await ctx.database.get("cave", { ...getScopeQuery(session, config), id });
       if (!targetCave) return `回声洞（${id}）不存在`;
       updateCooldownTimestamp(session, config, lastUsed);
       return buildCaveMessage(targetCave, config, fileManager, logger);
@@ -997,17 +935,14 @@ function apply(ctx, config) {
       return "查看失败，请稍后再试";
     }
   });
-  cave.subcommand(".del <id:posint>", "删除指定回声洞").usage("通过序号删除对应的回声洞。").action(async ({ session }, id) => {
+  cave.subcommand(".del <id:posint>", "删除指定回声洞").action(async ({ session }, id) => {
     if (!id) return "请输入要删除的回声洞序号";
     try {
       const [targetCave] = await ctx.database.get("cave", { id, status: "active" });
       if (!targetCave) return `回声洞（${id}）不存在`;
-      const adminChannelId = config.adminChannel?.split(":")[1];
       const isAuthor = targetCave.userId === session.userId;
-      const isAdmin = session.channelId === adminChannelId;
-      if (!isAuthor && !isAdmin) {
-        return "你没有权限删除这条回声洞";
-      }
+      const isAdmin = session.channelId === config.adminChannel?.split(":")[1];
+      if (!isAuthor && !isAdmin) return "你没有权限删除这条回声洞";
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessage = await buildCaveMessage(targetCave, config, fileManager, logger);
       cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
@@ -1017,10 +952,9 @@ function apply(ctx, config) {
       return "删除失败，请稍后再试";
     }
   });
-  cave.subcommand(".list", "查询我的投稿").usage("查询并列出你所有投稿的回声洞序号。").action(async ({ session }) => {
+  cave.subcommand(".list", "查询我的投稿").action(async ({ session }) => {
     try {
-      const query = { ...getScopeQuery(session, config), userId: session.userId };
-      const userCaves = await ctx.database.get("cave", query, { fields: ["id"] });
+      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} 条回声洞，序号为：

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最强大的回声洞现已重构完成啦！注意数据格式需要使用脚本转换哦~",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],