cuxml 1.0.6 → 2.1.0

package/src/converter.js

@@ -0,0 +1,260 @@
+const fs = require('fs');
+const path = require('path');
+const lodash = require('lodash');
+const XMLParser = require('./parser');
+const { generateCallbackTemplate, processFunctionName } = require('./templates');
+
+/**
+ * 回调函数转换器
+ * 负责将 XML 中的回调函数配置转换为 JavaScript 代码
+ */
+class XMLConverter {
+    /**
+     * 将 XML 文件转换为 JavaScript 回调函数文件
+     * @param {string} inputPath - 输入的 XML 文件路径
+     * @param {string} outputPath - 输出的 JS 文件路径
+     * @param {object} options - 转换选项
+     * @param {boolean} [options.overwrite=false] - 是否覆盖输出文件
+     * @returns {object} 转换结果
+     */
+    static convert(inputPath, outputPath, options = {}) {
+        // 验证输入参数
+        if (!inputPath || typeof inputPath !== 'string') {
+            throw new Error('输入文件路径必须是非空字符串');
+        }
+
+        if (!outputPath || typeof outputPath !== 'string') {
+            throw new Error('输出文件路径必须是非空字符串');
+        }
+
+        if (!inputPath.endsWith('.xml')) {
+            throw new Error('输入文件必须是 .xml 格式');
+        }
+
+        if (!outputPath.endsWith('.js')) {
+            throw new Error('输出文件必须是 .js 格式');
+        }
+
+        // 检查输入文件是否存在
+        if (!fs.existsSync(inputPath)) {
+            throw new Error(`输入文件不存在: ${inputPath}`);
+        }
+
+        // 加载配置
+        const clashAttributes = require('../lib/clashAttributes.json').crashs;
+        const stDelegate = require('../lib/StDelegate.json');
+
+        // 解析 XML
+        const flatElements = XMLParser.parseAndFlatten(inputPath);
+
+        // 提取有回调函数的元素
+        const callbackElements = this.extractCallbackElements(flatElements, stDelegate, clashAttributes);
+
+        if (callbackElements.length === 0) {
+            return {
+                success: true,
+                message: '没有找到需要转换的回调函数',
+                functionsGenerated: 0
+            };
+        }
+
+        // 按函数名分组
+        const functionGroups = this.groupByFunctionName(callbackElements);
+
+        // 生成回调函数代码
+        const generatedFunctions = this.generateFunctions(functionGroups);
+
+        // 写入输出文件
+        this.writeOutputFile(outputPath, generatedFunctions, options.overwrite);
+
+        return {
+            success: true,
+            message: '转换成功',
+            functionsGenerated: generatedFunctions.length,
+            outputPath: outputPath
+        };
+    }
+
+    /**
+     * 提取包含回调函数的元素
+     * @param {Array} elements - 扁平化的元素数组
+     * @param {object} stDelegate - 回调函数配置
+     * @param {Array} clashAttributes - 冲突属性配置
+     * @returns {Array} 包含回调函数的元素
+     */
+    static extractCallbackElements(elements, stDelegate, clashAttributes) {
+        const results = [];
+
+        elements.forEach(element => {
+            if (!element.attributes || Object.keys(element.attributes).length === 0) {
+                return;
+            }
+
+            // 获取该元素支持的回调函数属性
+            const elementCallbacks = stDelegate[element.name];
+            if (!elementCallbacks) {
+                return;
+            }
+
+            // 检查是否有回调函数
+            const attrKeys = Object.keys(element.attributes);
+            const hasCallback = elementCallbacks.some(cb => {
+                return attrKeys.includes(cb) && element.attributes[cb].trim() !== '';
+            });
+
+            if (!hasCallback) {
+                return;
+            }
+
+            // 检查是否有冲突属性
+            const hasClash = clashAttributes.some(clash => {
+                return lodash.intersection(attrKeys, clash).length > 1;
+            });
+
+            if (hasClash) {
+                return;
+            }
+
+            // 提取回调函数信息
+            elementCallbacks.forEach(cb => {
+                const callbackValue = element.attributes[cb];
+                if (callbackValue && callbackValue.trim()) {
+                    results.push({
+                        functionName: processFunctionName(callbackValue),
+                        xmlPath: element.xmlpath,
+                        id: element.attributes.id,
+                        elementName: element.name,
+                        attribute: cb
+                    });
+                }
+            });
+        });
+
+        return results;
+    }
+
+    /**
+     * 按函数名分组
+     * @param {Array} callbackElements - 回调元素数组
+     * @returns {object} 分组后的对象
+     */
+    static groupByFunctionName(callbackElements) {
+        return lodash.groupBy(callbackElements, 'functionName');
+    }
+
+    /**
+     * 生成回调函数代码
+     * @param {object} functionGroups - 函数分组对象
+     * @returns {Array} 生成的函数信息数组
+     */
+    static generateFunctions(functionGroups) {
+        const functions = [];
+
+        Object.keys(functionGroups).forEach(functionName => {
+            const elements = functionGroups[functionName];
+            const controls = elements.map(el => ({
+                id: el.id,
+                xmlPath: el.xmlPath
+            }));
+
+            const functionCode = generateCallbackTemplate(functionName, controls);
+
+            functions.push({
+                name: functionName,
+                code: functionCode,
+                controls: controls.length
+            });
+        });
+
+        return functions;
+    }
+
+    /**
+     * 写入输出文件
+     * @param {string} outputPath - 输出文件路径
+     * @param {Array} functions - 函数信息数组
+     * @param {boolean} overwrite - 是否覆盖
+     */
+    static writeOutputFile(outputPath, functions, overwrite = false) {
+        const dir = path.dirname(outputPath);
+        
+        // 确保目录存在
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        // 如果是覆盖模式，先清空文件
+        if (overwrite) {
+            fs.writeFileSync(outputPath, '', 'utf-8');
+        }
+
+        // 如果文件不存在，创建空文件
+        if (!fs.existsSync(outputPath)) {
+            fs.writeFileSync(outputPath, '', 'utf-8');
+        }
+
+        // 读取现有内容
+        const existingContent = fs.readFileSync(outputPath, 'utf-8');
+
+        // 追加新函数
+        functions.forEach(func => {
+            // 检查函数是否已存在
+            const functionRegex = new RegExp(`function\\s+${func.name}\\s*\\(`);
+            
+            if (!existingContent.match(functionRegex)) {
+                fs.appendFileSync(outputPath, func.code + '\n', 'utf-8');
+            }
+        });
+
+        // 添加导出语句
+        const exportStatement = `
+// 导出所有回调函数（如果不需要导出，可以注释掉以下语句）
+module.exports = {
+${functions.map(func => `    ${func.name},`).join('\n')}
+};
+`;
+
+        // 检查是否已经有导出语句
+        if (!existingContent.includes('module.exports = {')) {
+            fs.appendFileSync(outputPath, exportStatement, 'utf-8');
+        }
+    }
+
+    /**
+     * 监视文件变化并自动转换
+     * @param {string} inputPath - 输入文件路径
+     * @param {string} outputPath - 输出文件路径
+     * @param {object} options - 转换选项
+     * @returns {object} watcher 对象
+     */
+    static watch(inputPath, outputPath, options = {}) {
+        const chokidar = require('chokidar');
+
+        console.log(`👀 开始监视文件: ${inputPath}`);
+
+        // 初始转换
+        this.convert(inputPath, outputPath, options);
+
+        const watcher = chokidar.watch(inputPath);
+
+        watcher.on('change', () => {
+            console.log(`📝 检测到文件变化，开始转换...`);
+            try {
+                const result = this.convert(inputPath, outputPath, options);
+                if (result.success) {
+                    console.log(`✅ 转换完成，生成了 ${result.functionsGenerated} 个函数`);
+                }
+            } catch (error) {
+                console.error(`❌ 转换失败: ${error.message}`);
+            }
+        });
+
+        watcher.on('error', (error) => {
+            console.error(`❌ 监视错误: ${error.message}`);
+        });
+
+        return watcher;
+    }
+}
+
+module.exports = XMLConverter;

