sloth-d2c-mcp 1.0.4-beta100

package/dist/build/utils/image-matcher.js

@@ -0,0 +1,154 @@
+import Jimp from 'jimp';
+import { getCV } from './opencv-loader.js';
+import { Logger } from './logger.js';
+export class ImageMatcher {
+    /**
+     * 使用 OpenCV 模板匹配在大图中查找小图
+     * @param haystackPath 大图路径（当前设计稿）
+     * @param needlePath 小图路径（历史截图）
+     * @param threshold 匹配阈值 (0-1)
+     */
+    async findMatch(haystackPath, needlePath, threshold = 0.8) {
+        try {
+            const startTime = Date.now();
+            Logger.log(`开始 OpenCV 模板匹配: ${needlePath}`);
+            // 获取 OpenCV 实例
+            const cv = getCV();
+            // 使用 Jimp 读取图片
+            const haystackImg = await Jimp.read(haystackPath);
+            const needleImg = await Jimp.read(needlePath);
+            Logger.log(`大图尺寸: ${haystackImg.bitmap.width}x${haystackImg.bitmap.height}`);
+            Logger.log(`小图尺寸: ${needleImg.bitmap.width}x${needleImg.bitmap.height}`);
+            // 转换为 OpenCV Mat
+            const haystack = this.jimpToMat(haystackImg, cv);
+            const needle = this.jimpToMat(needleImg, cv);
+            // 创建结果矩阵
+            const result = new cv.Mat();
+            const mask = new cv.Mat();
+            // 执行模板匹配
+            // TM_CCOEFF_NORMED: 归一化相关系数匹配，返回值 -1 到 1
+            cv.matchTemplate(haystack, needle, result, cv.TM_CCOEFF_NORMED, mask);
+            // 找到最佳匹配位置
+            const minMax = cv.minMaxLoc(result);
+            const maxVal = minMax.maxVal; // 最大相似度（-1 到 1）
+            const maxLoc = minMax.maxLoc; // 最佳匹配位置
+            const elapsedTime = Date.now() - startTime;
+            Logger.log(`OpenCV 匹配完成，耗时: ${elapsedTime}ms，最大相似度: ${maxVal.toFixed(4)}`);
+            // 清理内存
+            haystack.delete();
+            needle.delete();
+            result.delete();
+            mask.delete();
+            // 判断是否满足阈值
+            if (maxVal >= threshold) {
+                return {
+                    matched: true,
+                    confidence: maxVal,
+                    position: {
+                        left: maxLoc.x,
+                        top: maxLoc.y,
+                        width: needleImg.bitmap.width,
+                        height: needleImg.bitmap.height,
+                    },
+                };
+            }
+            Logger.log(`匹配失败，相似度 ${maxVal.toFixed(4)} 低于阈值 ${threshold}`);
+            return null;
+        }
+        catch (error) {
+            Logger.error('OpenCV 图像匹配失败:', error);
+            return null;
+        }
+    }
+    /**
+     * 将 Jimp 图像转换为 OpenCV Mat
+     */
+    jimpToMat(jimpImg, cv) {
+        const { width, height, data } = jimpImg.bitmap;
+        // 创建 Mat (RGBA 格式)
+        const mat = new cv.Mat(height, width, cv.CV_8UC4);
+        // 复制像素数据
+        mat.data.set(data);
+        // 转换为 RGB（模板匹配只需要 RGB，去掉 Alpha 通道）
+        const rgbMat = new cv.Mat();
+        cv.cvtColor(mat, rgbMat, cv.COLOR_RGBA2RGB);
+        mat.delete();
+        return rgbMat;
+    }
+    /**
+     * 使用多尺度模板匹配（处理截图可能有缩放的情况）
+     * @param haystackPath 大图路径
+     * @param needlePath 小图路径
+     * @param threshold 匹配阈值
+     * @param scales 尝试的缩放比例列表
+     */
+    async findMatchMultiScale(haystackPath, needlePath, threshold = 0.8, scales = [1.0, 0.95, 1.05, 0.9, 1.1]) {
+        Logger.log(`开始多尺度匹配，尝试 ${scales.length} 个缩放比例`);
+        let bestMatch = null;
+        for (const scale of scales) {
+            try {
+                // 读取并缩放模板图片
+                const needleImg = await Jimp.read(needlePath);
+                if (scale !== 1.0) {
+                    needleImg.scale(scale);
+                    Logger.log(`尝试缩放比例: ${scale}`);
+                }
+                // 保存临时缩放图片
+                const fs = await import('fs/promises');
+                const path = await import('path');
+                const tempPath = needlePath.replace('.png', `_scale${scale}.png`);
+                await needleImg.writeAsync(tempPath);
+                // 执行匹配
+                const result = await this.findMatch(haystackPath, tempPath, threshold);
+                // 清理临时文件
+                await fs.unlink(tempPath).catch(() => { });
+                if (result && (!bestMatch || result.confidence > bestMatch.confidence)) {
+                    // 调整位置和尺寸（补偿缩放）
+                    result.position.width = Math.round(result.position.width / scale);
+                    result.position.height = Math.round(result.position.height / scale);
+                    bestMatch = result;
+                    Logger.log(`找到更好的匹配，缩放比例: ${scale}，置信度: ${result.confidence.toFixed(4)}`);
+                }
+                // 如果找到完美匹配，提前退出
+                if (result && result.confidence >= 0.95) {
+                    Logger.log('找到完美匹配，提前退出多尺度搜索');
+                    break;
+                }
+            }
+            catch (error) {
+                Logger.error(`缩放比例 ${scale} 匹配失败:`, error);
+                continue;
+            }
+        }
+        if (bestMatch) {
+            Logger.log(`多尺度匹配完成，最佳置信度: ${bestMatch.confidence.toFixed(4)}`);
+        }
+        else {
+            Logger.log('多尺度匹配未找到符合要求的结果');
+        }
+        return bestMatch;
+    }
+    /**
+     * 批量匹配多个历史截图
+     */
+    async batchMatch(haystackPath, needlePaths, threshold = 0.8) {
+        Logger.log(`开始批量匹配 ${needlePaths.length} 个历史截图`);
+        const matches = [];
+        for (const { path, groupData } of needlePaths) {
+            try {
+                const result = await this.findMatch(haystackPath, path, threshold);
+                if (result && result.matched) {
+                    result.groupData = groupData;
+                    matches.push(result);
+                    Logger.log(`匹配成功: ${groupData.componentMapping?.name || 'Unknown'}`);
+                }
+            }
+            catch (error) {
+                Logger.error(`批量匹配失败 (${path}):`, error);
+                continue;
+            }
+        }
+        Logger.log(`批量匹配完成，找到 ${matches.length} 个匹配`);
+        return matches;
+    }
+}

