mioku-plugin-chat 2.5.0 → 2.5.2

package/core/media/image-analyzer.ts

@@ -27,6 +27,13 @@ export interface ImageAnalysisResult {
 
 export interface ImageAnalysisOptions {
   runAIRequest?<T>(request: () => Promise<T>): Promise<T | null>;
+  /**
+   * When non-empty, only memes whose detected character is in this list
+   * get downloaded into `data/chat/meme/<character>/<emotion>/`. Other
+   * characters still get a DB record but no local file.
+   * Empty (default) = no restriction; save for every detected character.
+   */
+  allowedCharacters?: string[];
 }
 
 function formatImageRecognitionLog(record: {
@@ -382,8 +389,29 @@ export async function processImage(
           ? analysis.characters
           : [analysis.character || "unknown"];
 
-      // 为每个角色创建文件夹并保存图片
-      const savePromises = characters.map(async (character) => {
+      // 应用 allowedCharacters 过滤：配置非空时只对列表内角色本地保存
+      const allowed = options?.allowedCharacters;
+      const hasRestriction = Array.isArray(allowed) && allowed.length > 0;
+      const normalizeName = (s: string) => String(s || "").trim().toLowerCase();
+      const allowedSet = hasRestriction
+        ? new Set((allowed as string[]).map(normalizeName))
+        : null;
+
+      const saveableCharacters = allowedSet
+        ? characters.filter((c) => allowedSet.has(normalizeName(c)))
+        : characters;
+
+      const skipped = characters.filter(
+        (c) => !saveableCharacters.includes(c),
+      );
+      if (skipped.length > 0) {
+        logger.info(
+          `[image-analyzer] Skipping local file save for characters outside allowedCharacters: ${skipped.join(", ")}`,
+        );
+      }
+
+      // 为每个允许保存的角色创建文件夹并保存图片
+      const savePromises = saveableCharacters.map(async (character) => {
         const memeDir = path.join(
           process.cwd(),
           "data",
@@ -429,7 +457,7 @@ export async function processImage(
     // 保存到数据库
     const record: ImageRecord = {
       hash,
-      url: imageUrl,
+      url: normalizeImageUrl(imageUrl) || imageUrl,
       type: analysis.type,
       description: analysis.description || "未知",
       emotion: analysis.emotion,
@@ -452,12 +480,64 @@ export async function processImage(
  * 命中数据库记录时返回 [meme:描述] 或 [image:描述]，否则返回 [image]。
  * 收集聊天历史时用它，之前没识别到的图片不会再次触发请求。
  */
-export function getImageTag(imageUrl: string, db: ChatDatabase): string {
-  const record = db.getImageByUrl(imageUrl);
+export async function getImageTag(imageUrl: string, db: ChatDatabase): Promise<string> {
+  const exact = db.getImageByUrl(imageUrl);
+  if (exact) {
+    return `[${exact.type}:${exact.description}]`;
+  }
 
-  if (record) {
-    return `[${record.type}:${record.description}]`;
+  const normalized = normalizeImageUrl(imageUrl);
+  if (normalized && normalized !== imageUrl) {
+    const normalizedHit = db.getImageByUrl(normalized);
+    if (normalizedHit) {
+      return `[${normalizedHit.type}:${normalizedHit.description}]`;
+    }
+  }
+
+  const hash = await calculateImageHash(imageUrl);
+  if (hash) {
+    const byHash = db.getImageByHash(hash);
+    if (byHash) {
+      try {
+        db.saveImage({
+          hash: byHash.hash,
+          url: normalized || imageUrl,
+          type: byHash.type,
+          description: byHash.description,
+          emotion: byHash.emotion,
+          character: byHash.character,
+          filePath: byHash.filePath,
+          createdAt: byHash.createdAt,
+        });
+      } catch {
+        // ignore — best-effort URL caching for next time
+      }
+      return `[${byHash.type}:${byHash.description}]`;
+    }
   }
 
   return "[image]";
 }
+
+/**
+ * Strip query string and hash so URLs from different NapCat code paths
+ * (live vs. get_group_msg_history) still match. QQ gchat.qpic.cn URLs
+ * include varying `?term=2`, `?spec=0`, signed tokens, etc.
+ */
+export function normalizeImageUrl(url: string): string {
+  if (!url || typeof url !== "string") return "";
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  try {
+    const u = new URL(trimmed);
+    return `${u.protocol}//${u.host}${u.pathname}`;
+  } catch {
+    const qIdx = trimmed.indexOf("?");
+    const hashIdx = trimmed.indexOf("#");
+    let cutAt = -1;
+    if (qIdx >= 0 && hashIdx >= 0) cutAt = Math.min(qIdx, hashIdx);
+    else if (qIdx >= 0) cutAt = qIdx;
+    else if (hashIdx >= 0) cutAt = hashIdx;
+    return cutAt >= 0 ? trimmed.slice(0, cutAt) : trimmed;
+  }
+}

package/db.ts

@@ -377,8 +377,11 @@ export async function initDatabase(): Promise<ChatDatabase> {
     `),
     // 图片记录
     insertImage: db.prepare(`
-      INSERT OR IGNORE INTO images (hash, url, type, description, emotion, character, file_path, created_at)
+      INSERT INTO images (hash, url, type, description, emotion, character, file_path, created_at)
       VALUES ($hash, $url, $type, $description, $emotion, $character, $filePath, $createdAt)
+      ON CONFLICT(hash) DO UPDATE SET
+        url = excluded.url,
+        created_at = excluded.created_at
     `),
     getImageByHash: db.prepare(`SELECT * FROM images WHERE hash = $hash`),
     getImageByUrl: db.prepare(`SELECT * FROM images WHERE url = $url`),

package/handlers/message.ts

@@ -104,6 +104,10 @@ export function createMessageHandler(
                     groupId,
                     label: "image-analysis",
                   }),
+                allowedCharacters:
+                  cfg.emoji?.characters && cfg.emoji.characters.length > 0
+                    ? cfg.emoji.characters
+                    : undefined,
               }).catch((err) =>
                 ctx.logger.error(`[image-analyzer] Failed: ${err}`),
               );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-chat",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "AI 智能聊天插件",
   "main": "index.ts",
   "type": "module",

package/utils/message.ts

@@ -14,7 +14,10 @@ import {
   type HistoryMediaProcessingOptions,
   type MediaMessageSegment,
 } from "../core/media/history-media";
-import { getImageTag } from "../core/media/image-analyzer";
+import {
+  calculateImageHash,
+  normalizeImageUrl,
+} from "../core/media/image-analyzer";
 
 const HISTORY_MEDIA_CONCURRENCY = 8;
 
@@ -217,11 +220,14 @@ interface HistoryFormatContext {
   db:
     | {
         getImageByUrl?(url: string): ImageRecord | null;
+        getImageByHash?(hash: string): ImageRecord | null;
+        saveImage?(image: ImageRecord): void;
       }
     | undefined;
   historyMediaOptions: HistoryMediaProcessingOptions;
   botUin: number;
   memberNameCache: Map<string, string>;
+  hashLookupCache: Map<string, string | null>;
 }
 
 async function resolveMemberName(
@@ -286,7 +292,7 @@ function buildReplyAnnotation(source: any, ctx: HistoryFormatContext): string |
   if (sourceUserId == null && !sourceText && !sourceNickname) return null;
 
   const idStr = sourceId != null ? String(sourceId) : "?";
-  let displayName = sourceNickname;
+  let displayName: string | undefined;
   if (sourceUserId != null) {
     displayName = ctx.memberNameCache.get(String(sourceUserId)) || String(sourceUserId);
   }
@@ -296,6 +302,49 @@ function buildReplyAnnotation(source: any, ctx: HistoryFormatContext): string |
   return `↪ reply to #${idStr} ${displayName}: "${text}"`;
 }
 
+async function getImageTagWithHashCache(
+  imageUrl: string,
+  db: NonNullable<HistoryFormatContext["db"]>,
+  ctx: HistoryFormatContext,
+): Promise<string> {
+  const exact = db.getImageByUrl?.(imageUrl);
+  if (exact) return `[${exact.type}:${exact.description}]`;
+
+  const normalized = normalizeImageUrl(imageUrl);
+  if (normalized && normalized !== imageUrl) {
+    const hit = db.getImageByUrl?.(normalized);
+    if (hit) return `[${hit.type}:${hit.description}]`;
+  }
+
+  let hash = ctx.hashLookupCache.get(`hash:${imageUrl}`);
+  if (hash === undefined) {
+    hash = (await calculateImageHash(imageUrl)) || null;
+    ctx.hashLookupCache.set(`hash:${imageUrl}`, hash);
+  }
+  if (!hash) return "[image]";
+
+  const byHash = db.getImageByHash?.(hash);
+  if (byHash) {
+    try {
+      db.saveImage?.({
+        hash: byHash.hash,
+        url: normalized || imageUrl,
+        type: byHash.type,
+        description: byHash.description,
+        emotion: byHash.emotion,
+        character: byHash.character,
+        filePath: byHash.filePath,
+        createdAt: byHash.createdAt,
+      });
+    } catch {
+      // best-effort URL caching for next call
+    }
+    return `[${byHash.type}:${byHash.description}]`;
+  }
+
+  return "[image]";
+}
+
 async function formatHistoryMessage(
   msg: any,
   ctx: HistoryFormatContext,
@@ -359,15 +408,30 @@ async function buildMessageContent(
   if (atContent) parts.push(atContent);
   if (textContent) parts.push(textContent);
 
-  for (const imageSeg of msg.message.filter((seg: any) => seg.type === "image")) {
-    const imageUrl = imageSeg.url || imageSeg.data?.url;
-    if (imageUrl) {
-      parts.push(
-        db?.getImageByUrl
-          ? getImageTag(String(imageUrl), db as any)
-          : "[image]",
-      );
-    }
+  const imageSegments = msg.message.filter((seg: any) => seg.type === "image");
+  if (imageSegments.length > 0 && db?.getImageByUrl) {
+    const imageTags = await Promise.all(
+      imageSegments.map(async (seg: any) => {
+        const imageUrl = seg.url || seg.data?.url;
+        if (!imageUrl) return "[image]";
+
+        const cached = ctx.hashLookupCache.get(imageUrl);
+        if (cached !== undefined) {
+          return cached;
+        }
+
+        const tag = await getImageTagWithHashCache(
+          String(imageUrl),
+          db as any,
+          ctx,
+        );
+        ctx.hashLookupCache.set(imageUrl, tag);
+        return tag;
+      }),
+    );
+    for (const tag of imageTags) parts.push(tag);
+  } else if (imageSegments.length > 0) {
+    for (const _ of imageSegments) parts.push("[image]");
   }
 
   for (const videoSeg of msg.message.filter(
@@ -393,7 +457,7 @@ async function buildMessageContent(
   }
 
   for (const cardSeg of msg.message.filter((seg: any) =>
-    ["xml", "json", "lightapp", "ark"].includes(cardSeg.type),
+    ["xml", "json", "lightapp", "ark"].includes(seg.type),
   )) {
     const cardData =
       cardSeg.data?.data || cardSeg.data?.xml || cardSeg.data || cardSeg.xml || "";
@@ -530,6 +594,7 @@ export async function getGroupHistory(
 
     const botUin = selfId;
     const memberNameCache = new Map<string, string>();
+    const hashLookupCache = new Map<string, string | null>();
 
     for (const m of messages) {
       const uid = m?.user_id;
@@ -544,6 +609,7 @@ export async function getGroupHistory(
       historyMediaOptions,
       botUin,
       memberNameCache,
+      hashLookupCache,
     };
 
     const formattedResults = await mapWithConcurrency(