v2er-insight 1.0.0

package/dist/core/analyzer/builder.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Analyzer 输出构建器
+ * 整合所有模块，生成最终的 AI 输入数据
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnalyzerOutput = buildAnalyzerOutput;
+const periods_1 = require("./periods");
+const user_overview_1 = require("./stats/user-overview");
+const topic_stats_1 = require("./stats/topic-stats");
+const reply_stats_1 = require("./stats/reply-stats");
+const content_1 = require("./content");
+const utils_1 = require("./utils");
+/**
+ * 构建完整的 Analyzer 输出
+ *
+ * 处理流程：
+ * 1. 计算用户总览
+ * 2. 提取所有活动日期
+ * 3. 检测活跃期边界
+ * 4. 将数据分割到各活跃期
+ * 5. 计算每个活跃期的统计
+ * 6. 转换并分片内容
+ *
+ * @param data - V2EX 抓取的原始用户数据
+ * @param referenceDate - 参考日期（用于相对时间解析）
+ * @returns 完整的 Analyzer 输出
+ */
+function buildAnalyzerOutput(data, referenceDate = new Date()) {
+    // 1. 计算用户总览
+    const userOverview = (0, user_overview_1.calculateUserOverview)(data, referenceDate);
+    // 2. 提取所有活动日期并排序
+    const activities = extractActivities(data, referenceDate);
+    // 3. 检测活跃期边界
+    const boundaries = (0, periods_1.detectPeriodBoundaries)(activities);
+    // 4. 将数据分割到各活跃期
+    const periods = (0, periods_1.splitByPeriods)(boundaries, data.topics, data.replies, referenceDate);
+    // 5. 计算每个活跃期的统计
+    const periodStats = periods.map((period) => calculatePeriodStats(period, referenceDate));
+    // 6. 构建 PeriodsSummary
+    const summary = {
+        totalPeriods: periods.length,
+        periods: periodStats,
+    };
+    // 7. 转换并分片内容
+    const contents = buildContents(periods);
+    return {
+        userOverview,
+        summary,
+        contents,
+    };
+}
+/**
+ * 从原始数据中提取所有活动日期
+ * 用于检测活跃期边界
+ */
+function extractActivities(data, referenceDate) {
+    const activities = [];
+    // 从帖子提取日期（绝对时间）
+    for (const topic of data.topics) {
+        const parsed = (0, utils_1.parseAbsoluteDate)(topic.createdAt);
+        if (parsed) {
+            activities.push({ date: parsed.date });
+        }
+    }
+    // 从回复提取日期（相对时间）
+    for (const reply of data.replies) {
+        const parsed = (0, utils_1.parseRelativeTime)(reply.replyTime, referenceDate);
+        if (parsed) {
+            activities.push({ date: parsed.date });
+        }
+    }
+    // 按日期升序排序
+    activities.sort((a, b) => a.date.getTime() - b.date.getTime());
+    return activities;
+}
+/**
+ * 计算单个活跃期的统计
+ */
+function calculatePeriodStats(period, referenceDate) {
+    const topicStats = (0, topic_stats_1.calculateTopicStats)({
+        topics: period.topics,
+        startDate: period.startDate,
+        endDate: period.endDate,
+    });
+    const replyStats = (0, reply_stats_1.calculateReplyStats)({
+        replies: period.replies,
+        referenceDate,
+    });
+    return {
+        ...topicStats,
+        ...replyStats,
+    };
+}
+/**
+ * 构建所有活跃期的内容
+ */
+function buildContents(periods) {
+    const contents = [];
+    for (const period of periods) {
+        const result = (0, content_1.chunkPeriodContent)(period);
+        if (Array.isArray(result)) {
+            // 分片结果
+            contents.push(...result);
+        }
+        else {
+            // 完整内容
+            contents.push(result);
+        }
+    }
+    return contents;
+}
+//# sourceMappingURL=builder.js.map

package/dist/core/analyzer/content/chunker.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 内容分片器
+ * 将大量内容分割成适合 AI 处理的小块
+ */
+import type { ActivePeriod } from '../types';
+import type { PeriodContent, PeriodContentChunk } from '../types';
+/**
+ * 将活跃期内容转换并按需分片
+ *
+ * 分片规则：
+ * - topics > CHUNK_MAX_TOPICS 或 replies > CHUNK_MAX_REPLIES → 分片
+ * - 同一 chunk 只能包含同一活跃期的内容
+ *
+ * @param period - 单个活跃期数据
+ * @returns 完整内容 PeriodContent 或分片数组 PeriodContentChunk[]
+ */
+export declare function chunkPeriodContent(period: ActivePeriod): PeriodContent | PeriodContentChunk[];
+//# sourceMappingURL=chunker.d.ts.map

