koishi-plugin-chatluna-affinity 0.0.1

package/lib/affinity-store.js

@@ -0,0 +1,194 @@
+const MODEL_NAME = 'chatluna_affinity_records';
+
+function clamp(value, low, high) {
+  if (typeof value !== 'number' || Number.isNaN(value)) return low;
+  return Math.min(high, Math.max(low, Math.round(value)));
+}
+
+function normalizeRelationshipConfig(config) {
+  if (Array.isArray(config.relationships)) return [...config.relationships];
+  return [];
+}
+
+function extendModel(ctx) {
+  ctx.model.extend(
+    MODEL_NAME,
+    {
+      id: 'string',
+      platform: 'string',
+      selfId: { type: 'string', nullable: true },
+      userId: 'string',
+      affinity: 'integer',
+      affinityInited: 'boolean',
+      relation: { type: 'string', nullable: true },
+      updatedAt: { type: 'timestamp', nullable: true },
+      relationUpdatedAt: { type: 'timestamp', nullable: true }
+    },
+    { primary: 'id' }
+  );
+}
+
+function createAffinityStore(ctx, config, log) {
+  extendModel(ctx);
+
+  const makeId = (platform, userId) => `${platform || 'unknown'}:${userId || 'anonymous'}`;
+
+  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 now = new Date();
+      return {
+        id: makeId(platform, userId),
+        platform,
+        selfId: '',
+        userId,
+        affinity: initial,
+        affinityInited: Boolean(legacy.affinityInited),
+        relation: '',
+        updatedAt: now,
+        relationUpdatedAt: now
+      };
+    } catch (error) {
+      log('warn', '读取旧版好感度数据失败', error);
+      return null;
+    }
+  };
+
+  const load = async (platform, userId) => {
+    if (!platform || !userId) return null;
+    const id = makeId(platform, userId);
+    const record = await ctx.database.get(MODEL_NAME, { id });
+    if (record?.length) return record[0];
+    const legacy = await readLegacy(platform, userId);
+    if (!legacy) return null;
+    await ctx.database.upsert(MODEL_NAME, [legacy]);
+    return legacy;
+  };
+
+  const normalizeIdentity = (seed) => {
+    if (!seed) return { platform: '', userId: '', selfId: '' };
+    return {
+      platform: seed.platform ?? seed?.session?.platform ?? '',
+      userId: seed.userId ?? seed?.session?.userId ?? '',
+      selfId: seed.selfId ?? seed?.session?.selfId ?? ''
+    };
+  };
+
+  const save = async (seed, value, inited = true, relation) => {
+    const identity = normalizeIdentity(seed);
+    if (!identity.platform || !identity.userId) return null;
+
+    const id = makeId(identity.platform, identity.userId);
+    const existing = await ctx.database.get(MODEL_NAME, { id });
+    const current = existing?.[0];
+    const now = new Date();
+    const relationText = relation !== undefined && relation !== null ? String(relation).trim() : undefined;
+
+    const payload = {
+      id,
+      platform: identity.platform,
+      selfId: identity.selfId || current?.selfId || '',
+      userId: identity.userId,
+      affinity: typeof value === 'number' ? value : current?.affinity ?? config.initial,
+      affinityInited: inited ?? current?.affinityInited ?? false,
+      relation: relationText !== undefined ? relationText : current?.relation ?? '',
+      updatedAt: now,
+      relationUpdatedAt: relationText !== undefined ? now : current?.relationUpdatedAt ?? now
+    };
+
+    await ctx.database.upsert(MODEL_NAME, [payload]);
+    return payload;
+  };
+
+  const resolveLevelByAffinity = (value) => {
+    if (typeof value !== 'number') return null;
+    return (config.relationshipAffinityLevels || []).find((level) => {
+      if (!level) return false;
+      const min = Number.isFinite(level.min) ? level.min : -Infinity;
+      const max = Number.isFinite(level.max) ? level.max : Infinity;
+      return value >= min && value <= max;
+    }) || null;
+  };
+
+  const resolveLevelByRelation = (relationName) => {
+    if (!relationName) return null;
+    return (config.relationshipAffinityLevels || []).find((level) => level?.relation === relationName) || null;
+  };
+
+  const findManualRelationship = (platform, userId) => {
+    const list = normalizeRelationshipConfig(config);
+    return list.find((item) => {
+      if (!item?.userId) return false;
+      return String(item.userId).trim() === String(userId).trim();
+    }) || null;
+  };
+
+  const applyConfigUpdate = () => {
+    ctx.scope?.update?.(config, true);
+  };
+
+  const updateRelationshipConfig = (userId, relationName, affinityValue) => {
+    const list = normalizeRelationshipConfig(config);
+    const normalizedId = String(userId).trim();
+    const index = list.findIndex((item) => item && String(item.userId ?? '').trim() === normalizedId);
+    const existing = index >= 0 ? list[index] : {};
+    const entry = {
+      userId: normalizedId,
+      relation: relationName ?? existing.relation ?? '',
+      note: existing.note ?? '',
+      initialAffinity: Number.isFinite(affinityValue) ? clamp(affinityValue, config.min, config.max) : existing.initialAffinity ?? null
+    };
+    list[index >= 0 ? index : list.length] = entry;
+    config.relationships = list;
+    applyConfigUpdate();
+  };
+
+  const ensure = async (session, clampFn, fallbackInitial) => {
+    const platform = session?.platform;
+    const userId = session?.userId;
+    if (!platform || !userId) {
+      const manual = fallbackInitial !== undefined ? null : (session?.userId ? findManualRelationship(session?.platform, session?.userId) : null);
+      const base = fallbackInitial !== undefined
+        ? fallbackInitial
+        : manual?.initialAffinity ?? config.initial;
+      return { affinity: clampFn(base, config.min, config.max), isNew: false };
+    }
+
+    const record = await load(platform, userId);
+    if (!record || !record.affinityInited) {
+      const manual = findManualRelationship(platform, userId);
+      const base = fallbackInitial !== undefined
+        ? fallbackInitial
+        : manual?.initialAffinity ?? config.initial;
+      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);
+    if (normalized !== record.affinity) {
+      const level = resolveLevelByAffinity(normalized);
+      await save({ platform, userId, selfId: session?.selfId }, normalized, record.affinityInited, level?.relation ?? record.relation ?? '');
+    }
+    return { affinity: normalized, isNew: false };
+  };
+
+  return {
+    clamp: (value) => clamp(value, config.min, config.max),
+    save,
+    load,
+    ensure,
+    resolveLevelByAffinity,
+    resolveLevelByRelation,
+    findManualRelationship,
+    updateRelationshipConfig,
+    defaultInitial: config.initial
+  };
+}
+
+module.exports = { createAffinityStore };

