koishi-plugin-chatluna-affinity 0.3.1 → 0.3.2

package/lib/index.js

@@ -417,6 +417,7 @@ __export(index_exports, {
   COMMON_STYLE: () => COMMON_STYLE,
   Config: () => ConfigSchema,
   ConfigSchema: () => ConfigSchema,
+  DASHBOARD_SNAPSHOT_MODEL_NAME: () => DASHBOARD_SNAPSHOT_MODEL_NAME,
   DEFAULT_MEMBER_INFO_ITEMS: () => DEFAULT_MEMBER_INFO_ITEMS,
   FETCH_CONSTANTS: () => FETCH_CONSTANTS,
   MIGRATION_MODEL_NAME: () => MIGRATION_MODEL_NAME,
@@ -430,6 +431,7 @@ __export(index_exports, {
   THRESHOLDS: () => THRESHOLDS,
   TIME_CONSTANTS: () => TIME_CONSTANTS,
   TIMING_CONSTANTS: () => TIMING_CONSTANTS,
+  USER_AFFINITY_SNAPSHOT_MODEL_NAME: () => USER_AFFINITY_SNAPSHOT_MODEL_NAME,
   USER_ALIAS_MODEL_NAME: () => USER_ALIAS_MODEL_NAME,
   USER_ALIAS_MODEL_NAME_V2: () => USER_ALIAS_MODEL_NAME_V2,
   appendActionEntry: () => appendActionEntry,
@@ -474,6 +476,7 @@ __export(index_exports, {
   escapeHtmlForRender: () => escapeHtmlForRender,
   extendAffinityModel: () => extendAffinityModel,
   extendBlacklistModel: () => extendBlacklistModel,
+  extendDashboardSnapshotModel: () => extendDashboardSnapshotModel,
   extendMigrationModel: () => extendMigrationModel,
   extendUserAliasModel: () => extendUserAliasModel,
   fetchGroupMemberIds: () => fetchGroupMemberIds,
@@ -860,6 +863,7 @@ var VariableSettingsSchema = import_koishi4.Schema.object({
   )
 }).description("\u53D8\u91CF\u8BBE\u7F6E");
 var OtherSettingsSchema = import_koishi4.Schema.object({
+  enableDashboard: import_koishi4.Schema.boolean().default(true).description("\u5728 Koishi \u63A7\u5236\u53F0\u4FA7\u680F\u663E\u793A\u597D\u611F\u5EA6\u4EEA\u8868\u76D8"),
   rankRenderAsImage: import_koishi4.Schema.boolean().default(false).description("\u5C06\u597D\u611F\u5EA6\u6392\u884C\u6E32\u67D3\u4E3A\u56FE\u7247"),
   blacklistRenderAsImage: import_koishi4.Schema.boolean().default(false).description("\u5C06\u9ED1\u540D\u5355\u6E32\u67D3\u4E3A\u56FE\u7247"),
   shortTermBlacklistRenderAsImage: import_koishi4.Schema.boolean().default(false).description("\u5C06\u4E34\u65F6\u9ED1\u540D\u5355\u6E32\u67D3\u4E3A\u56FE\u7247"),
@@ -1012,12 +1016,57 @@ function extendMigrationModel(ctx) {
   );
 }
 
+// src/models/dashboard-snapshot.ts
+var DASHBOARD_SNAPSHOT_MODEL_NAME = "chatluna_affinity_dashboard_snapshot";
+var USER_AFFINITY_SNAPSHOT_MODEL_NAME = "chatluna_affinity_user_snapshot";
+function extendDashboardSnapshotModel(ctx) {
+  ctx.model.extend(
+    DASHBOARD_SNAPSHOT_MODEL_NAME,
+    {
+      scopeId: { type: "string", length: 32 },
+      date: { type: "string", length: 10 },
+      recordedAt: { type: "timestamp" },
+      generatedBy: { type: "string", length: 32, nullable: true },
+      users: { type: "integer", initial: 0 },
+      affinityTotal: { type: "integer", initial: 0 },
+      longTermAffinityTotal: { type: "integer", initial: 0 },
+      shortTermAffinityTotal: { type: "integer", initial: 0 },
+      chatCount: { type: "integer", initial: 0 },
+      blacklisted: { type: "integer", initial: 0 },
+      permanentBlacklisted: { type: "integer", initial: 0 },
+      temporaryBlacklisted: { type: "integer", initial: 0 },
+      aliases: { type: "integer", initial: 0 },
+      latestInteractionAt: { type: "timestamp", nullable: true }
+    },
+    { primary: ["scopeId", "date"] }
+  );
+  ctx.model.extend(
+    USER_AFFINITY_SNAPSHOT_MODEL_NAME,
+    {
+      scopeId: { type: "string", length: 32 },
+      userId: { type: "string", length: 64 },
+      date: { type: "string", length: 10 },
+      recordedAt: { type: "timestamp" },
+      nickname: { type: "string", length: 255, nullable: true },
+      affinity: { type: "integer", initial: 0 },
+      longTermAffinity: { type: "integer", initial: 0 },
+      shortTermAffinity: { type: "integer", initial: 0 },
+      chatCount: { type: "integer", initial: 0 },
+      relation: { type: "string", length: 64, nullable: true },
+      specialRelation: { type: "string", length: 64, nullable: true },
+      lastInteractionAt: { type: "timestamp", nullable: true }
+    },
+    { primary: ["scopeId", "userId", "date"] }
+  );
+}
+
 // src/models/index.ts
 function registerModels(ctx) {
   extendAffinityModel(ctx);
   extendBlacklistModel(ctx);
   extendUserAliasModel(ctx);
   extendMigrationModel(ctx);
+  extendDashboardSnapshotModel(ctx);
 }
 
 // src/helpers/logger.ts
@@ -3834,6 +3883,600 @@ function createMigrationService(options) {
   return { run };
 }
 
+// src/services/dashboard/snapshot.ts
+async function readRecordedDashboardSnapshots(ctx, scopeId) {
+  const dashboardSnapshots = await ctx.database.get(
+    DASHBOARD_SNAPSHOT_MODEL_NAME,
+    { scopeId }
+  );
+  const userAffinitySnapshots = await ctx.database.get(
+    USER_AFFINITY_SNAPSHOT_MODEL_NAME,
+    { scopeId }
+  );
+  return { dashboardSnapshots, userAffinitySnapshots };
+}
+function formatSnapshotDate(value) {
+  const year = value.getFullYear();
+  const month = String(value.getMonth() + 1).padStart(2, "0");
+  const day = String(value.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseSnapshotDate(value) {
+  const matched = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!matched) return null;
+  const year = Number(matched[1]);
+  const month = Number(matched[2]);
+  const day = Number(matched[3]);
+  const date = new Date(year, month - 1, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+    return null;
+  }
+  return date;
+}
+async function readDashboardSnapshotSource(ctx, scopeId) {
+  const affinityRows = await ctx.database.get(MODEL_NAME_V2, { scopeId });
+  const blacklistRows = await ctx.database.get(BLACKLIST_MODEL_NAME_V2, {
+    scopeId
+  });
+  const aliasRows = await ctx.database.get(USER_ALIAS_MODEL_NAME_V2, {
+    scopeId
+  });
+  return { affinityRows, blacklistRows, aliasRows };
+}
+function createDashboardSnapshot(scopeId, now, source, trigger = "backend") {
+  const permanentBlacklisted = source.blacklistRows.filter(
+    (row) => row.mode === "permanent"
+  ).length;
+  const temporaryBlacklisted = source.blacklistRows.filter(
+    (row) => row.mode === "temporary"
+  ).length;
+  const latestInteractionAt = source.affinityRows.reduce(
+    (latest, row) => {
+      const value = row.lastInteractionAt;
+      if (!value) return latest;
+      if (!latest || value.getTime() > latest.getTime()) return value;
+      return latest;
+    },
+    null
+  );
+  return {
+    scopeId,
+    date: formatSnapshotDate(now),
+    recordedAt: now,
+    generatedBy: trigger,
+    users: source.affinityRows.length,
+    affinityTotal: source.affinityRows.reduce(
+      (total, row) => total + Number(row.affinity || 0),
+      0
+    ),
+    longTermAffinityTotal: source.affinityRows.reduce(
+      (total, row) => total + Number(row.longTermAffinity ?? row.affinity ?? 0),
+      0
+    ),
+    shortTermAffinityTotal: source.affinityRows.reduce(
+      (total, row) => total + Number(row.shortTermAffinity || 0),
+      0
+    ),
+    chatCount: source.affinityRows.reduce(
+      (total, row) => total + Number(row.chatCount || 0),
+      0
+    ),
+    blacklisted: source.blacklistRows.length,
+    permanentBlacklisted,
+    temporaryBlacklisted,
+    aliases: source.aliasRows.length,
+    latestInteractionAt
+  };
+}
+function createUserAffinitySnapshots(scopeId, now, source, existingSnapshots = []) {
+  const date = formatSnapshotDate(now);
+  const latestSnapshotsByUserId = /* @__PURE__ */ new Map();
+  for (const snapshot of existingSnapshots) {
+    if (snapshot.scopeId !== scopeId || !parseSnapshotDate(snapshot.date)) {
+      continue;
+    }
+    const latest = latestSnapshotsByUserId.get(snapshot.userId);
+    if (!latest || snapshot.date >= latest.date) {
+      latestSnapshotsByUserId.set(snapshot.userId, snapshot);
+    }
+  }
+  return source.affinityRows.filter((row) => {
+    const latest = latestSnapshotsByUserId.get(row.userId);
+    return !latest || Number(latest.affinity || 0) !== Number(row.affinity || 0) || Number(latest.longTermAffinity || 0) !== Number(row.longTermAffinity ?? row.affinity ?? 0) || Number(latest.chatCount || 0) !== Number(row.chatCount || 0);
+  }).map((row) => ({
+    scopeId,
+    userId: row.userId,
+    date,
+    recordedAt: now,
+    nickname: row.nickname || null,
+    affinity: Number(row.affinity || 0),
+    longTermAffinity: Number(row.longTermAffinity ?? row.affinity ?? 0),
+    shortTermAffinity: Number(row.shortTermAffinity || 0),
+    chatCount: Number(row.chatCount || 0),
+    relation: row.relation || null,
+    specialRelation: row.specialRelation || null,
+    lastInteractionAt: row.lastInteractionAt || null
+  }));
+}
+function hasSnapshotSourceData(source) {
+  return source.affinityRows.length > 0 || source.blacklistRows.length > 0 || source.aliasRows.length > 0;
+}
+function mergeDashboardSnapshot(rows, snapshot) {
+  return [
+    ...rows.filter(
+      (row) => row.scopeId !== snapshot.scopeId || row.date !== snapshot.date
+    ),
+    snapshot
+  ];
+}
+function mergeUserAffinitySnapshots(rows, snapshots) {
+  const snapshotKeys = new Set(
+    snapshots.map(
+      (snapshot) => `${snapshot.scopeId}:${snapshot.userId}:${snapshot.date}`
+    )
+  );
+  return [
+    ...rows.filter(
+      (row) => !snapshotKeys.has(`${row.scopeId}:${row.userId}:${row.date}`)
+    ),
+    ...snapshots
+  ];
+}
+async function recordDashboardSnapshot(ctx, options) {
+  const scopeId = options.scopeId.trim();
+  if (!scopeId) {
+    return { dashboardSnapshots: [], userAffinitySnapshots: [] };
+  }
+  const now = options.now || /* @__PURE__ */ new Date();
+  const source = options.source || await readDashboardSnapshotSource(ctx, scopeId);
+  const existingSnapshots = options.existingSnapshots || await ctx.database.get(DASHBOARD_SNAPSHOT_MODEL_NAME, { scopeId });
+  const existingUserAffinitySnapshots = options.existingUserAffinitySnapshots || await ctx.database.get(USER_AFFINITY_SNAPSHOT_MODEL_NAME, { scopeId });
+  if (!hasSnapshotSourceData(source) && existingSnapshots.length === 0) {
+    return {
+      dashboardSnapshots: existingSnapshots,
+      userAffinitySnapshots: existingUserAffinitySnapshots
+    };
+  }
+  const snapshot = createDashboardSnapshot(
+    scopeId,
+    now,
+    source,
+    options.trigger
+  );
+  const userSnapshots = createUserAffinitySnapshots(
+    scopeId,
+    now,
+    source,
+    existingUserAffinitySnapshots
+  );
+  await ctx.database.upsert(DASHBOARD_SNAPSHOT_MODEL_NAME, [snapshot]);
+  if (userSnapshots.length > 0) {
+    await ctx.database.upsert(USER_AFFINITY_SNAPSHOT_MODEL_NAME, userSnapshots);
+  }
+  return {
+    dashboardSnapshots: mergeDashboardSnapshot(existingSnapshots, snapshot),
+    userAffinitySnapshots: mergeUserAffinitySnapshots(
+      existingUserAffinitySnapshots,
+      userSnapshots
+    )
+  };
+}
+
+// src/services/dashboard/backend.ts
+var DEFAULT_SNAPSHOT_INTERVAL_MS = 60 * 60 * 1e3;
+function registerDashboardBackend(options) {
+  const { config, ctx, log } = options;
+  if (config.enableDashboard === false) return;
+  const getNow = options.now || (() => /* @__PURE__ */ new Date());
+  const intervalMs = options.sampleIntervalMs || DEFAULT_SNAPSHOT_INTERVAL_MS;
+  const schedule = options.setInterval || setInterval;
+  const clear = options.clearInterval || clearInterval;
+  let timer = null;
+  let running = false;
+  const record = async () => {
+    if (running) return;
+    running = true;
+    try {
+      await recordDashboardSnapshot(ctx, {
+        scopeId: config.scopeId,
+        now: getNow()
+      });
+    } catch (error) {
+      log("warn", "\u8BB0\u5F55\u4EEA\u8868\u76D8\u540E\u53F0\u5FEB\u7167\u5931\u8D25", error);
+    } finally {
+      running = false;
+    }
+  };
+  ctx.on("ready", () => {
+    if (timer !== null) return;
+    void record();
+    timer = schedule(() => {
+      void record();
+    }, intervalMs);
+  });
+  ctx.on("dispose", () => {
+    if (timer === null) return;
+    clear(timer);
+    timer = null;
+  });
+}
+
+// src/services/dashboard/index.ts
+var DASHBOARD_EVENT = "chatluna-affinity/dashboard";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var WEEK_DAYS = 7;
+var MONTH_DAYS = 30;
+var HISTORY_POINT_LIMIT = 12;
+function toIsoString(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toISOString();
+}
+function toCount(value) {
+  return Number.isFinite(value) ? Number(value) : 0;
+}
+function roundAverage(total, count) {
+  if (!count) return 0;
+  return Math.round(total / count * 100) / 100;
+}
+function roundPercent(value) {
+  return Math.round(value * 100) / 100;
+}
+function snapshotAffinityTotal(snapshot) {
+  return toCount(snapshot.affinityTotal);
+}
+function snapshotUsers(snapshot) {
+  return toCount(snapshot.users);
+}
+function snapshotChatCount(snapshot) {
+  return toCount(snapshot.chatCount);
+}
+function snapshotBlacklisted(snapshot) {
+  return toCount(snapshot.blacklisted);
+}
+function snapshotAliases(snapshot) {
+  return toCount(snapshot.aliases);
+}
+function createMetricChange(current, previous) {
+  return {
+    current,
+    previous,
+    percent: previous === 0 ? current === 0 ? 0 : null : roundPercent((current - previous) / previous * 100)
+  };
+}
+function getDisplayRelation(record) {
+  return record.specialRelation || record.relation || "\u672A\u5206\u7EC4";
+}
+function getRelationKind(record) {
+  return record.specialRelation ? "custom" : "preset";
+}
+function getRelationTone(record, levels) {
+  if (record.specialRelation) return "custom";
+  const relation = record.relation || "";
+  const orderedLevels = [...levels || []].filter((level) => level.relation).sort((left, right) => left.min - right.min);
+  const index = orderedLevels.findIndex((level) => level.relation === relation);
+  if (index < 0) return "unknown";
+  const ratio = orderedLevels.length > 1 ? index / (orderedLevels.length - 1) : 1;
+  if (ratio <= 0.25) return "low";
+  if (ratio < 0.75) return "medium";
+  return "high";
+}
+function getDisplayName(record) {
+  return record.nickname || record.userId;
+}
+function getOneBotAvatarUrl(userId) {
+  const numericId = userId.match(/^\d+$/)?.[0];
+  return numericId ? `https://q1.qlogo.cn/g?b=qq&nk=${numericId}&s=640` : null;
+}
+function getBlacklistDisplayName(record) {
+  return record.nickname || record.userId;
+}
+function formatTrendLabel(date) {
+  return `${date.getMonth() + 1}/${date.getDate()}`;
+}
+function startOfLocalDay(value) {
+  return new Date(value.getFullYear(), value.getMonth(), value.getDate());
+}
+function createEmptyTrendPoint(date) {
+  return {
+    label: formatTrendLabel(date),
+    users: 0,
+    averageAffinity: 0,
+    chatCount: 0,
+    blacklisted: 0
+  };
+}
+function createSnapshotTrendPoint(snapshot) {
+  const date = parseSnapshotDate(snapshot.date);
+  if (!date) return null;
+  return {
+    label: formatTrendLabel(date),
+    users: snapshotUsers(snapshot),
+    averageAffinity: roundAverage(
+      snapshotAffinityTotal(snapshot),
+      snapshotUsers(snapshot)
+    ),
+    chatCount: snapshotChatCount(snapshot),
+    blacklisted: snapshotBlacklisted(snapshot)
+  };
+}
+function createDailyTrend(snapshots, anchor, days) {
+  const snapshotsByDate = new Map(
+    snapshots.map((snapshot) => [snapshot.date, snapshot])
+  );
+  const end = startOfLocalDay(anchor).getTime() + DAY_MS;
+  const start = new Date(end - days * DAY_MS);
+  return Array.from({ length: days }, (_, index) => {
+    const date = new Date(start.getTime() + index * DAY_MS);
+    const snapshot = snapshotsByDate.get(formatSnapshotDate(date));
+    const point = snapshot ? createSnapshotTrendPoint(snapshot) : null;
+    return point || createEmptyTrendPoint(date);
+  });
+}
+function createAllTrend(snapshots) {
+  const latestByMonth = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    const date = parseSnapshotDate(snapshot.date);
+    if (!date) continue;
+    const key = `${date.getFullYear()}-${date.getMonth()}`;
+    const current = latestByMonth.get(key);
+    if (!current || snapshot.date > current.date) {
+      latestByMonth.set(key, snapshot);
+    }
+  }
+  return [...latestByMonth.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, snapshot]) => {
+    const point = createSnapshotTrendPoint(snapshot);
+    const date = parseSnapshotDate(snapshot.date);
+    return {
+      ...point || createEmptyTrendPoint(date || /* @__PURE__ */ new Date()),
+      label: date ? `${date.getFullYear()}/${date.getMonth() + 1}` : snapshot.date
+    };
+  });
+}
+function getSnapshotTime(snapshot) {
+  return parseSnapshotDate(snapshot.date)?.getTime() ?? null;
+}
+function getLatestSnapshotDate(snapshots) {
+  const times = snapshots.map(getSnapshotTime).filter((value) => value !== null);
+  if (!times.length) return null;
+  return new Date(Math.max(...times));
+}
+function findLatestSnapshotInWindow(snapshots, start, end) {
+  let latest = null;
+  let latestTime = -Infinity;
+  for (const snapshot of snapshots) {
+    const time = getSnapshotTime(snapshot);
+    if (time === null || time < start || time >= end || time < latestTime) {
+      continue;
+    }
+    latest = snapshot;
+    latestTime = time;
+  }
+  return latest;
+}
+function snapshotAverage(snapshot) {
+  if (!snapshot) return 0;
+  return roundAverage(snapshotAffinityTotal(snapshot), snapshotUsers(snapshot));
+}
+function createUserHistoryPoints(row, snapshots, trendAnchor) {
+  const points = snapshots.map((snapshot) => {
+    const date = parseSnapshotDate(snapshot.date);
+    if (!date) return null;
+    return {
+      date,
+      point: {
+        label: formatTrendLabel(date),
+        timestamp: toIsoString(snapshot.recordedAt) || toIsoString(date),
+        affinity: toCount(snapshot.affinity),
+        longTermAffinity: toCount(snapshot.longTermAffinity),
+        chatCount: toCount(snapshot.chatCount)
+      }
+    };
+  }).filter(
+    (point) => point !== null
+  ).sort((left, right) => left.date.getTime() - right.date.getTime());
+  if (points.length) {
+    const anchorDate = startOfLocalDay(trendAnchor);
+    const latest = points.at(-1);
+    if (latest && latest.date.getTime() < anchorDate.getTime()) {
+      points.push({
+        date: anchorDate,
+        point: {
+          label: formatTrendLabel(anchorDate),
+          timestamp: toIsoString(anchorDate),
+          affinity: latest.point.affinity,
+          longTermAffinity: toCount(row.longTermAffinity ?? row.affinity),
+          chatCount: toCount(row.chatCount)
+        }
+      });
+    }
+    return points.slice(-HISTORY_POINT_LIMIT).map(({ point }) => point);
+  }
+  return [
+    {
+      label: "\u5F53\u524D",
+      timestamp: toIsoString(row.lastInteractionAt),
+      affinity: toCount(row.affinity),
+      longTermAffinity: toCount(row.longTermAffinity ?? row.affinity),
+      chatCount: toCount(row.chatCount)
+    }
+  ];
+}
+function groupUserSnapshots(snapshots) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const snapshot of snapshots) {
+    const rows = grouped.get(snapshot.userId) || [];
+    rows.push(snapshot);
+    grouped.set(snapshot.userId, rows);
+  }
+  return grouped;
+}
+async function getDashboardData(ctx, options) {
+  const scopeId = options.scopeId;
+  const now = options.now || /* @__PURE__ */ new Date();
+  const relationshipAffinityLevels = options.relationshipAffinityLevels || [];
+  const affinityRows = await ctx.database.get(MODEL_NAME_V2, {
+    scopeId
+  });
+  const blacklistRows = await ctx.database.get(BLACKLIST_MODEL_NAME_V2, {
+    scopeId
+  });
+  const aliasRows = await ctx.database.get(USER_ALIAS_MODEL_NAME_V2, {
+    scopeId
+  });
+  const recordedSnapshots = await readRecordedDashboardSnapshots(ctx, scopeId);
+  const snapshotRows = recordedSnapshots.dashboardSnapshots;
+  const userSnapshotRows = recordedSnapshots.userAffinitySnapshots;
+  const trendAnchor = getLatestSnapshotDate(snapshotRows) || now;
+  let chatCount = 0;
+  let affinityTotal = 0;
+  let longTermTotal = 0;
+  let shortTermTotal = 0;
+  let latestInteractionAt = null;
+  const relationCounts = /* @__PURE__ */ new Map();
+  const affinityByUserId = /* @__PURE__ */ new Map();
+  const userSnapshotsByUserId = groupUserSnapshots(userSnapshotRows);
+  for (const row of affinityRows) {
+    chatCount += toCount(row.chatCount);
+    affinityTotal += toCount(row.affinity);
+    longTermTotal += toCount(row.longTermAffinity ?? row.affinity);
+    shortTermTotal += toCount(row.shortTermAffinity);
+    const relation = getDisplayRelation(row);
+    const kind = getRelationKind(row);
+    const relationKey = `${kind}:${relation}`;
+    const currentRelation = relationCounts.get(relationKey) || {
+      relation,
+      kind,
+      count: 0
+    };
+    currentRelation.count += 1;
+    relationCounts.set(relationKey, currentRelation);
+    affinityByUserId.set(row.userId, toCount(row.affinity));
+    const currentInteractionAt = toIsoString(row.lastInteractionAt);
+    if (currentInteractionAt && (!latestInteractionAt || currentInteractionAt > latestInteractionAt)) {
+      latestInteractionAt = currentInteractionAt;
+    }
+  }
+  const topUsers = [...affinityRows].sort((left, right) => right.affinity - left.affinity).map((row) => ({
+    userId: row.userId,
+    name: getDisplayName(row),
+    avatarUrl: getOneBotAvatarUrl(row.userId),
+    affinity: toCount(row.affinity),
+    longTermAffinity: toCount(row.longTermAffinity ?? row.affinity),
+    relation: getDisplayRelation(row),
+    relationTone: getRelationTone(row, relationshipAffinityLevels),
+    chatCount: toCount(row.chatCount),
+    lastInteractionAt: toIsoString(row.lastInteractionAt),
+    historyPoints: createUserHistoryPoints(
+      row,
+      userSnapshotsByUserId.get(row.userId) || [],
+      trendAnchor
+    )
+  }));
+  const relationStats = [...relationCounts.values()].sort((left, right) => right.count - left.count);
+  const currentWeekEnd = startOfLocalDay(trendAnchor).getTime() + DAY_MS;
+  const currentWeekStart = currentWeekEnd - WEEK_DAYS * DAY_MS;
+  const previousWeekStart = currentWeekStart - WEEK_DAYS * DAY_MS;
+  const currentWeekSnapshot = findLatestSnapshotInWindow(
+    snapshotRows,
+    currentWeekStart,
+    currentWeekEnd
+  );
+  const previousWeekSnapshot = findLatestSnapshotInWindow(
+    snapshotRows,
+    previousWeekStart,
+    currentWeekStart
+  );
+  const blacklistItems = [...blacklistRows].sort((left, right) => {
+    const leftTime = toIsoString(left.blockedAt) || "";
+    const rightTime = toIsoString(right.blockedAt) || "";
+    return rightTime.localeCompare(leftTime);
+  }).map((row) => ({
+    platform: row.platform,
+    userId: row.userId,
+    name: getBlacklistDisplayName(row),
+    avatarUrl: getOneBotAvatarUrl(row.userId),
+    affinity: affinityByUserId.get(row.userId) ?? null,
+    mode: row.mode,
+    blockedAt: toIsoString(row.blockedAt),
+    expiresAt: toIsoString(row.expiresAt),
+    note: row.note || ""
+  }));
+  const permanentBlacklisted = blacklistRows.filter(
+    (row) => row.mode === "permanent"
+  ).length;
+  const temporaryBlacklisted = blacklistRows.filter(
+    (row) => row.mode === "temporary"
+  ).length;
+  return {
+    scopeId,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totals: {
+      users: affinityRows.length,
+      blacklisted: blacklistRows.length,
+      permanentBlacklisted,
+      temporaryBlacklisted,
+      aliases: aliasRows.length,
+      chatCount
+    },
+    averages: {
+      affinity: roundAverage(affinityTotal, affinityRows.length),
+      longTermAffinity: roundAverage(longTermTotal, affinityRows.length),
+      shortTermAffinity: roundAverage(shortTermTotal, affinityRows.length)
+    },
+    latestInteractionAt,
+    weeklyChanges: {
+      users: createMetricChange(
+        currentWeekSnapshot ? snapshotUsers(currentWeekSnapshot) : 0,
+        previousWeekSnapshot ? snapshotUsers(previousWeekSnapshot) : 0
+      ),
+      averageAffinity: createMetricChange(
+        snapshotAverage(currentWeekSnapshot),
+        snapshotAverage(previousWeekSnapshot)
+      ),
+      chatCount: createMetricChange(
+        currentWeekSnapshot ? snapshotChatCount(currentWeekSnapshot) : 0,
+        previousWeekSnapshot ? snapshotChatCount(previousWeekSnapshot) : 0
+      ),
+      aliases: createMetricChange(
+        currentWeekSnapshot ? snapshotAliases(currentWeekSnapshot) : 0,
+        previousWeekSnapshot ? snapshotAliases(previousWeekSnapshot) : 0
+      )
+    },
+    trends: {
+      week: createDailyTrend(snapshotRows, trendAnchor, WEEK_DAYS),
+      month: createDailyTrend(snapshotRows, trendAnchor, MONTH_DAYS),
+      all: createAllTrend(snapshotRows)
+    },
+    relationStats,
+    blacklistItems,
+    topUsers
+  };
+}
+function registerDashboardWebui(options) {
+  const { config, ctx, entry, log } = options;
+  if (config.enableDashboard === false) return;
+  ctx.inject(["console"], (innerCtx) => {
+    const consoleService = innerCtx.console;
+    consoleService.addEntry(entry);
+    consoleService.addListener(
+      DASHBOARD_EVENT,
+      async () => getDashboardData(ctx, {
+        scopeId: config.scopeId,
+        relationshipAffinityLevels: config.relationshipAffinityLevels
+      }),
+      { authority: 1 }
+    );
+    if (config.debugLogging) {
+      log("debug", "\u5DF2\u6CE8\u518C\u63A7\u5236\u53F0\u4EEA\u8868\u76D8\u9875\u9762\u4E0E\u6570\u636E\u63A5\u53E3", {
+        event: DASHBOARD_EVENT,
+        scopeId: config.scopeId
+      });
+    }
+  });
+}
+
 // src/renders/base.ts
 function getPuppeteer(ctx) {
   return ctx.puppeteer || null;
@@ -5211,20 +5854,26 @@ function registerClearAllCommand(deps) {
         await ctx.database.remove(USER_ALIAS_MODEL_NAME_V2, {
           scopeId: config.scopeId
         });
+        await ctx.database.remove(DASHBOARD_SNAPSHOT_MODEL_NAME, {
+          scopeId: config.scopeId
+        });
+        await ctx.database.remove(USER_AFFINITY_SNAPSHOT_MODEL_NAME, {
+          scopeId: config.scopeId
+        });
         cache.clearAll?.();
         log("info", "\u5F53\u524D\u4F5C\u7528\u57DF\u6570\u636E\u5E93\u5DF2\u6E05\u7A7A", {
           scopeId: config.scopeId,
           operator: session.userId,
           platform: session.platform
         });
-        return `\u2705 \u5DF2\u6210\u529F\u6E05\u7A7A\u4F5C\u7528\u57DF ${config.scopeId} \u4E0B\u7684\u597D\u611F\u5EA6\u3001\u9ED1\u540D\u5355\u4E0E\u6635\u79F0\u6570\u636E\u3002`;
+        return `\u2705 \u5DF2\u6210\u529F\u6E05\u7A7A\u4F5C\u7528\u57DF ${config.scopeId} \u4E0B\u7684\u597D\u611F\u5EA6\u3001\u9ED1\u540D\u5355\u3001\u6635\u79F0\u4E0E\u8D8B\u52BF\u5FEB\u7167\u6570\u636E\u3002`;
       } catch (error) {
         log("warn", "\u6E05\u7A7A\u6570\u636E\u5E93\u5931\u8D25", error);
         return "\u274C \u6E05\u7A7A\u6570\u636E\u5E93\u65F6\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u67E5\u770B\u65E5\u5FD7\u3002";
       }
     }
     pendingClearConfirmations.set(sessionKey, { expiresAt: now + 60 * 1e3 });
-    return `\u26A0\uFE0F \u8B66\u544A\uFF1A\u6B64\u64CD\u4F5C\u5C06\u6C38\u4E45\u5220\u9664\u4F5C\u7528\u57DF ${config.scopeId} \u4E0B\u7684\u597D\u611F\u5EA6\u3001\u9ED1\u540D\u5355\u4E0E\u6635\u79F0\u6570\u636E\uFF0C\u4E14\u65E0\u6CD5\u6062\u590D\uFF01
+    return `\u26A0\uFE0F \u8B66\u544A\uFF1A\u6B64\u64CD\u4F5C\u5C06\u6C38\u4E45\u5220\u9664\u4F5C\u7528\u57DF ${config.scopeId} \u4E0B\u7684\u597D\u611F\u5EA6\u3001\u9ED1\u540D\u5355\u3001\u6635\u79F0\u4E0E\u8D8B\u52BF\u5FEB\u7167\u6570\u636E\uFF0C\u4E14\u65E0\u6CD5\u6062\u590D\uFF01
 \u8BF7\u5728 60 \u79D2\u5185\u4F7F\u7528 \`${buildScopedCommandName(config.scopeId, "clearAll")} -y\` \u6216 \`\u6E05\u7A7A\u597D\u611F\u5EA6 -y\` \u786E\u8BA4\u6267\u884C\u3002`;
   });
 }