package/dist/core/analyzer/content/chunker.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * 内容分片器
+ * 将大量内容分割成适合 AI 处理的小块
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkPeriodContent = chunkPeriodContent;
+const config_1 = require("../../../config");
+const transformer_1 = require("./transformer");
+/**
+ * 将活跃期内容转换并按需分片
+ *
+ * 分片规则：
+ * - topics > CHUNK_MAX_TOPICS 或 replies > CHUNK_MAX_REPLIES → 分片
+ * - 同一 chunk 只能包含同一活跃期的内容
+ *
+ * @param period - 单个活跃期数据
+ * @returns 完整内容 PeriodContent 或分片数组 PeriodContentChunk[]
+ */
+function chunkPeriodContent(period) {
+    const analyzerConfig = (0, config_1.getConfig)().analyzer;
+    const CHUNK_MAX_TOPICS = analyzerConfig?.chunkMaxTopics ?? 20;
+    const CHUNK_MAX_REPLIES = analyzerConfig?.chunkMaxReplies ?? 100;
+    const { index: periodIndex, topics, replies } = period;
+    // 转换为 AI 格式
+    const contentTopics = (0, transformer_1.transformTopics)(topics);
+    const contentReplies = (0, transformer_1.transformReplies)(replies);
+    // 判断是否需要分片
+    const needsChunking = contentTopics.length > CHUNK_MAX_TOPICS || contentReplies.length > CHUNK_MAX_REPLIES;
+    if (!needsChunking) {
+        // 内容量小，返回完整内容
+        return {
+            periodIndex,
+            topics: contentTopics,
+            replies: contentReplies,
+        };
+    }
+    // 需要分片
+    return createChunks(periodIndex, contentTopics, contentReplies, CHUNK_MAX_TOPICS, CHUNK_MAX_REPLIES);
+}
+/**
+ * 创建内容分片
+ *
+ * 分片策略：
+ * - 帖子按 CHUNK_MAX_TOPICS 分组
+ * - 回复按 CHUNK_MAX_REPLIES 分组
+ * - 每个 chunk 可同时包含帖子和回复
+ */
+function createChunks(periodIndex, topics, replies, CHUNK_MAX_TOPICS, CHUNK_MAX_REPLIES) {
+    // 计算需要的 chunk 数量
+    const topicChunks = Math.ceil(topics.length / CHUNK_MAX_TOPICS);
+    const replyChunks = Math.ceil(replies.length / CHUNK_MAX_REPLIES);
+    const totalChunks = Math.max(topicChunks, replyChunks, 1);
+    const chunks = [];
+    for (let i = 0; i < totalChunks; i++) {
+        // 切分帖子
+        const topicStart = i * CHUNK_MAX_TOPICS;
+        const topicEnd = topicStart + CHUNK_MAX_TOPICS;
+        const chunkTopics = topics.slice(topicStart, topicEnd);
+        // 切分回复
+        const replyStart = i * CHUNK_MAX_REPLIES;
+        const replyEnd = replyStart + CHUNK_MAX_REPLIES;
+        const chunkReplies = replies.slice(replyStart, replyEnd);
+        chunks.push({
+            periodIndex,
+            chunkIndex: i,
+            totalChunksInPeriod: totalChunks,
+            topics: chunkTopics,
+            replies: chunkReplies,
+        });
+    }
+    return chunks;
+}
+//# sourceMappingURL=chunker.js.map

package/dist/core/analyzer/content/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 内容处理模块
+ * 导出转换器和分片器
+ */
+export { transformTopics, transformReplies } from './transformer';
+export { chunkPeriodContent } from './chunker';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/analyzer/content/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * 内容处理模块
+ * 导出转换器和分片器
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkPeriodContent = exports.transformReplies = exports.transformTopics = void 0;
+var transformer_1 = require("./transformer");
+Object.defineProperty(exports, "transformTopics", { enumerable: true, get: function () { return transformer_1.transformTopics; } });
+Object.defineProperty(exports, "transformReplies", { enumerable: true, get: function () { return transformer_1.transformReplies; } });
+var chunker_1 = require("./chunker");
+Object.defineProperty(exports, "chunkPeriodContent", { enumerable: true, get: function () { return chunker_1.chunkPeriodContent; } });
+//# sourceMappingURL=index.js.map