package/lib/cache.js

@@ -0,0 +1,19 @@
+function createAffinityCache() {
+  let entry = null;
+
+  const match = (platform, userId) => entry && entry.platform === platform && entry.userId === userId;
+
+  return {
+    get(platform, userId) {
+      return match(platform, userId) ? entry.value : null;
+    },
+    set(platform, userId, value) {
+      entry = { platform, userId, value };
+    },
+    clear(platform, userId) {
+      if (match(platform, userId)) entry = null;
+    }
+  };
+}
+
+module.exports = { createAffinityCache };

package/lib/history.js

@@ -0,0 +1,94 @@
+function createHistoryManager(ctx, config, log) {
+  const cache = new Map();
+  const limit = Math.max((config.historyMessageCount || 0) * 6, 60);
+
+  function makeKey(session) {
+    if (!session) return 'unknown';
+    if (session.guildId) {
+      return `${session.platform || 'unknown'}:${session.selfId || 'self'}:${session.guildId}:${session.channelId || session.guildId}`;
+    }
+    return `${session.platform || 'unknown'}:${session.selfId || 'self'}:direct:${session.channelId || session.userId || 'unknown'}`;
+  }
+
+  function normalizeEntries(entries, size) {
+    if (!Array.isArray(entries) || !entries.length) return [];
+    return entries
+      .slice(-size)
+      .map((item) => ({
+        userId: item.userId,
+        username: item.username || item.user?.name || item.author?.name || item.sender?.name || item.userId || '未知用户',
+        content: typeof item.content === 'string' && item.content.trim() ? item.content.trim() : '[无文本内容]',
+        timestamp: new Date(item.timestamp ?? Date.now()).getTime()
+      }))
+      .sort((a, b) => a.timestamp - b.timestamp)
+      .map((item) => {
+        const name = item.username || item.userId || '未知用户';
+        const idText = item.userId ? `（${item.userId}）` : '';
+        return `${name}${idText}: ${item.content}`;
+      });
+  }
+
+  function record(session) {
+    if (!session?.platform) return;
+    const key = makeKey(session);
+    const list = cache.get(key) || [];
+    list.push({
+      userId: session.userId,
+      username: session.username || session.author?.name || session.event?.user?.name || session.user?.name || session.userId,
+      content: session.content ?? '',
+      timestamp: new Date(session.timestamp ?? Date.now()).getTime()
+    });
+    if (list.length > limit) list.splice(0, list.length - limit);
+    cache.set(key, list);
+  }
+
+  async function readFromService(session, count) {
+    const service = ctx.chatluna_group_analysis_message;
+    if (!service?.getHistoricalMessages) return [];
+    try {
+      const messages = await service.getHistoricalMessages({
+        guildId: session.guildId,
+        channelId: session.channelId,
+        limit: count,
+        selfId: session.selfId,
+        platform: session.platform,
+        endTime: new Date()
+      });
+      return normalizeEntries(messages, count);
+    } catch (error) {
+      log('warn', '调用 chatluna_group_analysis_message 获取历史消息失败', error);
+      return [];
+    }
+  }
+
+  async function readFromCache(session, count) {
+    const cached = cache.get(makeKey(session));
+    if (cached?.length) return normalizeEntries(cached, count);
+    if (!ctx.database?.tables?.message || !ctx.database.get) return [];
+    try {
+      const rows = await ctx.database.get(
+        'message',
+        { platform: session.platform, channelId: session.channelId },
+        { limit: count, sort: { time: 'desc' } }
+      );
+      return normalizeEntries(rows, count);
+    } catch (error) {
+      log('warn', '获取历史消息失败', error);
+      return [];
+    }
+  }
+
+  async function fetch(session) {
+    const count = config.historyMessageCount || 0;
+    if (count <= 0) return [];
+    const serviceEntries = await readFromService(session, count);
+    if (serviceEntries.length) return serviceEntries;
+    return readFromCache(session, count);
+  }
+
+  ctx.on('message', record);
+
+  return { fetch };
+}
+
+module.exports = { createHistoryManager };

