koishi-plugin-best-cave 2.7.6 → 2.7.8

package/lib/HashManager.d.ts

@@ -7,7 +7,7 @@ import { FileManager } from './FileManager';
 export interface CaveHashObject {
     cave: number;
     hash: string;
-    type: 'simhash' | 'phash';
+    type: 'text' | 'image';
 }
 /**
  * @class HashManager
@@ -32,11 +32,6 @@ export declare class HashManager {
      * @param cave - 主 `cave` 命令实例。
      */
     registerCommands(cave: any): void;
-    /**
-     * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希。
-     * @returns 一个包含操作结果的报告字符串。
-     */
-    generateHashesForHistoricalCaves(): Promise<string>;
     /**
      * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
      * @param cave - 回声洞对象。
@@ -44,27 +39,24 @@ export declare class HashManager {
      */
     generateAllHashesForCave(cave: Pick<CaveObject, 'id' | 'elements'>): Promise<CaveHashObject[]>;
     /**
-     * @description 对数据库中所有哈希进行两两比较，找出相似度过高的内容。
-     * @param options 包含临时阈值的可选对象。
-     * @returns 一个包含检查结果的报告字符串。
+     * @description 执行一维离散余弦变换 (DCT-II) 的方法。
+     * @param input - 输入的数字数组。
+     * @returns DCT 变换后的数组。
      */
-    checkForSimilarCaves(options?: {
-        textThreshold?: number;
-        imageThreshold?: number;
-    }): Promise<string>;
+    private dct1D;
     /**
-     * @description 执行二维离散余弦变换 (DCT-II)。
+     * @description 执行二维离散余弦变换 (DCT-II) 的方法。
+     * 通过对行和列分别应用一维 DCT 来实现。
      * @param matrix - 输入的 N x N 像素亮度矩阵。
-     * @returns DCT变换后的 N x N 系数矩阵。
+     * @returns DCT 变换后的 N x N 系数矩阵。
      */
-    private _dct2D;
+    private dct2D;
     /**
-     * @description pHash 算法核心实现。
-     * @param imageBuffer - 图片的Buffer。
-     * @param size - 期望的哈希位数 (必须是完全平方数, 如 64 或 256)。
-     * @returns 十六进制pHash字符串。
+     * @description pHash 算法核心实现，使用 Jimp 和自定义 DCT。
+     * @param imageBuffer - 图片的 Buffer。
+     * @returns 64位十六进制 pHash 字符串。
      */
-    generatePHash(imageBuffer: Buffer, size: number): Promise<string>;
+    generatePHash(imageBuffer: Buffer): Promise<string>;
     /**
      * @description 计算两个十六进制哈希字符串之间的汉明距离 (不同位的数量)。
      * @param hex1 - 第一个哈希。

package/lib/Utils.d.ts

@@ -20,7 +20,7 @@ export declare function buildCaveMessage(cave: CaveObject, config: Config, fileM
  * @param logger 日志记录器实例。
  * @param reusableIds 可复用 ID 的内存缓存。
  */
