koishi-plugin-chatluna-affinity 0.0.1 → 0.0.3

package/lib/affinity-store.js

@@ -5,6 +5,34 @@ function clamp(value, low, high) {
   return Math.min(high, Math.max(low, Math.round(value)));
 }
 
+function formatBeijingTimestamp() {
+  try {
+    const formatter = new Intl.DateTimeFormat('en-CA', {
+      timeZone: 'Asia/Shanghai',
+      hour12: false,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+    const parts = formatter.formatToParts(new Date()).reduce((acc, part) => {
+      if (part.type !== 'literal') acc[part.type] = part.value;
+      return acc;
+    }, {});
+    const { year, month, day, hour, minute, second } = parts;
+    if (year && month && day && hour && minute && second) {
+      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    }
+  } catch (_) {
+    // ignore and fallback
+  }
+  const now = new Date();
+  const pad = (value) => value.toString().padStart(2, '0');
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+
 function normalizeRelationshipConfig(config) {
   if (Array.isArray(config.relationships)) return [...config.relationships];
   return [];
@@ -33,13 +61,41 @@ function createAffinityStore(ctx, config, log) {
 
   const makeId = (platform, userId) => `${platform || 'unknown'}:${userId || 'anonymous'}`;
 
+  const resolveInitialRange = () => {
+    const rawMin = Number.isFinite(config.min) ? config.min : 0;
+    const rawMax = Number.isFinite(config.max) ? config.max : 100;
+    const boundaryMin = Math.min(rawMin, rawMax);
+    const boundaryMax = Math.max(rawMin, rawMax);
+    const fallbackCenter = clamp(Math.round((boundaryMin + boundaryMax) / 2), boundaryMin, boundaryMax);
+    let lower = Number.isFinite(config.initialRandomMin) ? config.initialRandomMin : fallbackCenter;
+    let upper = Number.isFinite(config.initialRandomMax) ? config.initialRandomMax : fallbackCenter;
+    lower = clamp(lower, boundaryMin, boundaryMax);
+    upper = clamp(upper, boundaryMin, boundaryMax);
+    if (lower > upper) [lower, upper] = [upper, lower];
+    return { low: lower, high: upper, min: boundaryMin, max: boundaryMax };
+  };
+
+  const rollInitial = () => {
+    const range = resolveInitialRange();
+    if (range.low === range.high) return range.low;
+    const span = Math.max(0, range.high - range.low);
+    if (span <= 0) return range.low;
+    return range.low + Math.round(Math.random() * span);
+  };
+
+  const defaultInitialValue = () => {
+    const range = resolveInitialRange();
+    if (range.low === range.high) return range.low;
+    return clamp((range.low + range.high) / 2, range.min, range.max);
+  };
+
   const readLegacy = async (platform, userId) => {
     if (!ctx.database?.getUser) return null;
     try {
       const legacy = await ctx.database.getUser(platform, userId, ['affinity', 'affinityInited']);
       if (!legacy) return null;
       if (typeof legacy.affinity !== 'number' && !legacy.affinityInited) return null;
-      const initial = typeof legacy.affinity === 'number' ? legacy.affinity : config.initial;
+      const initial = typeof legacy.affinity === 'number' ? legacy.affinity : rollInitial();
       const now = new Date();
       return {
         id: makeId(platform, userId),
@@ -93,7 +149,7 @@ function createAffinityStore(ctx, config, log) {
       platform: identity.platform,
       selfId: identity.selfId || current?.selfId || '',
       userId: identity.userId,
-      affinity: typeof value === 'number' ? value : current?.affinity ?? config.initial,
+      affinity: typeof value === 'number' ? value : current?.affinity ?? defaultInitialValue(),
       affinityInited: inited ?? current?.affinityInited ?? false,
       relation: relationText !== undefined ? relationText : current?.relation ?? '',
       updatedAt: now,
@@ -147,6 +203,55 @@ function createAffinityStore(ctx, config, log) {
     applyConfigUpdate();
   };
 
+  const recordBlacklist = (platform, userId, note = '') => {
+    const normalizedPlatform = String(platform ?? '').trim();
+    const normalizedUser = String(userId ?? '').trim();
+    if (!normalizedPlatform || !normalizedUser) return null;
+    const list = Array.isArray(config.autoBlacklist) ? [...config.autoBlacklist] : [];
+    const index = list.findIndex((item) => item && String(item.platform ?? '').trim() === normalizedPlatform && String(item.userId ?? '').trim() === normalizedUser);
+    const entry = {
+      platform: normalizedPlatform,
+      userId: normalizedUser,
+      blockedAt: formatBeijingTimestamp(),
+      note: note != null ? String(note) : ''
+    };
+    list[index >= 0 ? index : list.length] = entry;
+    config.autoBlacklist = list;
+    applyConfigUpdate();
+    return entry;
+  };
+
+  const removeBlacklist = (platform, userId) => {
+    const normalizedPlatform = String(platform ?? '').trim();
+    const normalizedUser = String(userId ?? '').trim();
+    if (!normalizedPlatform || !normalizedUser) return false;
+    const list = Array.isArray(config.autoBlacklist) ? [...config.autoBlacklist] : [];
+    const nextList = list.filter((item) => {
+      if (!item) return false;
+      const p = String(item.platform ?? '').trim();
+      const u = String(item.userId ?? '').trim();
+      return !(p === normalizedPlatform && u === normalizedUser);
+    });
+    const changed = nextList.length !== list.length;
+    if (changed) {
+      config.autoBlacklist = nextList;
+      applyConfigUpdate();
+    }
+    return changed;
+  };
+
+  const isBlacklisted = (platform, userId) => {
+    const normalizedPlatform = String(platform ?? '').trim();
+    const normalizedUser = String(userId ?? '').trim();
+    if (!normalizedPlatform || !normalizedUser) return false;
+    return (config.autoBlacklist || []).some((item) => {
+      if (!item) return false;
+      const p = String(item.platform ?? '').trim();
+      const u = String(item.userId ?? '').trim();
+      return p === normalizedPlatform && u === normalizedUser;
+    });
+  };
+
   const ensure = async (session, clampFn, fallbackInitial) => {
     const platform = session?.platform;
     const userId = session?.userId;
@@ -154,7 +259,7 @@ function createAffinityStore(ctx, config, log) {
       const manual = fallbackInitial !== undefined ? null : (session?.userId ? findManualRelationship(session?.platform, session?.userId) : null);
       const base = fallbackInitial !== undefined
         ? fallbackInitial
-        : manual?.initialAffinity ?? config.initial;
+        : manual?.initialAffinity ?? defaultInitialValue();
       return { affinity: clampFn(base, config.min, config.max), isNew: false };
     }
 
@@ -163,14 +268,14 @@ function createAffinityStore(ctx, config, log) {
       const manual = findManualRelationship(platform, userId);
       const base = fallbackInitial !== undefined
         ? fallbackInitial
-        : manual?.initialAffinity ?? config.initial;
+        : manual?.initialAffinity ?? rollInitial();
       const initial = clampFn(base, config.min, config.max);
       const level = resolveLevelByAffinity(initial);
       await save({ platform, userId, selfId: session?.selfId }, initial, true, level?.relation ?? '');
       return { affinity: initial, isNew: true };
     }
 
-    const normalized = clampFn(record.affinity ?? config.initial, config.min, config.max);
+    const normalized = clampFn(record.affinity ?? defaultInitialValue(), config.min, config.max);
     if (normalized !== record.affinity) {
       const level = resolveLevelByAffinity(normalized);
       await save({ platform, userId, selfId: session?.selfId }, normalized, record.affinityInited, level?.relation ?? record.relation ?? '');
@@ -187,7 +292,12 @@ function createAffinityStore(ctx, config, log) {
     resolveLevelByRelation,
     findManualRelationship,
     updateRelationshipConfig,
-    defaultInitial: config.initial
+    recordBlacklist,
+    removeBlacklist,
+    isBlacklisted,
+    defaultInitial: defaultInitialValue,
+    randomInitial: rollInitial,
+    initialRange: resolveInitialRange
   };
 }
 

package/lib/index.d.ts

@@ -2,13 +2,23 @@ import { Context, Schema } from 'koishi';
 export declare function apply(ctx: Context, config: Config): void;
 export interface Config {
   variableName: string;
-  initial: number;
+  initialRandomMin: number;
+  initialRandomMax: number;
   min: number;
   max: number;
   model: string;
   analysisPrompt: string;
-  maxDeltaPerMessage: number;
+  maxIncreasePerMessage: number;
+  maxDecreasePerMessage: number;
   enableAnalysis: boolean;
+  enableAutoBlacklist: boolean;
+  blacklistThreshold: number;
+  autoBlacklist: Array<{
+    platform: string;
+    userId: string;
+    blockedAt: string;
+    note: string;
+  }>;
   debugLogging: boolean;
   triggerNicknames: string[];
   useLastAffinity: boolean;

package/lib/index.js

@@ -27,6 +27,19 @@ function apply(ctx, config) {
   const affinityProvider = createAffinityProvider({ config, cache, store });
   const relationshipProvider = createRelationshipProvider({ config, store });
 
+  const globalGuard = async (session, next) => {
+    if (!config.enableAutoBlacklist) return next();
+    const platform = session?.platform;
+    const userId = session?.userId;
+    if (!platform || !userId) return next();
+    if (!store.isBlacklisted(platform, userId)) return next();
+    cache.clear(platform, userId);
+    log('info', '消息已因自动拉黑被拦截', { platform, userId });
+    return;
+  };
+
+  ctx.middleware(globalGuard, true);
+
   ctx.on('ready', async () => {
     try {
       modelRef = await ctx.chatluna.createChatModel(config.model || ctx.chatluna.config.defaultModel);

package/lib/middleware.js

@@ -51,28 +51,65 @@ async function resolveTriggerNicknames(ctx, config) {
   return Array.from(names).map((name) => name.toLowerCase());
 }
 
+const tryBlacklistUser = async (ctx, session, store, cache, log) => {
+  const platform = session?.platform;
+  const userId = session?.userId;
+  if (!platform || !userId) return { skipped: true };
+  if (store.isBlacklisted(platform, userId)) {
+    log('debug', '用户已在自动拉黑列表，跳过重复处理', { platform, userId });
+    return { skipped: true };
+  }
+
+  const recorded = store.recordBlacklist(platform, userId, 'local guard');
+  if (recorded) log('info', '已记录自动拉黑用户', { platform, userId, note: 'local guard' });
+  cache?.clear?.(platform, userId);
+
+  return { recorded: Boolean(recorded) };
+};
+
 function createAnalysisMiddleware(ctx, config, { store, history, cache, getModel, renderTemplate, getMessageContent, log }) {
   const debugEnabled = config.debugLogging;
 
-  return async (session, next) => {
-    if (!config.enableAnalysis) return next();
+  const clampValue = (value, low, high) => Math.min(high, Math.max(low, value));
+
+  const resolveIncreaseLimit = () => {
+    if (Number.isFinite(config.maxIncreasePerMessage)) return Math.abs(config.maxIncreasePerMessage);
+    return 5;
+  };
+
+  const resolveDecreaseLimit = () => {
+    if (Number.isFinite(config.maxDecreasePerMessage)) return Math.abs(config.maxDecreasePerMessage);
+    return 5;
+  };
+
+  const executeAnalysis = async (session) => {
+    if (config.enableAutoBlacklist && store.isBlacklisted(session?.platform, session?.userId)) {
+      cache.clear(session?.platform, session?.userId);
+      if (debugEnabled) log('debug', '用户处于自动拉黑名单，跳过分析', { platform: session?.platform, userId: session?.userId });
+      return;
+    }
+
     const nicknames = await resolveTriggerNicknames(ctx, config);
-    if (!shouldAnalyzeSession(session, nicknames, log, debugEnabled)) return next();
-    if (!session?.platform || !session?.userId) return next();
+    if (!shouldAnalyzeSession(session, nicknames, log, debugEnabled)) return;
+    if (!session?.platform || !session?.userId) return;
 
-    const clampValue = (value, low, high) => Math.min(high, Math.max(low, value));
     try {
       const manual = store.findManualRelationship(session.platform, session.userId);
       const fallback = manual && typeof manual.initialAffinity === 'number' ? manual.initialAffinity : undefined;
       const result = await store.ensure(session, clampValue, fallback);
       const oldAffinity = result.affinity;
       if (debugEnabled) log('debug', '读取已有好感度', { userId: session.userId, platform: session.platform, affinity: oldAffinity });
+      if (config.useLastAffinity) cache.set(session.platform, session.userId, oldAffinity);
 
       const historyLines = await history.fetch(session);
+      const maxIncreaseLimit = resolveIncreaseLimit();
+      const maxDecreaseLimit = resolveDecreaseLimit();
       const prompt = renderTemplate(config.analysisPrompt, {
         currentAffinity: oldAffinity,
         minAffinity: config.min,
         maxAffinity: config.max,
+        maxIncreasePerMessage: maxIncreaseLimit,
+        maxDecreasePerMessage: maxDecreaseLimit,
         historyCount: historyLines.length,
         historyText: historyLines.join('\n'),
         historyJson: JSON.stringify(historyLines, null, 2),
@@ -82,9 +119,8 @@ function createAnalysisMiddleware(ctx, config, { store, history, cache, getModel
 
       const model = getModel();
       if (!model) {
-        if (config.useLastAffinity) cache.set(session.platform, session.userId, oldAffinity);
         log('warn', '模型尚未就绪，跳过分析', { userId: session.userId, platform: session.platform });
-        return next();
+        return;
       }
 
       const message = await model.invoke(prompt);
@@ -107,7 +143,11 @@ function createAnalysisMiddleware(ctx, config, { store, history, cache, getModel
         }
       }
 
-      const limitedDelta = clampValue(delta, -Math.abs(config.maxDeltaPerMessage), Math.abs(config.maxDeltaPerMessage));
+      const positiveLimit = resolveIncreaseLimit();
+      const negativeLimit = resolveDecreaseLimit();
+      const limitedDelta = delta >= 0
+        ? Math.min(delta, positiveLimit)
+        : Math.max(delta, -negativeLimit);
       const nextAffinity = clampValue(oldAffinity + limitedDelta, config.min, config.max);
       if (nextAffinity !== oldAffinity) {
         const level = store.resolveLevelByAffinity(nextAffinity);
@@ -117,9 +157,24 @@ function createAnalysisMiddleware(ctx, config, { store, history, cache, getModel
       } else if (config.useLastAffinity) {
         cache.set(session.platform, session.userId, oldAffinity);
       }
+
+      if (config.enableAutoBlacklist && nextAffinity < config.blacklistThreshold) {
+        await tryBlacklistUser(ctx, session, store, cache, log);
+      }
     } catch (error) {
       log('warn', '分析流程异常', error);
     }
+  };
+
+  return async (session, next) => {
+    if (!config.enableAnalysis) return next();
+
+    if (config.useLastAffinity) {
+      executeAnalysis(session).catch((error) => log('warn', '异步分析流程异常', error));
+      return next();
+    }
+
+    await executeAnalysis(session);
     return next();
   };
 }

package/lib/providers.js

@@ -2,7 +2,7 @@ function createAffinityProvider({ config, cache, store }) {
   return async (_, __, configurable) => {
     const session = configurable?.session;
     if (!session?.platform || !session?.userId) {
-      return store.clamp(config.initial);
+      return store.clamp(store.defaultInitial());
     }
 
     const cached = config.useLastAffinity ? cache.get(session.platform, session.userId) : null;
@@ -34,7 +34,8 @@ function createRelationshipProvider({ config, store }) {
       if (!level) return '';
       return level.note ? `${level.relation}（${level.note}）` : level.relation;
     }
-    const level = store.resolveLevelByAffinity(config.initial);
+    const fallback = store.defaultInitial();
+    const level = store.resolveLevelByAffinity(fallback);
     return level ? level.relation : '';
   };
 }

package/lib/schema.js

@@ -9,22 +9,34 @@ const inject = {
 
 const AffinitySchema = Schema.object({
   variableName: Schema.string().default('affinity').description('变量名称'),
-  initial: Schema.number().default(30).description('初始好感度'),
-  min: Schema.number().default(0).description('最小值'),
-  max: Schema.number().default(100).description('最大值'),
-  maxDeltaPerMessage: Schema.number().default(5).description('单次增减的最大幅度'),
+  initialRandomMin: Schema.number().default(20).description('初始好感度随机范围下限'),
+  initialRandomMax: Schema.number().default(40).description('初始好感度随机范围上限'),
+  min: Schema.number().default(0).description('好感度最小值'),
+  max: Schema.number().default(100).description('好感度最大值'),
+  maxIncreasePerMessage: Schema.number().default(5).description('单次增加的最大幅度'),
+  maxDecreasePerMessage: Schema.number().default(5).description('单次减少的最大幅度'),
   model: Schema.dynamic('model').description('用于好感度分析的模型'),
   enableAnalysis: Schema.boolean().default(true).description('是否启用好感度分析'),
   useLastAffinity: Schema.boolean().default(false).description('允许直接返回上一次的好感度，不等待分析结果写入'),
   historyMessageCount: Schema.number().default(10).min(0).description('用于分析的最近消息条数'),
+  enableAutoBlacklist: Schema.boolean().default(false).description('当好感度低于阈值时自动拉黑用户'),
+  blacklistThreshold: Schema.number().default(0).description('好感度低于该值时触发自动拉黑'),
+  autoBlacklist: Schema.array(
+    Schema.object({
+      platform: Schema.string().default('').description('平台'),
+      userId: Schema.string().default('').description('用户 ID'),
+      blockedAt: Schema.string().default('').description('拉黑时间'),
+      note: Schema.string().default('').description('备注')
+    })
+  ).role('table').default([]).description('自动拉黑记录'),
   triggerNicknames: Schema.array(Schema.string().description('昵称'))
     .role('table')
     .default([])
-    .description('触发分析的额外昵称列表'),
+    .description('触发分析的 bot 昵称列表'),
   analysisPrompt: Schema.string()
     .role('textarea')
     .default(
-      '你是好感度管家，需要根据上下文评估是否调整好感度。\n- 关注最近若干条群聊消息，判断整体语气与语境；\n- 当用户友善、感谢、积极互动时，适度增加；\n- 当用户正常交流且无明显倾向时，保持不变；\n- 当用户冒犯、敷衍、重复打扰时，减少；\n- 每次调整幅度不超过 5 ，并保持在提供的范围内；\n- 使用 action 表示行为：increase 增加、decrease 减少、hold 保持。\n\n角色设定：{{personaPrompt}}\n\n当前好感度：{{currentAffinity}} （范围 {{minAffinity}} ~ {{maxAffinity}}）\n最近 {{historyCount}} 条消息（旧 -> 新）：\n{{historyText}}\n\n本次用户消息：\n{{userMessage}}\n\n请仅输出 JSON：{"delta": 整数, "action": "increase|decrease|hold", "reason": "简短中文原因"}。'
+      '你是好感度管家，需要根据上下文评估是否调整好感度。\n- 关注最近若干条群聊消息，判断整体语气与语境；\n- 当用户友善、感谢、积极互动时，适度增加；\n- 当用户正常交流且无明显倾向时，保持不变；\n- 当用户冒犯、敷衍、重复打扰时，减少；\n- 增加幅度不超过 {{maxIncreasePerMessage}} ，减少幅度不超过 {{maxDecreasePerMessage}} ，并保持在提供的范围内；\n- 使用 action 表示行为：increase 增加、decrease 减少、hold 保持。\n\n角色设定：{{personaPrompt}}\n\n当前好感度：{{currentAffinity}} （范围 {{minAffinity}} ~ {{maxAffinity}}）\n最近 {{historyCount}} 条消息（旧 -> 新）：\n{{historyText}}\n\n本次用户消息：\n{{userMessage}}\n\n请仅输出 JSON：{"delta": 整数, "action": "increase|decrease|hold", "reason": "简短中文原因"}。'
     )
     .description('好感度分析主提示词'),
   personaPrompt: Schema.string()

package/lib/tools.js

@@ -56,7 +56,8 @@ function createRelationshipTool(options) {
       if (!level && Array.isArray(options.relationLevels)) {
         level = options.relationLevels.find((item) => item && item.relation === relationName) || null;
       }
-      const base = level ? options.clamp(level.min) : options.clamp(options.defaultInitial);
+      const baseValue = level ? level.min : options.defaultInitial();
+      const base = options.clamp(baseValue);
       await options.save({ platform, userId, selfId: session?.selfId }, base, true, relationName);
       options.cache.set(platform, userId, base);
       options.updateRelationshipConfig(userId, relationName, base);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna-affinity",
-  "description": "为 ChatLuna 提供{好感度}与{关系}变量并提供对应的工具调用",
-  "version": "0.0.1",
+  "description": "为 ChatLuna 提供{好感度}与{关系}变量并提供对应的工具调用和低好感自动拉黑功能。",
+  "version": "0.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -6,7 +6,10 @@
 
 - `affinity()` 变量：随时取得用户与机器人的好感度。初次使用会自动初始化并写入数据库。
 - `relationship()` 变量：返回友好度对应的称谓，支持自定义关系区间与备注。
-- 自动分析：收到私聊、@、引用或命中昵称时，调用指定模型分析对话并调整好感度。
+- 初始好感度：可在自定义范围内随机生成，避免所有用户同值起步。
+- 安全守卫：当好感度低于自定义阈值时，记录到插件黑名单并全局拦截后续消息。
+- 控制台名单：自动拉黑后会同步到配置表，方便复核与手动维护。
+- 自动分析：收到私聊、@、引用或命中 bot 昵称时，调用指定模型分析对话并调整好感度。
 - 调整工具：
   - `adjust_affinity` 将好感度设为指定数值，并同步关系区间。
   - `adjust_relationship` 将关系切换为自定义称谓，同时把好感度调至对应区间的下限。
@@ -17,14 +20,19 @@
 | 字段 | 说明 |
 | --- | --- |
 | `variableName` | 好感度变量名称，默认 `affinity` |
-| `initial` / `min` / `max` | 好感度初始值与上下限 |
-| `maxDeltaPerMessage` | 单次分析允许的最大变动幅度 |
+| `min` / `max` | 好感度最小值 / 最大值 |
+| `initialRandomMin` / `initialRandomMax` | 初始好感度随机区间（含边界，默认 20~40，取整数） |
+| `maxIncreasePerMessage` | 单次允许增加的最大幅度（提示词变量 `{{maxIncreasePerMessage}}`） |
+| `maxDecreasePerMessage` | 单次允许减少的最大幅度（提示词变量 `{{maxDecreasePerMessage}}`） |
 | `model` | 用于分析的 ChatLuna 模型 |
 | `analysisPrompt` | 主提示词模板，支持 `{{currentAffinity}}` 等占位符 |
 | `personaPrompt` | 机器人的人设补充说明 |
-| `triggerNicknames` | 额外触发昵称列表（默认含 ChatLuna 配置的昵称/@ 名） |
+| `triggerNicknames` | 触发分析的 bot 昵称列表（默认含 ChatLuna 配置的昵称/@ 名） |
 | `useLastAffinity` | 开启后变量能立即返回上一次结果（无需等待分析完成） |
 | `historyMessageCount` | 提供给模型的历史消息条数（从数据库或 group-analysis 插件取得） |
+| `enableAutoBlacklist` | 启用后，好感度低于阈值会写入黑名单并阻断消息 |
+| `blacklistThreshold` | 自动拉黑触发值（小于该值即触发） |
+| `autoBlacklist` | 自动拉黑记录列表（自动维护，可在控制台查看与编辑） |
 | `relationships` | 特殊关系配置：`userId`、`initialAffinity`、`relation`、`note` |
 | `relationshipAffinityLevels` | 区间 → 称谓映射，默认提供“陌生人/友好/亲近/挚友” |
 | `registerAffinityTool` / `registerRelationshipTool` | 是否注册对应 ChatLuna 工具 |