package/dist/core/analyzer/content/transformer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 内容转换器
+ * 将原始 V2EX 数据转换为 AI 可消费的格式
+ */
+import type { V2exReply, V2exTopicDetail } from '../../../core/v2ex/types/entities';
+import type { ContentTopic, ContentReply } from '../types';
+/**
+ * 将帖子转换为 AI 输入格式
+ * @param topics - 单个活跃期内的帖子数组
+ * @returns 转换后的 ContentTopic 数组
+ */
+export declare function transformTopics(topics: V2exTopicDetail[]): ContentTopic[];
+/**
+ * 将回复转换为 AI 输入格式
+ * @param replies - 单个活跃期内的回复数组
+ * @returns 转换后的 ContentReply 数组
+ */
+export declare function transformReplies(replies: V2exReply[]): ContentReply[];
+//# sourceMappingURL=transformer.d.ts.map

package/dist/core/analyzer/content/transformer.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * 内容转换器
+ * 将原始 V2EX 数据转换为 AI 可消费的格式
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTopics = transformTopics;
+exports.transformReplies = transformReplies;
+/**
+ * 将帖子转换为 AI 输入格式
+ * @param topics - 单个活跃期内的帖子数组
+ * @returns 转换后的 ContentTopic 数组
+ */
+function transformTopics(topics) {
+    return topics.map((topic) => ({
+        title: topic.title,
+        nodeName: topic.nodeName,
+        content: topic.content,
+    }));
+}
+/**
+ * 将回复转换为 AI 输入格式
+ * @param replies - 单个活跃期内的回复数组
+ * @returns 转换后的 ContentReply 数组
+ */
+function transformReplies(replies) {
+    return replies.map((reply) => ({
+        topicTitle: reply.topicTitle,
+        nodeName: reply.nodeName,
+        content: reply.content,
+    }));
+}
+//# sourceMappingURL=transformer.js.map