package/lib/index.d.ts

@@ -0,0 +1,35 @@
+import { Context, Schema } from 'koishi';
+export declare function apply(ctx: Context, config: Config): void;
+export interface Config {
+  variableName: string;
+  initial: number;
+  min: number;
+  max: number;
+  model: string;
+  analysisPrompt: string;
+  maxDeltaPerMessage: number;
+  enableAnalysis: boolean;
+  debugLogging: boolean;
+  triggerNicknames: string[];
+  useLastAffinity: boolean;
+  historyMessageCount: number;
+  personaPrompt: string;
+  relationshipVariableName: string;
+  relationships: Array<{
+    initialAffinity: number | null;
+    userId: string;
+    relation: string;
+    note: string;
+  }>;
+  relationshipAffinityLevels: Array<{
+    min: number;
+    max: number;
+    relation: string;
+    note: string;
+  }>;
+  registerAffinityTool: boolean;
+  registerRelationshipTool: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare const inject: string[];
+export declare const name = "chatluna-affinity";

package/lib/index.js

@@ -0,0 +1,68 @@
+const { modelSchema } = require('koishi-plugin-chatluna/utils/schema');
+const { ChatLunaPlugin } = require('koishi-plugin-chatluna/services/chat');
+const { getMessageContent } = require('koishi-plugin-chatluna/utils/string');
+
+const { Config, inject, name } = require('./schema');
+const { createLogger } = require('./logger');
+const { renderTemplate } = require('./template');
+const { createAffinityStore } = require('./affinity-store');
+const { createHistoryManager } = require('./history');
+const { createAffinityCache } = require('./cache');
+const { createAffinityProvider, createRelationshipProvider } = require('./providers');
+const { createToolRegistry } = require('./tools');
+const { createAnalysisMiddleware } = require('./middleware');
+
+function apply(ctx, config) {
+  const plugin = new ChatLunaPlugin(ctx, config, 'affinity', false);
+  modelSchema(ctx);
+
+  const log = createLogger(ctx, config);
+  const cache = createAffinityCache();
+  const store = createAffinityStore(ctx, config, log);
+  const history = createHistoryManager(ctx, config, log);
+
+  let modelRef;
+  const getModel = () => modelRef?.value ?? modelRef ?? null;
+
+  const affinityProvider = createAffinityProvider({ config, cache, store });
+  const relationshipProvider = createRelationshipProvider({ config, store });
+
+  ctx.on('ready', async () => {
+    try {
+      modelRef = await ctx.chatluna.createChatModel(config.model || ctx.chatluna.config.defaultModel);
+    } catch (error) {
+      log('warn', '模型初始化失败', error);
+    }
+
+    ctx.chatluna.promptRenderer.registerFunctionProvider(config.variableName, affinityProvider);
+    ctx.chatluna.promptRenderer.registerFunctionProvider(config.relationshipVariableName, relationshipProvider);
+
+    const registry = createToolRegistry(config, store, cache);
+    if (config.registerAffinityTool) {
+      plugin.registerTool('adjust_affinity', {
+        selector: registry.affinitySelector,
+        createTool: registry.createAffinityTool
+      });
+    }
+    if (config.registerRelationshipTool) {
+      plugin.registerTool('adjust_relationship', {
+        selector: registry.relationshipSelector,
+        createTool: registry.createRelationshipTool
+      });
+    }
+  });
+
+  const middleware = createAnalysisMiddleware(ctx, config, {
+    store,
+    history,
+    cache,
+    renderTemplate,
+    getMessageContent,
+    getModel,
+    log
+  });
+
+  ctx.middleware(middleware);
+}
+
+module.exports = { apply, Config, inject, name };

package/lib/logger.js

@@ -0,0 +1,10 @@
+function createLogger(ctx, config) {
+  const base = ctx.logger ? ctx.logger('chatluna-affinity') : console;
+  return (level, message, detail) => {
+    if (!config.debugLogging) return;
+    const writer = typeof base?.[level] === 'function' ? base[level] : base?.info ?? base?.log ?? console.log;
+    detail === undefined ? writer.call(base, message) : writer.call(base, message, detail);
+  };
+}
+
+module.exports = { createLogger };

package/lib/middleware.js

@@ -0,0 +1,127 @@
+function shouldAnalyzeSession(session, nicknames, log, debugEnabled) {
+  const text = String(session.content ?? '');
+  const lowerText = text.toLowerCase();
+  const nicknameHit = nicknames.some((name) => lowerText.includes(name.toLowerCase()));
+  if (debugEnabled && nicknameHit) log('debug', '昵称匹配命中', { text, nicknames });
+
+  const selfIdLower = String(session.selfId ?? '').toLowerCase();
+  const mentionHit = Boolean(
+    session.elements?.some((el) => {
+      if (el.type !== 'at') return false;
+      const attrs = el.attrs ?? {};
+      const candidates = [attrs.id, attrs.userId, attrs.cid, attrs.name, attrs.nickname]
+        .filter(Boolean)
+        .map((value) => String(value).toLowerCase());
+      return selfIdLower ? candidates.includes(selfIdLower) : candidates.length > 0;
+    })
+  );
+  if (debugEnabled && mentionHit) log('debug', '@ 匹配命中', { elements: session.elements });
+
+  const quote = session.quote;
+  const quoteHit = Boolean(
+    quote && (
+      quote.userId === session.selfId ||
+      quote?.author?.userId === session.selfId ||
+      quote?.author?.id === session.selfId ||
+      quote?.user?.id === session.selfId
+    )
+  );
+
+  return session.isDirect || session?.atMe || nicknameHit || mentionHit || quoteHit;
+}
+
+async function resolveTriggerNicknames(ctx, config) {
+  const names = new Set();
+  for (const value of config.triggerNicknames || []) {
+    if (value) names.add(String(value).trim());
+  }
+  const chatlunaConfig = ctx.chatluna?.config ?? {};
+  const possibleNames = [chatlunaConfig.nicknames, chatlunaConfig.nickname, chatlunaConfig.names, chatlunaConfig.name, chatlunaConfig.botNames];
+  for (const item of possibleNames) {
+    if (Array.isArray(item)) item.forEach((name) => name && names.add(String(name).trim()));
+    else if (item) names.add(String(item).trim());
+  }
+  const rendererNames = ctx.chatluna?.promptRenderer?.nicknames;
+  if (rendererNames?.size) for (const name of rendererNames) names.add(String(name).trim());
+  const rendererGetter = ctx.chatluna?.promptRenderer?.getNicknames;
+  if (typeof rendererGetter === 'function') {
+    const extra = await rendererGetter();
+    if (Array.isArray(extra)) extra.forEach((name) => name && names.add(String(name).trim()));
+  }
+  return Array.from(names).map((name) => name.toLowerCase());
+}
+
+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 nicknames = await resolveTriggerNicknames(ctx, config);
+    if (!shouldAnalyzeSession(session, nicknames, log, debugEnabled)) return next();
+    if (!session?.platform || !session?.userId) return next();
+
+    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 });
+
+      const historyLines = await history.fetch(session);
+      const prompt = renderTemplate(config.analysisPrompt, {
+        currentAffinity: oldAffinity,
+        minAffinity: config.min,
+        maxAffinity: config.max,
+        historyCount: historyLines.length,
+        historyText: historyLines.join('\n'),
+        historyJson: JSON.stringify(historyLines, null, 2),
+        userMessage: session.content ?? '',
+        personaPrompt: config.personaPrompt ?? ''
+      });
+
+      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();
+      }
+
+      const message = await model.invoke(prompt);
+      const text = getMessageContent(message?.content ?? message);
+      const jsonCandidate = typeof text === 'string' ? text : String(text ?? '');
+      const match = jsonCandidate.match(/\{[\s\S]*\}/);
+      let delta = 0;
+      if (match) {
+        try {
+          const parsed = JSON.parse(match[0]);
+          const raw = typeof parsed.delta === 'number' ? parsed.delta : parseInt(parsed.delta, 10);
+          if (Number.isFinite(raw)) delta = Math.trunc(raw);
+          const action = typeof parsed.action === 'string' ? parsed.action.toLowerCase() : '';
+          if (action === 'increase' && delta <= 0) delta = Math.max(1, Math.abs(delta));
+          if (action === 'decrease' && delta >= 0) delta = -Math.max(1, Math.abs(delta));
+          if (action === 'hold') delta = 0;
+          if (debugEnabled) log('info', '模型返回', { raw: parsed, parsedDelta: delta, action, userId: session.userId, platform: session.platform });
+        } catch (error) {
+          log('warn', '解析模型响应失败', { text: jsonCandidate, error });
+        }
+      }
+
+      const limitedDelta = clampValue(delta, -Math.abs(config.maxDeltaPerMessage), Math.abs(config.maxDeltaPerMessage));
+      const nextAffinity = clampValue(oldAffinity + limitedDelta, config.min, config.max);
+      if (nextAffinity !== oldAffinity) {
+        const level = store.resolveLevelByAffinity(nextAffinity);
+        await store.save({ platform: session.platform, userId: session.userId, selfId: session?.selfId }, nextAffinity, true, level?.relation ?? '');
+        cache.set(session.platform, session.userId, nextAffinity);
+        log('info', '好感度已更新', { oldAffinity, delta: limitedDelta, nextAffinity, userId: session.userId, platform: session.platform });
+      } else if (config.useLastAffinity) {
+        cache.set(session.platform, session.userId, oldAffinity);
+      }
+    } catch (error) {
+      log('warn', '分析流程异常', error);
+    }
+    return next();
+  };
+}
+
+module.exports = { createAnalysisMiddleware };

