sloth-d2c-mcp 1.0.4-beta65

package/dist/build/utils/extract.js

@@ -0,0 +1,166 @@
+/**
+ * 从LLM的文本输出中提取JSON代码块
+ * @param text LLM返回的文本内容
+ * @returns 提取到的JSON对象和解析状态
+ */
+export function extractJson(text) {
+    try {
+        // 移除文本前后的空白字符
+        const trimmedText = text.trim();
+        // 正则表达式匹配 ```json 代码块
+        const jsonBlockRegex = /```json\s*\n([\s\S]*?)\n\s*```/gi;
+        const matches = Array.from(trimmedText.matchAll(jsonBlockRegex));
+        if (matches.length > 0) {
+            // 取最后一个匹配的JSON代码块
+            const jsonContent = matches[matches.length - 1][1].trim();
+            try {
+                const parsed = JSON.parse(jsonContent);
+                return { state: 'successful-parse', value: parsed };
+            }
+            catch (parseError) {
+                return {
+                    state: 'failed-parse',
+                    error: `JSON解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+                };
+            }
+        }
+        // 如果没有找到 ```json 代码块，尝试直接解析整个文本
+        // 寻找可能的JSON对象（以 { 开始，以 } 结束）
+        const jsonObjectRegex = /\{[\s\S]*\}/;
+        const jsonMatch = trimmedText.match(jsonObjectRegex);
+        if (jsonMatch) {
+            try {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return { state: 'successful-parse', value: parsed };
+            }
+            catch (parseError) {
+                return {
+                    state: 'failed-parse',
+                    error: `JSON对象解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+                };
+            }
+        }
+        // 尝试寻找数组格式的JSON（以 [ 开始，以 ] 结束）
+        const jsonArrayRegex = /\[[\s\S]*\]/;
+        const arrayMatch = trimmedText.match(jsonArrayRegex);
+        if (arrayMatch) {
+            try {
+                const parsed = JSON.parse(arrayMatch[0]);
+                return { state: 'successful-parse', value: parsed };
+            }
+            catch (parseError) {
+                return {
+                    state: 'failed-parse',
+                    error: `JSON数组解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+                };
+            }
+        }
+        return {
+            state: 'failed-parse',
+            error: '未找到有效的JSON内容。请确保响应包含 ```json 代码块或有效的JSON对象/数组。'
+        };
+    }
+    catch (error) {
+        return {
+            state: 'failed-parse',
+            error: `提取JSON时发生错误: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+/**
+ * 从 markdown 文本中提取代码块
+ * 遵循 CommonMark 规范，使用三个反引号包围的代码块格式
+ * @param text 包含 markdown 代码块的文本
+ * @returns 提取到的代码块数组
+ */
+export function extractCodeBlocks(text) {
+    const trimmedText = text.trim();
+    // 匹配 markdown 代码块的正则表达式
+    // 兼容以下情况：
+    // - 结尾处没有换行直接关闭 ```
+    // - Windows 换行 \r\n
+    // - 语言标记包含短横线（如 "c++" 之类极少数场景，放宽为 [\w-]）
+    // 格式: ```language\ncode\n?```
+    const codeBlockRegex = /```([\w-]+)?\s*\r?\n([\s\S]*?)\r?\n?\s*```/g;
+    const codeBlocks = [];
+    let match;
+    while ((match = codeBlockRegex.exec(trimmedText)) !== null) {
+        const language = match[1];
+        const code = match[2].trim();
+        if (code) {
+            const componentName = extractComponentName(code, language);
+            codeBlocks.push({
+                language,
+                code,
+                componentName
+            });
+        }
+    }
+    return codeBlocks;
+}
+/**
+ * 从代码中提取组件名
+ * 支持多种常见的组件定义模式
+ * @param code 代码内容
+ * @param language 编程语言
+ * @returns 组件名或 undefined
+ */
+export function extractComponentName(code, language) {
+    // 移除注释和空白字符
+    const cleanCode = code.trim();
+    // React 函数组件模式
+    const patterns = [
+        // export default function ComponentName / export default async function ComponentName
+        /export\s+default\s+(?:async\s+)?function\s+([A-Z][a-zA-Z0-9]*)/,
+        // export async function ComponentName / export function ComponentName
+        /export\s+(?:async\s+)?function\s+([A-Z][a-zA-Z0-9]*)/,
+        // function ComponentName
+        /^function\s+([A-Z][a-zA-Z0-9]*)/m,
+        // export default memo(function ComponentName ...) / React.memo
+        /export\s+default\s+(?:React\.)?memo\(\s*function\s+([A-Z][a-zA-Z0-9]*)/,
+        // export default forwardRef(..., function ComponentName ...) / React.forwardRef
+        /export\s+default\s+(?:React\.)?forwardRef\([^,]*,\s*function\s+([A-Z][a-zA-Z0-9]*)/,
+        // export default NamedComponent
+        /export\s+default\s+([A-Z][a-zA-Z0-9]*)/,
+        // export const ComponentName: Type = ...  (可选类型注解)
+        /export\s+const\s+([A-Z][a-zA-Z0-9]*)\s*(?::[^=]+)?\s*=/,
+        // const ComponentName: Type = ...  (可选类型注解)
+        /const\s+([A-Z][a-zA-Z0-9]*)\s*(?::[^=]+)?\s*=/,
+        // class ComponentName / export default class ComponentName
+        /export\s+default\s+class\s+([A-Z][a-zA-Z0-9]*)/,
+        /class\s+([A-Z][a-zA-Z0-9]*)/,
+        // export { ComponentName } / export { ComponentName as default }
+        /export\s*\{\s*([A-Z][a-zA-Z0-9]*)\s*(?:as\s*default)?\s*\}/,
+        // interface ComponentNameProps / type ComponentNameProps  (用于推断组件名)
+        /interface\s+([A-Z][a-zA-Z0-9]*)Props/,
+        /type\s+([A-Z][a-zA-Z0-9]*)Props/
+    ];
+    for (const pattern of patterns) {
+        const match = cleanCode.match(pattern);
+        if (match && match[1]) {
+            let componentName = match[1];
+            // 如果是 Props 接口，移除 Props 后缀
+            if (componentName.endsWith('Props')) {
+                componentName = componentName.slice(0, -5);
+            }
+            // 验证组件名符合 PascalCase 规范
+            if (/^[A-Z][a-zA-Z0-9]*$/.test(componentName)) {
+                return componentName;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * 从文本中提取所有代码块并获取组件信息
+ * @param text 包含代码块的文本
+ * @returns 包含代码和组件名的信息数组
+ */
+export function extractCodeAndComponents(text) {
+    const codeBlocks = extractCodeBlocks(text);
+    return codeBlocks.map(block => ({
+        code: block.code,
+        componentName: block.componentName,
+        language: block.language
+    }));
+}

package/dist/build/utils/file-manager.js

@@ -0,0 +1,241 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import envPaths from 'env-paths';
+import { Logger } from '../utils/logger.js';
+/**
+ * 通用文件管理器
+ * 可以保存任何类型的文件，使用fileKey和nodeId组织目录结构
+ */
+export class FileManager {
+    paths; // 应用路径配置
+    baseDir; // 基础存储目录
+    constructor(appName) {
+        this.paths = envPaths(appName);
+        this.baseDir = path.join(this.paths.data, 'files');
+    }
+    /**
+     * 生成文件路径
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @returns 完整的文件路径
+     */
+    getFilePath(fileKey, nodeId, filename) {
+        // 清理文件名中的特殊字符
+        const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+        const cleanNodeId = nodeId ? nodeId.replace(/[^a-zA-Z0-9-_:]/g, '_') : 'root';
+        const cleanFilename = filename.replace(/[^a-zA-Z0-9-_.]/g, '_');
+        return path.join(this.baseDir, cleanFileKey, cleanNodeId, cleanFilename);
+    }
+    /**
+     * 保存文件内容
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @param content - 文件内容
+     */
+    async saveFile(fileKey, nodeId, filename, content) {
+        try {
+            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            // 确保目录存在
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            // 保存文件内容
+            await fs.writeFile(filePath, content, 'utf-8');
+            Logger.log(`文件已保存: ${filePath}`);
+        }
+        catch (error) {
+            Logger.error(`保存文件失败: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 读取文件内容
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @returns Promise<string> - 文件内容，如果文件不存在则返回空字符串
+     */
+    async loadFile(fileKey, nodeId, filename) {
+        try {
+            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content;
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                Logger.log(`文件不存在: ${filename}`);
+                return '';
+            }
+            Logger.error(`读取文件失败: ${err.toString()}`);
+            throw err;
+        }
+    }
+    /**
+     * 检查文件是否存在
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @returns Promise<boolean> - 如果文件存在则返回true
+     */
+    async exists(fileKey, nodeId, filename) {
+        try {
+            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 删除文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     */
+    async deleteFile(fileKey, nodeId, filename) {
+        try {
+            const filePath = this.getFilePath(fileKey, nodeId, filename);
+            await fs.unlink(filePath);
+            Logger.log(`文件已删除: ${filePath}`);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                Logger.error(`删除文件失败: ${err.toString()}`);
+                throw err; // 如果不是文件不存在错误，则抛出异常
+            }
+        }
+    }
+    /**
+     * 清理特定fileKey的所有文件
+     * @param fileKey - Figma文件的key
+     */
+    async cleanupFileKey(fileKey) {
+        try {
+            const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+            const fileKeyDir = path.join(this.baseDir, cleanFileKey);
+            await fs.rm(fileKeyDir, { recursive: true, force: true });
+            Logger.log(`文件Key目录已清理: ${fileKeyDir}`);
+        }
+        catch (error) {
+            Logger.error(`清理文件Key目录失败: ${error}`);
+        }
+    }
+    /**
+     * 清理特定fileKey和nodeId的所有文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     */
+    async cleanupNode(fileKey, nodeId) {
+        try {
+            const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+            const cleanNodeId = nodeId ? nodeId.replace(/[^a-zA-Z0-9-_:]/g, '_') : 'root';
+            const nodeDir = path.join(this.baseDir, cleanFileKey, cleanNodeId);
+            await fs.rm(nodeDir, { recursive: true, force: true });
+            Logger.log(`节点目录已清理: ${nodeDir}`);
+        }
+        catch (error) {
+            Logger.error(`清理节点目录失败: ${error}`);
+        }
+    }
+    /**
+     * 清理整个存储目录
+     */
+    async cleanup() {
+        try {
+            await fs.rm(this.baseDir, { recursive: true, force: true });
+            Logger.log(`存储目录已清理: ${this.baseDir}`);
+        }
+        catch (error) {
+            Logger.error(`清理存储目录失败: ${error}`);
+        }
+    }
+    /**
+     * 获取文件的完整路径（公共方法）
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param filename - 文件名
+     * @returns string - 文件的完整路径
+     */
+    getFilePathPublic(fileKey, nodeId, filename) {
+        return this.getFilePath(fileKey, nodeId, filename);
+    }
+    /**
+     * 获取基础存储目录路径
+     * @returns string - 基础存储目录的完整路径
+     */
+    getBaseDir() {
+        return this.baseDir;
+    }
+    /**
+     * 获取特定fileKey的目录路径
+     * @param fileKey - Figma文件的key
+     * @returns string - fileKey目录的完整路径
+     */
+    getFileKeyDir(fileKey) {
+        const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return path.join(this.baseDir, cleanFileKey);
+    }
+    /**
+     * 获取特定fileKey和nodeId的目录路径
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @returns string - 节点目录的完整路径
+     */
+    getNodeDir(fileKey, nodeId) {
+        const cleanFileKey = fileKey.replace(/[^a-zA-Z0-9-_]/g, '_');
+        const cleanNodeId = nodeId ? nodeId.replace(/[^a-zA-Z0-9-_:]/g, '_') : 'root';
+        return path.join(this.baseDir, cleanFileKey, cleanNodeId);
+    }
+    /**
+     * 保存 groupsData 到特定的 nodeId 文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param groupsData - 分组数据
+     */
+    async saveGroupsData(fileKey, nodeId, groupsData) {
+        await this.saveFile(fileKey, nodeId, 'groupsData.json', JSON.stringify(groupsData, null, 2));
+    }
+    /**
+     * 加载 groupsData 从特定的 nodeId 文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @returns Promise<any[]> - 分组数据，如果文件不存在则返回空数组
+     */
+    async loadGroupsData(fileKey, nodeId) {
+        try {
+            const content = await this.loadFile(fileKey, nodeId, 'groupsData.json');
+            return content ? JSON.parse(content) : [];
+        }
+        catch (error) {
+            Logger.log(`加载 groupsData 失败，返回空数组: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * 保存 promptSetting 到特定的 nodeId 文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @param promptSetting - 提示词设置
+     */
+    async savePromptSetting(fileKey, nodeId, promptSetting) {
+        await this.saveFile(fileKey, nodeId, 'promptSetting.json', JSON.stringify(promptSetting, null, 2));
+    }
+    /**
+     * 加载 promptSetting 从特定的 nodeId 文件
+     * @param fileKey - Figma文件的key
+     * @param nodeId - 节点ID（可选）
+     * @returns Promise<any> - 提示词设置，如果文件不存在则返回 null
+     */
+    async loadPromptSetting(fileKey, nodeId) {
+        try {
+            const content = await this.loadFile(fileKey, nodeId, 'promptSetting.json');
+            return content ? JSON.parse(content) : null;
+        }
+        catch (error) {
+            Logger.log(`加载 promptSetting 失败，返回 null: ${error}`);
+            return null;
+        }
+    }
+}
+export default FileManager;

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/update.js

@@ -0,0 +1,54 @@
+import { Logger } from './logger.js';
+import { getResourceMapAdvanced } from 'sloth-d2c-node/convert';
+/**
+ * 检查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) {
+    // 提取相关的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 };
+    }
+}