package/src/mcp.js

@@ -0,0 +1,289 @@
+const CUXMLAPI = require('./api');
+
+/**
+ * CUXML MCP (Model Context Protocol) 插件
+ * 提供 MCP 标准接口供 AI 工具链调用
+ */
+class CUXMLMCP {
+    /**
+     * MCP 服务器信息
+     */
+    static getServerInfo() {
+        return {
+            name: 'cuxml',
+            version: require('../package.json').version,
+            description: 'CUXML - WPS Office RibbonUI XML 处理工具'
+        };
+    }
+
+    /**
+     * MCP 工具列表
+     */
+    static getTools() {
+        return [
+            {
+                name: 'convert',
+                description: '将 RibbonUI XML 文件转换为 JavaScript 回调函数文件',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        inputFile: {
+                            type: 'string',
+                            description: '输入的 XML 文件路径'
+                        },
+                        outputFile: {
+                            type: 'string',
+                            description: '输出的 JS 文件路径'
+                        },
+                        overwrite: {
+                            type: 'boolean',
+                            description: '是否覆盖输出文件',
+                            default: false
+                        }
+                    },
+                    required: ['inputFile', 'outputFile']
+                }
+            },
+            {
+                name: 'check',
+                description: '检查 XML 文件或字符串是否符合 CustomUI 规范',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        input: {
+                            type: 'string',
+                            description: 'XML 文件路径或 XML 字符串'
+                        },
+                        detailed: {
+                            type: 'boolean',
+                            description: '是否返回详细信息',
+                            default: false
+                        }
+                    },
+                    required: ['input']
+                }
+            }
+        ];
+    }
+
+    /**
+     * 执行 MCP 工具
+     * @param {string} toolName - 工具名称
+     * @param {object} args - 工具参数
+     * @returns {Promise<object>} 执行结果
+     */
+    static async executeTool(toolName, args) {
+        try {
+            switch (toolName) {
+                case 'convert':
+                    return await this.convert(args);
+                case 'check':
+                    return await this.check(args);
+                default:
+                    throw new Error(`未知的工具: ${toolName}`);
+            }
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * 转换 XML 文件
+     * @param {object} args - 参数
+     * @param {string} args.inputFile - 输入文件
+     * @param {string} args.outputFile - 输出文件
+     * @param {boolean} args.overwrite - 是否覆盖
+     * @returns {Promise<object>} 转换结果
+     */
+    static async convert(args) {
+        const { inputFile, outputFile, overwrite = false } = args;
+        
+        const result = await CUXMLAPI.convert(inputFile, outputFile, { overwrite });
+        
+        return {
+            success: result.success,
+            message: result.message,
+            functionsGenerated: result.functionsGenerated,
+            outputPath: result.outputPath
+        };
+    }
+
+    /**
+     * 检查 XML
+     * @param {object} args - 参数
+     * @param {string} args.input - XML 文件或字符串
+     * @param {boolean} args.detailed - 是否详细
+     * @returns {Promise<object>} 检查结果
+     */
+    static async check(args) {
+        const { input, detailed = false } = args;
+        
+        const result = await CUXMLAPI.check(input, { detailed });
+        
+        if (detailed) {
+            return {
+                success: result.errors === 0,
+                ...result
+            };
+        } else {
+            return {
+                success: result.success,
+                totalNodes: result.totalNodes,
+                passed: result.passed,
+                errors: result.errors,
+                warnings: result.warnings
+            };
+        }
+    }
+
+    /**
+     * MCP 资源列表
+     */
+    static getResources() {
+        return [
+            {
+                uri: 'cuxml://config/simpleTypes',
+                name: 'Simple Types 配置',
+                description: 'CustomUI Simple Types 规范配置',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'cuxml://config/clashAttributes',
+                name: '冲突属性配置',
+                description: 'CustomUI 冲突属性配置',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'cuxml://config/stDelegate',
+                name: '回调函数属性配置',
+                description: 'CustomUI 回调函数属性配置',
+                mimeType: 'application/json'
+            }
+        ];
+    }
+
+    /**
+     * 读取 MCP 资源
+     * @param {string} uri - 资源 URI
+     * @returns {Promise<object>} 资源内容
+     */
+    static async readResource(uri) {
+        try {
+            switch (uri) {
+                case 'cuxml://config/simpleTypes':
+                    return {
+                        uri: uri,
+                        mimeType: 'application/json',
+                        content: JSON.stringify(require('../lib/simpleTypes.json'), null, 2)
+                    };
+                case 'cuxml://config/clashAttributes':
+                    return {
+                        uri: uri,
+                        mimeType: 'application/json',
+                        content: JSON.stringify(require('../lib/clashAttributes.json'), null, 2)
+                    };
+                case 'cuxml://config/stDelegate':
+                    return {
+                        uri: uri,
+                        mimeType: 'application/json',
+                        content: JSON.stringify(require('../lib/StDelegate.json'), null, 2)
+                    };
+                default:
+                    throw new Error(`未知的资源: ${uri}`);
+            }
+        } catch (error) {
+            return {
+                uri: uri,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * MCP 提示模板
+     */
+    static getPrompts() {
+        return [
+            {
+                name: 'generate-ribbon-ui',
+                description: '生成 RibbonUI XML 配置',
+                arguments: [
+                    {
+                        name: 'requirements',
+                        description: '功能需求描述',
+                        required: true
+                    }
+                ]
+            },
+            {
+                name: 'debug-xml',
+                description: '调试 XML 配置问题',
+                arguments: [
+                    {
+                        name: 'xmlContent',
+                        description: 'XML 内容',
+                        required: true
+                    },
+                    {
+                        name: 'error',
+                        description: '错误信息',
+                        required: false
+                    }
+                ]
+            }
+        ];
+    }
+}
+
+// 如果直接运行此文件，启动 MCP 服务器
+if (require.main === module) {
+    const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+    const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+    
+    const server = new Server(
+        CUXMLMCP.getServerInfo(),
+        {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {}
+            }
+        }
+    );
+
+    // 注册工具
+    server.setRequestHandler('tools/list', async () => {
+        return { tools: CUXMLMCP.getTools() };
+    });
+
+    server.setRequestHandler('tools/call', async (request) => {
+        const { name, arguments: args } = request.params;
+        return await CUXMLMCP.executeTool(name, args);
+    });
+
+    // 注册资源
+    server.setRequestHandler('resources/list', async () => {
+        return { resources: CUXMLMCP.getResources() };
+    });
+
+    server.setRequestHandler('resources/read', async (request) => {
+        return await CUXMLMCP.readResource(request.params.uri);
+    });
+
+    // 注册提示
+    server.setRequestHandler('prompts/list', async () => {
+        return { prompts: CUXMLMCP.getPrompts() };
+    });
+
+    // 启动服务器
+    const transport = new StdioServerTransport();
+    server.connect(transport).catch(error => {
+        console.error('MCP 服务器启动失败:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = CUXMLMCP;

package/src/parser.js

@@ -0,0 +1,117 @@
+const xmljs = require('xml-js');
+const fs = require('fs');
+const lodash = require('lodash');
+
+/**
+ * XML 解析器模块
+ * 负责解析 XML 文件并将其转换为扁平化的 JSON 结构
+ */
+class XMLParser {
+    /**
+     * 解析 XML 文件
+     * @param {string} xmlPath - XML 文件路径
+     * @returns {object} 解析后的 JSON 对象
+     * @throws {Error} 如果文件不存在或解析失败
+     */
+    static parseFile(xmlPath) {
+        if (!xmlPath || typeof xmlPath !== 'string') {
+            throw new Error('XML 文件路径必须是非空字符串');
+        }
+
+        if (!fs.existsSync(xmlPath)) {
+            throw new Error(`XML 文件不存在: ${xmlPath}`);
+        }
+
+        const xmlContent = fs.readFileSync(xmlPath, 'utf-8');
+        
+        if (!xmlContent.trim()) {
+            throw new Error('XML 文件为空');
+        }
+
+        return this.parseString(xmlContent);
+    }
+
+    /**
+     * 解析 XML 字符串
+     * @param {string} xmlString - XML 字符串
+     * @returns {object} 解析后的 JSON 对象
+     * @throws {Error} 如果解析失败
+     */
+    static parseString(xmlString) {
+        try {
+            return xmljs.xml2js(xmlString, { compact: false, spaces: 4 });
+        } catch (error) {
+            throw new Error(`XML 解析失败: ${error.message}`);
+        }
+    }
+
+    /**
+     * 将 XML JSON 对象扁平化为数组
+     * @param {object} obj - XML JSON 对象
+     * @returns {Array} 扁平化后的元素数组
+     */
+    static flatten(obj) {
+        const result = [];
+        const resNames = [];
+
+        function flattenInternal(currentObj, path = []) {
+            // 提取 type, name, attributes
+            const wanted = lodash.pick(currentObj, ['type', 'name', 'attributes']);
+            
+            if (Object.keys(wanted).length > 0) {
+                Object.assign(wanted, { xmlpath: resNames.join('>') });
+                result.push(wanted);
+            }
+
+            if (currentObj && typeof currentObj === 'object') {
+                Object.keys(currentObj).forEach(key => {
+                    const value = currentObj[key];
+                    const newPath = path.concat(key);
+
+                    // 处理数组索引
+                    if (Number.isInteger(Number(key))) {
+                        let eItem = `${value.name}[${key}]`;
+                        
+                        if (Number(key) > 0) {
+                            const beDeleted = `${value.name}[${key - 1}]`;
+                            const index = resNames.lastIndexOf(beDeleted);
+                            const resNamesCopy = resNames.slice(0, index);
+                            resNames.splice(0, resNames.length, ...resNamesCopy, eItem);
+                        } else {
+                            resNames.push(eItem);
+                        }
+                    }
+
+                    if (value && typeof value === 'object') {
+                        flattenInternal(value, newPath);
+                    }
+                });
+            }
+        }
+
+        flattenInternal(obj);
+        return result;
+    }
+
+    /**
+     * 解析并扁平化 XML 文件
+     * @param {string} xmlPath - XML 文件路径
+     * @returns {Array} 扁平化后的元素数组
+     */
+    static parseAndFlatten(xmlPath) {
+        const jsonObj = this.parseFile(xmlPath);
+        return this.flatten(jsonObj);
+    }
+
+    /**
+     * 解析字符串并扁平化
+     * @param {string} xmlString - XML 字符串
+     * @returns {Array} 扁平化后的元素数组
+     */
+    static parseStringAndFlatten(xmlString) {
+        const jsonObj = this.parseString(xmlString);
+        return this.flatten(jsonObj);
+    }
+}
+
+module.exports = XMLParser;