package/lib/providers.js

@@ -0,0 +1,42 @@
+function createAffinityProvider({ config, cache, store }) {
+  return async (_, __, configurable) => {
+    const session = configurable?.session;
+    if (!session?.platform || !session?.userId) {
+      return store.clamp(config.initial);
+    }
+
+    const cached = config.useLastAffinity ? cache.get(session.platform, session.userId) : null;
+    if (cached !== null) return store.clamp(cached);
+
+    const manual = store.findManualRelationship(session.platform, session.userId);
+    const override = manual && typeof manual.initialAffinity === 'number' ? manual.initialAffinity : undefined;
+    const { affinity } = await store.ensure(session, (value, lo, hi) => Math.min(hi, Math.max(lo, value)), override);
+    cache.set(session.platform, session.userId, affinity);
+    return affinity;
+  };
+}
+
+function createRelationshipProvider({ config, store }) {
+  return async (args, _variables, configurable) => {
+    const session = configurable?.session;
+    const [userArg, platformArg] = args || [];
+    const userId = String(userArg || session?.userId || '').trim();
+    const platform = String(platformArg || session?.platform || '').trim();
+    if (!userId) return '';
+
+    const manual = store.findManualRelationship(platform, userId);
+    if (manual?.relation) return manual.note ? `${manual.relation}（${manual.note}）` : manual.relation;
+
+    const record = await store.load(platform, userId);
+    const affinity = record?.affinity;
+    if (typeof affinity === 'number') {
+      const level = store.resolveLevelByAffinity(affinity);
+      if (!level) return '';
+      return level.note ? `${level.relation}（${level.note}）` : level.relation;
+    }
+    const level = store.resolveLevelByAffinity(config.initial);
+    return level ? level.relation : '';
+  };
+}
+
+module.exports = { createAffinityProvider, createRelationshipProvider };