package/dist/build/utils/logger.js

@@ -0,0 +1,90 @@
+import { VSCodeLogger } from './vscode-logger.js';
+// 日志工具类，带时间戳输出日志，同时发送到 VSCode
+export class Logger {
+    static vscodeLogger = null;
+    static vscodeLoggerInitialized = false;
+    static log(...args) {
+        const timestamp = new Date().toISOString();
+        console.log(`[${timestamp}]`, ...args);
+        // fs.writeFileSync('log.txt', `[${timestamp}] ${args.join(' ')}\n`, { flag: 'a' });
+        // 同时发送到 VSCode
+        this.tryVSCodeLog('log', ...args);
+    }
+    static error(...args) {
+        const timestamp = new Date().toISOString();
+        console.error(`[${timestamp}]`, ...args);
+        // 同时发送到 VSCode
+        this.tryVSCodeLog('error', ...args);
+    }
+    static warn(...args) {
+        const timestamp = new Date().toISOString();
+        console.warn(`[${timestamp}]`, ...args);
+        // 同时发送到 VSCode
+        this.tryVSCodeLog('warn', ...args);
+    }
+    static info(...args) {
+        const timestamp = new Date().toISOString();
+        console.info(`[${timestamp}]`, ...args);
+        // 同时发送到 VSCode
+        this.tryVSCodeLog('info', ...args);
+    }
+    // 初始化 VSCode 日志服务
+    static initVSCodeLogger() {
+        if (this.vscodeLoggerInitialized)
+            return;
+        try {
+            this.vscodeLogger = VSCodeLogger.getInstance();
+            this.vscodeLoggerInitialized = true;
+            console.log(`[${new Date().toISOString()}] VSCode 日志服务初始化成功`);
+        }
+        catch (error) {
+            this.vscodeLogger = null;
+            this.vscodeLoggerInitialized = true;
+            console.warn(`[${new Date().toISOString()}] VSCode 日志服务初始化失败，将仅使用控制台日志:`, error);
+        }
+    }
+    // 尝试发送日志到 VSCode
+    static tryVSCodeLog(level, ...args) {
+        if (!this.vscodeLoggerInitialized) {
+            this.initVSCodeLogger();
+        }
+        if (this.vscodeLogger) {
+            try {
+                this.vscodeLogger[level](...args);
+            }
+            catch (error) {
+                // 静默忽略 VSCode 日志发送错误，避免影响主要功能
+                // 只在第一次失败时输出警告
+                if (this.vscodeLogger !== null) {
+                    console.warn(`[${new Date().toISOString()}] VSCode 日志服务连接中断，切换到仅控制台模式`);
+                    this.vscodeLogger = null;
+                }
+            }
+        }
+    }
+    // 重连 VSCode 日志
+    static reconnectVSCodeLogging() {
+        try {
+            console.log(`[${new Date().toISOString()}] 正在重新连接 VSCode 日志服务...`);
+            this.vscodeLoggerInitialized = false;
+            this.vscodeLogger = null;
+            this.initVSCodeLogger();
+            this.log('VSCode 日志服务重连完成');
+        }
+        catch (error) {
+            this.error('VSCode 日志服务重连失败:', error);
+        }
+    }
+    // 清理资源
+    static cleanup() {
+        try {
+            if (this.vscodeLogger) {
+                this.vscodeLogger.destroy();
+                this.vscodeLogger = null;
+            }
+        }
+        catch (error) {
+            // 忽略清理错误
+        }
+    }
+}

