koishi-plugin-best-cave 2.1.1 → 2.1.3

package/lib/DataManager.d.ts

@@ -0,0 +1,38 @@
+import { Context, Logger } from 'koishi';
+import { FileManager } from './FileManager';
+import { Config } from './index';
+/**
+ * @class DataManager
+ * @description 负责处理回声洞数据的导入和导出功能。
+ */
+export declare class DataManager {
+    private ctx;
+    private config;
+    private fileManager;
+    private logger;
+    private reusableIds;
+    /**
+     * @constructor
+     * @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 注册 `.export` 和 `.import` 子命令。
+     * @param cave - 主 `cave` 命令实例。
+     */
+    registerCommands(cave: any): void;
+    /**
+     * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
+     * @returns 描述导出结果的消息字符串。
+     */
+    exportData(): Promise<string>;
+    /**
+     * @description 从 `cave_import.json` 文件导入回声洞数据。
+     * @returns 描述导入结果的消息字符串。
+     */
+    importData(): Promise<string>;
+}

package/lib/FileManager.d.ts

@@ -0,0 +1,48 @@
+import { Logger } from 'koishi';
+import { Config } from './index';
+/**
+ * @class FileManager
+ * @description 封装了对文件的存储、读取和删除操作。
+ * 能根据配置自动选择使用本地文件系统或 AWS S3 作为存储后端。
+ * 内置 Promise 文件锁，防止本地文件的并发写入冲突。
+ */
+export declare class FileManager {
+    private logger;
+    private resourceDir;
+    private locks;
+    private s3Client?;
+    private s3Bucket?;
+    /**
+     * @constructor
+     * @param baseDir Koishi 应用的基础数据目录 (ctx.baseDir)。
+     * @param config 插件的配置对象。
+     * @param logger 日志记录器实例。
+     */
+    constructor(baseDir: string, config: Config, logger: Logger);
+    /**
+     * @description 使用文件锁安全地执行异步文件操作，防止并发读写冲突。
+     * @template T 异步操作的返回类型。
+     * @param fullPath 需要加锁的文件的完整路径。
+     * @param operation 要执行的异步函数。
+     * @returns 返回异步操作的结果。
+     */
+    private withLock;
+    /**
+     * @description 保存文件，自动选择 S3 或本地存储。
+     * @param fileName 用作 S3 Key 或本地文件名。
+     * @param data 要写入的 Buffer 数据。
+     * @returns 返回保存时使用的文件名/标识符。
+     */
+    saveFile(fileName: string, data: Buffer): Promise<string>;
+    /**
+     * @description 读取文件，自动从 S3 或本地存储读取。
+     * @param fileName 要读取的文件名/标识符。
+     * @returns 文件的 Buffer 数据。
+     */
+    readFile(fileName: string): Promise<Buffer>;
+    /**
+     * @description 删除文件，自动从 S3 或本地删除。
+     * @param fileIdentifier 要删除的文件名/标识符。
+     */
+    deleteFile(fileIdentifier: string): Promise<void>;
+}

package/lib/HashManager.d.ts

