sloth-d2c-mcp 1.0.4-beta71 → 1.0.4-beta73

package/dist/build/index.js

@@ -203,6 +203,7 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
         const savedPromptSetting = await fileManager.loadPromptSetting(fileKey, nodeId);
         const convertConfig = config.fileConfigs?.[fileKey] || defaultConfigData;
         // 获取提示词，优先使用用户保存的提示词，否则使用默认提示词
+        const frameworkPrompt = savedPromptSetting?.frameworkGuidePrompt;
         const chunkPrompt = savedPromptSetting?.chunkOptimizePrompt || chunkOptimizeCodePrompt;
         const aggregationPrompt = savedPromptSetting?.aggregationOptimizePrompt || aggregationOptimizeCodePrompt;
         const finalPrompt = savedPromptSetting?.finalOptimizePrompt || finalOptimizeCodePrompt;
@@ -218,6 +219,7 @@ mcpServer.tool('d2c_figma', 'Convert Figma Design File to Code', {
             imageMap,
             convertConfig,
             chunkPrompt,
+            frameworkPrompt,
             mcpServer,
             componentMappings,
             codeSnippets,

package/dist/build/server.js

@@ -17,6 +17,8 @@ import { ComponentMappingSystem } from './component-mapping/index.js';
 import multer from 'multer';
 import { ImageMatcher } from './utils/image-matcher.js';
 import { initOpenCV } from './utils/opencv-loader.js';
+import { extractJson } from './utils/extract.js';
+import { componentAnalysisPrompt, componentAnalysisPromptVue } from 'sloth-d2c-node/convert';
 // 配置 multer 用于文件上传
 const storage = multer.memoryStorage();
 const upload = multer({
@@ -91,6 +93,7 @@ export async function loadConfig(mcpServer, configManagerInstance) {
                     chunkOptimizePrompt: chunkOptimizeCodePrompt,
                     aggregationOptimizePrompt: aggregationOptimizeCodePrompt,
                     finalOptimizePrompt: finalOptimizeCodePrompt,
+                    componentAnalysisPrompt: componentAnalysisPrompt,
                 });
                 const reactConfigPath = configManager.getFrameworkConfigPath('react');
                 Logger.log(`已创建默认 react 配置文件: ${reactConfigPath}`);
@@ -102,10 +105,22 @@ export async function loadConfig(mcpServer, configManagerInstance) {
                     chunkOptimizePrompt: chunkOptimizeCodePromptVue,
                     aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
                     finalOptimizePrompt: finalOptimizeCodePromptVue,
+                    componentAnalysisPrompt: componentAnalysisPromptVue,
                 });
                 const vueConfigPath = configManager.getFrameworkConfigPath('vue');
                 Logger.log(`已创建默认 vue 配置文件: ${vueConfigPath}`);
             }
+            else {
+                const vueConfig = await configManager.loadFrameworkConfig('vue');
+                if (!vueConfig || Object.keys(vueConfig).length < 3) {
+                    await configManager.saveFrameworkConfig('vue', {
+                        chunkOptimizePrompt: chunkOptimizeCodePromptVue,
+                        aggregationOptimizePrompt: aggregationOptimizeCodePromptVue,
+                        finalOptimizePrompt: finalOptimizeCodePromptVue,
+                        ...(vueConfig || {}),
+                    });
+                }
+            }
         }
         catch (error) {
             Logger.error(`获取配置信息时出错: ${error}`);
@@ -159,6 +174,8 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
     // 为认证端点添加中间件 - 需要同时支持 JSON 和表单数据
     app.use(express.urlencoded({ extended: true }));
     app.use('/saveGlobalConfig', express.json());
+    app.use('/analyzeComponents', express.json());
+    app.use('/saveComponents', express.json());
     // 设置跨域
     app.use((req, res, next) => {
         res.header('Access-Control-Allow-Origin', '*');
@@ -666,6 +683,337 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             return './';
         }
     }
+    /**
+     * 获取项目文件树
+     */
+    app.get('/getProjectFiles', async (req, res) => {
+        try {
+            const { directory = '' } = req.query;
+            const projectPath = getProjectRoot();
+            const targetPath = path.join(projectPath, directory);
+            Logger.log(`获取项目文件树: ${targetPath}`);
+            // 排除的文件扩展名（静态资源和配置文件）
+            const excludeExtensions = [
+                // 图片
+                '.png',
+                '.jpg',
+                '.jpeg',
+                '.gif',
+                '.svg',
+                '.ico',
+                '.webp',
+                '.bmp',
+                // 视频/音频
+                '.mp4',
+                '.avi',
+                '.mov',
+                '.mp3',
+                '.wav',
+                // 字体
+                '.ttf',
+                '.woff',
+                '.woff2',
+                '.eot',
+                // 配置文件
+                '.json',
+                '.lock',
+                '.yaml',
+                '.yml',
+                '.toml',
+                // 文档
+                '.md',
+                '.txt',
+                '.pdf',
+                '.doc',
+                '.docx',
+                // 其他
+                '.zip',
+                '.tar',
+                '.gz',
+                '.rar',
+                '.map',
+                '.d.ts.map',
+            ];
+            // 递归读取文件树
+            const buildFileTree = async (dirPath, relativePath = '') => {
+                const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+                const files = [];
+                for (const entry of entries) {
+                    // 排除特殊目录
+                    const excludeDirs = ['node_modules', 'dist', 'build', '.git', '.next', 'coverage', '.sloth', 'public', 'static', 'assets'];
+                    if (excludeDirs.includes(entry.name) || entry.name.startsWith('.')) {
+                        continue;
+                    }
+                    const entryRelativePath = path.join(relativePath, entry.name);
+                    const entryFullPath = path.join(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        const children = await buildFileTree(entryFullPath, entryRelativePath);
+                        if (children.length > 0) {
+                            files.push({
+                                title: entry.name,
+                                key: entryRelativePath,
+                                path: entryRelativePath,
+                                isLeaf: false,
+                                selectable: false,
+                                children,
+                            });
+                        }
+                    }
+                    else {
+                        // 排除静态资源文件
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!excludeExtensions.includes(ext)) {
+                            files.push({
+                                title: entry.name,
+                                key: entryRelativePath,
+                                path: entryRelativePath,
+                                isLeaf: true,
+                                selectable: true,
+                            });
+                        }
+                    }
+                }
+                return files;
+            };
+            const fileTree = await buildFileTree(targetPath);
+            res.json({
+                success: true,
+                data: {
+                    projectPath,
+                    files: fileTree,
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('获取项目文件树失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '获取项目文件树失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    /**
+     * 分析项目中的组件
+     */
+    app.post('/analyzeComponents', async (req, res) => {
+        try {
+            const { filePaths, fileKey, nodeId } = req.body;
+            if (!filePaths || !Array.isArray(filePaths)) {
+                res.status(400).json({
+                    success: false,
+                    message: '缺少必要参数: filePaths',
+                });
+                return;
+            }
+            Logger.log(`分析 ${filePaths.length} 个项目文件`);
+            const projectPath = getProjectRoot();
+            const results = [];
+            // 尝试加载保存的提示词设置（如果提供了 fileKey 和 nodeId）
+            let savedPromptSetting = null;
+            if (fileKey && nodeId) {
+                try {
+                    savedPromptSetting = await fileManager.loadPromptSetting(fileKey, nodeId);
+                    Logger.log(`已加载提示词设置: fileKey=${fileKey}, nodeId=${nodeId}`);
+                }
+                catch (error) {
+                    Logger.warn(`加载提示词设置失败: ${error}`);
+                }
+            }
+            const frameworkGuidePrompt = savedPromptSetting?.frameworkGuidePrompt;
+            const _componentAnalysisPrompt = savedPromptSetting?.componentAnalysisPrompt || componentAnalysisPrompt;
+            // 读取并分析每个文件
+            for (const filePath of filePaths) {
+                try {
+                    const fullPath = path.join(projectPath, filePath);
+                    // 安全检查：确保文件在项目目录内
+                    if (!fullPath.startsWith(projectPath)) {
+                        results.push({
+                            success: false,
+                            filename: filePath,
+                            error: '无权访问该文件',
+                        });
+                        continue;
+                    }
+                    // 读取文件内容
+                    const content = await fs.promises.readFile(fullPath, 'utf-8');
+                    const filename = path.basename(filePath);
+                    // 使用 MCP Sampling 进行实际分析
+                    if (mcpServer) {
+                        try {
+                            // 构建提示词，替换占位符
+                            const prompt = _componentAnalysisPrompt.replace(/{filename}/g, filename).replace(/{fileContent}/g, content);
+                            // 调用 MCP Sampling API
+                            const { content: { text }, } = await mcpServer.server.createMessage({
+                                messages: [
+                                    frameworkGuidePrompt && {
+                                        role: 'user',
+                                        content: {
+                                            type: 'text',
+                                            text: frameworkGuidePrompt,
+                                        },
+                                    },
+                                    {
+                                        role: 'user',
+                                        content: {
+                                            type: 'text',
+                                            text: prompt,
+                                        },
+                                    },
+                                ].filter(Boolean),
+                                maxTokens: 8000,
+                            }, { timeout: 2 * 60 * 1000 });
+                            // 解析 AI 返回的 JSON
+                            const extractResult = extractJson(text);
+                            if (extractResult.state === 'successful-parse' && extractResult.value) {
+                                const analysisResult = extractResult.value;
+                                // 构建组件信息
+                                const component = {
+                                    id: `comp-${Date.now()}-${Math.random()}`,
+                                    name: analysisResult.componentName || path.basename(filePath, path.extname(filePath)),
+                                    type: 'custom',
+                                    path: filePath,
+                                    import: analysisResult.import,
+                                    props: analysisResult.props || [],
+                                    description: analysisResult.description || '组件描述',
+                                };
+                                results.push({
+                                    success: true,
+                                    component,
+                                    filename: filePath,
+                                });
+                                Logger.log(`成功分析组件: ${filePath}, 组件名: ${component.name}`);
+                            }
+                            else {
+                                // JSON 解析失败，使用默认值
+                                Logger.warn(`解析组件分析结果失败: ${extractResult.error}, 文件: ${filePath}`);
+                                results.push({
+                                    success: true,
+                                    component: {
+                                        id: `comp-${Date.now()}-${Math.random()}`,
+                                        name: path.basename(filePath, path.extname(filePath)),
+                                        type: 'custom',
+                                        path: filePath,
+                                        import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
+                                        props: [],
+                                        description: '组件描述',
+                                    },
+                                    filename: filePath,
+                                });
+                            }
+                        }
+                        catch (samplingError) {
+                            Logger.error(`调用采样 API 失败: ${filePath}`, samplingError);
+                            // 采样失败时使用默认值
+                            results.push({
+                                success: true,
+                                component: {
+                                    id: `comp-${Date.now()}-${Math.random()}`,
+                                    name: path.basename(filePath, path.extname(filePath)),
+                                    type: 'custom',
+                                    path: filePath,
+                                    import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
+                                    props: [],
+                                    description: '组件描述',
+                                },
+                                filename: filePath,
+                            });
+                        }
+                    }
+                    else {
+                        // MCP 服务器未初始化，使用默认值
+                        Logger.warn('MCP 服务器未初始化，使用默认组件信息');
+                        results.push({
+                            success: true,
+                            component: {
+                                id: `comp-${Date.now()}-${Math.random()}`,
+                                name: path.basename(filePath, path.extname(filePath)),
+                                type: 'custom',
+                                path: filePath,
+                                import: `import { ${path.basename(filePath, path.extname(filePath))} } from './${filePath}'`,
+                                props: [],
+                                description: '组件描述',
+                            },
+                            filename: filePath,
+                        });
+                    }
+                }
+                catch (error) {
+                    Logger.error(`读取文件失败: ${filePath}`, error);
+                    results.push({
+                        success: false,
+                        filename: filePath,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            const succeeded = results.filter((r) => r.success).length;
+            const failed = results.filter((r) => !r.success).length;
+            res.json({
+                success: true,
+                data: {
+                    total: filePaths.length,
+                    succeeded,
+                    failed,
+                    components: results.filter((r) => r.success).map((r) => r.component),
+                    errors: results
+                        .filter((r) => !r.success)
+                        .map((r) => ({
+                        filename: r.filename,
+                        error: r.error,
+                    })),
+                },
+            });
+        }
+        catch (error) {
+            Logger.error('分析项目组件失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '分析项目组件失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    /**
+     * 保存项目中的组件到components.json
+     */
+    app.post('/saveComponents', async (req, res) => {
+        try {
+            const { components } = req.body;
+            if (!components || !Array.isArray(components)) {
+                res.status(400).json({
+                    success: false,
+                    message: '无效的组件数据',
+                });
+                return;
+            }
+            Logger.log(`准备保存 ${components.length} 个组件`);
+            // 读取现有组件
+            const existingComponents = await fileManager.loadComponentsDatabase();
+            // 直接追加（暂不处理冲突）
+            const allComponents = [...components, ...existingComponents];
+            // 保存到文件（带备份）
+            await fileManager.saveComponentsDatabase(allComponents);
+            Logger.log(`✅ 成功保存，当前共 ${allComponents.length} 个组件`);
+            res.json({
+                success: true,
+                data: {
+                    added: components.length,
+                    total: allComponents.length,
+                    components: allComponents,
+                },
+                message: '组件导入成功',
+            });
+        }
+        catch (error) {
+            Logger.error('保存组件失败:', error);
+            res.status(500).json({
+                success: false,
+                message: '保存组件失败',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     /**
      * 获取或创建映射系统实例
      */
@@ -689,56 +1037,10 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 });
                 return;
             }
-            Logger.log('扫描项目组件:', { platform, includePaths, excludePaths });
-            const system = await getMappingSystem();
-            const adapter = system.adapterManager.getAdapter(platform);
-            if (!adapter) {
-                res.status(400).json({
-                    success: false,
-                    message: `不支持的平台: ${platform}`,
-                });
-                return;
-            }
             const projectPath = getProjectRoot();
-            Logger.log('开始扫描，项目路径:', projectPath);
-            // 扫描项目组件
-            const components = await adapter.scanComponents(projectPath, {
-                includePaths,
-                excludePaths,
-            });
-            Logger.log(`扫描完成，发现 ${components.length} 个项目组件`);
-            // 将绝对路径转换为相对路径
-            const normalizePath = (filePath) => {
-                if (!filePath || !projectPath)
-                    return filePath;
-                try {
-                    const path = require('path');
-                    const relativePath = path.relative(projectPath, filePath);
-                    // 统一使用正斜杠
-                    return relativePath.replace(/\\/g, '/');
-                }
-                catch {
-                    return filePath;
-                }
-            };
-            const projectComponents = components.map((c) => ({
-                id: c.id,
-                name: c.name,
-                type: c.type,
-                path: normalizePath(c.path),
-                props: c.props.map((p) => ({
-                    name: p.name,
-                    type: p.type,
-                    required: p.required,
-                })),
-                framework: c.metadata.framework,
-                description: c.metadata.description,
-                source: 'project', // 标记为项目组件
-                importType: c.metadata.importType || 'default', // 导入类型
-                signature: c.metadata.signature,
-            }));
+            Logger.log('扫描项目组件:', { platform, includePaths, excludePaths });
             // 读取外部依赖组件（从 .sloth/components.json）
-            let externalComponents = [];
+            let projectComponents = [];
             const slothPath = path.join(projectPath, '.sloth', 'components.json');
             const fs = await import('fs/promises');
             try {
@@ -749,7 +1051,7 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                 // 验证数据结构
                 if (Array.isArray(componentsData)) {
                     // 验证每个组件的基本字段
-                    externalComponents = componentsData
+                    projectComponents = componentsData
                         .filter((comp) => comp && comp.id && comp.name && comp.path)
                         .map((c) => ({
                         id: c.id,
@@ -761,13 +1063,10 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
                             type: p.type || 'any',
                             required: p.required || false,
                         })),
-                        framework: c.framework || c.metadata?.framework || 'React',
                         description: c.description || c.metadata?.description,
-                        source: 'external', // 标记为外部依赖组件
-                        lib: c.lib, // 业务库名称
-                        importType: c.importType || c.metadata?.importType || 'named', // 导入类型，外部组件默认为具名导入
+                        import: c.import,
                     }));
-                    Logger.log(`从 .sloth/components.json 加载了 ${externalComponents.length} 个外部组件`);
+                    Logger.log(`从 .sloth/components.json 加载了 ${projectComponents.length} 个项目组件`);
                 }
                 else {
                     Logger.warn('.sloth/components.json 格式错误：应为组件数组');
@@ -782,11 +1081,9 @@ export async function startHttpServer(port = PORT, mcpServer, configManagerInsta
             res.json({
                 success: true,
                 data: {
-                    total: projectComponents.length + externalComponents.length,
+                    total: projectComponents.length,
                     platform,
-                    projectPath,
                     projectComponents, // 项目组件
-                    externalComponents, // 外部依赖组件
                 },
             });
         }

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

@@ -333,9 +333,7 @@ export class FileManager {
             }
             const slothDir = path.join(this.workspaceRoot, '.sloth');
             const entries = await fs.readdir(slothDir, { withFileTypes: true });
-            const fileKeys = entries
-                .filter(entry => entry.isDirectory())
-                .map(entry => entry.name);
+            const fileKeys = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
             Logger.log(`找到 ${fileKeys.length} 个 fileKey:`, fileKeys);
             return fileKeys;
         }
@@ -528,5 +526,77 @@ export class FileManager {
             Logger.error(`清理旧截图失败: ${error}`);
         }
     }
+    /**
+     * 读取组件数据库
+     * @returns Promise<StoredComponent[]> - 组件列表
+     */
+    async loadComponentsDatabase() {
+        const workspaceRoot = this.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            Logger.warn('工作目录根路径未设置，无法加载组件数据库');
+            return [];
+        }
+        const componentsPath = path.join(workspaceRoot, '.sloth', 'components.json');
+        try {
+            const content = await fs.readFile(componentsPath, 'utf-8');
+            // 验证文件内容不为空
+            if (!content || !content.trim()) {
+                Logger.warn('components.json 文件为空，返回空数组');
+                return [];
+            }
+            const components = JSON.parse(content);
+            // 验证数据格式
+            if (!Array.isArray(components)) {
+                Logger.warn('components.json 格式错误（不是数组），返回空数组');
+                return [];
+            }
+            Logger.log(`成功加载 ${components.length} 个组件`);
+            return components;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                // 文件不存在，返回空数组
+                Logger.log('components.json 不存在，将创建新文件');
+                return [];
+            }
+            if (err instanceof SyntaxError) {
+                Logger.error('components.json JSON 解析失败:', err.message);
+                return [];
+            }
+            Logger.error('读取组件数据库失败:', err);
+            throw error;
+        }
+    }
+    /**
+     * 保存组件数据库
+     * @param components - 要保存的组件列表
+     */
+    async saveComponentsDatabase(components) {
+        const workspaceRoot = this.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            throw new Error('工作目录根路径未设置，无法保存组件数据库');
+        }
+        const slothDir = path.join(workspaceRoot, '.sloth');
+        const componentsPath = path.join(slothDir, 'components.json');
+        // 确保目录存在
+        try {
+            await fs.mkdir(slothDir, { recursive: true });
+        }
+        catch (error) {
+            Logger.error('创建 .sloth 目录失败:', error);
+            throw new Error(`无法创建目录: ${slothDir}`);
+        }
+        // 写入数据
+        try {
+            const jsonContent = JSON.stringify(components, null, 2);
+            await fs.writeFile(componentsPath, jsonContent, 'utf-8');
+            Logger.log(`✅ 已保存 ${components.length} 个组件到 components.json`);
+        }
+        catch (error) {
+            Logger.error('写入组件数据库失败:', error);
+            throw new Error(`无法写入文件: ${componentsPath}`);
+        }
+    }
 }
 export default FileManager;

package/dist/interceptor-web/dist/build-report.json

@@ -1,18 +1,18 @@
 {
-  "buildTime": "2025-12-01T03:49:02.385Z",
+  "buildTime": "2025-12-02T07:57:55.137Z",
   "mode": "build",
   "pages": {
     "main": {
       "file": "index.html",
-      "size": 1414275,
-      "sizeFormatted": "1.35 MB"
+      "size": 1494888,
+      "sizeFormatted": "1.43 MB"
     },
     "detail": {
       "file": "detail.html",
-      "size": 281682,
-      "sizeFormatted": "275.08 KB"
+      "size": 280311,
+      "sizeFormatted": "273.74 KB"
     }
   },
-  "totalSize": 1695957,
-  "totalSizeFormatted": "1.62 MB"
+  "totalSize": 1775199,
+  "totalSizeFormatted": "1.69 MB"
 }