package/dist/build/utils/opencv-loader.js

@@ -0,0 +1,70 @@
+import { Logger } from './logger.js';
+let cv = null;
+let isOpencvReady = false;
+/**
+ * 初始化 OpenCV.js
+ */
+export async function initOpenCV() {
+    if (isOpencvReady && cv) {
+        Logger.log('OpenCV.js 已经初始化');
+        return;
+    }
+    try {
+        Logger.log('开始初始化 OpenCV.js...');
+        // 动态导入 OpenCV.js
+        const opencvModule = await import('@techstark/opencv-js');
+        cv = opencvModule.default || opencvModule;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('OpenCV.js 初始化超时（30秒）'));
+            }, 30000);
+            if (cv.getBuildInformation) {
+                // OpenCV 已经加载完成
+                clearTimeout(timeout);
+                isOpencvReady = true;
+                Logger.log('OpenCV.js 已就绪');
+                Logger.log('OpenCV 版本信息:', cv.getBuildInformation());
+                resolve();
+            }
+            else {
+                // 等待 OpenCV 运行时初始化
+                cv.onRuntimeInitialized = () => {
+                    clearTimeout(timeout);
+                    isOpencvReady = true;
+                    Logger.log('OpenCV.js 运行时初始化完成');
+                    if (cv.getBuildInformation) {
+                        Logger.log('OpenCV 版本信息:', cv.getBuildInformation());
+                    }
+                    resolve();
+                };
+            }
+        });
+    }
+    catch (error) {
+        Logger.error('OpenCV.js 初始化失败:', error);
+        throw error;
+    }
+}
+/**
+ * 检查 OpenCV 是否就绪
+ */
+export function isReady() {
+    return isOpencvReady;
+}
+/**
+ * 获取 OpenCV 实例
+ */
+export function getCV() {
+    if (!cv || !isOpencvReady) {
+        throw new Error('OpenCV.js 尚未初始化，请先调用 initOpenCV()');
+    }
+    return cv;
+}
+/**
+ * 清理 OpenCV 资源（如果需要）
+ */
+export function cleanup() {
+    isOpencvReady = false;
+    cv = null;
+    Logger.log('OpenCV.js 资源已清理');
+}

package/dist/build/utils/prompt-parser.js

@@ -0,0 +1,46 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { Logger } from './logger.js';
+/**
+ * 解析提示词中的艾特引用并读取文件内容
+ * @param prompt - 提示词字符串
+ * @param workspaceRoot - 工作目录根路径
+ * @returns 解析后的提示词（包含引用文件的内容）
+ */
+export async function parsePromptWithMentions(prompt, workspaceRoot) {
+    if (!prompt)
+        return prompt;
+    // 匹配 @[filename](filepath) 格式
+    const mentionRegex = /@\[([^\]]+)\]\(([^)]+)\)/g;
+    const matches = Array.from(prompt.matchAll(mentionRegex));
+    if (matches.length === 0)
+        return prompt;
+    // 使用 Map 去重（基于文件路径）
+    const mentionsMap = new Map();
+    for (const match of matches) {
+        const display = match[1];
+        const filePath = match[2];
+        // 如果已经处理过这个文件路径，跳过
+        if (mentionsMap.has(filePath))
+            continue;
+        try {
+            // 读取文件内容
+            const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            mentionsMap.set(filePath, { display, path: filePath, content });
+            Logger.log(`读取艾特引用文件: ${filePath}`);
+        }
+        catch (error) {
+            Logger.warn(`无法读取艾特引用文件 ${filePath}: ${error}`);
+        }
+    }
+    // 如果有引用的文件，在提示词最后拼接文档内容
+    if (mentionsMap.size > 0) {
+        let result = prompt + '\n\n---\n\n**参考文档：**\n\n';
+        mentionsMap.forEach((mention) => {
+            result += `\n### ${mention.display}\n\n${mention.content}\n`;
+        });
+        return result;
+    }
+    return prompt;
+}