@@ -0,0 +1,77 @@
+import { Context, Logger } from 'koishi';
+import { Config } from './index';
+import { FileManager } from './FileManager';
+/**
+ * @class HashManager
+ * @description 封装了所有与文本和图片哈希生成、相似度比较、以及相关命令的功能。
+ */
+export declare class HashManager {
+    private ctx;
+    private config;
+    private logger;
+    private fileManager;
+    /**
+     * @constructor
+     * @param ctx - Koishi 上下文，用于数据库操作。
+     * @param config - 插件配置，用于获取相似度阈值。
+     * @param logger - 日志记录器实例。
+     * @param fileManager - 文件管理器实例，用于处理历史数据。
+     */
+    constructor(ctx: Context, config: Config, logger: Logger, fileManager: FileManager);
+    /**
+     * @description 注册与哈希校验相关的子命令。
+     * @param cave - 主 `cave` 命令实例。
+     */
+    registerCommands(cave: any): void;
+    /**
+     * @description 检查数据库中所有回声洞，并为没有哈希记录的历史数据生成哈希。
+     * @returns {Promise<string>} 返回一个包含操作结果的报告字符串。
+     */
+    private validateAllCaves;
+    /**
+     * @description 将图片切割为4个象限并为每个象限生成pHash。
+     * @param imageBuffer - 图片的 Buffer 数据。
+     * @returns {Promise<Set<string>>} 返回一个包含最多4个唯一哈希值的集合。
+     */
+    generateImageSubHashes(imageBuffer: Buffer): Promise<Set<string>>;
+    /**
+     * @description 根据pHash（感知哈希）算法为图片生成哈希值。
+     * @param imageBuffer - 图片的 Buffer 数据。
+     * @returns {Promise<string>} 返回一个64位的二进制哈希字符串。
+     */
+    generateImagePHash(imageBuffer: Buffer): Promise<string>;
+    /**
+     * @description 计算两个哈希字符串之间的汉明距离（不同字符的数量）。
+     * @param hash1 - 第一个哈希字符串。
+     * @param hash2 - 第二个哈希字符串。
+     * @returns {number} 两个哈希之间的距离。
+     */
+    calculateHammingDistance(hash1: string, hash2: string): number;
+    /**
+     * @description 根据汉明距离计算图片pHash的相似度。
+     * @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;
+    /**
+     * @description 为文本生成基于Shingling的哈希字符串。
+     * @param text - 需要处理的文本。
+     * @returns {string} 由排序后的shingles组成的、用'|'分隔的哈希字符串。
+     */
+    generateTextHash(text: string): string;
+    /**
+     * @description 使用Jaccard相似度系数计算两个文本哈希的相似度。
+     * @param hash1 - 第一个文本哈希。
+     * @param hash2 - 第二个文本哈希。
+     * @returns {number} 范围在0到1之间的相似度得分。
+     */
+    calculateTextSimilarity(hash1: string, hash2: string): number;
+}

package/lib/ProfileManager.d.ts