@@ -5302,14 +5951,21 @@ function apply(ctx, config) {
   config.initialAffinity = Number.isFinite(config.initialAffinity) ? Number(config.initialAffinity) : BASE_AFFINITY_DEFAULTS.initialAffinity;
   normalizeToolSettings(config);
   registerModels(ctx);
-  ctx.inject(["console"], (innerCtx) => {
-    const consoleService = innerCtx.console;
-    consoleService?.addEntry?.({
+  const log = createLogger(ctx, config);
+  registerDashboardBackend({
+    ctx,
+    config,
+    log
+  });
+  registerDashboardWebui({
+    ctx,
+    config,
+    log,
+    entry: {
       dev: path.resolve(__dirname, "../client/index.ts"),
       prod: path.resolve(__dirname, "../dist")
-    });
+    }
   });
-  const log = createLogger(ctx, config);
   log("info", runtimeFingerprint);
   log(
     "warn",
@@ -5795,6 +6451,7 @@ var usage = `
   COMMON_STYLE,
   Config,
   ConfigSchema,
+  DASHBOARD_SNAPSHOT_MODEL_NAME,
   DEFAULT_MEMBER_INFO_ITEMS,
   FETCH_CONSTANTS,
   MIGRATION_MODEL_NAME,
@@ -5808,6 +6465,7 @@ var usage = `
   THRESHOLDS,
   TIME_CONSTANTS,
   TIMING_CONSTANTS,
+  USER_AFFINITY_SNAPSHOT_MODEL_NAME,
   USER_ALIAS_MODEL_NAME,
   USER_ALIAS_MODEL_NAME_V2,
   appendActionEntry,
@@ -5852,6 +6510,7 @@ var usage = `
   escapeHtmlForRender,
   extendAffinityModel,
   extendBlacklistModel,
+  extendDashboardSnapshotModel,
   extendMigrationModel,
   extendUserAliasModel,
   fetchGroupMemberIds,