package/dist/build/utils/tj.js

@@ -0,0 +1,139 @@
+import * as os from 'os';
+import axios from 'axios';
+import pkg from 'node-machine-id';
+import { Logger } from './logger.js';
+const { machineIdSync } = pkg;
+/*
+ * 统计上报
+ */
+const isOnline = process.env.NODE_ENV === 'production';
+let lastEvent = '';
+/**
+ * 获取设备信息
+ */
+const getDeviceInfo = () => {
+    return {
+        platform: os.platform(), // darwin, win32, linux
+        arch: os.arch(), // x64, arm64
+        osVersion: os.release(),
+        hostname: os.hostname(),
+        nodeVersion: process.version,
+    };
+};
+/**
+ * 获取用户信息（从环境变量或系统）
+ */
+const getUserInfo = () => {
+    // 尝试从环境变量获取
+    const userId = process.env.USER_ID || String(os.userInfo().uid) || os.hostname();
+    const userName = process.env.USER || process.env.LOGNAME || os.userInfo().username;
+    return {
+        id: userId,
+        name: userName,
+    };
+};
+/**
+ * 自定义 beacon 上报
+ */
+const customizebeaconReport = (eventName, params) => {
+    const user = getUserInfo();
+    const device = getDeviceInfo();
+    const machineId = machineIdSync(true);
+    const uniqueKey = `${machineId}/${user.id || 'unknown'}/${user.name || 'anonymous'}`;
+    // 设备标识
+    const deviceIdentifier = `${device.platform || 'Unknown'} ${device.arch || ''} ${device.osVersion || ''} Node${device.nodeVersion || ''}`;
+    axios
+        .post('https://otheve.beacon.qq.com/analytics/v2_upload?appkey=0WEB0IK7H05E5K4S', {
+        appVersion: '',
+        sdkId: 'js',
+        sdkVersion: '4.5.9-web',
+        mainAppKey: '0WEB0IK7H05E5K4S',
+        platformId: 3,
+        common: {
+            bizType: 'd2c_mcp',
+            platCode: '0',
+            utm_source: '',
+            plat: 'tme',
+            abtestName: '',
+            userStatus: '1',
+            accountType: '1',
+            uniqueKey: uniqueKey,
+            A2: '59x14SkHQFdNp6HrSnYmiSWGeT9tBBFY',
+            A8: '',
+            A12: 'zh-CN',
+            A17: '',
+            A23: '',
+            A50: '2846217',
+            A76: '0WEB0IK7H05E5K4S_' + Date.now(),
+            A101: deviceIdentifier, // 设备信息
+            A102: '',
+            A104: '',
+            A119: '',
+            A153: '',
+        },
+        events: [
+            {
+                eventCode: eventName,
+                eventTime: '' + Date.now(),
+                mapValue: {
+                    ...params,
+                    // 附加设备信息
+                    devicePlatform: device.platform,
+                    deviceArch: device.arch,
+                    deviceOsVersion: device.osVersion,
+                    nodeVersion: device.nodeVersion,
+                    A99: 'Y',
+                    A100: '370',
+                    A72: '4.5.9-web',
+                    A88: '1744294371735',
+                },
+            },
+        ],
+    })
+        .then((res) => {
+        Logger.info('Beacon report success:', res);
+    })
+        .catch((err) => {
+        // 静默处理上报错误，避免影响主流程
+        console.error('Beacon report error:', err.message);
+    });
+};
+/**
+ * 向 beacon 服务上报事件
+ */
+const trackEvent = (eventName, params) => {
+    if (!eventName) {
+        return;
+    }
+    try {
+        customizebeaconReport(eventName, {
+            lastEvent,
+            eventCode: eventName,
+            ...params,
+        });
+        lastEvent = eventName;
+    }
+    catch (err) {
+        console.error('Track event error:', err);
+    }
+};
+/**
+ * 上报工具调用事件
+ */
+export const trackToolCall = (toolName, extParam) => {
+    try {
+        if (toolName) {
+            trackEvent('mcp_tool_call', {
+                toolName,
+                ...extParam,
+            });
+        }
+    }
+    catch (err) {
+        console.error('Track tool call error:', err);
+    }
+};
+/**
+ * 导出获取设备信息和用户信息的工具函数
+ */
+export { getDeviceInfo, getUserInfo };

