momo-ai 1.0.20 → 1.0.22

package/src/executor/executeDomain.js

@@ -0,0 +1,293 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const Ec = require('../epic');
+const { parseOptional } = require('../utils/momo-args');
+
+// 脚本路径（相对于项目根目录）
+const SCRIPT_PATH_DOMAIN = 'src/python/r2mo_proto_domain.py';
+const SCRIPT_PATH_DATABASE = 'src/python/r2mo_proto_database.py';
+
+/**
+ * 检查命令是否可用
+ * @param {string} command 命令名称
+ * @returns {Promise<boolean>}
+ */
+const _isCommandAvailable = async (command) => {
+    return new Promise((resolve) => {
+        const whereCmd = process.platform === 'win32' ? 'where' : 'which';
+        const childProcess = spawn(whereCmd, [command], { stdio: 'pipe' });
+        childProcess.on('close', (code) => {
+            resolve(code === 0);
+        });
+        childProcess.on('error', () => {
+            resolve(false);
+        });
+    });
+};
+
+/**
+ * 解析 pom.xml 提取 artifactId（排除 parent 节点）
+ * @param {string} pomPath pom.xml 文件路径
+ * @returns {string|null} artifactId，如果解析失败返回 null
+ */
+const _parsePomXml = (pomPath) => {
+    try {
+        const content = fs.readFileSync(pomPath, 'utf8');
+        
+        // 移除 <parent>...</parent> 节点，避免提取 parent 的 artifactId
+        const withoutParent = content.replace(/<parent>[\s\S]*?<\/parent>/gi, '');
+        
+        // 在剩余内容中查找 artifactId
+        const match = withoutParent.match(/<artifactId>([^<]+)<\/artifactId>/);
+        if (match && match[1]) {
+            return match[1].trim();
+        }
+        return null;
+    } catch (error) {
+        return null;
+    }
+};
+
+/**
+ * 验证 Maven 项目结构
+ * @param {string} targetDir 目标目录
+ * @returns {Object} { isValid: boolean, artifactId: string|null, missing: string[] }
+ */
+const _validateMavenProject = (targetDir) => {
+    const pomPath = path.join(targetDir, 'pom.xml');
+    
+    // 1. 检查 pom.xml 是否存在
+    if (!fs.existsSync(pomPath)) {
+        return {
+            isValid: false,
+            artifactId: null,
+            missing: ['pom.xml'],
+            error: '目录中未找到 pom.xml 文件'
+        };
+    }
+    
+    // 2. 解析 pom.xml 提取 artifactId
+    const artifactId = _parsePomXml(pomPath);
+    if (!artifactId) {
+        return {
+            isValid: false,
+            artifactId: null,
+            missing: ['artifactId'],
+            error: '无法从 pom.xml 中提取 artifactId'
+        };
+    }
+    
+    // 3. 检查 -domain 模块是否存在
+    const missing = [];
+    const domainPath = path.join(targetDir, `${artifactId}-domain`);
+    
+    // 检查同级目录
+    if (!fs.existsSync(domainPath)) {
+        missing.push(`${artifactId}-domain`);
+    }
+    
+    return {
+        isValid: missing.length === 0,
+        artifactId: artifactId,
+        missing: missing,
+        error: missing.length > 0 ? `缺少必需的模块: ${missing.join(', ')}` : null
+    };
+};
+
+/**
+ * 检查目录中是否存在 Flyway 目录（仅考虑 src/main/resources 下）
+ * @param {string} targetDir 目标目录
+ * @returns {boolean}
+ */
+const _checkFlywayDirectory = (targetDir) => {
+    try {
+        const resourcesDir = path.join(targetDir, 'src', 'main', 'resources');
+        if (!fs.existsSync(resourcesDir) || !fs.statSync(resourcesDir).isDirectory()) {
+            return false;
+        }
+        const checkDir = (dir, depth = 0) => {
+            if (depth > 8) return false;
+            const items = fs.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                try {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        const lowerPath = fullPath.toLowerCase();
+                        if (lowerPath.includes('flyway') && lowerPath.includes('mysql')) {
+                            return true;
+                        }
+                        if (checkDir(fullPath, depth + 1)) return true;
+                    }
+                } catch (e) {}
+            }
+            return false;
+        };
+        return checkDir(resourcesDir);
+    } catch (error) {
+        return false;
+    }
+};
+
+/**
+ * 执行 Python 脚本
+ * @param {string} targetDir 目标目录（工作目录）
+ * @param {string} scriptPath 脚本路径（绝对路径）
+ * @param {string[]} [args] 传给脚本的参数，如 ['-i', '.', '-o', '/path/to/out']
+ */
+const _executePythonScript = async (targetDir, scriptPath, args = []) => {
+    return new Promise((resolve, reject) => {
+        Ec.waiting(`🚀 正在执行脚本: ${path.basename(scriptPath).cyan}...`);
+        Ec.waiting(`📁 工作目录: ${targetDir.cyan}`);
+        
+        const child = spawn('python3', [scriptPath, ...args], {
+            cwd: targetDir,
+            stdio: 'inherit',
+            shell: false
+        });
+
+        child.on('close', (code) => {
+            if (code === 0) {
+                Ec.info(`✅ 脚本执行成功`);
+                resolve();
+            } else {
+                reject(new Error(`脚本执行失败，退出码: ${code}`));
+            }
+        });
+
+        child.on('error', (error) => {
+            reject(new Error(`执行脚本失败: ${error.message}`));
+        });
+    });
+};
+
+module.exports = async (options) => {
+    try {
+        // 1. 解析参数
+        const dirArg = parseOptional('dir', 'd');
+        const entityArg = parseOptional('entity', 'e');
+        
+        const targetDir = dirArg.hasFlag && dirArg.value 
+            ? path.resolve(dirArg.value) 
+            : process.cwd();
+        
+        // 默认从 Entity 生成（-e true 或不传参数）
+        const fromEntity = !entityArg.hasFlag || entityArg.value === 'true' || entityArg.value === true;
+        
+        const mode = fromEntity ? 'Entity (Java Domain)' : 'Database (Flyway SQL)';
+        const scriptPath = fromEntity ? SCRIPT_PATH_DOMAIN : SCRIPT_PATH_DATABASE;
+        
+        Ec.info(`📋 生成模式: ${mode.cyan}`);
+        
+        // 2. 验证目录是否存在
+        if (!fs.existsSync(targetDir)) {
+            Ec.error(`❌ 目录不存在: ${targetDir}`);
+            process.exit(1);
+        }
+        
+        if (!fs.statSync(targetDir).isDirectory()) {
+            Ec.error(`❌ 路径不是目录: ${targetDir}`);
+            process.exit(1);
+        }
+        
+        // 3. 如果是 Entity 模式，验证 Maven 项目结构
+        if (fromEntity) {
+            Ec.waiting('正在验证 Maven 项目结构...');
+            const validation = _validateMavenProject(targetDir);
+            
+            if (!validation.isValid) {
+                if (!validation.artifactId) {
+                    Ec.error(`❌ ${validation.error}`);
+                    if (validation.missing.includes('pom.xml')) {
+                        Ec.waiting('请确保指定目录是包含 pom.xml 的 Maven 项目根目录');
+                    } else {
+                        Ec.waiting('请检查 pom.xml 文件格式是否正确');
+                    }
+                    console.log('');
+                    process.exit(1);
+                } else {
+                    Ec.error(`❌ ${validation.error}`);
+                    console.log('');
+                    Ec.waiting(`项目 ID: ${validation.artifactId.cyan}`);
+                    Ec.waiting(`缺少的模块:`);
+                    validation.missing.forEach(module => {
+                        Ec.waiting(`  - ${module.red}`);
+                    });
+                    console.log('');
+                    Ec.waiting('请确保以下模块存在于项目根目录:');
+                    Ec.waiting(`  - ${validation.artifactId}-domain`.cyan);
+                    console.log('');
+                    process.exit(1);
+                }
+            }
+            
+            Ec.info(`✓ Maven 项目验证通过`);
+            Ec.info(`  项目 ID: ${validation.artifactId.cyan}`);
+            Ec.info(`  找到模块: ${validation.artifactId}-domain`.green);
+        } else {
+            // Database 模式：检查是否有 flyway 目录
+            Ec.waiting('正在检查 Flyway SQL 文件...');
+            const hasFlywayDir = _checkFlywayDirectory(targetDir);
+            if (!hasFlywayDir) {
+                Ec.warn(`⚠ 未在目录中找到 flyway/MYSQL 目录`);
+                Ec.waiting('将尝试扫描所有 SQL 文件...');
+            } else {
+                Ec.info('✓ 找到 Flyway 目录');
+            }
+        }
+        
+        // 4. 检查 python3 是否安装
+        Ec.waiting('正在检查 python3 命令...');
+        const python3Available = await _isCommandAvailable('python3');
+        
+        if (!python3Available) {
+            Ec.error('❌ 未找到 python3 命令');
+            console.log('');
+            Ec.error('请先安装 Python 3:');
+            if (process.platform === 'darwin') {
+                console.log('  brew install python3'.cyan);
+            } else if (process.platform === 'win32') {
+                console.log('  从 https://www.python.org/downloads/ 下载安装'.cyan);
+            } else {
+                console.log('  sudo apt-get install python3'.cyan);
+            }
+            console.log('');
+            process.exit(1);
+        }
+        
+        Ec.info('✓ python3 已安装');
+        
+        // 5. 检查脚本文件是否存在
+        const projectRoot = path.resolve(__dirname, '../..');
+        const fullScriptPath = path.join(projectRoot, scriptPath);
+        
+        if (!fs.existsSync(fullScriptPath)) {
+            Ec.error(`❌ 脚本文件不存在: ${fullScriptPath}`);
+            Ec.waiting(`请确保 ${scriptPath} 文件存在`);
+            process.exit(1);
+        }
+        
+        Ec.info(`✓ 找到脚本: ${scriptPath}`);
+        
+        // 6. 执行 Python 脚本（Database 模式需指定输出到 -ui/.r2mo/domain，与 Domain 模式一致）
+        console.log('');
+        let scriptArgs = [];
+        if (!fromEntity) {
+            const rootDir = targetDir.endsWith('-domain') ? path.join(targetDir, '..') : targetDir;
+            const artifactId = _parsePomXml(path.join(rootDir, 'pom.xml'));
+            const outputDir = artifactId
+                ? path.join(rootDir, `${artifactId}-ui`, '.r2mo', 'domain')
+                : path.join(targetDir, 'proto');
+            scriptArgs = ['-i', targetDir, '-o', outputDir];
+            Ec.info(`  输出目录: ${outputDir.cyan}`);
+        }
+        await _executePythonScript(targetDir, fullScriptPath, scriptArgs);
+        
+        process.exit(0);
+        
+    } catch (error) {
+        Ec.error(`❌ 执行失败: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/executeEnv.js

@@ -80,67 +80,77 @@ module.exports = async () => {
 
     Ec.waiting('------------------------------------------------------------');
 
+    // 检查操作系统信息
+    try {
+        const os = require('os');
+        const osType = os.type();
+        const displayOs = osType === 'Darwin' ? 'macOS' : osType;
+        Ec.waiting(`🖥️ OS 版本      : ${displayOs} ${os.release()} ${os.arch()}`);
+    } catch (error) {
+        Ec.waiting('⚠️ 无法获取 OS 系统信息');
+    }
+
+    // 检查 JDK 版本
+    try {
+        // java -version 输出通常在 stderr
+        const { stderr } = await execAsync('java -version');
+        const versionLine = stderr.split('\n')[0]; // 取第一行
+        // 尝试提取引号中的版本号
+        const versionMatch = versionLine.match(/"([^"]+)"/);
+        const version = versionMatch ? versionMatch[1] : versionLine;
+        Ec.waiting(`♨️  JDK 版本     : ${version}`);
+    } catch (error) {
+        Ec.waiting('⚠️ JDK 未安装或无法获取版本信息');
+    }
+
     // 检查额外的环境信息
     try {
         const {stdout: nodeVersion} = await execAsync('node --version');
-        Ec.waiting(`💻 Node.js 版本: ${nodeVersion.trim()}`);
+        Ec.waiting(`💻  Node.js 版本 : ${nodeVersion.trim()}`);
     } catch (error) {
         Ec.waiting('⚠️ 无法获取 Node.js 版本信息');
     }
 
     try {
         const {stdout: npmVersion} = await execAsync('npm --version');
-        Ec.waiting(`📦 NPM 版本: ${npmVersion.trim()}`);
+        Ec.waiting(`📦  NPM 版本     : ${npmVersion.trim()}`);
     } catch (error) {
         Ec.waiting('⚠️ 无法获取 NPM 版本信息');
     }
 
     try {
         const {stdout: gitVersion} = await execAsync('git --version');
-        Ec.waiting(`🌱 Git 版本: ${gitVersion.trim()}`);
+        Ec.waiting(`🌱  Git 版本     : ${gitVersion.trim()}`);
     } catch (error) {
         Ec.waiting('⚠️ 无法获取 Git 版本信息');
     }
 
-    // 检查 trae 版本（可选命令）
-    try {
-        const {stdout: traeVersion} = await execAsync('trae --version');
-        const traeItems = (traeVersion.split("\n"));
-        Ec.waiting(`----> 🎯 Trae 版本: ${traeItems[0].trim()}`);
-    } catch (error) {
-        Ec.waiting('⚠️ Trae 未安装或无法获取版本信息（可选工具）');
-    }
-    
-    // 检查 lingma 版本（可选命令）
-    try {
-        const {stdout: lingmaVersion} = await execAsync('lingma --version');
-        const lingmaItems = (lingmaVersion.split("\n"));
-        Ec.waiting(`----> 🧠 Lingma 版本: ${lingmaItems[0].trim()}`);
-    } catch (error) {
-        Ec.waiting('⚠️ Lingma 未安装或无法获取版本信息（可选工具）');
-    }
-    
-    // 检查 cursor 版本（可选命令）
-    try {
-        const {stdout: cursorVersion} = await execAsync('cursor --version');
-        const cursorItems = (cursorVersion.split("\n"));
-        Ec.waiting(`----> 🖱️ Cursor 版本: ${cursorItems[0].trim()}`);
-    } catch (error) {
-        Ec.waiting('⚠️ Cursor 未安装或无法获取版本信息（可选工具）');
-    }
-    
-    // 检查 kiro 版本（可选命令）
-    try {
-        const {stdout: kiroVersion} = await execAsync('kiro --version');
-        const kiroItems = (kiroVersion.split("\n"));
-        Ec.waiting(`----> ⚡ Kiro 版本: ${kiroItems[0].trim()}`);
-    } catch (error) {
-        Ec.waiting('⚠️ Kiro 未安装或无法获取版本信息（可选工具）');
+    // 定义可选工具列表
+    const optionalTools = [
+        { cmd: 'trae', label: 'Trae 版本   ', emoji: '🎯' },
+        { cmd: 'lingma', label: 'Lingma 版本 ', emoji: '🧠' },
+        { cmd: 'cursor', label: 'Cursor 版本 ', emoji: '👾' },
+        { cmd: 'kiro', label: 'Kiro 版本   ', emoji: '🔮' },
+        { cmd: 'claude', label: 'Claude 版本 ', emoji: '🤖' },
+        { cmd: 'gemini', label: 'Gemini 版本 ', emoji: '🌟' },
+        { cmd: 'codex', label: 'Codex 版本  ', emoji: '💬' }
+    ];
+
+    for (const tool of optionalTools) {
+        try {
+            const {stdout} = await execAsync(`${tool.cmd} --version`);
+            const versionLines = stdout.split("\n");
+            const currentVersion = versionLines[0].trim();
+            Ec.waiting(`----> ${tool.emoji} ${tool.label}: ${currentVersion.cyan}`);
+        } catch (error) {
+             const name = tool.label.trim().replace(' 版本', '');
+             Ec.waiting(`⚠️ ${name} 未安装或无法获取版本信息（可选工具）`);
+        }
     }
 
     // 显示 Momo 版本
     const momoVersion = _getVersion();
-    Ec.waiting(`🤖 Momo 版本: ${momoVersion}`);
+    Ec.waiting(`🤖 Momo 版本: ${momoVersion.red}`);
 
     // 总结（只检查必需命令）
     if (allCommandsAvailable) {

package/src/executor/executeHelp.js

@@ -1,27 +1,88 @@
 const Ec = require('../epic');
-const os = require('os');
+
 module.exports = (options) => {
+    const parsed = Ec.parseArgument(options);
     const metadata = Ec.parseMetadata();
-    metadata.forEach(runner => {
-        Ec.waiting(`命令：` + `momo ${runner.command} [-options]`.green);
-        // 检查描述中是否包含"CV"，如果包含则在(CV)和说明之间添加红色高亮emoji
+
+    // 优先读取 options 中的 command，如果没有则尝试读取位置参数
+    const commandName = parsed.command ? parsed.command : (process.argv[3] && !process.argv[3].startsWith('-') ? process.argv[3] : null);
+
+    if (commandName) {
+        // ---------------------------------------------------------
+        // 单命令详细模式
+        // ---------------------------------------------------------
+        const runner = metadata.find(runner => runner.command === commandName);
+        if (!runner) {
+            Ec.error(`未找到命令 [ ${commandName} ] 的定义信息！`);
+            process.exit(1);
+        }
+
+        // 处理描述文字
         let description = runner.description;
         if (description.includes("（CV）")) {
             description = description.replace("（CV）", "（CV）📋️ ");
         }
-        Ec.waiting(`说明`.yellow + `：${description}`);
-        const options = runner.options || [];
-        options.forEach(option => {
-            if (option.hasOwnProperty('default')) {
-                const str = option.default + '';
-                Ec.waiting(`\t-${option.alias},--${option.name}`.red + `\t${option.description}, 默认值：\uD83C\uDF37 ` + str.blue);
-            } else {
-                Ec.waiting(`\t-${option.alias},--${option.name}`.red + `\t${option.description}`);
+
+        console.log(``);
+        console.log(`${description}`);
+        console.log(``);
+
+        console.log(`Usage:`);
+        console.log(`momo ${runner.command} [options]`);
+        console.log(``);
+
+        const opts = runner.options || [];
+        if (opts.length > 0) {
+            console.log(`Options:`);
+            opts.forEach(option => {
+                const flags = `[-${option.alias}|--${option.name}]`;
+                let desc = option.description;
+                if (option.hasOwnProperty('default')) {
+                    desc += ` (默认: ${option.default})`.blue;
+                }
+
+                // 对齐设置
+                const minPadding = 25;
+                let paddingSpace = minPadding - flags.length;
+                if (paddingSpace < 2) paddingSpace = 2;
+
+                console.log(`${flags.yellow}${' '.repeat(paddingSpace)}${desc}`);
+            });
+            console.log(``);
+        }
+
+    } else {
+        // ---------------------------------------------------------
+        // 所有命令列表模式
+        // ---------------------------------------------------------
+        console.log(``);
+        console.log(`Usage:`);
+        console.log(`momo <command>`);
+        console.log(``);
+        console.log(`All commands:`);
+        console.log(``);
+
+        // 计算最大长度以对齐
+        let maxCmdLen = 0;
+        metadata.forEach(r => {
+            if (r.command.length > maxCmdLen) maxCmdLen = r.command.length;
+        });
+        const alignLen = maxCmdLen + 6;
+
+        metadata.forEach(runner => {
+            let description = runner.description;
+            if (description.includes("（CV）")) {
+                description = description.replace("（CV）", "📋️");
             }
-        })
-        Ec.waiting();
-    });
-    Ec.info("命令执行完成！");
+
+            const padding = ' '.repeat(alignLen - runner.command.length);
+            console.log(`    ${runner.command.green}${padding}${description}`);
+        });
+
+        console.log(``);
+        console.log(`Run "momo help -c <command>" for more info`);
+        console.log(``);
+    }
 
     // 退出程序
     process.exit(0);