@@ -0,0 +1,50 @@
+import { Context } from 'koishi';
+/**
+ * @description 数据库 `cave_user` 表的结构定义。
+ * @property userId 用户唯一ID，作为主键。
+ * @property nickname 用户自定义的昵称。
+ */
+export interface UserProfile {
+    userId: string;
+    nickname: string;
+}
+declare module 'koishi' {
+    interface Tables {
+        cave_user: UserProfile;
+    }
+}
+/**
+ * @class ProfileManager
+ * @description 负责管理用户在回声洞中的自定义昵称。
+ * 当插件配置 `enableProfile` 为 true 时实例化。
+ */
+export declare class ProfileManager {
+    private ctx;
+    /**
+     * @constructor
+     * @param ctx - Koishi 上下文，用于初始化数据库模型。
+     */
+    constructor(ctx: Context);
+    /**
+     * @description 注册 `.profile` 子命令，用于管理用户昵称。
+     * @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/ReviewManager.d.ts

@@ -0,0 +1,40 @@
+import { Context, Logger } from 'koishi';
+import { CaveObject, Config } from './index';
+import { FileManager } from './FileManager';
+/**
+ * @class ReviewManager
+ * @description 负责处理回声洞的审核流程，处理新洞的提交、审核通知和审核操作。
+ */
+export declare class ReviewManager {
+    private ctx;
+    private config;
+    private fileManager;
+    private logger;
+    private reusableIds;
+    /**
+     * @constructor
+     * @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' 的回声洞对象。
+     */
+    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

@@ -1,6 +1,7 @@
 import { Context, h, Logger, Session } from 'koishi';
-import { CaveObject, Config, StoredElement } from './index';
+import { CaveObject, Config, StoredElement, CaveHashObject } from './index';
 import { FileManager } from './FileManager';
+import { HashManager } from './HashManager';
 /**
  * @description 将数据库存储的 StoredElement[] 转换为 Koishi 的 h() 元素数组。
  * @param elements 从数据库读取的元素数组。
@@ -22,8 +23,9 @@ export declare function buildCaveMessage(cave: CaveObject, config: Config, fileM
  * @param ctx Koishi 上下文。
  * @param fileManager FileManager 实例。
  * @param logger Logger 实例。
+ * @param reusableIds 可复用 ID 的内存缓存。
  */
-export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileManager, logger: Logger): Promise<void>;
+export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
 /**
  * @description 根据配置（是否分群）和当前会话，生成数据库查询的范围条件。
  * @param session 当前会话对象。
@@ -32,13 +34,14 @@ export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileM
  */
 export declare function getScopeQuery(session: Session, config: Config): object;
 /**
- * @description 获取下一个可用的回声洞 ID（最小的未使用正整数）。
+ * @description 获取下一个可用的回声洞 ID。
+ * 实现了三阶段逻辑：优先使用回收ID -> 扫描空闲ID -> 获取最大ID+1。
  * @param ctx Koishi 上下文。
  * @param query 查询范围条件，用于分群模式。
+ * @param reusableIds 可复用 ID 的内存缓存。
  * @returns 可用的新 ID。
- * @performance 在大数据集下，此函数可能存在性能瓶颈，因为它需要获取所有现有ID。
  */
-export declare function getNextCaveId(ctx: Context, query?: object): Promise<number>;
+export declare function getNextCaveId(ctx: Context, query: object, reusableIds: Set<number>): Promise<number>;
 /**
  * @description 检查用户是否处于指令冷却中。
  * @returns 若在冷却中则返回提示字符串，否则返回 null。
@@ -64,16 +67,20 @@ export declare function processMessageElements(sourceElements: h[], newId: numbe
     }[];
 }>;
 /**
- * @description 异步处理文件上传和状态更新的后台任务。
+ * @description 异步处理文件上传、查重和状态更新的后台任务。
  * @param ctx - Koishi 上下文。
  * @param config - 插件配置。
- * @param fileManager - 文件管理器实例。
+ * @param fileManager - FileManager 实例，用于保存文件。
  * @param logger - 日志记录器实例。
- * @param reviewManager - 审核管理器实例 (可能为 null)。
- * @param cave - 已创建的、状态为 'preload' 的回声洞对象。
- * @param mediaToSave - 需要下载和保存的媒体文件列表。
+ * @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: any, cave: CaveObject, mediaToSave: {
     sourceUrl: string;
     fileName: string;
-}[]): Promise<void>;
+}[], reusableIds: Set<number>, session: Session, hashManager: HashManager | null, textHashesToStore: Omit<CaveHashObject, 'cave'>[]): Promise<void>;

package/lib/index.d.ts

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

package/lib/index.js

@@ -212,10 +212,99 @@ var ProfileManager = class {
   }
 };
 
+// src/DataManager.ts
+var DataManager = class {
+  /**
+   * @constructor
+   * @param ctx Koishi 上下文，用于数据库操作。
+   * @param config 插件配置。
+   * @param fileManager 文件管理器实例。
+   * @param logger 日志记录器实例。
+   * @param reusableIds 可复用 ID 的内存缓存。
+   */
+  constructor(ctx, config, fileManager, logger2, reusableIds) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = logger2;
+    this.reusableIds = reusableIds;
+  }
+  static {
+    __name(this, "DataManager");
+  }
+  /**
+   * @description 注册 `.export` 和 `.import` 子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    const requireAdmin = /* @__PURE__ */ __name((action) => async ({ session }) => {
+      const adminChannelId = this.config.adminChannel?.split(":")[1];
+      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
+      try {
+        await session.send("正在处理，请稍候...");
+        return await action();
+      } catch (error) {
+        this.logger.error("数据操作时发生错误:", error);
+        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()));
+  }
+  /**
+   * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
+   * @returns 描述导出结果的消息字符串。
+   */
+  async exportData() {
+    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));
+    return `成功导出 ${portableCaves.length} 条数据`;
+  }
+  /**
+   * @description 从 `cave_import.json` 文件导入回声洞数据。
+   * @returns 描述导入结果的消息字符串。
+   */
+  async importData() {
+    const fileName = "cave_import.json";
+    let importedCaves;
+    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("导入文件为空");
+    } 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"]
+    });
+    let startId = (lastCave?.id || 0) + 1;
+    const newCavesToInsert = importedCaves.map((cave, index) => ({
+      ...cave,
+      id: startId + index,
+      status: "active"
+    }));
+    await this.ctx.database.upsert("cave", newCavesToInsert);
+    this.reusableIds.clear();
+    await this.ctx.database.remove("cave_hash", {});
+    return `成功导入 ${newCavesToInsert.length} 条数据`;
+  }
+};
+
+// src/ReviewManager.ts
+var import_koishi2 = require("koishi");
+
 // src/Utils.ts
 var import_koishi = require("koishi");
 var path2 = __toESM(require("path"));
 var mimeTypeMap = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".mp4": "video/mp4", ".mp3": "audio/mpeg", ".webp": "image/webp" };