package/dist/build/utils/update.js

@@ -0,0 +1,100 @@
+import { Logger } from './logger.js';
+import { getResourceMapAdvanced } from 'sloth-d2c-node/convert';
+import { replacePathVariables } from './webpack-substitutions.js';
+import { getSystemSupportFileName } from './utils.js';
+import { sha1 } from 'js-sha1';
+/**
+ * 移除 base64 字符串的前缀（如 data:image/png;base64,），只保留纯 base64 数据
+ * @param base64String 带前缀的 base64 字符串
+ * @returns 纯 base64 数据
+ */
+export function removeBase64Prefix(base64String) {
+    if (!base64String)
+        return '';
+    const commaIndex = base64String.indexOf(',');
+    if (commaIndex !== -1) {
+        return base64String.slice(commaIndex + 1);
+    }
+    return base64String;
+}
+/**
+ * 检查imageSetting配置是否有变化，如果有变化则重新生成imageMap
+ * @param currentImageMap 当前的imageMap
+ * @param imageNodeList 图片节点列表
+ * @param oldConfig 旧的配置
+ * @param newConfig 新的配置
+ * @returns Promise<{ imageMap: any, updated: boolean }> - 返回新的imageMap和是否更新的标志
+ */
+export async function updateImageMapIfNeeded(currentImageMap, imageNodeList, oldConfig, newConfig, local) {
+    if (local) {
+        Logger.log('本地模式，直接更新imageMap');
+        for (let node of imageNodeList) {
+            const type = node.srcType === 'PNG' ? 'png' : 'svg';
+            const base64 = removeBase64Prefix(currentImageMap[node.id]?.base64);
+            const { imageStorageType, imageStorageNamingRule, imageStoragePath } = newConfig?.imageSetting;
+            if (imageStorageType === 'local') {
+                let webpackPathRule = imageStorageNamingRule;
+                if (!webpackPathRule.endsWith('.[ext]')) {
+                    webpackPathRule += '.[ext]';
+                }
+                const name = replacePathVariables(webpackPathRule, {
+                    filename: [getSystemSupportFileName(node.name), type].join('.'),
+                    chunk: {
+                        id: node.id,
+                        name: getSystemSupportFileName(node.name),
+                        contentHash: {
+                            [type]: sha1(base64).substring(0, 8),
+                        },
+                    },
+                    contentHashType: type,
+                }, undefined);
+                const path = [imageStoragePath, name].join('/');
+                node.src = path;
+                currentImageMap[node.id].path = path;
+            }
+        }
+        return { imageMap: currentImageMap, updated: true };
+    }
+    // 提取相关的imageSetting配置项
+    const oldImageSetting = oldConfig?.imageSetting || {};
+    const newImageSetting = newConfig?.imageSetting || {};
+    // 检查影响imageMap生成的关键配置项
+    const relevantKeys = [
+        'imageStorageType',
+        'imageStorageScale',
+        'imageIconType',
+        'imageStoragePath',
+        'imageStorageNamingRule',
+        'ossRegion',
+        'ossAccessKeyId',
+        'ossAccessKeySecret',
+        'ossBucket',
+        'ossPath',
+        'ossCdnDomain',
+        'imageStorageApiUrl',
+        'imageStorageApiFileField',
+        'imageStorageApiUrlField',
+        'imageStorageApiCustomHeader',
+        'imageStorageApiCustomBody',
+    ];
+    // 检查是否有相关配置发生变化
+    const hasImageSettingChanged = relevantKeys.some((key) => {
+        return oldImageSetting[key] !== newImageSetting[key];
+    });
+    if (!hasImageSettingChanged) {
+        Logger.log('imageSetting配置未发生变化，使用现有imageMap');
+        return { imageMap: currentImageMap, updated: false };
+    }
+    Logger.log('检测到imageSetting配置变化，重新生成imageMap');
+    Logger.log('变化的配置项:', relevantKeys.filter((key) => oldImageSetting[key] !== newImageSetting[key]));
+    try {
+        // 重新生成imageMap
+        const newImageMap = await getResourceMapAdvanced(imageNodeList, newConfig);
+        Logger.log('已根据新配置重新生成imageMap');
+        return { imageMap: newImageMap, updated: true };
+    }
+    catch (error) {
+        Logger.log('重新生成imageMap失败，使用现有imageMap:', error);
+        return { imageMap: currentImageMap, updated: false };
+    }
+}