-export declare function cleanupPendingDeletions(ctx: Context, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
+export declare function cleanupPendingDeletions(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, reusableIds: Set<number>): Promise<void>;
 /**
  * @description 根据配置和会话，生成数据库查询的范围条件。
  * @param session 当前会话。
@@ -81,7 +81,7 @@ export declare function performSimilarityChecks(ctx: Context, config: Config, ha
 export declare function handleFileUploads(ctx: Context, config: Config, fileManager: FileManager, logger: Logger, cave: CaveObject, downloadedMedia: {
     fileName: string;
     buffer: Buffer;
-}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active' | 'delete'>;
+}[], reusableIds: Set<number>, session: Session): Promise<'pending' | 'active'>;
 /**
  * @description 校验会话是否来自指定的管理群组。
  * @param session 当前会话。

package/lib/index.d.ts

@@ -61,7 +61,7 @@ export interface Config {
     aiEndpoint?: string;
     aiApiKey?: string;
     aiModel?: string;
-    aiTPM?: number;
+    aiRPM?: number;
     AnalysePrompt?: string;
     aiCheckPrompt?: string;
     aiAnalyseSchema?: string;

package/lib/index.js

@@ -37,7 +37,7 @@ __export(src_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi4 = require("koishi");
+var import_koishi3 = require("koishi");
 
 // src/FileManager.ts
 var import_client_s3 = require("@aws-sdk/client-s3");
@@ -321,7 +321,7 @@ async function buildCaveMessage(cave, config, fileManager, logger2, platform, pr
   return [finalInitialMessage, ...followUpMessages].filter((msg) => msg.length > 0);
 }
 __name(buildCaveMessage, "buildCaveMessage");
-async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
+async function cleanupPendingDeletions(ctx, config, fileManager, logger2, reusableIds) {
   try {
     const cavesToDelete = await ctx.database.get("cave", { status: "delete" });
     if (!cavesToDelete.length) return;
@@ -331,7 +331,7 @@ async function cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds) {
     idsToDelete.forEach((id) => reusableIds.add(id));
     await ctx.database.remove("cave", { id: { $in: idsToDelete } });
     await ctx.database.remove("cave_hash", { cave: { $in: idsToDelete } });
-    await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
+    if (config.enableAI) await ctx.database.remove("cave_meta", { cave: { $in: idsToDelete } });
   } catch (error) {
     logger2.error("清理回声洞时发生错误:", error);
   }
@@ -457,25 +457,25 @@ async function performSimilarityChecks(ctx, config, hashManager, finalElementsFo
   if (combinedText) {
     const newSimhash = hashManager.generateTextSimhash(combinedText);
     if (newSimhash) {
-      const existingTextHashes = await ctx.database.get("cave_hash", { type: "simhash" });
+      const existingTextHashes = await ctx.database.get("cave_hash", { type: "text" });
       for (const existing of existingTextHashes) {
         const similarity = hashManager.calculateSimilarity(newSimhash, existing.hash);
         if (similarity >= config.textThreshold) return { duplicate: true, message: `文本与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
       }
-      textHashesToStore.push({ hash: newSimhash, type: "simhash" });
+      textHashesToStore.push({ hash: newSimhash, type: "text" });
     }
   }
   if (downloadedMedia.length > 0) {
-    const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "phash" });
+    const allExistingImageHashes = await ctx.database.get("cave_hash", { type: "image" });
     for (const media of downloadedMedia) {
       if ([".png", ".jpg", ".jpeg", ".webp"].includes(path2.extname(media.fileName).toLowerCase())) {
-        const imageHash = await hashManager.generatePHash(media.buffer, 256);
+        const imageHash = await hashManager.generatePHash(media.buffer);
         for (const existing of allExistingImageHashes) {
           const similarity = hashManager.calculateSimilarity(imageHash, existing.hash);
           if (similarity >= config.imageThreshold) return { duplicate: true, message: `图片与回声洞（${existing.cave}）的相似度（${similarity.toFixed(2)}%）超过阈值` };
         }
-        imageHashesToStore.push({ hash: imageHash, type: "phash" });
-        allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "phash" });
+        imageHashesToStore.push({ hash: imageHash, type: "image" });
+        allExistingImageHashes.push({ cave: 0, hash: imageHash, type: "image" });
       }
     }
   }
@@ -492,8 +492,8 @@ async function handleFileUploads(ctx, config, fileManager, logger2, cave, downlo
   } catch (fileProcessingError) {
     logger2.error(`回声洞（${cave.id}）文件处理失败:`, fileProcessingError);
     await ctx.database.upsert("cave", [{ id: cave.id, status: "delete" }]);
-    cleanupPendingDeletions(ctx, fileManager, logger2, reusableIds);
-    return "delete";
+    cleanupPendingDeletions(ctx, config, fileManager, logger2, reusableIds);
+    throw fileProcessingError;
   }
 }
 __name(handleFileUploads, "handleFileUploads");
@@ -655,7 +655,7 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
         if (cavesToProcess.length === 0) return `回声洞（${idsToProcess.join("|")}）无需审核或不存在`;
         const processedIds = cavesToProcess.map((cave2) => cave2.id);
         await this.ctx.database.upsert("cave", processedIds.map((id) => ({ id, status: targetStatus })));
-        if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.fileManager, this.logger, this.reusableIds);
+        if (targetStatus === "delete") cleanupPendingDeletions(this.ctx, this.config, this.fileManager, this.logger, this.reusableIds);
         return `已${actionText}回声洞（${processedIds.join("|")}）`;
       } catch (error) {
         this.logger.error(`审核操作失败:`, error);
@@ -686,7 +686,7 @@ ${pendingCaves.map((c) => c.id).join("|")}`;
 };
 
 // src/HashManager.ts
-var import_sharp = __toESM(require("sharp"));
+var import_jimp = __toESM(require("jimp"));
 var crypto = __toESM(require("crypto"));
 var HashManager = class {
   /**
@@ -718,73 +718,167 @@ var HashManager = class {
    * @param cave - 主 `cave` 命令实例。
    */
   registerCommands(cave) {
-    const adminCheck = /* @__PURE__ */ __name(({ session }) => {
-      const adminChannelId = this.config.adminChannel?.split(":")[1];
-      if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
-    }, "adminCheck");
-    cave.subcommand(".hash", "校验回声洞", { hidden: true, authority: 3 }).usage("校验缺失哈希的回声洞，补全哈希记录。").action(async (argv) => {
-      const checkResult = adminCheck(argv);
-      if (checkResult) return checkResult;
-      await argv.session.send("正在处理，请稍候...");
+    cave.subcommand(".hash", "校验回声洞", { hidden: true, authority: 3 }).usage("校验缺失哈希的回声洞，补全哈希记录。").action(async ({ session }) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
       try {
-        return await this.generateHashesForHistoricalCaves();
+        const allCaves = await this.ctx.database.get("cave", { status: "active" });
+        if (allCaves.length === 0) return "无需补全回声洞哈希";
+        await session.send(`开始补全 ${allCaves.length} 个回声洞的哈希...`);
+        const existingHashes = await this.ctx.database.get("cave_hash", {});
+        const existingHashSet = new Set(existingHashes.map((h4) => `${h4.cave}-${h4.hash}-${h4.type}`));
+        let hashesToInsert = [];
+        let processedCaveCount = 0;
+        let totalHashesGenerated = 0;
+        let errorCount = 0;
+        const flushBatch = /* @__PURE__ */ __name(async () => {
+          if (hashesToInsert.length === 0) return;
+          await this.ctx.database.upsert("cave_hash", hashesToInsert);
+          totalHashesGenerated += hashesToInsert.length;
+          this.logger.info(`[${processedCaveCount}/${allCaves.length}] 正在导入 ${hashesToInsert.length} 条回声洞哈希...`);
+          hashesToInsert = [];
+        }, "flushBatch");
+        for (const cave2 of allCaves) {
+          processedCaveCount++;
+          try {
+            const newHashesForCave = await this.generateAllHashesForCave(cave2);
+            for (const hashObj of newHashesForCave) {
+              const uniqueKey = `${hashObj.cave}-${hashObj.hash}-${hashObj.type}`;
+              if (!existingHashSet.has(uniqueKey)) {
+                hashesToInsert.push(hashObj);
+                existingHashSet.add(uniqueKey);
+              }
+            }
+            if (hashesToInsert.length >= 100) await flushBatch();
+          } catch (error) {
+            errorCount++;
+            this.logger.warn(`补全回声洞（${cave2.id}）哈希时出错: ${error.message}`);
+          }
+        }
+        await flushBatch();
+        return `已补全 ${allCaves.length} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
       } catch (error) {
-        this.logger.error("生成历史哈希失败:", error);
+        this.logger.error("生成哈希失败:", error);
         return `操作失败: ${error.message}`;
       }
     });
-    cave.subcommand(".check", "检查相似度", { hidden: true }).usage("检查所有回声洞，找出相似度过高的内容。").option("textThreshold", "-t <threshold:number> 文本相似度阈值 (%)").option("imageThreshold", "-i <threshold:number> 图片相似度阈值 (%)").action(async (argv) => {
-      const checkResult = adminCheck(argv);
-      if (checkResult) return checkResult;
-      await argv.session.send("正在检查，请稍候...");
+    cave.subcommand(".check", "检查相似度", { hidden: true }).usage("检查所有回声洞，找出相似度过高的内容。").option("textThreshold", "-t <threshold:number> 文本相似度阈值 (%)").option("imageThreshold", "-i <threshold:number> 图片相似度阈值 (%)").action(async ({ session, options }) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
+      await session.send("正在检查，请稍候...");
       try {
-        return await this.checkForSimilarCaves(argv.options);
+        const textThreshold = options.textThreshold ?? this.config.textThreshold;
+        const imageThreshold = options.imageThreshold ?? this.config.imageThreshold;
+        const allHashes = await this.ctx.database.get("cave_hash", {});
+        if (allHashes.length < 2) return "无可比较哈希";
+        const buckets = /* @__PURE__ */ new Map();
+        const hashLookup = /* @__PURE__ */ new Map();
+        for (const hashObj of allHashes) {
+          if (!hashLookup.has(hashObj.cave)) hashLookup.set(hashObj.cave, {});
+          hashLookup.get(hashObj.cave)[hashObj.type] = hashObj.hash;
+          const binHash = BigInt("0x" + hashObj.hash).toString(2).padStart(64, "0");
+          for (let i = 0; i < 4; i++) {
+            const band = binHash.substring(i * 16, (i + 1) * 16);
+            const bucketKey = `${hashObj.type}:${i}:${band}`;
+            if (!buckets.has(bucketKey)) buckets.set(bucketKey, []);
+            buckets.get(bucketKey).push(hashObj.cave);
+          }
+        }
+        const candidatePairs = /* @__PURE__ */ new Set();
+        const similarPairs = { text: /* @__PURE__ */ new Set(), image: /* @__PURE__ */ new Set() };
+        for (const ids of buckets.values()) {
+          if (ids.length < 2) continue;
+          for (let i = 0; i < ids.length; i++) {
+            for (let j = i + 1; j < ids.length; j++) {
+              const id1 = ids[i];
+              const id2 = ids[j];
+              const pairKey = [id1, id2].sort((a, b) => a - b).join("-");
+              if (candidatePairs.has(pairKey)) continue;
+              candidatePairs.add(pairKey);
+              const cave1Hashes = hashLookup.get(id1);
+              const cave2Hashes = hashLookup.get(id2);
+              if (cave1Hashes?.text && cave2Hashes?.text) {
+                const similarity = this.calculateSimilarity(cave1Hashes.text, cave2Hashes.text);
+                if (similarity >= textThreshold) similarPairs.text.add(`${id1} & ${id2} = ${similarity.toFixed(2)}%`);
+              }
+              if (cave1Hashes?.image && cave2Hashes?.image) {
+                const similarity = this.calculateSimilarity(cave1Hashes.image, cave2Hashes.image);
+                if (similarity >= imageThreshold) similarPairs.image.add(`${id1} & ${id2} = ${similarity.toFixed(2)}%`);
+              }
+            }
+          }
+        }
+        const totalFindings = similarPairs.text.size + similarPairs.image.size;
+        if (totalFindings === 0) return "未发现高相似度的内容";
+        let report = `已发现 ${totalFindings} 组高相似度的内容:`;
+        if (similarPairs.text.size > 0) report += "\n文本内容相似:\n" + [...similarPairs.text].join("\n");
+        if (similarPairs.image.size > 0) report += "\n图片内容相似:\n" + [...similarPairs.image].join("\n");
+        return report.trim();
       } catch (error) {
         this.logger.error("检查相似度失败:", error);
         return `检查失败: ${error.message}`;
       }
     });
-  }
-  /**
-   * @description 检查数据库中所有回声洞，为没有哈希记录的历史数据生成哈希。
-   * @returns 一个包含操作结果的报告字符串。
-   */
-  async generateHashesForHistoricalCaves() {
-    const allCaves = await this.ctx.database.get("cave", { status: "active" });
-    const existingHashes = await this.ctx.database.get("cave_hash", {});
-    const existingHashSet = new Set(existingHashes.map((h5) => `${h5.cave}-${h5.hash}-${h5.type}`));
-    if (allCaves.length === 0) return "无需补全回声洞哈希";
-    this.logger.info(`开始补全 ${allCaves.length} 个回声洞的哈希...`);
-    let hashesToInsert = [];
-    let processedCaveCount = 0;
-    let totalHashesGenerated = 0;
-    let errorCount = 0;
-    const flushBatch = /* @__PURE__ */ __name(async () => {
-      if (hashesToInsert.length === 0) return;
-      await this.ctx.database.upsert("cave_hash", hashesToInsert);
-      totalHashesGenerated += hashesToInsert.length;
-      this.logger.info(`[${processedCaveCount}/${allCaves.length}] 正在导入 ${hashesToInsert.length} 条回声洞哈希...`);
-      hashesToInsert = [];
-    }, "flushBatch");
-    for (const cave of allCaves) {
-      processedCaveCount++;
+    cave.subcommand(".fix [...ids:posint]", "修复回声洞", { hidden: true, authority: 3 }).usage("扫描并修复回声洞中的图片，可指定一个或多个 ID。").action(async ({ session }, ...ids) => {
+      if (requireAdmin(session, this.config)) return requireAdmin(session, this.config);
+      let cavesToProcess;
       try {
-        const newHashesForCave = await this.generateAllHashesForCave(cave);
-        for (const hashObj of newHashesForCave) {
-          const uniqueKey = `${hashObj.cave}-${hashObj.hash}-${hashObj.type}`;
-          if (!existingHashSet.has(uniqueKey)) {
-            hashesToInsert.push(hashObj);
-            existingHashSet.add(uniqueKey);
+        if (ids.length === 0) {
+          await session.send("正在修复，请稍候...");
+          cavesToProcess = await this.ctx.database.get("cave", { status: "active" });
+        } else {
+          cavesToProcess = await this.ctx.database.get("cave", { id: { $in: ids }, status: "active" });
+        }
+        if (!cavesToProcess.length) return "无可修复回声洞";
+        let fixedFiles = 0;
+        let errorCount = 0;
+        const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+        const JPEG_SIGNATURE = Buffer.from([255, 216]);
+        const GIF_SIGNATURE = Buffer.from("GIF");
+        for (const cave2 of cavesToProcess) {
+          const imageElements = cave2.elements.filter((el) => el.type === "image" && el.file);
+          for (const element of imageElements) {
+            try {
+              const originalBuffer = await this.fileManager.readFile(element.file);
+              let sanitizedBuffer = originalBuffer;
+              if (originalBuffer.slice(0, 8).equals(PNG_SIGNATURE)) {
+                const IEND_CHUNK = Buffer.from("IEND");
+                const iendIndex = originalBuffer.lastIndexOf(IEND_CHUNK);
+                if (iendIndex !== -1) {
+                  const endOfPngData = iendIndex + 8;
+                  if (originalBuffer.length > endOfPngData) sanitizedBuffer = originalBuffer.slice(0, endOfPngData);
+                }
+              } else if (originalBuffer.slice(0, 2).equals(JPEG_SIGNATURE)) {
+                const EOI_MARKER = Buffer.from([255, 217]);
+                const eoiIndex = originalBuffer.lastIndexOf(EOI_MARKER);
+                if (eoiIndex !== -1) {
+                  const endOfJpegData = eoiIndex + 2;
+                  if (originalBuffer.length > endOfJpegData) sanitizedBuffer = originalBuffer.slice(0, endOfJpegData);
+                }
+              } else if (originalBuffer.slice(0, 3).equals(GIF_SIGNATURE)) {
+                const GIF_TERMINATOR = Buffer.from([59]);
+                const terminatorIndex = originalBuffer.lastIndexOf(GIF_TERMINATOR);
+                if (terminatorIndex !== -1) {
+                  const endOfGifData = terminatorIndex + 1;
+                  if (originalBuffer.length > endOfGifData) sanitizedBuffer = originalBuffer.slice(0, endOfGifData);
+                }
+              }
+              if (!originalBuffer.equals(sanitizedBuffer)) {
+                await this.fileManager.saveFile(element.file, sanitizedBuffer);
+                fixedFiles++;
+              }
+            } catch (error) {
+              if (error.code !== "ENOENT" && error.name !== "NoSuchKey") {
+                this.logger.warn(`无法修复回声洞（${cave2.id}）的图片（${element.file}）:`, error);
+                errorCount++;
+              }
+            }
           }
         }
-        if (hashesToInsert.length >= 100) await flushBatch();
+        return `已修复 ${cavesToProcess.length} 个回声洞的 ${fixedFiles} 张图片（失败 ${errorCount} 条）`;
       } catch (error) {
-        errorCount++;
-        this.logger.warn(`补全回声洞（${cave.id}）哈希时发生错误: ${error.message}`);
+        this.logger.error("修复图像文件时发生严重错误:", error);
+        return `操作失败: ${error.message}`;
       }
-    }
-    await flushBatch();
-    return `已补全 ${allCaves.length} 个回声洞的 ${totalHashesGenerated} 条哈希（失败 ${errorCount} 条）`;
+    });
   }
   /**
    * @description 为单个回声洞对象生成所有类型的哈希（文本+图片）。
@@ -804,115 +898,72 @@ var HashManager = class {
     const combinedText = cave.elements.filter((el) => el.type === "text" && el.content).map((el) => el.content).join(" ");
     if (combinedText) {
       const textHash = this.generateTextSimhash(combinedText);
-      if (textHash) addUniqueHash({ cave: cave.id, hash: textHash, type: "simhash" });
+      if (textHash) addUniqueHash({ cave: cave.id, hash: textHash, type: "text" });
     }
     for (const el of cave.elements.filter((el2) => el2.type === "image" && el2.file)) {
       try {
         const imageBuffer = await this.fileManager.readFile(el.file);
-        const imageHash = await this.generatePHash(imageBuffer, 256);
-        addUniqueHash({ cave: cave.id, hash: imageHash, type: "phash" });
-      } catch (e) {
-        this.logger.warn(`无法为回声洞（${cave.id}）的图片（${el.file}）生成哈希:`, e);
+        const imageHash = await this.generatePHash(imageBuffer);
+        addUniqueHash({ cave: cave.id, hash: imageHash, type: "image" });
+      } catch (error) {
+        this.logger.warn(`无法为回声洞（${cave.id}）的图片（${el.file}）生成哈希:`, error);
+        throw error;
       }
     }
     return tempHashes;
   }
   /**
-   * @description 对数据库中所有哈希进行两两比较，找出相似度过高的内容。
-   * @param options 包含临时阈值的可选对象。
-   * @returns 一个包含检查结果的报告字符串。
+   * @description 执行一维离散余弦变换 (DCT-II) 的方法。
+   * @param input - 输入的数字数组。
+   * @returns DCT 变换后的数组。
    */
-  async checkForSimilarCaves(options = {}) {
-    const textThreshold = options.textThreshold ?? this.config.textThreshold;
-    const imageThreshold = options.imageThreshold ?? this.config.imageThreshold;
-    const allHashes = await this.ctx.database.get("cave_hash", {});
-    const allCaveIds = [...new Set(allHashes.map((h5) => h5.cave))];
-    const textHashes = /* @__PURE__ */ new Map();
-    const imageHashes = /* @__PURE__ */ new Map();
-    for (const hash of allHashes) {
-      if (hash.type === "simhash") {
-        textHashes.set(hash.cave, hash.hash);
-      } else if (hash.type === "phash") {
-        imageHashes.set(hash.cave, hash.hash);
-      }
+  dct1D(input) {
+    const N = input.length;
+    const output = new Array(N).fill(0);
+    const c0 = 1 / Math.sqrt(2);
+    for (let k = 0; k < N; k++) {
+      let sum = 0;
+      for (let n = 0; n < N; n++) sum += input[n] * Math.cos(Math.PI * (2 * n + 1) * k / (2 * N));
+      const ck = k === 0 ? c0 : 1;
+      output[k] = Math.sqrt(2 / N) * ck * sum;
     }
-    const similarPairs = {
-      text: /* @__PURE__ */ new Set(),
-      image: /* @__PURE__ */ new Set()
-    };
-    for (let i = 0; i < allCaveIds.length; i++) {
-      for (let j = i + 1; j < allCaveIds.length; j++) {
-        const id1 = allCaveIds[i];
-        const id2 = allCaveIds[j];
-        const pair = [id1, id2].sort((a, b) => a - b).join(" & ");
-        const text1 = textHashes.get(id1);
-        const text2 = textHashes.get(id2);
-        if (text1 && text2) {
-          const similarity = this.calculateSimilarity(text1, text2);
-          if (similarity >= textThreshold) similarPairs.text.add(`${pair} = ${similarity.toFixed(2)}%`);
-        }
-        const image1 = imageHashes.get(id1);
-        const image2 = imageHashes.get(id2);
-        if (image1 && image2) {
-          const similarity = this.calculateSimilarity(image1, image2);
-          if (similarity >= imageThreshold) similarPairs.image.add(`${pair} = ${similarity.toFixed(2)}%`);
-        }
-      }
-    }
-    const totalFindings = similarPairs.text.size + similarPairs.image.size;
-    if (totalFindings === 0) return "未发现高相似度的内容";
-    let report = `已发现 ${totalFindings} 组高相似度的内容:`;
-    if (similarPairs.text.size > 0) report += "\n文本内容相似:\n" + [...similarPairs.text].join("\n");
-    if (similarPairs.image.size > 0) report += "\n图片内容相似:\n" + [...similarPairs.image].join("\n");
-    return report.trim();
+    return output;
   }
   /**
-   * @description 执行二维离散余弦变换 (DCT-II)。
+   * @description 执行二维离散余弦变换 (DCT-II) 的方法。
+   * 通过对行和列分别应用一维 DCT 来实现。
    * @param matrix - 输入的 N x N 像素亮度矩阵。
-   * @returns DCT变换后的 N x N 系数矩阵。
+   * @returns DCT 变换后的 N x N 系数矩阵。
    */
-  _dct2D(matrix) {
+  dct2D(matrix) {
     const N = matrix.length;
     if (N === 0) return [];
-    const cosines = Array.from(
-      { length: N },
-      (_, i) => Array.from({ length: N }, (_2, j) => Math.cos(Math.PI * (2 * i + 1) * j / (2 * N)))
-    );
-    const applyDct1D = /* @__PURE__ */ __name((input) => {
-      const output = new Array(N).fill(0);
-      const scale = Math.sqrt(2 / N);
-      for (let k = 0; k < N; k++) {
-        let sum = 0;
-        for (let n = 0; n < N; n++) sum += input[n] * cosines[n][k];
-        output[k] = scale * sum;
-      }
-      output[0] /= Math.sqrt(2);
-      return output;
-    }, "applyDct1D");
-    const tempMatrix = matrix.map((row) => applyDct1D(row));
-    const transposed = tempMatrix[0].map((_, col) => tempMatrix.map((row) => row[col]));
-    const dctResult = transposed.map((row) => applyDct1D(row));
-    return dctResult[0].map((_, col) => dctResult.map((row) => row[col]));
+    const tempMatrix = matrix.map((row) => this.dct1D(row));
+    const transposed = tempMatrix.map((_, colIndex) => tempMatrix.map((row) => row[colIndex]));
+    const dctResultTransposed = transposed.map((row) => this.dct1D(row));
+    const dctResult = dctResultTransposed.map((_, colIndex) => dctResultTransposed.map((row) => row[colIndex]));
+    return dctResult;
   }
   /**
-   * @description pHash 算法核心实现。
-   * @param imageBuffer - 图片的Buffer。
-   * @param size - 期望的哈希位数 (必须是完全平方数, 如 64 或 256)。
-   * @returns 十六进制pHash字符串。
+   * @description pHash 算法核心实现，使用 Jimp 和自定义 DCT。
+   * @param imageBuffer - 图片的 Buffer。
+   * @returns 64位十六进制 pHash 字符串。
    */
-  async generatePHash(imageBuffer, size) {
-    const dctSize = 32;
-    const hashGridSize = Math.sqrt(size);
-    if (!Number.isInteger(hashGridSize)) throw new Error("哈希位数必须是完全平方数");
-    const pixels = await (0, import_sharp.default)(imageBuffer).grayscale().resize(dctSize, dctSize, { fit: "fill" }).raw().toBuffer();
-    const matrix = [];
-    for (let y = 0; y < dctSize; y++) matrix.push(Array.from(pixels.slice(y * dctSize, (y + 1) * dctSize)));
-    const dctMatrix = this._dct2D(matrix);
+  async generatePHash(imageBuffer) {
+    const image = await import_jimp.default.read(imageBuffer);
+    image.resize(32, 32, import_jimp.default.RESIZE_BILINEAR).greyscale();
+    const matrix = Array.from({ length: 32 }, () => new Array(32).fill(0));
+    image.scan(0, 0, 32, 32, (x, y, idx) => {
+      matrix[y][x] = image.bitmap.data[idx];
+    });
+    const dctMatrix = this.dct2D(matrix);
     const coefficients = [];
-    for (let y = 0; y < hashGridSize; y++) for (let x = 0; x < hashGridSize; x++) coefficients.push(dctMatrix[y][x]);
-    const median = [...coefficients.slice(1)].sort((a, b) => a - b)[Math.floor((coefficients.length - 1) / 2)];
-    const binaryHash = coefficients.map((val) => val > median ? "1" : "0").join("");
-    return BigInt("0b" + binaryHash).toString(16).padStart(size / 4, "0");
+    for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) coefficients.push(dctMatrix[y][x]);
+    const acCoefficients = coefficients.slice(1);
+    const average = acCoefficients.reduce((sum, val) => sum + val, 0) / acCoefficients.length;
+    let binaryHash = "";
+    for (const val of coefficients) binaryHash += val > average ? "1" : "0";
+    return BigInt("0b" + binaryHash).toString(16).padStart(16, "0");
   }
   /**
    * @description 计算两个十六进制哈希字符串之间的汉明距离 (不同位的数量)。
@@ -922,8 +973,10 @@ var HashManager = class {
    */
   calculateHammingDistance(hex1, hex2) {
     let distance = 0;
-    const bin1 = hexToBinary(hex1);
-    const bin2 = hexToBinary(hex2);
+    let bin1 = "";
+    for (const char of hex1) bin1 += parseInt(char, 16).toString(2).padStart(4, "0");
+    let bin2 = "";
+    for (const char of hex2) bin2 += parseInt(char, 16).toString(2).padStart(4, "0");
     const len = Math.min(bin1.length, bin2.length);
     for (let i = 0; i < len; i++) if (bin1[i] !== bin2[i]) distance++;
     return distance;
@@ -947,14 +1000,8 @@ var HashManager = class {
   generateTextSimhash(text) {
     const cleanText = (text || "").toLowerCase().replace(/\s+/g, "");
     if (!cleanText) return "";
-    const n = 2;
-    const tokens = /* @__PURE__ */ new Set();
-    if (cleanText.length < n) {
-      tokens.add(cleanText);
-    } else {
-      for (let i = 0; i <= cleanText.length - n; i++) tokens.add(cleanText.substring(i, i + n));
-    }
-    const tokenArray = Array.from(tokens);
+    const tokens = Array.from(cleanText);
+    const tokenArray = Array.from(new Set(tokens));
     if (tokenArray.length === 0) return "";
     const vector = new Array(64).fill(0);
     tokenArray.forEach((token) => {
@@ -965,15 +1012,8 @@ var HashManager = class {
     return BigInt("0b" + binaryHash).toString(16).padStart(16, "0");
   }
 };
-function hexToBinary(hex) {
-  let bin = "";
-  for (const char of hex) bin += parseInt(char, 16).toString(2).padStart(4, "0");
-  return bin;
-}
-__name(hexToBinary, "hexToBinary");
 
 // src/AIManager.ts
-var import_koishi3 = require("koishi");
 var path3 = __toESM(require("path"));
 var AIManager = class {
   /**
@@ -1015,40 +1055,21 @@ var AIManager = class {
         if (cavesToAnalyze.length === 0) return "无需分析回声洞";
         await session.send(`开始分析 ${cavesToAnalyze.length} 个回声洞...`);
         let successCount = 0;
-        let failedCount = 0;
         for (const [index, cave2] of cavesToAnalyze.entries()) {
-          this.logger.info(`[${index + 1}/${cavesToAnalyze.length}] 正在分析回声洞 (${cave2.id})...`);
           try {
+            this.logger.info(`[${index + 1}/${cavesToAnalyze.length}] 正在分析回声洞 (${cave2.id})...`);
             await this.analyzeAndStore(cave2);
             successCount++;
           } catch (error) {
-            failedCount++;
-            this.logger.error(`分析回声洞（${cave2.id}）时出错:`, error);
+            return `分析回声洞（${cave2.id}）时出错: ${error.message}`;
           }
         }
-        return `已分析 ${successCount} 个回声洞（失败 ${failedCount} 个）`;
+        return `已分析 ${successCount} 个回声洞`;
       } catch (error) {
         this.logger.error("分析回声洞失败:", error);
         return `操作失败: ${error.message}`;
       }
     });
-    cave.subcommand(".desc <id:posint>", "查询回声洞").action(async ({}, id) => {
-      if (!id) return "请输入要查看的回声洞序号";
-      try {
-        const [meta] = await this.ctx.database.get("cave_meta", { cave: id });
-        if (!meta) return `回声洞（${id}）尚未分析`;
-        const report = [
-          `回声洞（${id}）分析结果：`,
-          `描述：${meta.description}`,
-          `关键词：${meta.keywords.join(", ")}`,
-          `综合评分：${meta.rating}/100`
-        ];
-        return import_koishi3.h.text(report.join("\n"));
-      } catch (error) {
-        this.logger.error(`查询回声洞（${id}）失败:`, error);
-        return "查询失败，请稍后再试";
-      }
-    });
   }
   /**
    * @description 对新提交的内容执行 AI 驱动的查重检查。
@@ -1170,17 +1191,26 @@ var AIManager = class {
       this.rateLimitResetTime = now + 6e4;
       this.requestCount = 0;
     }
-    if (this.requestCount >= this.config.aiTPM) {
+    if (this.requestCount >= this.config.aiRPM) {
       const delay = this.rateLimitResetTime - now;
       await new Promise((resolve) => setTimeout(resolve, delay));
       this.rateLimitResetTime = Date.now() + 6e4;
       this.requestCount = 0;
     }
     let schema = JSON.parse(schemaString);
+    const toolName = "extract_data";
     const payload = {
       model: this.config.aiModel,
       messages: [{ role: "system", content: systemPrompt }, ...messages],
-      response_format: { type: "json_schema", strict: true, schema }
+      tools: [{
+        type: "function",
+        function: {
+          name: toolName,
+          description: "根据提供的内容提取或分析信息。",
+          parameters: schema
+        }
+      }],
+      tool_choice: { type: "function", function: { name: toolName } }
     };
     const fullUrl = `${this.config.aiEndpoint.replace(/\/$/, "")}/chat/completions`;
     const headers = {
@@ -1190,7 +1220,13 @@ var AIManager = class {
     try {
       this.requestCount++;
       const response = await this.http.post(fullUrl, payload, { headers, timeout: 9e4 });
-      return JSON.parse(response.choices[0].message.content);
+      const toolCall = response.choices?.[0]?.message?.tool_calls?.[0];
+      if (toolCall?.function?.arguments) {
+        return JSON.parse(toolCall.function.arguments);
+      } else {
+        this.logger.error("AI 响应格式不正确:", JSON.stringify(response));
+        throw new Error("AI 响应格式不正确");
+      }
     } catch (error) {
       const errorMessage = error.response ? JSON.stringify(error.response.data) : error.message;
       this.logger.error(`请求 API 失败: ${errorMessage}`);
@@ -1214,29 +1250,29 @@ var usage = `
   <p>🐛 遇到问题？请通过 <strong>Issues</strong> 提交反馈，或加入 QQ 群 <a href="https://qm.qq.com/q/PdLMx9Jowq" style="color:#e0574a;text-decoration:none;"><strong>855571375</strong></a> 进行交流</p>
 </div>
 `;
-var logger = new import_koishi4.Logger("best-cave");
-var Config = import_koishi4.Schema.intersect([
-  import_koishi4.Schema.object({
-    perChannel: import_koishi4.Schema.boolean().default(false).description("启用分群模式"),
-    enableName: import_koishi4.Schema.boolean().default(false).description("启用自定义昵称"),
-    enableIO: import_koishi4.Schema.boolean().default(false).description("启用导入导出"),
-    adminChannel: import_koishi4.Schema.string().default("onebot:").description("管理群组 ID"),
-    caveFormat: import_koishi4.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本（参见 README）")
+var logger = new import_koishi3.Logger("best-cave");
+var Config = import_koishi3.Schema.intersect([
+  import_koishi3.Schema.object({
+    perChannel: import_koishi3.Schema.boolean().default(false).description("启用分群模式"),
+    enableName: import_koishi3.Schema.boolean().default(false).description("启用自定义昵称"),
+    enableIO: import_koishi3.Schema.boolean().default(false).description("启用导入导出"),
+    adminChannel: import_koishi3.Schema.string().default("onebot:").description("管理群组 ID"),
+    caveFormat: import_koishi3.Schema.string().default("回声洞 ——（{id}）|—— {name}").description("自定义文本（参见 README）")
   }).description("基础配置"),
-  import_koishi4.Schema.object({
-    enablePend: import_koishi4.Schema.boolean().default(false).description("启用审核"),
-    enableSimilarity: import_koishi4.Schema.boolean().default(false).description("启用查重"),
-    textThreshold: import_koishi4.Schema.number().min(0).max(100).step(0.01).default(90).description("文本相似度阈值 (%)"),
-    imageThreshold: import_koishi4.Schema.number().min(0).max(100).step(0.01).default(90).description("图片相似度阈值 (%)")
+  import_koishi3.Schema.object({
+    enablePend: import_koishi3.Schema.boolean().default(false).description("启用审核"),
+    enableSimilarity: import_koishi3.Schema.boolean().default(false).description("启用查重"),
+    textThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(90).description("文本相似度阈值 (%)"),
+    imageThreshold: import_koishi3.Schema.number().min(0).max(100).step(0.01).default(90).description("图片相似度阈值 (%)")
   }).description("复核配置"),
-  import_koishi4.Schema.object({
-    enableAI: import_koishi4.Schema.boolean().default(false).description("启用 AI"),
-    aiEndpoint: import_koishi4.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta/openai"),
-    aiApiKey: import_koishi4.Schema.string().description("密钥 (Key)").role("secret"),
-    aiModel: import_koishi4.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
-    aiTPM: import_koishi4.Schema.number().description("每分钟请求数 (TPM)").default(60),
-    AnalysePrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我提供的内容，总结关键词，概括内容并进行评分。`).description("分析 Prompt"),
-    aiAnalyseSchema: import_koishi4.Schema.string().role("textarea").default(
+  import_koishi3.Schema.object({
+    enableAI: import_koishi3.Schema.boolean().default(false).description("启用 AI"),
+    aiEndpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link").default("https://generativelanguage.googleapis.com/v1beta/openai"),
+    aiApiKey: import_koishi3.Schema.string().description("密钥 (Key)").role("secret"),
+    aiModel: import_koishi3.Schema.string().description("模型 (Model)").default("gemini-2.5-flash"),
+    aiRPM: import_koishi3.Schema.number().description("每分钟请求数 (RPM)").default(60),
+    AnalysePrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容分析专家。请分析我提供的内容，总结关键词，概括内容并进行评分。`).description("分析 Prompt"),
+    aiAnalyseSchema: import_koishi3.Schema.string().role("textarea").default(
       `{
         "type": "object",
         "properties": {
@@ -1259,8 +1295,8 @@ var Config = import_koishi4.Schema.intersect([
         "required": ["keywords", "description", "rating"]
       }`
     ).description("分析 JSON Schema"),
-    aiCheckPrompt: import_koishi4.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
-    aiCheckSchema: import_koishi4.Schema.string().role("textarea").default(
+    aiCheckPrompt: import_koishi3.Schema.string().role("textarea").default(`你是一位内容查重专家。请判断我提供的"新内容"是否与"已有内容"重复或高度相似。`).description("查重 Prompt"),
+    aiCheckSchema: import_koishi3.Schema.string().role("textarea").default(
       `{
         "type": "object",
         "properties": {
@@ -1277,15 +1313,15 @@ var Config = import_koishi4.Schema.intersect([
       }`
     ).description("查重 JSON Schema")
   }).description("模型配置"),
-  import_koishi4.Schema.object({
-    localPath: import_koishi4.Schema.string().description("文件映射路径"),
-    enableS3: import_koishi4.Schema.boolean().default(false).description("启用 S3 存储"),
-    publicUrl: import_koishi4.Schema.string().description("公共访问 URL").role("link"),
-    endpoint: import_koishi4.Schema.string().description("端点 (Endpoint)").role("link"),
-    bucket: import_koishi4.Schema.string().description("存储桶 (Bucket)"),
-    region: import_koishi4.Schema.string().default("auto").description("区域 (Region)"),
-    accessKeyId: import_koishi4.Schema.string().description("Access Key ID").role("secret"),
-    secretAccessKey: import_koishi4.Schema.string().description("Secret Access Key").role("secret")
+  import_koishi3.Schema.object({
+    localPath: import_koishi3.Schema.string().description("文件映射路径"),
+    enableS3: import_koishi3.Schema.boolean().default(false).description("启用 S3 存储"),
+    publicUrl: import_koishi3.Schema.string().description("公共访问 URL").role("link"),
+    endpoint: import_koishi3.Schema.string().description("端点 (Endpoint)").role("link"),
+    bucket: import_koishi3.Schema.string().description("存储桶 (Bucket)"),
+    region: import_koishi3.Schema.string().default("auto").description("区域 (Region)"),
+    accessKeyId: import_koishi3.Schema.string().description("Access Key ID").role("secret"),
+    secretAccessKey: import_koishi3.Schema.string().description("Secret Access Key").role("secret")
   }).description("存储配置")
 ]);
 function apply(ctx, config) {
@@ -1314,7 +1350,7 @@ function apply(ctx, config) {
       if (staleCaves.length > 0) {
         const idsToMark = staleCaves.map((c) => ({ id: c.id, status: "delete" }));
         await ctx.database.upsert("cave", idsToMark);
-        await cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
+        await cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
       }
     } catch (error) {
       logger.error("清理残留回声洞时发生错误:", error);
@@ -1332,7 +1368,7 @@ function apply(ctx, config) {
       const randomId = candidates[Math.floor(Math.random() * candidates.length)].id;
       const [randomCave] = await ctx.database.get("cave", { ...query, id: randomId });
       const messages = await buildCaveMessage(randomCave, config, fileManager, logger, session.platform);
-      for (const message of messages) if (message.length > 0) await session.send(import_koishi4.h.normalize(message));
+      for (const message of messages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
     } catch (error) {
       logger.error("随机获取回声洞失败:", error);
       return "随机获取回声洞失败";
@@ -1344,12 +1380,12 @@ function apply(ctx, config) {
       if (session.quote?.elements) {
         sourceElements = session.quote.elements;
       } else if (content?.trim()) {
-        sourceElements = import_koishi4.h.parse(content);
+        sourceElements = import_koishi3.h.parse(content);
       } else {
         await session.send("请在一分钟内发送你要添加的内容");
         const reply = await session.prompt(6e4);
         if (!reply) return "等待操作超时";
-        sourceElements = import_koishi4.h.parse(reply);
+        sourceElements = import_koishi3.h.parse(reply);
       }
       const newId = await getNextCaveId(ctx, reusableIds);
       const creationTime = /* @__PURE__ */ new Date();
@@ -1388,11 +1424,11 @@ function apply(ctx, config) {
         time: creationTime
       });
       if (hasMedia) finalStatus = await handleFileUploads(ctx, config, fileManager, logger, newCave, downloadedMedia, reusableIds, session);
-      if (finalStatus !== "preload" && finalStatus !== "delete") {
+      if (finalStatus !== "preload") {
         newCave.status = finalStatus;
         if (aiManager) await aiManager.analyzeAndStore(newCave, downloadedMedia);
         if (hashManager) {
-          const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h5) => ({ ...h5, cave: newCave.id }));
+          const allHashesToInsert = [...textHashesToStore, ...imageHashesToStore].map((h4) => ({ ...h4, cave: newCave.id }));
           if (allHashesToInsert.length > 0) await ctx.database.upsert("cave_hash", allHashesToInsert);
         }
         if (finalStatus === "pending" && reviewManager) reviewManager.sendForPend(newCave);
@@ -1409,7 +1445,7 @@ function apply(ctx, config) {
       const [targetCave] = await ctx.database.get("cave", { ...getScopeQuery(session, config), id });
       if (!targetCave) return `回声洞（${id}）不存在`;
       const messages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform);
-      for (const message of messages) if (message.length > 0) await session.send(import_koishi4.h.normalize(message));
+      for (const message of messages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
     } catch (error) {
       logger.error(`查看回声洞（${id}）失败:`, error);
       return "查看失败，请稍后再试";
@@ -1425,8 +1461,8 @@ function apply(ctx, config) {
       if (!isAuthor && !isAdmin) return "你没有权限删除这条回声洞";
       await ctx.database.upsert("cave", [{ id, status: "delete" }]);
       const caveMessages = await buildCaveMessage(targetCave, config, fileManager, logger, session.platform, "已删除");
-      cleanupPendingDeletions(ctx, fileManager, logger, reusableIds);
-      for (const message of caveMessages) if (message.length > 0) await session.send(import_koishi4.h.normalize(message));
+      for (const message of caveMessages) if (message.length > 0) await session.send(import_koishi3.h.normalize(message));
+      cleanupPendingDeletions(ctx, config, fileManager, logger, reusableIds);
     } catch (error) {
       logger.error(`标记回声洞（${id}）失败:`, error);
       return "删除失败，请稍后再试";
@@ -1437,7 +1473,7 @@ function apply(ctx, config) {
       const adminChannelId = config.adminChannel?.split(":")[1];
       if (session.channelId !== adminChannelId) return "此指令仅限在管理群组中使用";
       try {
-        const aggregatedStats = await ctx.database.select("cave", { status: "active" }).groupBy(["userId", "userName"], { count: /* @__PURE__ */ __name((row) => import_koishi4.$.count(row.id), "count") }).execute();
+        const aggregatedStats = await ctx.database.select("cave", { status: "active" }).groupBy(["userId", "userName"], { count: /* @__PURE__ */ __name((row) => import_koishi3.$.count(row.id), "count") }).execute();
         if (!aggregatedStats.length) return "目前没有回声洞投稿";
         const userStats = /* @__PURE__ */ new Map();
         for (const stat of aggregatedStats) {

package/package.json

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