+var MAX_ID_FLAG = 0;
 function storedFormatToHElements(elements) {
   return elements.map((el) => {
     if (el.type === "text") return import_koishi.h.text(el.content);
@@ -256,14 +345,17 @@ async function buildCaveMessage(cave, config, fileManager, logger2) {
   return finalMessage;
 }
 __name(buildCaveMessage, "buildCaveMessage");
-async function cleanupPendingDeletions(ctx, fileManager, logger2) {
+async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
   try {
     const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
     if (!cavesToDelete.length) return;
     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 });
     }
   } catch (error) {
     logger2.error("清理回声洞时发生错误:", error);
@@ -275,13 +367,34 @@ function getScopeQuery(session, config) {
   return config.perChannel && session.channelId ? { ...baseQuery, channelId: session.channelId } : baseQuery;
 }
 __name(getScopeQuery, "getScopeQuery");
-async function getNextCaveId(ctx, query = {}) {
+async function getNextCaveId(ctx, query = {}, reusableIds) {
+  for (const id of reusableIds) {
+    if (id > MAX_ID_FLAG) {
+      reusableIds.delete(id);
+      return id;
+    }
+  }
+  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 newId2 = (lastCave?.id || 0) + 1;
+    reusableIds.add(MAX_ID_FLAG);
+    return newId2;
+  }
   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) {
+    reusableIds.add(MAX_ID_FLAG);
+  }
   return newId;
 }
 __name(getNextCaveId, "getNextCaveId");
@@ -339,104 +452,70 @@ async function processMessageElements(sourceElements, newId, channelId, userId)
   return { finalElementsForDb, mediaToSave };
 }
 __name(processMessageElements, "processMessageElements");
-async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, mediaToSave) {
+async function handleFileUploads(ctx, config, fileManager, logger2, reviewManager, cave, mediaToSave, reusableIds, session, hashManager, textHashesToStore) {
   try {
-    const uploadPromises = mediaToSave.map(async (media) => {
-      const response = await ctx.http.get(media.sourceUrl, { responseType: "arraybuffer", timeout: 3e4 });
-      await fileManager.saveFile(media.fileName, Buffer.from(response));
-    });
-    await Promise.all(uploadPromises);
+    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 newHash of allNewImageHashes) {
+          for (const existing of existingImageHashes) {
+            const similarity = hashManager.calculateImageSimilarity(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);
+              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) });
+      }
+    }
+    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 }))
+      ];
+      if (allHashesToInsert.length > 0) {
+        await ctx.database.upsert("cave_hash", allHashesToInsert);
+      }
+    }
     if (finalStatus === "pending" && reviewManager) {
       const [finalCave] = await ctx.database.get("cave", { id: cave.id });
       if (finalCave) reviewManager.sendForReview(finalCave);
     }
-  } catch (fileSaveError) {
-    logger2.error(`回声洞（${cave.id}）文件保存失败:`, fileSaveError);
+  } catch (fileProcessingError) {
+    logger2.error(`回声洞（${cave.id}）文件处理失败:`, fileProcessingError);
     await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
-    cleanupPendingDeletions(ctx, fileManager, logger2);
+    cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
   }
 }
 __name(handleFileUploads, "handleFileUploads");
 