package/lib/schema.js

@@ -0,0 +1,66 @@
+const { Schema } = require('koishi');
+
+const name = 'chatluna-affinity';
+
+const inject = {
+  required: ['chatluna', 'database'],
+  optional: ['chatluna_group_analysis_message', 'chatluna_group_analysis']
+};
+
+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('单次增减的最大幅度'),
+  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('用于分析的最近消息条数'),
+  triggerNicknames: Schema.array(Schema.string().description('昵称'))
+    .role('table')
+    .default([])
+    .description('触发分析的额外昵称列表'),
+  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": "简短中文原因"}。'
+    )
+    .description('好感度分析主提示词'),
+  personaPrompt: Schema.string()
+    .role('textarea')
+    .default('你是一位温暖可靠的伙伴，会根据好感度高低调整语气：好感度越高越亲近，越低越保持礼貌。')
+    .description('补充的人设提示词，会注入到分析提示词中'),
+  debugLogging: Schema.boolean().default(false).description('输出调试日志'),
+  registerAffinityTool: Schema.boolean().default(false).description('注册 ChatLuna 工具：调整好感度')
+}).description('好感度设置');
+
+const RelationshipSchema = Schema.object({
+  relationshipVariableName: Schema.string().default('relationship').description('关系变量名称'),
+  relationships: Schema.array(
+    Schema.object({
+      initialAffinity: Schema.number().default(null).description('针对该用户的初始好感度（留空则使用全局初始值）'),
+      userId: Schema.string().default('').description('用户 ID'),
+      relation: Schema.string().default('').description('关系'),
+      note: Schema.string().default('').description('备注')
+    })
+  ).role('table').default([]).description('关系配置列表'),
+  relationshipAffinityLevels: Schema.array(
+    Schema.object({
+      min: Schema.number().default(0).description('好感度下限'),
+      max: Schema.number().default(100).description('好感度上限'),
+      relation: Schema.string().description('关系'),
+      note: Schema.string().default('').description('备注')
+    })
+  ).role('table').default([
+    { min: 0, max: 29, relation: '陌生人', note: '保持距离' },
+    { min: 30, max: 59, relation: '友好', note: '一般关系' },
+    { min: 60, max: 89, relation: '亲近', note: '值得信赖' },
+    { min: 90, max: 100, relation: '挚友', note: '非常重要' }
+  ]).description('好感度区间关系'),
+  registerRelationshipTool: Schema.boolean().default(false).description('注册 ChatLuna 工具：调整关系')
+}).description('关系设置');
+
+const Config = Schema.intersect([AffinitySchema, RelationshipSchema]);
+
+module.exports = { name, inject, Config };