package/dist/core/analyzer/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Analyzer 模块公共 API
+ *
+ * 用法示例：
+ * ```typescript
+ * import { buildAnalyzerOutput } from '../../core/analyzer';
+ *
+ * const rawData: RawUserData = { profile, topics, replies, isTopicsHidden };
+ * const output = buildAnalyzerOutput(rawData);
+ * // output.userOverview - 用户总览
+ * // output.summary - 活跃期统计汇总
+ * // output.contents - 分片后的内容
+ * ```
+ */
+export { buildAnalyzerOutput } from './builder';
+export type { RawUserData, AnalyzerOutput, UserOverview, PeriodsSummary, SinglePeriodStats, PeriodContent, PeriodContentChunk, ContentTopic, ContentReply, ActivePeriod, PeriodBoundary, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/analyzer/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Analyzer 模块公共 API
+ *
+ * 用法示例：
+ * ```typescript
+ * import { buildAnalyzerOutput } from '../../core/analyzer';
+ *
+ * const rawData: RawUserData = { profile, topics, replies, isTopicsHidden };
+ * const output = buildAnalyzerOutput(rawData);
+ * // output.userOverview - 用户总览
+ * // output.summary - 活跃期统计汇总
+ * // output.contents - 分片后的内容
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnalyzerOutput = void 0;
+// 主入口函数
+var builder_1 = require("./builder");
+Object.defineProperty(exports, "buildAnalyzerOutput", { enumerable: true, get: function () { return builder_1.buildAnalyzerOutput; } });
+//# sourceMappingURL=index.js.map

package/dist/core/analyzer/periods/detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 活跃期检测器
+ * 通过检测暂停期（>60天无活动）将用户活动分割为多个活跃期
+ */
+import type { PeriodBoundary } from '../types';
+interface Activity {
+    date: Date;
+}
+/**
+ * 检测活跃期边界
+ * @param activities 按时间升序排列的活动列表
+ * @param thresholdDays 暂停期阈值（天），默认 60
+ * @returns 活跃期边界列表
+ */
+export declare function detectPeriodBoundaries(activities: Activity[], thresholdDays?: number): PeriodBoundary[];
+export {};
+//# sourceMappingURL=detector.d.ts.map

package/dist/core/analyzer/periods/detector.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * 活跃期检测器
+ * 通过检测暂停期（>60天无活动）将用户活动分割为多个活跃期
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPeriodBoundaries = detectPeriodBoundaries;
+const config_1 = require("../../../config");
+/**
+ * 检测活跃期边界
+ * @param activities 按时间升序排列的活动列表
+ * @param thresholdDays 暂停期阈值（天），默认 60
+ * @returns 活跃期边界列表
+ */
+function detectPeriodBoundaries(activities, thresholdDays = (0, config_1.getConfig)().analyzer?.inactivityThreshold ?? 60) {
+    if (activities.length === 0)
+        return [];
+    const thresholdMs = thresholdDays * 24 * 60 * 60 * 1000;
+    const periods = [];
+    let periodStart = activities[0].date;
+    let lastActivity = activities[0].date;
+    for (let i = 1; i < activities.length; i++) {
+        const current = activities[i].date;
+        const gap = current.getTime() - lastActivity.getTime();
+        if (gap > thresholdMs) {
+            // 间隔超过阈值，结束当前活跃期并开启新的
+            periods.push({ startDate: periodStart, endDate: lastActivity });
+            periodStart = current;
+        }
+        lastActivity = current;
+    }
+    // 结束最后一个活跃期
+    periods.push({ startDate: periodStart, endDate: lastActivity });
+    return periods;
+}
+//# sourceMappingURL=detector.js.map

package/dist/core/analyzer/periods/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Periods 入口
+ */
+export { detectPeriodBoundaries } from './detector';
+export { splitByPeriods } from './splitter';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/analyzer/periods/index.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Periods 入口
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitByPeriods = exports.detectPeriodBoundaries = void 0;
+var detector_1 = require("./detector");
+Object.defineProperty(exports, "detectPeriodBoundaries", { enumerable: true, get: function () { return detector_1.detectPeriodBoundaries; } });
+var splitter_1 = require("./splitter");
+Object.defineProperty(exports, "splitByPeriods", { enumerable: true, get: function () { return splitter_1.splitByPeriods; } });
+//# sourceMappingURL=index.js.map

package/dist/core/analyzer/periods/splitter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 数据分割器
+ * 将帖子和回复分配到对应的活跃期
+ */
+import type { V2exReply, V2exTopicDetail } from '../../../core/v2ex/types/entities';
+import type { ActivePeriod, PeriodBoundary } from '../types';
+/**
+ * 将帖子和回复分配到各活跃期
+ */
+export declare function splitByPeriods(boundaries: PeriodBoundary[], topics: V2exTopicDetail[], replies: V2exReply[], referenceDate?: Date): ActivePeriod[];
+//# sourceMappingURL=splitter.d.ts.map

package/dist/core/analyzer/periods/splitter.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * 数据分割器
+ * 将帖子和回复分配到对应的活跃期
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitByPeriods = splitByPeriods;
+const utils_1 = require("../utils");
+/**
+ * 将帖子和回复分配到各活跃期
+ */
+function splitByPeriods(boundaries, topics, replies, referenceDate = new Date()) {
+    return boundaries.map((boundary, index) => {
+        const periodTopics = topics.filter((topic) => {
+            const parsed = (0, utils_1.parseAbsoluteDate)(topic.createdAt);
+            if (!parsed)
+                return false;
+            return parsed.date >= boundary.startDate && parsed.date <= boundary.endDate;
+        });
+        const periodReplies = replies.filter((reply) => {
+            const parsed = (0, utils_1.parseRelativeTime)(reply.replyTime, referenceDate);
+            if (!parsed)
+                return false;
+            return parsed.date >= boundary.startDate && parsed.date <= boundary.endDate;
+        });
+        return {
+            index,
+            startDate: boundary.startDate,
+            endDate: boundary.endDate,
+            topics: periodTopics,
+            replies: periodReplies,
+        };
+    });
+}
+//# sourceMappingURL=splitter.js.map

package/dist/core/analyzer/stats/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Stats 入口
+ */
+export { calculateUserOverview } from './user-overview';
+export { calculateTopicStats } from './topic-stats';
+export { calculateReplyStats } from './reply-stats';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/analyzer/stats/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Stats 入口
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateReplyStats = exports.calculateTopicStats = exports.calculateUserOverview = void 0;
+var user_overview_1 = require("./user-overview");
+Object.defineProperty(exports, "calculateUserOverview", { enumerable: true, get: function () { return user_overview_1.calculateUserOverview; } });
+var topic_stats_1 = require("./topic-stats");
+Object.defineProperty(exports, "calculateTopicStats", { enumerable: true, get: function () { return topic_stats_1.calculateTopicStats; } });
+var reply_stats_1 = require("./reply-stats");
+Object.defineProperty(exports, "calculateReplyStats", { enumerable: true, get: function () { return reply_stats_1.calculateReplyStats; } });
+//# sourceMappingURL=index.js.map

package/dist/core/analyzer/stats/reply-stats.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 回复统计计算
+ */
+import type { V2exReply } from '../../../core/v2ex/types/entities';
+import type { SinglePeriodStats } from '../types';
+interface ReplyStatsInput {
+    replies: V2exReply[];
+    referenceDate?: Date;
+}
+/**
+ * 计算回复相关统计
+ */
+export declare function calculateReplyStats(input: ReplyStatsInput): Pick<SinglePeriodStats, 'replyCount' | 'avgReplyLength' | 'directReplyRatio' | 'avgRepliedTopicHeat' | 'replyWeekdayDistribution' | 'replyNodeDistribution'>;
+export {};
+//# sourceMappingURL=reply-stats.d.ts.map

package/dist/core/analyzer/stats/reply-stats.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * 回复统计计算
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateReplyStats = calculateReplyStats;
+const config_1 = require("../../../config");
+const utils_1 = require("../utils");
+/**
+ * 计算回复相关统计
+ */
+function calculateReplyStats(input) {
+    const { replies, referenceDate = new Date() } = input;
+    if (replies.length === 0) {
+        return {
+            replyCount: 0,
+            avgReplyLength: 0,
+            directReplyRatio: 0,
+            avgRepliedTopicHeat: 0,
+            replyWeekdayDistribution: null,
+            replyNodeDistribution: {},
+        };
+    }
+    // 计算平均长度
+    const lengths = replies.map((r) => r.content.length);
+    // 计算直接回复率
+    const directReplies = replies.filter((r) => r.isDirectReply).length;
+    // 计算参与话题热度
+    const topicHeats = replies.map((r) => r.topicReplyCount);
+    // 计算星期分布
+    const replyDates = replies
+        .map((r) => (0, utils_1.parseRelativeTime)(r.replyTime, referenceDate)?.date)
+        .filter((d) => d !== undefined);
+    // 只有足够的解析成功才计算星期分布
+    const weekdayDist = replyDates.length >= replies.length * 0.5 ? (0, utils_1.weekdayDistribution)(replyDates) : null;
+    return {
+        replyCount: replies.length,
+        avgReplyLength: (0, utils_1.average)(lengths),
+        directReplyRatio: directReplies / replies.length,
+        avgRepliedTopicHeat: (0, utils_1.average)(topicHeats),
+        replyWeekdayDistribution: weekdayDist,
+        replyNodeDistribution: (0, utils_1.topN)(replies, (r) => r.nodeName, (0, config_1.getConfig)().analyzer?.nodeDistributionTopN ?? 3),
+    };
+}
+//# sourceMappingURL=reply-stats.js.map

package/dist/core/analyzer/stats/topic-stats.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 帖子统计计算
+ */
+import type { V2exTopicDetail } from '../../../core/v2ex/types/entities';
+import type { SinglePeriodStats } from '../types';
+interface TopicStatsInput {
+    topics: V2exTopicDetail[];
+    startDate: Date;
+    endDate: Date;
+}
+/**
+ * 计算帖子相关统计
+ */
+export declare function calculateTopicStats(input: TopicStatsInput): Pick<SinglePeriodStats, 'timeRange' | 'topicCount' | 'avgTopicReplyCount' | 'avgTopicClickCount' | 'avgTopicLifecycleDays' | 'topicInteractionRatio' | 'topicHourDistribution' | 'topicNodeDistribution'>;
+export {};
+//# sourceMappingURL=topic-stats.d.ts.map

package/dist/core/analyzer/stats/topic-stats.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * 帖子统计计算
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTopicStats = calculateTopicStats;
+const config_1 = require("../../../config");
+const utils_1 = require("../utils");
+/**
+ * 计算帖子相关统计
+ */
+function calculateTopicStats(input) {
+    const { topics, startDate, endDate } = input;
+    const replyCounts = topics.map((t) => t.replyCount);
+    const clickCounts = topics.map((t) => t.clickCount);
+    // 计算帖子生命周期
+    const lifecycleDays = topics
+        .map((t) => calculateLifecycleDays(t))
+        .filter((d) => d !== null);
+    // 计算小时分布
+    const topicDates = topics
+        .map((t) => (0, utils_1.parseAbsoluteDate)(t.createdAt)?.date)
+        .filter((d) => d !== undefined);
+    // 计算互动率
+    const totalReplies = replyCounts.reduce((a, b) => a + b, 0);
+    const totalClicks = clickCounts.reduce((a, b) => a + b, 0);
+    return {
+        timeRange: (0, utils_1.formatTimeRange)(startDate, endDate),
+        topicCount: topics.length,
+        avgTopicReplyCount: (0, utils_1.average)(replyCounts),
+        avgTopicClickCount: (0, utils_1.average)(clickCounts),
+        avgTopicLifecycleDays: (0, utils_1.average)(lifecycleDays),
+        topicInteractionRatio: totalClicks > 0 ? totalReplies / totalClicks : 0,
+        topicHourDistribution: (0, utils_1.hourDistribution)(topicDates),
+        topicNodeDistribution: (0, utils_1.topN)(topics, (t) => t.nodeName, (0, config_1.getConfig)().analyzer?.nodeDistributionTopN ?? 3),
+    };
+}
+/**
+ * 计算帖子生命周期（天）
+ */
+function calculateLifecycleDays(topic) {
+    if (!topic.lastReplyTime)
+        return null;
+    const created = (0, utils_1.parseAbsoluteDate)(topic.createdAt);
+    const lastReply = (0, utils_1.parseAbsoluteDate)(topic.lastReplyTime);
+    if (!created || !lastReply)
+        return null;
+    const diffMs = lastReply.date.getTime() - created.date.getTime();
+    return diffMs / (1000 * 60 * 60 * 24);
+}
+//# sourceMappingURL=topic-stats.js.map

package/dist/core/analyzer/stats/user-overview.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 用户总览计算
+ */
+import type { RawUserData, UserOverview } from '../types';
+/**
+ * 计算用户总览
+ */
+export declare function calculateUserOverview(data: RawUserData, referenceDate?: Date): UserOverview;
+//# sourceMappingURL=user-overview.d.ts.map

package/dist/core/analyzer/stats/user-overview.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * 用户总览计算
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateUserOverview = calculateUserOverview;
+const utils_1 = require("../utils");
+/**
+ * 计算用户总览
+ */
+function calculateUserOverview(data, referenceDate = new Date()) {
+    const { profile, topics, replies, isTopicsHidden } = data;
+    // 计算最后活动时间
+    const lastActiveTime = getLastActiveTime(topics, replies, referenceDate);
+    // 计算发帖/回复比率，无回复时为 null
+    const topicReplyRatio = replies.length > 0 ? topics.length / replies.length : null;
+    return {
+        joinDate: profile.joinDate,
+        lastActiveTime,
+        topicReplyRatio,
+        totalTopics: isTopicsHidden ? null : topics.length,
+        totalReplies: replies.length,
+        isTopicsHidden,
+        dailyRanking: profile.dailyRanking,
+    };
+}
+/**
+ * 获取最后活动时间
+ */
+function getLastActiveTime(topics, replies, referenceDate) {
+    let lastDate = null;
+    // 检查帖子的最后时间
+    for (const topic of topics) {
+        const parsed = (0, utils_1.parseAbsoluteDate)(topic.createdAt);
+        if (parsed && (!lastDate || parsed.date > lastDate)) {
+            lastDate = parsed.date;
+        }
+    }
+    // 检查回复的最后时间
+    for (const reply of replies) {
+        const parsed = (0, utils_1.parseRelativeTime)(reply.replyTime, referenceDate);
+        if (parsed && (!lastDate || parsed.date > lastDate)) {
+            lastDate = parsed.date;
+        }
+    }
+    if (!lastDate) {
+        return 'unknown';
+    }
+    // 格式化为 ISO 字符串
+    return lastDate.toISOString();
+}
+//# sourceMappingURL=user-overview.js.map