-// src/DataManager.ts
-var DataManager = class {
-  /**
-   * @constructor
-   * @param ctx Koishi 上下文，用于数据库操作。
-   * @param config 插件配置。
-   * @param fileManager 文件管理器实例。
-   * @param logger 日志记录器实例。
-   */
-  constructor(ctx, config, fileManager, logger2) {
-    this.ctx = ctx;
-    this.config = config;
-    this.fileManager = fileManager;
-    this.logger = logger2;
-  }
-  static {
-    __name(this, "DataManager");
-  }
-  /**
-   * @description 注册 `.export` 和 `.import` 子命令。
-   * @param cave - 主 `cave` 命令实例。
-   */
-  registerCommands(cave) {
-    const requireAdmin = /* @__PURE__ */ __name((action) => async ({ session }) => {
-      const adminChannelId = this.config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
-      try {
-        await session.send("正在处理，请稍候...");
-        return await action();
-      } catch (error) {
-        this.logger.error("数据操作时发生错误:", error);
-        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()));
-  }
-  /**
-   * @description 导出所有 'active' 状态的回声洞数据到 `cave_export.json`。
-   * @returns 描述导出结果的消息字符串。
-   */
-  async exportData() {
-    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));
-    return `成功导出 ${portableCaves.length} 条数据`;
-  }
-  /**
-   * @description 从 `cave_import.json` 文件导入回声洞数据。
-   * @returns 描述导入结果的消息字符串。
-   */
-  async importData() {
-    const fileName = "cave_import.json";
-    let importedCaves;
-    try {
-      const fileContent = await this.fileManager.readFile(fileName);
-      importedCaves = JSON.parse(fileContent.toString("utf-8"));
-      if (!Array.isArray(importedCaves)) throw new Error("导入文件格式无效");
-    } catch (error) {
-      this.logger.error(`读取导入文件失败:`, error);
-      throw new Error(`读取导入文件失败: ${error.message || "未知错误"}`);
-    }
-    let successCount = 0;
-    for (const cave of importedCaves) {
-      const newId = await getNextCaveId(this.ctx, {});
-      const newCave = { ...cave, id: newId, status: "active" };
-      await this.ctx.database.create("cave", newCave);
-      successCount++;
-    }
-    return `成功导入 ${successCount} 条回声洞数据`;
-  }
-};
-
 // src/ReviewManager.ts
-var import_koishi2 = require("koishi");
 var ReviewManager = class {
   /**
    * @constructor
@@ -444,46 +523,68 @@ var ReviewManager = class {
    * @param config 插件配置。
    * @param fileManager 文件管理器实例。
    * @param logger 日志记录器实例。
+   * @param reusableIds 可复用 ID 的内存缓存。
    */
-  constructor(ctx, config, fileManager, logger2) {
+  constructor(ctx, config, fileManager, logger2, reusableIds) {
     this.ctx = ctx;
     this.config = config;
     this.fileManager = fileManager;
     this.logger = logger2;
+    this.reusableIds = reusableIds;
   }
   static {
     __name(this, "ReviewManager");
   }
   /**
-   * @description 注册与审核相关的 `.review` 子命令。
+   * @description 注册与审核相关的子命令。
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    cave.subcommand(".review [id:posint] [action:string]", "审核回声洞").usage("查看或审核回声洞，使用 <Y/N> 进行审核。").action(async ({ session }, id, action) => {
+    const requireAdmin = /* @__PURE__ */ __name((session) => {
       const adminChannelId = this.config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
+      if (session.channelId !== adminChannelId) {
+        return "此指令仅限在管理群组中使用";
+      }
+      return null;
+    }, "requireAdmin");
+    const review = cave.subcommand(".review [id:posint]", "审核回声洞").usage("查看所有待审核回声洞，或查看指定待审核回声洞。").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(", ")}`;
+${pendingCaves.map((c) => c.id).join("|")}`;
       }
       const [targetCave] = await this.ctx.database.get("cave", { id });
       if (!targetCave) return `回声洞（${id}）不存在`;
       if (targetCave.status !== "pending") return `回声洞（${id}）无需审核`;
-      if (!action) {
-        return [`待审核：`, ...await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger)];
-      }
-      const normalizedAction = action.toLowerCase();
-      if (["y", "yes", "pass", "approve"].includes(normalizedAction)) {
-        return this.processReview("approve", id);
-      }
-      if (["n", "no", "deny", "reject"].includes(normalizedAction)) {
-        return this.processReview("reject", id);
-      }
-      return `无效操作: "${action}"
-请使用 "Y" (通过) 或 "N" (拒绝)`;
+      return [`待审核`, ...await buildCaveMessage(targetCave, this.config, this.fileManager, this.logger)];
     });
