wechaty-web-panel 1.6.112 → 1.6.113

package/dist/mcp/src/services/McpTools.js

@@ -0,0 +1,504 @@
+import McpService from './McpService.js';
+import { Friend, Group, GroupMember, ChatMessage } from '../models/index.js';
+import { Op } from 'sequelize';
+/**
+ * MCP 工具集 - 提供便捷的查询和分析工具
+ */
+class McpTools {
+    constructor() {
+        this.mcpService = new McpService();
+    }
+    /**
+     * 快速查找工具 - 根据部分信息快速定位用户
+     * @param {Object} params - 查询参数
+     * @returns {Promise<Object>} 查找结果
+     */
+    async quickFind(params = {}) {
+        const { robotId, query, type = 'auto' } = params;
+        if (!query) {
+            throw new Error('查询内容不能为空');
+        }
+        const results = {
+            friends: [],
+            groups: [],
+            members: [],
+            exactMatch: null
+        };
+        try {
+            // 自动检测查询类型
+            const isWxId = query.includes('@') || query.startsWith('wxid_');
+            const isGroupId = query.includes('@@') || query.includes('chatroom');
+            if (type === 'auto' || type === 'friend') {
+                // 搜索好友
+                const friendSearchParams = {
+                    robotId,
+                    keyword: query,
+                    limit: 10
+                };
+                const friendResults = await this.mcpService.searchFriends(friendSearchParams);
+                results.friends = friendResults.data;
+                // 精确匹配检查
+                if (isWxId) {
+                    const exactFriend = await Friend.findOne({
+                        where: { robotId, wxid: query }
+                    });
+                    if (exactFriend)
+                        results.exactMatch = { type: 'friend', data: exactFriend };
+                }
+            }
+            if (type === 'auto' || type === 'group') {
+                // 搜索群组
+                const groupSearchParams = {
+                    robotId,
+                    keyword: query,
+                    includeMembers: true,
+                    limit: 10
+                };
+                const groupResults = await this.mcpService.searchGroups(groupSearchParams);
+                results.groups = groupResults.data;
+                // 精确匹配检查
+                if (isGroupId) {
+                    const exactGroup = await Group.findOne({
+                        where: { robotId, wxid: query }
+                    });
+                    if (exactGroup)
+                        results.exactMatch = { type: 'group', data: exactGroup };
+                }
+            }
+            if (type === 'auto' || type === 'member') {
+                // 搜索群成员
+                const whereClause = { robotId };
+                if (query) {
+                    whereClause[Op.or] = [
+                        { name: { [Op.iLike]: `%${query}%` } },
+                        { alias: { [Op.iLike]: `%${query}%` } },
+                        { remark: { [Op.iLike]: `%${query}%` } },
+                        { wxid: query }
+                    ];
+                }
+                const members = await GroupMember.findAll({
+                    where: whereClause,
+                    limit: 10,
+                    include: [{
+                            model: Group,
+                            as: 'group',
+                            attributes: ['name', 'wxid']
+                        }]
+                });
+                results.members = members;
+            }
+            return {
+                query,
+                type,
+                results,
+                summary: {
+                    totalFound: results.friends.length + results.groups.length + results.members.length,
+                    hasExactMatch: !!results.exactMatch
+                }
+            };
+        }
+        catch (error) {
+            console.error('❌ 快速查找失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 关系分析工具 - 分析用户间的关系
+     * @param {Object} params - 分析参数
+     * @returns {Promise<Object>} 关系分析结果
+     */
+    async analyzeRelationships(params = {}) {
+        const { robotId, userId, analysisType = 'comprehensive' } = params;
+        if (!robotId || !userId) {
+            throw new Error('robotId 和 userId 是必需参数');
+        }
+        try {
+            const result = {
+                userId,
+                relationships: {
+                    directFriend: null,
+                    commonGroups: [],
+                    mutualFriends: [],
+                    conversationHistory: null
+                }
+            };
+            // 检查是否为直接好友
+            const directFriend = await Friend.findOne({
+                where: { robotId, wxid: userId }
+            });
+            result.relationships.directFriend = directFriend;
+            // 查找共同群组
+            const userGroups = await GroupMember.findAll({
+                where: { robotId, wxid: userId },
+                include: [{
+                        model: Group,
+                        as: 'group'
+                    }]
+            });
+            result.relationships.commonGroups = userGroups.map(membership => ({
+                group: membership.group,
+                memberInfo: {
+                    name: membership.name,
+                    alias: membership.alias,
+                    remark: membership.remark
+                }
+            }));
+            // 分析会话历史
+            const conversationStats = await this.mcpService.getConversationDetails({
+                robotId,
+                conversationId: userId
+            });
+            if (conversationStats) {
+                result.relationships.conversationHistory = {
+                    totalMessages: conversationStats.statistics.totalMessages,
+                    firstContact: conversationStats.statistics.firstMessageTime,
+                    lastContact: conversationStats.statistics.lastMessageTime,
+                    activityLevel: this._calculateActivityLevel(conversationStats.statistics.totalMessages)
+                };
+            }
+            // 如果需要全面分析，查找共同好友
+            if (analysisType === 'comprehensive' && userGroups.length > 0) {
+                const mutualFriends = await this._findMutualFriends(robotId, userId, userGroups);
+                result.relationships.mutualFriends = mutualFriends;
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('❌ 关系分析失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 活动分析工具 - 分析用户或群组的活动模式
+     * @param {Object} params - 分析参数
+     * @returns {Promise<Object>} 活动分析结果
+     */
+    async analyzeActivity(params = {}) {
+        const { robotId, targetId, targetType = 'auto', // auto, user, group
+        timeRange = 30, // 天数
+        granularity = 'day' } = params;
+        if (!robotId || !targetId) {
+            throw new Error('robotId 和 targetId 是必需参数');
+        }
+        const endTime = Date.now();
+        const startTime = endTime - (timeRange * 24 * 60 * 60 * 1000);
+        try {
+            // 自动检测目标类型
+            let detectedType = targetType;
+            if (targetType === 'auto') {
+                if (targetId.includes('@@') || targetId.includes('chatroom')) {
+                    detectedType = 'group';
+                }
+                else {
+                    detectedType = 'user';
+                }
+            }
+            // 获取活动热力图
+            const heatmapData = await this.mcpService.getMessageHeatmap({
+                robotId,
+                conversationId: targetId,
+                startDate: new Date(startTime),
+                endDate: new Date(endTime),
+                granularity
+            });
+            // 获取详细统计
+            const messageStats = await this.mcpService.searchChatMessages({
+                robotId,
+                conversationId: targetId,
+                startTime,
+                endTime,
+                limit: 1000
+            });
+            // 计算活动指标
+            const metrics = this._calculateActivityMetrics(messageStats.data);
+            // 活动模式分析
+            const patterns = this._analyzeActivityPatterns(heatmapData);
+            return {
+                targetId,
+                targetType: detectedType,
+                timeRange: {
+                    startTime: new Date(startTime),
+                    endTime: new Date(endTime),
+                    days: timeRange
+                },
+                metrics,
+                patterns,
+                heatmapData,
+                summary: {
+                    totalMessages: messageStats.total,
+                    averagePerDay: Math.round(messageStats.total / timeRange),
+                    peakActivity: patterns.peakPeriod,
+                    activityLevel: metrics.activityLevel
+                }
+            };
+        }
+        catch (error) {
+            console.error('❌ 活动分析失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 内容分析工具 - 分析消息内容和类型
+     * @param {Object} params - 分析参数
+     * @returns {Promise<Object>} 内容分析结果
+     */
+    async analyzeContent(params = {}) {
+        const { robotId, conversationId, timeRange = 30, analysisTypes = ['contentType', 'keywords', 'sentiment'] } = params;
+        const endTime = Date.now();
+        const startTime = endTime - (timeRange * 24 * 60 * 60 * 1000);
+        try {
+            const messages = await this.mcpService.searchChatMessages({
+                robotId,
+                conversationId,
+                startTime,
+                endTime,
+                limit: 5000
+            });
+            const analysis = {
+                totalMessages: messages.total,
+                timeRange: { startTime, endTime, days: timeRange },
+                analysis: {}
+            };
+            // 内容类型分析
+            if (analysisTypes.includes('contentType')) {
+                analysis.analysis.contentTypes = this._analyzeContentTypes(messages.data);
+            }
+            // 关键词分析
+            if (analysisTypes.includes('keywords')) {
+                analysis.analysis.keywords = this._extractKeywords(messages.data);
+            }
+            // 情感分析（简单的基于关键词的方法）
+            if (analysisTypes.includes('sentiment')) {
+                analysis.analysis.sentiment = this._analyzeSentiment(messages.data);
+            }
+            // 活跃用户分析
+            analysis.analysis.activeUsers = this._analyzeActiveUsers(messages.data);
+            return analysis;
+        }
+        catch (error) {
+            console.error('❌ 内容分析失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 导出数据工具 - 导出指定格式的数据
+     * @param {Object} params - 导出参数
+     * @returns {Promise<Object>} 导出结果
+     */
+    async exportData(params = {}) {
+        const { robotId, exportType = 'messages', // messages, friends, groups, statistics
+        conversationId, format = 'json', // json, csv, txt
+        timeRange = 30, includeMetadata = true } = params;
+        try {
+            let data = null;
+            let metadata = {};
+            switch (exportType) {
+                case 'messages':
+                    const endTime = Date.now();
+                    const startTime = endTime - (timeRange * 24 * 60 * 60 * 1000);
+                    const messages = await this.mcpService.searchChatMessages({
+                        robotId,
+                        conversationId,
+                        startTime,
+                        endTime,
+                        limit: 10000
+                    });
+                    data = messages.data;
+                    metadata = {
+                        totalMessages: messages.total,
+                        timeRange: { startTime, endTime },
+                        conversationId
+                    };
+                    break;
+                case 'friends':
+                    const friends = await this.mcpService.searchFriends({
+                        robotId,
+                        limit: 10000
+                    });
+                    data = friends.data;
+                    metadata = { totalFriends: friends.total };
+                    break;
+                case 'groups':
+                    const groups = await this.mcpService.searchGroups({
+                        robotId,
+                        includeMembers: true,
+                        limit: 10000
+                    });
+                    data = groups.data;
+                    metadata = { totalGroups: groups.total };
+                    break;
+                case 'statistics':
+                    data = await this.mcpService.getRobotStatistics(robotId);
+                    metadata = { generatedAt: new Date() };
+                    break;
+                default:
+                    throw new Error(`不支持的导出类型: ${exportType}`);
+            }
+            // 格式化数据
+            const formattedData = this._formatExportData(data, format, includeMetadata ? metadata : null);
+            return {
+                exportType,
+                format,
+                recordCount: Array.isArray(data) ? data.length : 1,
+                generatedAt: new Date(),
+                data: formattedData
+            };
+        }
+        catch (error) {
+            console.error('❌ 数据导出失败:', error);
+            throw error;
+        }
+    }
+    // 私有辅助方法
+    _calculateActivityLevel(messageCount) {
+        if (messageCount === 0)
+            return 'inactive';
+        if (messageCount < 10)
+            return 'low';
+        if (messageCount < 100)
+            return 'medium';
+        if (messageCount < 1000)
+            return 'high';
+        return 'very_high';
+    }
+    async _findMutualFriends(robotId, userId, userGroups) {
+        // 实现查找共同好友的逻辑
+        const groupIds = userGroups.map(g => g.roomWxid);
+        const mutualMembers = await GroupMember.findAll({
+            where: {
+                robotId,
+                roomWxid: { [Op.in]: groupIds },
+                wxid: { [Op.ne]: userId }
+            },
+            include: [{
+                    model: Group,
+                    as: 'group',
+                    attributes: ['name', 'wxid']
+                }]
+        });
+        return mutualMembers.slice(0, 20); // 限制返回数量
+    }
+    _calculateActivityMetrics(messages) {
+        if (!messages || messages.length === 0) {
+            return { activityLevel: 'inactive', averageLength: 0, responseTime: null };
+        }
+        const totalLength = messages.reduce((sum, msg) => sum + (msg.content?.length || 0), 0);
+        const averageLength = Math.round(totalLength / messages.length);
+        return {
+            activityLevel: this._calculateActivityLevel(messages.length),
+            averageLength,
+            messageFrequency: messages.length,
+            contentTypes: [...new Set(messages.map(m => m.contentType))]
+        };
+    }
+    _analyzeActivityPatterns(heatmapData) {
+        if (!heatmapData || heatmapData.length === 0) {
+            return { peakPeriod: null, quietPeriod: null, pattern: 'unknown' };
+        }
+        const sorted = [...heatmapData].sort((a, b) => b.messageCount - a.messageCount);
+        return {
+            peakPeriod: sorted[0],
+            quietPeriod: sorted[sorted.length - 1],
+            pattern: this._identifyPattern(heatmapData)
+        };
+    }
+    _identifyPattern(heatmapData) {
+        // 简单的模式识别逻辑
+        return 'regular'; // 可以扩展为更复杂的模式识别
+    }
+    _analyzeContentTypes(messages) {
+        const typeCount = {};
+        messages.forEach(msg => {
+            const type = msg.contentType || '文字';
+            typeCount[type] = (typeCount[type] || 0) + 1;
+        });
+        return Object.entries(typeCount)
+            .map(([type, count]) => ({ type, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    _extractKeywords(messages) {
+        // 简单的关键词提取
+        const words = {};
+        messages.forEach(msg => {
+            if (msg.content && msg.contentType === '文字') {
+                const content = msg.content.toLowerCase();
+                const wordsArray = content.match(/[\u4e00-\u9fa5]+/g) || [];
+                wordsArray.forEach(word => {
+                    if (word.length > 1) {
+                        words[word] = (words[word] || 0) + 1;
+                    }
+                });
+            }
+        });
+        return Object.entries(words)
+            .map(([word, count]) => ({ word, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 20);
+    }
+    _analyzeSentiment(messages) {
+        // 简单的情感分析
+        const positiveWords = ['好', '棒', '赞', '喜欢', '开心', '高兴', '满意'];
+        const negativeWords = ['不好', '差', '不满', '生气', '难过', '失望'];
+        let positive = 0, negative = 0, neutral = 0;
+        messages.forEach(msg => {
+            if (msg.content && msg.contentType === '文字') {
+                const content = msg.content.toLowerCase();
+                const hasPositive = positiveWords.some(word => content.includes(word));
+                const hasNegative = negativeWords.some(word => content.includes(word));
+                if (hasPositive && !hasNegative)
+                    positive++;
+                else if (hasNegative && !hasPositive)
+                    negative++;
+                else
+                    neutral++;
+            }
+        });
+        const total = positive + negative + neutral;
+        return {
+            positive: { count: positive, percentage: total ? Math.round(positive / total * 100) : 0 },
+            negative: { count: negative, percentage: total ? Math.round(negative / total * 100) : 0 },
+            neutral: { count: neutral, percentage: total ? Math.round(neutral / total * 100) : 0 }
+        };
+    }
+    _analyzeActiveUsers(messages) {
+        const userStats = {};
+        messages.forEach(msg => {
+            const userId = msg.chatUserId;
+            if (!userStats[userId]) {
+                userStats[userId] = {
+                    userId,
+                    userName: msg.chatUserName,
+                    messageCount: 0,
+                    lastActive: 0
+                };
+            }
+            userStats[userId].messageCount++;
+            userStats[userId].lastActive = Math.max(userStats[userId].lastActive, msg.timestamp);
+        });
+        return Object.values(userStats)
+            .sort((a, b) => b.messageCount - a.messageCount)
+            .slice(0, 10);
+    }
+    _formatExportData(data, format, metadata) {
+        switch (format) {
+            case 'json':
+                return metadata ? { metadata, data } : data;
+            case 'csv':
+                if (Array.isArray(data) && data.length > 0) {
+                    const headers = Object.keys(data[0]).join(',');
+                    const rows = data.map(item => Object.values(item).map(val => typeof val === 'string' ? `"${val.replace(/"/g, '""')}"` : val).join(','));
+                    return [headers, ...rows].join('\n');
+                }
+                return '';
+            case 'txt':
+                if (Array.isArray(data)) {
+                    return data.map(item => JSON.stringify(item)).join('\n');
+                }
+                return JSON.stringify(data, null, 2);
+            default:
+                return data;
+        }
+    }
+}
+export default McpTools;
+//# sourceMappingURL=McpTools.js.map