package/lib/template.js

@@ -0,0 +1,8 @@
+function renderTemplate(template, variables) {
+  return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, key) => {
+    const value = variables[key];
+    return value === undefined || value === null ? '' : String(value);
+  });
+}
+
+module.exports = { renderTemplate };

package/lib/tools.js

@@ -0,0 +1,94 @@
+const { StructuredTool } = require('@langchain/core/tools');
+const { z } = require('zod');
+
+function createAffinityTool(options) {
+  return new (class extends StructuredTool {
+    constructor() {
+      super({});
+      this.name = 'adjust_affinity';
+      this.description = 'Adjust affinity for a specific user and sync derived relationship.';
+      this.schema = z.object({
+        affinity: z.number().min(options.min).max(options.max).describe(`Target affinity (range ${options.min}-${options.max})`),
+        targetUserId: z.string().optional().describe('Target user ID; defaults to current session'),
+        platform: z.string().optional().describe('Target platform; defaults to current session')
+      });
+    }
+    async _call(input, _manager, runnable) {
+      const session = runnable?.configurable?.session;
+      const platform = input.platform || session?.platform;
+      const userId = input.targetUserId || session?.userId;
+      if (!platform || !userId) return 'Missing platform or user ID. Unable to adjust affinity.';
+      const value = options.clamp(input.affinity);
+      const level = options.resolveLevelByAffinity(value);
+      await options.save({ platform, userId, selfId: session?.selfId }, value, true, level?.relation ?? options.defaultRelation);
+      options.cache.set(platform, userId, value);
+      if (level?.relation) {
+        return `Affinity for ${platform}/${userId} set to ${value}. Relationship updated to ${level.relation}.`;
+      }
+      return `Affinity for ${platform}/${userId} set to ${value}.`;
+    }
+  })();
+}
+
+function createRelationshipTool(options) {
+  return new (class extends StructuredTool {
+    constructor() {
+      super({});
+      this.name = 'adjust_relationship';
+      this.description = 'Set relationship for a user and align affinity to the relationship lower bound.';
+      const levels = Array.isArray(options.relationLevels)
+        ? options.relationLevels.map((item) => item && item.relation ? { ...item, relation: String(item.relation).trim() } : null).filter(Boolean)
+        : [];
+      const summary = levels.map((item) => `${item.relation}: ${item.min}-${item.max}`).join(' | ');
+      this.schema = z.object({
+        relation: z.string().min(1, 'Relation cannot be empty').describe(summary ? `Target relation (configured: ${summary})` : 'Target relation name'),
+        targetUserId: z.string().optional().describe('Target user ID; defaults to current session'),
+        platform: z.string().optional().describe('Target platform; defaults to current session')
+      });
+    }
+    async _call(input, _manager, runnable) {
+      const session = runnable?.configurable?.session;
+      const platform = input.platform || session?.platform;
+      const userId = input.targetUserId || session?.userId;
+      if (!platform || !userId) return 'Missing platform or user ID. Unable to adjust relationship.';
+      const relationName = input.relation.trim();
+      let level = options.resolveLevelByRelation(relationName);
+      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);
+      await options.save({ platform, userId, selfId: session?.selfId }, base, true, relationName);
+      options.cache.set(platform, userId, base);
+      options.updateRelationshipConfig(userId, relationName, base);
+      if (level) {
+        return `Relationship for ${platform}/${userId} set to ${relationName}. Affinity updated to ${base}.`;
+      }
+      return `Relationship for ${platform}/${userId} set to ${relationName} (custom). Affinity updated to ${base}.`;
+    }
+  })();
+}
+
+function createToolRegistry(config, store, cache) {
+  const options = {
+    clamp: store.clamp,
+    resolveLevelByAffinity: store.resolveLevelByAffinity,
+    resolveLevelByRelation: store.resolveLevelByRelation,
+    relationLevels: config.relationshipAffinityLevels || [],
+    defaultRelation: '',
+    defaultInitial: store.defaultInitial,
+    save: store.save,
+    cache,
+    updateRelationshipConfig: store.updateRelationshipConfig,
+    min: config.min,
+    max: config.max
+  };
+
+  return {
+    affinitySelector: () => true,
+    relationshipSelector: () => true,
+    createAffinityTool: () => createAffinityTool(options),
+    createRelationshipTool: () => createRelationshipTool(options)
+  };
+}
+
+module.exports = { createToolRegistry };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "koishi-plugin-chatluna-affinity",
+  "description": "为 ChatLuna 提供{好感度}与{关系}变量并提供对应的工具调用",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  },
+  "dependencies": {
+    "@langchain/core": "^0.3.62",
+    "koishi-plugin-chatluna": "^1.3.0-alpha.78",
+    "zod": "^3.23.8"
+  }
+}

