chatlab-cli 0.34.3 → 0.35.0

package/dist/{chunk-2WYXD5ZP.mjs → chunk-22YJOBA3.mjs}

@@ -40,13 +40,17 @@ var cliConfigSchema = z.object({
   /** Allow the read-only `sql` query command. */
   allow_sql: z.boolean().default(true)
 });
+var desktopConfigSchema = z.object({
+  close_behavior: z.enum(["background", "quit"]).default("background")
+});
 var configSchema = z.object({
   llm: llmConfigSchema.default({}),
   data: dataConfigSchema.default({}),
   api: apiConfigSchema.default({}),
   locale: localeConfigSchema.default({}),
   ui: uiConfigSchema.default({}),
-  cli: cliConfigSchema.default({})
+  cli: cliConfigSchema.default({}),
+  desktop: desktopConfigSchema.default({})
 });
 
 // ../../packages/config/src/loader.ts
@@ -4108,7 +4112,7 @@ function buildMsgConditions(options) {
 
 // ../../packages/core/src/query/advanced/social.ts
 function getMentionAnalysis(db, filter) {
-  const emptyResult = {
+  const emptyResult2 = {
     topMentioners: [],
     topMentioned: [],
     totalMentions: 0
@@ -4117,7 +4121,7 @@ function getMentionAnalysis(db, filter) {
     `SELECT id, platform_id as platformId, COALESCE(group_nickname, account_name, platform_id) as name
        FROM member WHERE COALESCE(account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'`
   ).all();
-  if (members.length === 0) return emptyResult;
+  if (members.length === 0) return emptyResult2;
   const nameToMemberId = /* @__PURE__ */ new Map();
   const memberIdToInfo = /* @__PURE__ */ new Map();
   for (const member of members) {
@@ -4158,7 +4162,7 @@ function getMentionAnalysis(db, filter) {
       }
     }
   }
-  if (totalMentions === 0) return emptyResult;
+  if (totalMentions === 0) return emptyResult2;
   const topMentioners = [];
   for (const [memberId, count] of mentionerCount.entries()) {
     const info = memberIdToInfo.get(memberId);
@@ -4185,87 +4189,13 @@ function getMentionAnalysis(db, filter) {
   topMentioned.sort((a, b) => b.count - a.count);
   return { topMentioners, topMentioned, totalMentions };
 }
-function getMentionGraph(db, filter) {
-  const emptyResult = { nodes: [], links: [], maxLinkValue: 0 };
-  const { clause, params } = buildTimeFilter(filter);
-  const msgFilterBase = clause ? clause.replace("WHERE", "AND") : "";
-  const msgFilterWithSystem = msgFilterBase + " AND COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'";
-  const members = db.prepare(
-    `SELECT m.id, m.platform_id as platformId, COALESCE(m.group_nickname, m.account_name, m.platform_id) as name,
-              COUNT(msg.id) as messageCount
-       FROM member m LEFT JOIN message msg ON m.id = msg.sender_id ${msgFilterWithSystem}
-       WHERE COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' GROUP BY m.id`
-  ).all(...params);
-  if (members.length === 0) return emptyResult;
-  const nameToMemberId = /* @__PURE__ */ new Map();
-  const memberIdToInfo = /* @__PURE__ */ new Map();
-  for (const member of members) {
-    memberIdToInfo.set(member.id, { name: member.name, messageCount: member.messageCount });
-    nameToMemberId.set(member.name, member.id);
-    const history = db.prepare("SELECT name FROM member_name_history WHERE member_id = ?").all(member.id);
-    for (const h of history) {
-      if (!nameToMemberId.has(h.name)) nameToMemberId.set(h.name, member.id);
-    }
-  }
-  let whereClause = clause;
-  if (whereClause.includes("WHERE")) {
-    whereClause += " AND COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' AND msg.type = 0 AND msg.content IS NOT NULL AND msg.content LIKE '%@%'";
-  } else {
-    whereClause = " WHERE COALESCE(m.account_name, '') != '\u7CFB\u7EDF\u6D88\u606F' AND msg.type = 0 AND msg.content IS NOT NULL AND msg.content LIKE '%@%'";
-  }
-  const messages = db.prepare(
-    `SELECT msg.sender_id as senderId, msg.content FROM message msg JOIN member m ON msg.sender_id = m.id ${whereClause}`
-  ).all(...params);
-  const mentionMatrix = /* @__PURE__ */ new Map();
-  const mentionRegex = /@([^\s@]+)/g;
-  for (const msg of messages) {
-    const matches = msg.content.matchAll(mentionRegex);
-    const mentionedInThisMsg = /* @__PURE__ */ new Set();
-    for (const match of matches) {
-      const mentionedId = nameToMemberId.get(match[1]);
-      if (mentionedId && mentionedId !== msg.senderId && !mentionedInThisMsg.has(mentionedId)) {
-        mentionedInThisMsg.add(mentionedId);
-        if (!mentionMatrix.has(msg.senderId)) mentionMatrix.set(msg.senderId, /* @__PURE__ */ new Map());
-        const fromMap = mentionMatrix.get(msg.senderId);
-        fromMap.set(mentionedId, (fromMap.get(mentionedId) || 0) + 1);
-      }
-    }
-  }
-  const involvedMemberIds = /* @__PURE__ */ new Set();
-  for (const [fromId, toMap] of mentionMatrix.entries()) {
-    involvedMemberIds.add(fromId);
-    for (const toId of toMap.keys()) involvedMemberIds.add(toId);
-  }
-  const maxMessageCount = Math.max(...members.filter((m) => involvedMemberIds.has(m.id)).map((m) => m.messageCount), 1);
-  const nodes = [];
-  for (const memberId of involvedMemberIds) {
-    const info = memberIdToInfo.get(memberId);
-    if (info) {
-      const symbolSize = 20 + info.messageCount / maxMessageCount * 40;
-      nodes.push({ id: memberId, name: info.name, value: info.messageCount, symbolSize: Math.round(symbolSize) });
-    }
-  }
-  const links = [];
-  let maxLinkValue = 0;
-  for (const [fromId, toMap] of mentionMatrix.entries()) {
-    const fromInfo = memberIdToInfo.get(fromId);
-    if (!fromInfo) continue;
-    for (const [toId, count] of toMap.entries()) {
-      const toInfo = memberIdToInfo.get(toId);
-      if (!toInfo) continue;
-      links.push({ source: fromInfo.name, target: toInfo.name, value: count });
-      maxLinkValue = Math.max(maxLinkValue, count);
-    }
-  }
-  return { nodes, links, maxLinkValue };
-}
 function keywordToPattern(keyword) {
   const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (keyword === "\u54C8\u54C8") return "\u54C8\u54C8+";
   return escaped;
 }
 function getLaughAnalysis(db, filter, keywords) {
-  const emptyResult = {
+  const emptyResult2 = {
     rankByRate: [],
     rankByCount: [],
     typeDistribution: [],
@@ -4274,7 +4204,7 @@ function getLaughAnalysis(db, filter, keywords) {
     groupLaughRate: 0
   };
   const laughKeywords = keywords?.map((keyword) => keyword.trim()).filter(Boolean) ?? [];
-  if (laughKeywords.length === 0) return emptyResult;
+  if (laughKeywords.length === 0) return emptyResult2;
   const patterns = laughKeywords.map(keywordToPattern);
   const laughRegex = new RegExp(`(${patterns.join("|")})`, "gi");
   const { clause, params } = buildTimeFilter(filter);
@@ -4289,7 +4219,7 @@ function getLaughAnalysis(db, filter, keywords) {
               COALESCE(m.group_nickname, m.account_name, m.platform_id) as name
        FROM message msg JOIN member m ON msg.sender_id = m.id ${whereClause}`
   ).all(...params);
-  if (messages.length === 0) return emptyResult;
+  if (messages.length === 0) return emptyResult2;
   const memberStats = /* @__PURE__ */ new Map();
   const typeCount = /* @__PURE__ */ new Map();
   let totalLaughs = 0;
@@ -4322,7 +4252,7 @@ function getLaughAnalysis(db, filter, keywords) {
       }
     }
   }
-  if (totalLaughs === 0) return emptyResult;
+  if (totalLaughs === 0) return emptyResult2;
   const rankItems = [];
   for (const [memberId, stats] of memberStats.entries()) {
     if (stats.laughCount > 0) {
@@ -4412,7 +4342,7 @@ function accumulateCoOccurrencePairs(messages, options) {
 }
 function getClusterGraph(db, filter, options) {
   const opts = { ...DEFAULT_CLUSTER_OPTIONS, ...options };
-  const emptyResult = {
+  const emptyResult2 = {
     nodes: [],
     links: [],
     maxLinkValue: 0,
@@ -4424,7 +4354,7 @@ function getClusterGraph(db, filter, options) {
               (SELECT COUNT(*) FROM message WHERE sender_id = member.id) as messageCount
        FROM member WHERE COALESCE(account_name, '') != '\u7CFB\u7EDF\u6D88\u606F'`
   ).all();
-  if (members.length < 2) return { ...emptyResult, stats: { ...emptyResult.stats, totalMembers: members.length } };
+  if (members.length < 2) return { ...emptyResult2, stats: { ...emptyResult2.stats, totalMembers: members.length } };
   const memberInfo = /* @__PURE__ */ new Map();
   for (const m of members)
     memberInfo.set(m.id, { name: m.name, platformId: m.platformId, messageCount: m.messageCount });
@@ -4441,8 +4371,8 @@ function getClusterGraph(db, filter, options) {
   ).all(...params);
   if (messages.length < 2)
     return {
-      ...emptyResult,
-      stats: { ...emptyResult.stats, totalMembers: members.length, totalMessages: messages.length }
+      ...emptyResult2,
+      stats: { ...emptyResult2.stats, totalMembers: members.length, totalMessages: messages.length }
     };
   const memberMsgCount = /* @__PURE__ */ new Map();
   for (const msg of messages) memberMsgCount.set(msg.senderId, (memberMsgCount.get(msg.senderId) || 0) + 1);
@@ -4481,8 +4411,8 @@ function getClusterGraph(db, filter, options) {
   const keptEdges = edges.slice(0, opts.topEdges);
   if (keptEdges.length === 0)
     return {
-      ...emptyResult,
-      stats: { ...emptyResult.stats, totalMembers: members.length, totalMessages: messages.length }
+      ...emptyResult2,
+      stats: { ...emptyResult2.stats, totalMembers: members.length, totalMessages: messages.length }
     };
   const involvedIds = /* @__PURE__ */ new Set();
   for (const edge of keptEdges) {
@@ -4755,7 +4685,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
        ORDER BY msg.ts ASC, msg.id ASC`
   ).all(...messageTimeFilter.params);
   const edgeStats = /* @__PURE__ */ new Map();
-  const ensureEdge = (aId, bId) => {
+  const ensureEdge2 = (aId, bId) => {
     const sourceId = Math.min(aId, bId);
     const targetId = Math.max(aId, bId);
     const key = `${sourceId}:${targetId}`;
@@ -4775,7 +4705,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
   };
   for (const pair of accumulateCoOccurrencePairs(coOccurrenceRows)) {
     if (!contactById.has(pair.sourceId) || !contactById.has(pair.targetId)) continue;
-    const edge = ensureEdge(pair.sourceId, pair.targetId);
+    const edge = ensureEdge2(pair.sourceId, pair.targetId);
     edge.coOccurrenceCount += pair.coOccurrenceCount;
     edge.coOccurrenceRawScore += pair.rawScore;
     edge.lastInteractionTs = Math.max(edge.lastInteractionTs ?? 0, pair.lastOccurrenceTs);
@@ -4797,7 +4727,7 @@ function getGroupRelationshipGraphFacts(db, ownerMemberId, options = {}) {
   for (const row of replyRows) {
     if (!contactById.has(row.replySenderId) || !contactById.has(row.targetSenderId)) continue;
     if (row.replySenderId === row.targetSenderId) continue;
-    const edge = ensureEdge(row.replySenderId, row.targetSenderId);
+    const edge = ensureEdge2(row.replySenderId, row.targetSenderId);
     if (row.replySenderId === edge.sourceId) edge.repliesFromSourceToTarget++;
     else edge.repliesFromTargetToSource++;
     edge.lastInteractionTs = Math.max(edge.lastInteractionTs ?? 0, row.replyTs);
@@ -6005,12 +5935,456 @@ function getCatchphraseAnalysis(db, filter) {
   return { members };
 }
 
+// ../../packages/core/src/query/advanced/group-relationship-galaxy.ts
+var GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION = "group-relationship-galaxy-v1";
+var REPLY_WEIGHT = 3;
+var MENTION_WEIGHT = 2;
+var CO_OCCURRENCE_COUNT_WEIGHT = 0.05;
+var MIN_EDGE_WEIGHT = 1e-6;
+var DEFAULT_LIMITS = {
+  nodeLimit: 400,
+  edgeLimit: 1200,
+  perNodeEdgeLimit: 10
+};
+var COMMUNITY_COLORS = [
+  "#7dd3fc",
+  "#c4b5fd",
+  "#f0abfc",
+  "#5eead4",
+  "#fda4af",
+  "#fde68a",
+  "#93c5fd",
+  "#6ee7b7",
+  "#d8b4fe",
+  "#fdba74"
+];
+function getGroupRelationshipGalaxy(db, filter, options = {}) {
+  const limits = normalizeLimits(options);
+  const allMembers = getNonSystemMembersForContacts(db);
+  const memberById = new Map(allMembers.map((member) => [member.id, member]));
+  const messageRows = queryRelationshipMessages(db, filter).filter((message) => memberById.has(message.senderId));
+  const activeMembers = buildActiveMembers(allMembers, messageRows);
+  const activeMemberById = new Map(activeMembers.map((member) => [member.id, member]));
+  if (activeMembers.length < 2) {
+    return emptyResult(allMembers.length, activeMembers.length);
+  }
+  const edgeByPair = /* @__PURE__ */ new Map();
+  for (const pair of accumulateCoOccurrencePairs(messageRows)) {
+    if (!activeMemberById.has(pair.sourceId) || !activeMemberById.has(pair.targetId)) continue;
+    const edge = ensureEdge(edgeByPair, activeMemberById, pair.sourceId, pair.targetId);
+    edge.coOccurrenceCount += pair.coOccurrenceCount;
+    edge.coOccurrenceRawScore += pair.rawScore;
+    edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, pair.lastOccurrenceTs);
+  }
+  accumulateReplies(db, filter, activeMemberById, edgeByPair);
+  accumulateMentions(db, filter, activeMembers, activeMemberById, edgeByPair);
+  const weightedEdges = [...edgeByPair.values()].map((edge) => ({ ...edge, weight: roundNum2(computeEdgeWeight(edge)) })).filter((edge) => edge.weight >= MIN_EDGE_WEIGHT).sort(compareEdges);
+  if (weightedEdges.length === 0) {
+    return emptyResult(allMembers.length, activeMembers.length);
+  }
+  const candidateNodeKeys = selectCandidateNodeKeys(weightedEdges, limits.nodeLimit);
+  const candidateEdges = weightedEdges.filter(
+    (edge) => candidateNodeKeys.has(edge.sourceKey) && candidateNodeKeys.has(edge.targetKey)
+  );
+  const keptEdges = selectEdges(candidateEdges, limits.perNodeEdgeLimit, limits.edgeLimit);
+  const displayedNodeKeys = /* @__PURE__ */ new Set();
+  for (const edge of keptEdges) {
+    displayedNodeKeys.add(edge.sourceKey);
+    displayedNodeKeys.add(edge.targetKey);
+  }
+  const displayedMembers = activeMembers.filter((member) => displayedNodeKeys.has(member.key));
+  const degreeByKey = computeDegreeByKey(keptEdges);
+  const rankedMembers = [...displayedMembers].sort((a, b) => {
+    const degreeDiff = (degreeByKey.get(b.key) ?? 0) - (degreeByKey.get(a.key) ?? 0);
+    return degreeDiff || b.messageCount - a.messageCount || a.key.localeCompare(b.key);
+  });
+  const communityAssignments = detectWeightedCommunities(rankedMembers, keptEdges, degreeByKey);
+  const communityByNodeKey = /* @__PURE__ */ new Map();
+  for (const community of communityAssignments) {
+    for (const nodeKey of community.nodeKeys) communityByNodeKey.set(nodeKey, community);
+  }
+  const maxDegree = Math.max(...degreeByKey.values(), 1);
+  const renderNodes = [];
+  const memberDetails = [];
+  const incidentTotals = buildIncidentTotals(weightedEdges);
+  for (const [index, member] of rankedMembers.entries()) {
+    const degree = degreeByKey.get(member.key) ?? 0;
+    const score = degree / maxDegree;
+    const community = communityByNodeKey.get(member.key);
+    const position = layoutNode(member.key, index, community, rankedMembers, communityByNodeKey);
+    const totals = incidentTotals.get(member.key) ?? createIncidentTotals();
+    const rank = index + 1;
+    renderNodes.push({
+      key: member.key,
+      displayName: member.displayName,
+      avatar: member.avatar,
+      score: roundNum2(score),
+      rank,
+      communityId: community.id,
+      x: position.x,
+      y: position.y,
+      size: roundNum2(18 + Math.sqrt(score) * 30, 2),
+      color: community.color,
+      labelVisibility: rank <= 8 ? 2 : rank <= 30 ? 1 : 0
+    });
+    memberDetails.push({
+      key: member.key,
+      memberId: member.id,
+      platformId: member.platformId,
+      displayName: member.displayName,
+      avatar: member.avatar,
+      messageCount: member.messageCount,
+      lastMessageTs: member.lastMessageTs,
+      relationshipScore: roundNum2(score),
+      rank,
+      communityId: community.id,
+      replyInteractionCount: totals.replyInteractionCount,
+      mentionInteractionCount: totals.mentionInteractionCount,
+      coOccurrenceCount: totals.coOccurrenceCount,
+      coOccurrenceRawScore: roundNum2(totals.coOccurrenceRawScore),
+      lastInteractionTs: totals.lastInteractionTs
+    });
+  }
+  const maxEdgeWeight = Math.max(...keptEdges.map((edge) => edge.weight), 1);
+  const renderEdges = keptEdges.map((edge) => ({
+    id: edge.id,
+    sourceKey: edge.sourceKey,
+    targetKey: edge.targetKey,
+    weight: edge.weight,
+    visibility: edge.weight / maxEdgeWeight >= 0.35 ? 2 : 1,
+    lastInteractionTs: edge.lastInteractionTs
+  }));
+  const edgeDetails = keptEdges.map((edge) => ({
+    id: edge.id,
+    sourceKey: edge.sourceKey,
+    targetKey: edge.targetKey,
+    weight: edge.weight,
+    coOccurrenceCount: edge.coOccurrenceCount,
+    coOccurrenceRawScore: roundNum2(edge.coOccurrenceRawScore),
+    replyInteractionCount: edge.replyInteractionCount,
+    mentionInteractionCount: edge.mentionInteractionCount,
+    lastInteractionTs: edge.lastInteractionTs
+  }));
+  const renderCommunities = communityAssignments.map((community, index) => ({
+    id: community.id,
+    label: `community-${index + 1}`,
+    size: community.nodeKeys.length,
+    x: community.x,
+    y: community.y,
+    color: community.color
+  }));
+  return {
+    graph: { nodes: renderNodes, edges: renderEdges, communities: renderCommunities },
+    members: memberDetails,
+    edges: edgeDetails,
+    stats: {
+      totalMembers: allMembers.length,
+      activeMembers: activeMembers.length,
+      displayedMembers: renderNodes.length,
+      displayedEdges: renderEdges.length,
+      communityCount: renderCommunities.length
+    },
+    algorithmVersion: GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION
+  };
+}
+function queryRelationshipMessages(db, filter) {
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const where = appendConditions(clause, ["msg.type NOT IN (80, 81)"]);
+  return db.prepare(`SELECT msg.sender_id as senderId, msg.ts FROM message msg ${where} ORDER BY msg.ts ASC, msg.id ASC`).all(...params);
+}
+function buildActiveMembers(allMembers, messages) {
+  const messageStats = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const stats = messageStats.get(message.senderId) ?? { count: 0, lastTs: 0 };
+    stats.count++;
+    stats.lastTs = Math.max(stats.lastTs, message.ts);
+    messageStats.set(message.senderId, stats);
+  }
+  const active = allMembers.filter((member) => messageStats.has(member.id)).map((member) => ({
+    ...member,
+    key: memberKey(member.id),
+    displayName: member.name,
+    messageCount: messageStats.get(member.id).count,
+    lastMessageTs: messageStats.get(member.id).lastTs || null
+  }));
+  const nameCounts = /* @__PURE__ */ new Map();
+  for (const member of active) nameCounts.set(member.displayName, (nameCounts.get(member.displayName) ?? 0) + 1);
+  for (const member of active) {
+    if ((nameCounts.get(member.displayName) ?? 0) > 1) {
+      member.displayName = `${member.displayName}#${member.platformId.slice(-4)}`;
+    }
+  }
+  return active;
+}
+function accumulateReplies(db, filter, activeMemberById, edgeByPair) {
+  if (!hasColumn(db, "message", "reply_to_message_id") || !hasColumn(db, "message", "platform_message_id")) return;
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const conditions = ["msg.type NOT IN (80, 81)", "target.type NOT IN (80, 81)", "msg.reply_to_message_id IS NOT NULL"];
+  const targetParams = [];
+  if (filter?.startTs !== void 0) {
+    conditions.push("target.ts >= ?");
+    targetParams.push(filter.startTs);
+  }
+  if (filter?.endTs !== void 0) {
+    conditions.push("target.ts <= ?");
+    targetParams.push(filter.endTs);
+  }
+  const rows = db.prepare(
+    `SELECT msg.sender_id as replySenderId, msg.ts as replyTs, target.sender_id as targetSenderId
+       FROM message msg
+       JOIN message target ON msg.reply_to_message_id = target.platform_message_id
+       ${appendConditions(clause, conditions)}`
+  ).all(...params, ...targetParams);
+  for (const row of rows) {
+    if (row.replySenderId === row.targetSenderId) continue;
+    if (!activeMemberById.has(row.replySenderId) || !activeMemberById.has(row.targetSenderId)) continue;
+    const edge = ensureEdge(edgeByPair, activeMemberById, row.replySenderId, row.targetSenderId);
+    edge.replyInteractionCount++;
+    edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, row.replyTs);
+  }
+}
+function accumulateMentions(db, filter, activeMembers, activeMemberById, edgeByPair) {
+  const nameToMemberId = buildMentionNameIndex(db, activeMembers);
+  const { clause, params } = buildTimeFilter(filter, "msg");
+  const where = appendConditions(clause, ["msg.type = 0", "msg.content IS NOT NULL", "msg.content LIKE '%@%'"]);
+  const rows = db.prepare(`SELECT msg.sender_id as senderId, msg.ts, msg.content FROM message msg ${where}`).all(...params);
+  const mentionRegex = /@([^\s@]+)/g;
+  for (const row of rows) {
+    if (!activeMemberById.has(row.senderId)) continue;
+    const mentionedInMessage = /* @__PURE__ */ new Set();
+    for (const match of row.content.matchAll(mentionRegex)) {
+      const mentionedId = nameToMemberId.get(match[1]);
+      if (mentionedId === null || mentionedId === void 0 || mentionedId === row.senderId) continue;
+      if (!activeMemberById.has(mentionedId) || mentionedInMessage.has(mentionedId)) continue;
+      mentionedInMessage.add(mentionedId);
+      const edge = ensureEdge(edgeByPair, activeMemberById, row.senderId, mentionedId);
+      edge.mentionInteractionCount++;
+      edge.lastInteractionTs = maxTimestamp(edge.lastInteractionTs, row.ts);
+    }
+  }
+}
+function buildMentionNameIndex(db, members) {
+  const index = /* @__PURE__ */ new Map();
+  const addName = (name, memberId) => {
+    const trimmed = name.trim();
+    if (!trimmed) return;
+    const existing = index.get(trimmed);
+    if (existing === void 0 || existing === memberId) index.set(trimmed, memberId);
+    else index.set(trimmed, null);
+  };
+  for (const member of members) {
+    addName(member.name, member.id);
+    for (const alias of member.aliases) addName(alias, member.id);
+  }
+  if (hasTable(db, "member_name_history")) {
+    const memberIds = new Set(members.map((member) => member.id));
+    const rows = db.prepare("SELECT member_id as memberId, name FROM member_name_history").all();
+    for (const row of rows) {
+      if (memberIds.has(row.memberId)) addName(row.name, row.memberId);
+    }
+  }
+  return index;
+}
+function ensureEdge(edgeByPair, memberById, aId, bId) {
+  const sourceId = Math.min(aId, bId);
+  const targetId = Math.max(aId, bId);
+  const id = `${memberKey(sourceId)}--${memberKey(targetId)}`;
+  const existing = edgeByPair.get(id);
+  if (existing) return existing;
+  const created = {
+    id,
+    sourceId,
+    targetId,
+    sourceKey: memberById.get(sourceId).key,
+    targetKey: memberById.get(targetId).key,
+    coOccurrenceCount: 0,
+    coOccurrenceRawScore: 0,
+    replyInteractionCount: 0,
+    mentionInteractionCount: 0,
+    lastInteractionTs: null,
+    weight: 0
+  };
+  edgeByPair.set(id, created);
+  return created;
+}
+function computeEdgeWeight(edge) {
+  return edge.coOccurrenceRawScore + edge.replyInteractionCount * REPLY_WEIGHT + edge.mentionInteractionCount * MENTION_WEIGHT + edge.coOccurrenceCount * CO_OCCURRENCE_COUNT_WEIGHT;
+}
+function selectCandidateNodeKeys(edges, nodeLimit) {
+  const degree = computeDegreeByKey(edges);
+  return new Set(
+    [...degree.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, nodeLimit).map(([key]) => key)
+  );
+}
+function selectEdges(edges, perNodeLimit, edgeLimit) {
+  const incident = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const key of [edge.sourceKey, edge.targetKey]) {
+      const list = incident.get(key) ?? [];
+      list.push(edge);
+      incident.set(key, list);
+    }
+  }
+  const selectedIds = /* @__PURE__ */ new Set();
+  for (const list of incident.values()) {
+    list.sort(compareEdges);
+    for (const edge of list.slice(0, perNodeLimit)) selectedIds.add(edge.id);
+  }
+  return edges.filter((edge) => selectedIds.has(edge.id)).sort(compareEdges).slice(0, edgeLimit);
+}
+function computeDegreeByKey(edges) {
+  const degree = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    degree.set(edge.sourceKey, (degree.get(edge.sourceKey) ?? 0) + edge.weight);
+    degree.set(edge.targetKey, (degree.get(edge.targetKey) ?? 0) + edge.weight);
+  }
+  return degree;
+}
+function detectWeightedCommunities(members, edges, degreeByKey) {
+  const parent = new Map(members.map((member) => [member.key, member.key]));
+  const strongestByKey = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    strongestByKey.set(edge.sourceKey, Math.max(strongestByKey.get(edge.sourceKey) ?? 0, edge.weight));
+    strongestByKey.set(edge.targetKey, Math.max(strongestByKey.get(edge.targetKey) ?? 0, edge.weight));
+  }
+  const find = (key) => {
+    const current = parent.get(key) ?? key;
+    if (current === key) return current;
+    const root = find(current);
+    parent.set(key, root);
+    return root;
+  };
+  const union = (a, b) => {
+    const aRoot = find(a);
+    const bRoot = find(b);
+    if (aRoot === bRoot) return;
+    const [source, target] = aRoot.localeCompare(bRoot) <= 0 ? [aRoot, bRoot] : [bRoot, aRoot];
+    parent.set(target, source);
+  };
+  for (const edge of edges) {
+    const sourceThreshold = (strongestByKey.get(edge.sourceKey) ?? edge.weight) * 0.6;
+    const targetThreshold = (strongestByKey.get(edge.targetKey) ?? edge.weight) * 0.6;
+    if (edge.weight >= sourceThreshold && edge.weight >= targetThreshold) union(edge.sourceKey, edge.targetKey);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const root = find(member.key);
+    const list = groups.get(root) ?? [];
+    list.push(member.key);
+    groups.set(root, list);
+  }
+  const sortedGroups = [...groups.values()].map((keys) => keys.sort()).sort((a, b) => {
+    const aWeight = a.reduce((sum, key) => sum + (degreeByKey.get(key) ?? 0), 0);
+    const bWeight = b.reduce((sum, key) => sum + (degreeByKey.get(key) ?? 0), 0);
+    return bWeight - aWeight || a[0].localeCompare(b[0]);
+  });
+  return sortedGroups.map((nodeKeys, index) => {
+    const center = layoutCommunity(index, sortedGroups.length);
+    return {
+      id: `community:${nodeKeys[0]}`,
+      nodeKeys,
+      color: COMMUNITY_COLORS[stableHash(nodeKeys[0]) % COMMUNITY_COLORS.length],
+      x: center.x,
+      y: center.y
+    };
+  });
+}
+function layoutCommunity(index, count) {
+  if (index === 0 || count === 1) return { x: 0, y: 0 };
+  const ringIndex = index - 1;
+  const ring = Math.floor(ringIndex / 6);
+  const position = ringIndex % 6;
+  const radius = 380 + ring * 280;
+  const angle = -Math.PI / 2 + position / 6 * Math.PI * 2 + ring * 0.31;
+  return { x: roundNum2(Math.cos(angle) * radius, 2), y: roundNum2(Math.sin(angle) * radius, 2) };
+}
+function layoutNode(nodeKey, globalIndex, community, members, communityByNodeKey) {
+  const communityMembers = members.filter((member) => communityByNodeKey.get(member.key)?.id === community.id);
+  const localIndex = communityMembers.findIndex((member) => member.key === nodeKey);
+  const angle = localIndex * 2.399963229728653 + stableHash(nodeKey) % 1e3 / 1e3;
+  const radius = localIndex === 0 ? 0 : 54 + Math.sqrt(localIndex) * 42;
+  const globalJitter = globalIndex % 3 * 2;
+  return {
+    x: roundNum2(community.x + Math.cos(angle) * (radius + globalJitter), 2),
+    y: roundNum2(community.y + Math.sin(angle) * (radius + globalJitter), 2)
+  };
+}
+function buildIncidentTotals(edges) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const key of [edge.sourceKey, edge.targetKey]) {
+      const item = totals.get(key) ?? createIncidentTotals();
+      item.replyInteractionCount += edge.replyInteractionCount;
+      item.mentionInteractionCount += edge.mentionInteractionCount;
+      item.coOccurrenceCount += edge.coOccurrenceCount;
+      item.coOccurrenceRawScore += edge.coOccurrenceRawScore;
+      item.lastInteractionTs = maxTimestamp(item.lastInteractionTs, edge.lastInteractionTs);
+      totals.set(key, item);
+    }
+  }
+  return totals;
+}
+function createIncidentTotals() {
+  return {
+    replyInteractionCount: 0,
+    mentionInteractionCount: 0,
+    coOccurrenceCount: 0,
+    coOccurrenceRawScore: 0,
+    lastInteractionTs: null
+  };
+}
+function normalizeLimits(options) {
+  return {
+    nodeLimit: normalizeLimit(options.nodeLimit, DEFAULT_LIMITS.nodeLimit),
+    edgeLimit: normalizeLimit(options.edgeLimit, DEFAULT_LIMITS.edgeLimit),
+    perNodeEdgeLimit: normalizeLimit(options.perNodeEdgeLimit, DEFAULT_LIMITS.perNodeEdgeLimit)
+  };
+}
+function normalizeLimit(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function appendConditions(clause, conditions) {
+  const existing = clause.trim().replace(/^WHERE\s+/i, "");
+  return `WHERE ${[existing, ...conditions].filter(Boolean).join(" AND ")}`;
+}
+function emptyResult(totalMembers, activeMembers) {
+  return {
+    graph: { nodes: [], edges: [], communities: [] },
+    members: [],
+    edges: [],
+    stats: { totalMembers, activeMembers, displayedMembers: 0, displayedEdges: 0, communityCount: 0 },
+    algorithmVersion: GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION
+  };
+}
+function compareEdges(a, b) {
+  return b.weight - a.weight || a.id.localeCompare(b.id);
+}
+function memberKey(memberId) {
+  return `member:${memberId}`;
+}
+function maxTimestamp(current, next) {
+  if (next === null) return current;
+  return Math.max(current ?? 0, next) || null;
+}
+function roundNum2(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function stableHash(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
 // ../../packages/core/src/query/advanced/relationship.ts
 var ICE_BREAK_THRESHOLD = 24 * 60 * 60;
 var DEFAULT_PERSEVERANCE_THRESHOLD = 300;
 function getRelationshipStats(db, filter, options) {
   const perseveranceThreshold = options?.perseveranceThreshold ?? DEFAULT_PERSEVERANCE_THRESHOLD;
-  const emptyResult = {
+  const emptyResult2 = {
     months: [],
     members: [],
     totalSessions: 0,
@@ -6022,7 +6396,7 @@ function getRelationshipStats(db, filter, options) {
     monthlyPerseverance: []
   };
   const sessionCount = db.prepare("SELECT COUNT(*) as count FROM segment").get();
-  if (!sessionCount || sessionCount.count === 0) return emptyResult;
+  if (!sessionCount || sessionCount.count === 0) return emptyResult2;
   const timeConditions = [];
   const params = [];
   if (filter?.startTs !== void 0) {
@@ -6755,7 +7129,7 @@ function getCheckInAnalysis(db, filter) {
   return computeCheckIn(dailyActivity);
 }
 function computeMemeBattle(messages) {
-  const emptyResult = {
+  const emptyResult2 = {
     topBattles: [],
     rankByCount: [],
     rankByImageCount: [],
@@ -6789,7 +7163,7 @@ function computeMemeBattle(messages) {
     }
   }
   processChain();
-  if (battles.length === 0) return emptyResult;
+  if (battles.length === 0) return emptyResult2;
   const topBattles = battles.map((battle) => ({
     startTime: battle.startTime,
     endTime: battle.endTime,
@@ -6868,7 +7242,7 @@ function getMemeBattleAnalysis(db, filter) {
   return computeMemeBattle(messages);
 }
 function computeNightOwl(messages) {
-  const emptyResult = {
+  const emptyResult2 = {
     nightOwlRank: [],
     lastSpeakerRank: [],
     firstSpeakerRank: [],
@@ -6876,7 +7250,7 @@ function computeNightOwl(messages) {
     champions: [],
     totalDays: 0
   };
-  if (messages.length === 0) return emptyResult;
+  if (messages.length === 0) return emptyResult2;
   function getNightOwlTitleByCount(count) {
     if (count === 0) return "\u517B\u751F\u8FBE\u4EBA";
     if (count <= 20) return "\u5076\u5C14\u5931\u7720";
@@ -9319,7 +9693,6 @@ export {
   isValidWord,
   buildExcludeKeywordsConditions,
   getMentionAnalysis,
-  getMentionGraph,
   getLaughAnalysis,
   getClusterGraph,
   resolveOwnerMember,
@@ -9366,6 +9739,8 @@ export {
   deleteMembers,
   deleteMember,
   getCatchphraseAnalysis,
+  GROUP_RELATIONSHIP_GALAXY_ALGORITHM_VERSION,
+  getGroupRelationshipGalaxy,
   getRelationshipStats,
   getJourneyStats,
   getLanguagePreferenceAnalysis,
@@ -9448,4 +9823,4 @@ export {
   StaticPathProvider,
   createDatabaseManagerAdapter
 };
-//# sourceMappingURL=chunk-2WYXD5ZP.mjs.map
+//# sourceMappingURL=chunk-22YJOBA3.mjs.map