+    const createReviewAction = /* @__PURE__ */ __name((actionType) => async ({ session }, id) => {
+      const adminError = requireAdmin(session);
+      if (adminError) return adminError;
+      try {
+        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} 条回声洞`;
+          }
+        }
+        return this.processReview(actionType, id);
+      } 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"));
   }
   /**
    * @description 将新回声洞提交到管理群组以供审核。
@@ -496,7 +597,7 @@ ${pendingCaves.map((c) => c.id).join(", ")}`;
       return;
     }
     try {
-      const reviewMessage = [`待审核：`, ...await buildCaveMessage(cave, this.config, this.fileManager, this.logger)];
+      const reviewMessage = [`待审核`, ...await buildCaveMessage(cave, this.config, this.fileManager, this.logger)];
       await this.ctx.broadcast([this.config.adminChannel], import_koishi2.h.normalize(reviewMessage));
     } catch (error) {
       this.logger.error(`发送回声洞（${cave.id}）审核消息失败:`, error);
@@ -516,12 +617,210 @@ ${pendingCaves.map((c) => c.id).join(", ")}`;
       return `回声洞（${caveId}）已通过`;
     } else {
       await this.ctx.database.upsert("cave", [{ id: caveId, status: "delete" }]);
-      cleanupPendingDeletions(this.ctx, this.fileManager, this.logger);
+      cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
       return `回声洞（${caveId}）已拒绝`;
     }
   }
 };
 
+// src/HashManager.ts
+var import_sharp = __toESM(require("sharp"));
+var HashManager = class {
+  /**
+   * @constructor
+   * @param ctx - Koishi 上下文，用于数据库操作。
+   * @param config - 插件配置，用于获取相似度阈值。
+   * @param logger - 日志记录器实例。
+   * @param fileManager - 文件管理器实例，用于处理历史数据。
+   */
+  constructor(ctx, config, logger2, fileManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.logger = logger2;
+    this.fileManager = fileManager;
+  }
+  static {
+    __name(this, "HashManager");
+  }
+  /**
+   * @description 注册与哈希校验相关的子命令。
+   * @param cave - 主 `cave` 命令实例。
+   */
+  registerCommands(cave) {
+    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;
+      } catch (error) {
+        this.logger.error("校验哈希失败:", error);
+        return `校验失败: ${error.message}`;
+      }
+    });
+  }
+  /**
+   * @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 = [];
+    let historicalCount = 0;
+    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 imageElements = cave.elements.filter((el) => el.type === "image" && el.file);
+      for (const el of imageElements) {
+        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" });
+          const subHashes = await this.generateImageSubHashes(imageBuffer);
+          subHashes.forEach((subHash) => {
+            hashesToInsert.push({ cave: cave.id, hash: subHash, type: "image", subType: "subImage" });
+          });
+        } catch (e) {
+          this.logger.warn(`无法为回声洞（${cave.id}）的内容（${el.file}）生成哈希:`, e);
+        }
+      }
+    }
+    if (hashesToInsert.length > 0) {
+      await this.ctx.database.upsert("cave_hash", hashesToInsert);
+    } else {
+      this.logger.info("无需补全哈希");
+    }
+    return `校验完成，共补全 ${historicalCount} 个回声洞的 ${hashesToInsert.length} 条哈希`;
+  }
+  /**
+   * @description 将图片切割为4个象限并为每个象限生成pHash。
+   * @param imageBuffer - 图片的 Buffer 数据。
+   * @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;
+      }
+      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);
+      }
+    } catch (e) {
+      this.logger.warn(`生成子哈希失败:`, e);
+    }
+    return hashes;
+  }
+  /**
+   * @description 根据pHash（感知哈希）算法为图片生成哈希值。
+   * @param imageBuffer - 图片的 Buffer 数据。
+   * @returns {Promise<string>} 返回一个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 avgLuminance = totalLuminance / 64;
+    let hash = "";
+    for (let i = 0; i < 64; i++) {
+      hash += smallImage[i] > avgLuminance ? "1" : "0";
+    }
+    return hash;
+  }
+  /**
+   * @description 计算两个哈希字符串之间的汉明距离（不同字符的数量）。
+   * @param hash1 - 第一个哈希字符串。
+   * @param hash2 - 第二个哈希字符串。
+   * @returns {number} 两个哈希之间的距离。
+   */
+  calculateHammingDistance(hash1, hash2) {
+    let distance = 0;
+    for (let i = 0; i < Math.min(hash1.length, hash2.length); i++) {
+      if (hash1[i] !== hash2[i]) {
+        distance++;
+      }
+    }
+    return distance;
+  }
+  /**
+   * @description 根据汉明距离计算图片pHash的相似度。
+   * @param hash1 - 第一个哈希字符串。
+   * @param hash2 - 第二个哈希字符串。
+   * @returns {number} 范围在0到1之间的相似度得分。
+   */
+  calculateImageSimilarity(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;
+  }
+  /**
+   * @description 为文本生成基于Shingling的哈希字符串。
+   * @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之间的相似度得分。
+   */
+  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;
+  }
+};
+
 // src/index.ts
 var name = "best-cave";
 var inject = ["database"];
@@ -548,8 +847,11 @@ var Config = import_koishi3.Schema.intersect([
     caveFormat: import_koishi3.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本")
   }).description("基础配置"),
   import_koishi3.Schema.object({
-    enableReview: import_koishi3.Schema.boolean().default(false).description("启用审核")
-  }).description("审核配置"),
+    enableReview: import_koishi3.Schema.boolean().default(false).description("启用审核"),
+    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("审核与查重配置"),
   import_koishi3.Schema.object({
     localPath: import_koishi3.Schema.string().description("文件映射路径"),
     enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
@@ -571,11 +873,21 @@ 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) : null;
-  const reviewManager = config.enableReview ? new ReviewManager(ctx, config, fileManager, logger) : 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 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}`);
@@ -607,18 +919,38 @@ function apply(ctx, config) {
       if (!sourceElements) {
         await session.send("请在一分钟内发送你要添加的内容");
         const reply = await session.prompt(6e4);
-        if (!reply) return "操作超时，已取消添加";
+        if (!reply) return "等待操作超时";
         sourceElements = import_koishi3.h.parse(reply);
       }
       const idScopeQuery = config.perChannel && session.channelId ? { channelId: session.channelId } : {};
-      const newId = await getNextCaveId(ctx, idScopeQuery);
+      const newId = await getNextCaveId(ctx, idScopeQuery, reusableIds);
       const { finalElementsForDb, mediaToSave } = await processMessageElements(
         sourceElements,
         newId,
         session.channelId,
         session.userId
       );
-      if (finalElementsForDb.length === 0) return "内容为空，已取消添加";
+      if (finalElementsForDb.length === 0) {
+        return "无可添加内容";
+      }
+      let 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 } });
+          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 userName = (config.enableProfile ? await profileManager.getNickname(session.userId) : null) || session.username;
       const hasMedia = mediaToSave.length > 0;
       const initialStatus = hasMedia ? "preload" : config.enableReview ? "pending" : "active";