package/readme.md

@@ -0,0 +1,67 @@
+# koishi-plugin-chatluna-affinity
+
+在 ChatLuna 中按用户维度维护“好感度”与“关系”状态，并提供可操作的工具与变量。
+
+## 亮点一览
+
+- `affinity()` 变量：随时取得用户与机器人的好感度。初次使用会自动初始化并写入数据库。
+- `relationship()` 变量：返回友好度对应的称谓，支持自定义关系区间与备注。
+- 自动分析：收到私聊、@、引用或命中昵称时，调用指定模型分析对话并调整好感度。
+- 调整工具：
+  - `adjust_affinity` 将好感度设为指定数值，并同步关系区间。
+  - `adjust_relationship` 将关系切换为自定义称谓，同时把好感度调至对应区间的下限。
+- 特殊关系：可为指定用户记录“初始好感度 + 自定义称谓”，工具操作会实时写回配置。
+
+## 主要配置
+
+| 字段 | 说明 |
+| --- | --- |
+| `variableName` | 好感度变量名称，默认 `affinity` |
+| `initial` / `min` / `max` | 好感度初始值与上下限 |
+| `maxDeltaPerMessage` | 单次分析允许的最大变动幅度 |
+| `model` | 用于分析的 ChatLuna 模型 |
+| `analysisPrompt` | 主提示词模板，支持 `{{currentAffinity}}` 等占位符 |
+| `personaPrompt` | 机器人的人设补充说明 |
+| `triggerNicknames` | 额外触发昵称列表（默认含 ChatLuna 配置的昵称/@ 名） |
+| `useLastAffinity` | 开启后变量能立即返回上一次结果（无需等待分析完成） |
+| `historyMessageCount` | 提供给模型的历史消息条数（从数据库或 group-analysis 插件取得） |
+| `relationships` | 特殊关系配置：`userId`、`initialAffinity`、`relation`、`note` |
+| `relationshipAffinityLevels` | 区间 → 称谓映射，默认提供“陌生人/友好/亲近/挚友” |
+| `registerAffinityTool` / `registerRelationshipTool` | 是否注册对应 ChatLuna 工具 |
+
+## 工具调用
+
+启用 `registerAffinityTool` 或 `registerRelationshipTool` 后，ChatLuna 代理可直接调用。
+
+若 `relation` 不在区间表中，会按全局初始值创建一条“自定义关系”条目，后续可在面板中继续编辑。
+
+## 数据存储
+
+插件会在数据库里创建表 `chatluna_affinity_records`，字段包含：
+
+- `platform` / `userId` / `selfId`
+- `affinity` 与 `affinityInited`
+- `relation` 与更新时间
+
+## 调试
+
+开启 `debugLogging` 后，控制台会输出：
+
+- 触发判定：昵称集合、@ 命中、引用命中
+- 模型返回的 `delta` 与解析日志
+- 好感度更新 / 未变化 / 异常提示
+
+方便快速定位触发条件和模型配置问题。
+
+## 常见问题
+
+1. **没有触发分析？**
+   - 确认 `enableAnalysis` 为 `true`，且消息满足私聊 / @ / 引用 / 昵称命中任一条件。
+2. **工具调用失败？**
+   - 确认配置里开启了对应工具开关；日志会提示是否缺失用户 ID 或关系名称。
+3. **如何清理数据？**
+   - 直接删除数据库中 `chatluna_affinity_records` 数据，或指定用户重新初始化即可。
+
+## 许可协议
+
+MIT License © 2024 chatluna-affinity contributors