@@ -633,11 +965,18 @@ function apply(ctx, config) {
       };
       await ctx.database.create("cave", newCave);
       if (hasMedia) {
-        handleFileUploads(ctx, config, fileManager, logger, reviewManager, newCave, mediaToSave);
-      } else if (initialStatus === "pending") {
-        reviewManager.sendForReview(newCave);
+        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);
+        }
+        if (initialStatus === "pending") {
+          reviewManager.sendForReview(newCave);
+        }
       }
-      return initialStatus === "pending" || initialStatus === "preload" && config.enableReview ? `提交成功，序号为（${newId}）` : `添加成功，序号为（${newId}）`;
+      const responseMessage = initialStatus === "pending" || initialStatus === "preload" && config.enableReview ? `提交成功，序号为（${newId}）` : `添加成功，序号为（${newId}）`;
+      return responseMessage;
     } catch (error) {
       logger.error("添加回声洞失败:", error);
       return "添加失败，请稍后再试";
@@ -671,7 +1010,7 @@ function apply(ctx, config) {
       }
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessage = await buildCaveMessage(targetCave, config, fileManager, logger);
-      cleanupPendingDeletions(ctx, fileManager, logger);
+      cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
       return [`已删除`, ...caveMessage];
     } catch (error) {
       logger.error(`标记回声洞（${id}）失败:`, error);
@@ -694,6 +1033,7 @@ ${caveIds}`;
   if (profileManager) profileManager.registerCommands(cave);
   if (dataManager) dataManager.registerCommands(cave);
   if (reviewManager) reviewManager.registerCommands(cave);
+  if (hashManager) hashManager.registerCommands(cave);
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-best-cave",
   "description": "最强大的回声洞现已重构完成啦！注意数据格式需要使用脚本转换哦~",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],
@@ -28,6 +28,7 @@
     "koishi": "^4.18.3"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.300.0"
+    "@aws-sdk/client-s3": "^3.800.0",
+    "sharp": "^0.34.3"
   }
 }