momo-ai 1.0.0 → 1.0.2

package/src/executor/executeList.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const path = require('path');
+const Ec = require('../epic');
+
+/**
+ * 从 Markdown 文件中提取编号信息
+ * @param {string} filePath 文件路径
+ * @returns {string} 编号信息或 'N/A'
+ */
+const _extractId = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return 'N/A';
+        }
+        
+        const content = fs.readFileSync(filePath, 'utf8');
+        
+        // 首先尝试查找 <!-- CODE: XXX --> 格式
+        const codeMatch = content.match(/<!--\s*CODE:\s*(.+?)\s*-->/i);
+        if (codeMatch) {
+            return codeMatch[1].trim();
+        }
+        
+        // 如果没有找到CODE格式，尝试查找 "- 编号：" 格式
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const idMatch = line.match(/-\s*编号[：:]\s*(.+)/);
+            if (idMatch) {
+                return idMatch[1].trim();
+            }
+        }
+        
+        return 'N/A';
+    } catch (error) {
+        return 'N/A';
+    }
+};
+
+/**
+ * 统计任务数量
+ * @param {string} tasksFile 任务文件路径
+ * @returns {number} 任务数量
+ */
+const _countTasks = (tasksFile) => {
+    try {
+        if (!fs.existsSync(tasksFile)) {
+            return 0;
+        }
+        
+        const content = fs.readFileSync(tasksFile, 'utf8');
+        const lines = content.split('\n');
+        let count = 0;
+        
+        // 使用更直接的方法匹配任务
+        for (const line of lines) {
+            // 匹配任务格式，例如: - [ ] [任务1简要描述](tasks/M01-T001-01.md)
+            if (line.trim().startsWith('- [') && line.includes('] [') && line.includes('](') && line.includes('tasks/')) {
+                count++;
+            }
+        }
+        
+        return count;
+    } catch (error) {
+        return 0;
+    }
+};
+
+module.exports = (options) => {
+    try {
+        // 构建路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        
+        // 检查 changes 目录是否存在
+        if (!fs.existsSync(changesDir)) {
+            Ec.waiting('未找到任何需求');
+            process.exit(0);
+        }
+        
+        // 读取所有需求目录
+        const requirements = fs.readdirSync(changesDir)
+            .filter(item => {
+                const itemPath = path.join(changesDir, item);
+                return fs.statSync(itemPath).isDirectory();
+            });
+        
+        if (requirements.length === 0) {
+            Ec.waiting('未找到任何需求');
+            process.exit(0);
+        }
+        
+        // 显示表头
+        Ec.waiting('编号\t\t名称\t\t\t任务数量');
+        Ec.waiting('------------------------------------------------');
+        
+        // 显示需求列表
+        requirements.forEach((requirement) => {
+            const proposalFile = path.join(changesDir, requirement, 'proposal.md');
+            const tasksFile = path.join(changesDir, requirement, 'tasks.md');
+            const id = _extractId(proposalFile);
+            const taskCount = _countTasks(tasksFile);
+            Ec.waiting(`${id}\t\t${requirement}\t\t\t${taskCount}`);
+        });
+        
+        Ec.info(`✅ 共找到 ${requirements.length} 个需求`);
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/executeOpen.js

@@ -0,0 +1,150 @@
+const Ec = require('../epic');
+const { spawn } = require('child_process');
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    try {
+        // 定义可用的AI工具
+        const aiTools = [
+            { name: 'Trae', command: 'trae' },
+            { name: 'Cursor', command: 'cursor' },
+            { name: 'Lingma', command: 'lingma' },
+            { name: 'Kiro', command: 'kiro' }
+        ];
+        
+        // 检查哪些工具可用
+        const availableTools = [];
+        for (const tool of aiTools) {
+            if (await _isCommandAvailable(tool.command)) {
+                availableTools.push(tool);
+            }
+        }
+        
+        // 如果没有可用工具，提示用户安装
+        if (availableTools.length === 0) {
+            Ec.error('❌ 未找到可用的AI工具，请确保已安装以下工具之一：Trae、Cursor、Lingma、Kiro');
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 如果只有一个工具可用，直接使用它
+        if (availableTools.length === 1) {
+            const tool = availableTools[0];
+            let toolDisplayName = tool.name;
+            if (tool.name === 'Trae' || tool.name === 'Cursor') {
+                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
+            }
+            if (tool.name === 'Trae') {
+                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName.green}`);
+            } else {
+                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName}`);
+            }
+            await _openWithTool(tool.command);
+            Ec.askClose();
+            process.exit(0);
+        }
+        
+        // 显示交互式选择菜单
+        Ec.waiting('🔍 检测到多个可用的AI工具，请选择要使用的工具:');
+        const choices = availableTools.map((tool, index) => {
+            let toolDisplayName = tool.name;
+            if (tool.name === 'Trae' || tool.name === 'Cursor') {
+                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
+            }
+            if (tool.name === 'Trae') {
+                return `${index + 1}. ${toolDisplayName} ${'推荐'.green}`;
+            } else {
+                return `${index + 1}. ${toolDisplayName}`;
+            }
+        });
+        
+        // 添加退出选项
+        choices.push(`${choices.length + 1}. 退出`);
+        
+        for (const choice of choices) {
+            Ec.waiting(choice);
+        }
+        
+        // 获取用户选择
+        const answer = await Ec.ask('请输入选项编号: ');
+        const selectedIndex = parseInt(answer) - 1;
+        
+        // 检查用户选择
+        if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= availableTools.length) {
+            if (selectedIndex === availableTools.length) {
+                Ec.waiting('👋 已取消操作');
+                Ec.askClose();
+                process.exit(0);
+            }
+            Ec.error('❌ 无效的选择');
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        // 执行选择的工具
+        const selectedTool = availableTools[selectedIndex];
+        let toolDisplayName = selectedTool.name;
+        if (selectedTool.name === 'Trae' || selectedTool.name === 'Cursor') {
+            toolDisplayName = `${selectedTool.name}（${'Multi-Agent'.cyan}）`;
+        }
+        Ec.waiting(`🚀 正在使用 ${toolDisplayName} 打开项目...`);
+        await _openWithTool(selectedTool.command);
+        Ec.askClose();
+        process.exit(0);
+        
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};
+
+/**
+ * 检查命令是否可用
+ * @param {string} command 命令名称
+ * @returns {Promise<boolean>} 命令是否可用
+ */
+const _isCommandAvailable = async (command) => {
+    return new Promise((resolve) => {
+        const process = spawn('which', [command]);
+        process.on('close', (code) => {
+            resolve(code === 0);
+        });
+    });
+};
+
+/**
+ * 使用指定工具打开当前目录
+ * @param {string} tool 工具命令
+ */
+const _openWithTool = async (tool) => {
+    return new Promise((resolve, reject) => {
+        // 使用工具命令打开当前目录
+        const child = spawn(tool, ['.'], { 
+            stdio: 'inherit',
+            cwd: process.cwd()
+        });
+        
+        child.on('close', (code) => {
+            if (code === 0) {
+                Ec.info(`✅ 项目已成功在 ${tool} 中打开`);
+                resolve();
+            } else {
+                Ec.error(`❌ ${tool} 执行失败，退出码: ${code}`);
+                reject(new Error(`${tool} 执行失败，退出码: ${code}`));
+            }
+        });
+        
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                Ec.error(`❌ 未找到命令: ${tool}，请确保已正确安装`);
+                reject(new Error(`未找到命令: ${tool}，请确保已正确安装`));
+            } else {
+                Ec.error(`❌ 执行 ${tool} 时发生错误: ${error.message}`);
+                reject(error);
+            }
+        });
+    });
+};

package/src/executor/executePlan.js

@@ -0,0 +1,134 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const Ec = require('../epic');
+const fsAsync = require('fs').promises;
+
+/**
+ * 读取模板文件并提取 <!-- BEGIN --> 到 <!-- END --> 之间的内容
+ * @param {string} templatePath 模板文件路径
+ * @returns {Promise<string>} 提取的模板内容
+ */
+const _readTemplate = async (templatePath) => {
+    try {
+        const content = await fsAsync.readFile(templatePath, 'utf8');
+        const lines = content.split('\n');
+        let beginIndex = -1;
+        let endIndex = -1;
+        
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('<!-- BEGIN -->')) {
+                beginIndex = i;
+            } else if (lines[i].includes('<!-- END -->')) {
+                endIndex = i;
+                break;
+            }
+        }
+        
+        if (beginIndex !== -1 && endIndex !== -1) {
+            // 提取 BEGIN 和 END 之间的内容（不包括 BEGIN 和 END 行）
+            return lines.slice(beginIndex + 1, endIndex).join('\n');
+        }
+        
+        return content;
+    } catch (error) {
+        Ec.waiting(`读取模板文件失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 渲染 EJS 模板
+ * @param {string} template 模板内容
+ * @param {Object} data 数据对象
+ * @returns {string} 渲染后的内容
+ */
+const _renderTemplate = (template, data) => {
+    let result = template;
+    for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+            const regex = new RegExp(`<%=\\s*${key}\\s*%>`, 'g');
+            result = result.replace(regex, data[key]);
+        }
+    }
+    return result;
+};
+
+/**
+ * 检查需求目录是否存在
+ * @param {string} changesDir changes目录路径
+ * @param {string} requirementName 需求名称
+ * @returns {boolean} 是否存在
+ */
+const _isRequirementExists = (changesDir, requirementName) => {
+    const requirementDir = path.join(changesDir, requirementName);
+    return fs.existsSync(requirementDir);
+};
+
+/**
+ * 将内容复制到剪贴板（去除换行符）
+ * @param {string} content 要复制的内容
+ */
+const _copyToClipboard = async (content) => {
+    try {
+        // 去除换行符，将内容合并为一行后再复制到剪贴板
+        const contentWithoutNewlines = content.replace(/\r?\n|\r/g, ' ');
+        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        proc.stdin.write(contentWithoutNewlines);
+        proc.stdin.end();
+        Ec.waiting('✅ 计划提示词已复制到剪贴板');
+    } catch (error) {
+        Ec.waiting(`复制到剪贴板失败: ${error.message}`);
+        // 在非 macOS 系统上可能没有 pbcopy，提供备选方案
+        Ec.waiting('计划提示词内容:');
+        console.log(content);
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    // 获取需求名称
+    const requirementName = parsed.name || parsed.n;
+    
+    // 验证参数
+    if (!requirementName) {
+        Ec.error("❌ 请提供需求名称 (-n, --name)");
+        process.exit(1);
+    }
+    
+    // 检查需求名称是否包含点号（扩展名）
+    if (requirementName.includes('.')) {
+        Ec.error("❌ 需求名称不能包含点号(.)，以防止与文件扩展名混淆");
+        process.exit(1);
+    }
+    
+    Ec.waiting(`准备生成需求计划: ${requirementName}`);
+    
+    try {
+        // 获取项目路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        const promptTemplatePath = path.join(__dirname, '../_template/PROMPT/plan.md.ejs');
+        
+        // 检查需求是否存在
+        if (!_isRequirementExists(changesDir, requirementName)) {
+            Ec.error(`❌ 需求 "${requirementName}" 不存在`);
+            process.exit(1);
+        }
+        
+        // 读取并处理提示词模板
+        const templateContent = await _readTemplate(promptTemplatePath);
+        const renderedContent = _renderTemplate(templateContent, { NAME: requirementName });
+        
+        // 将提示词复制到剪贴板
+        await _copyToClipboard(renderedContent);
+        
+        Ec.info(`✅ 成功生成需求 "${requirementName}" 的计划提示词`);
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};

package/src/executor/executeRepo.js

@@ -0,0 +1,234 @@
+const fs = require('fs');
+const path = require('path');
+const {exec} = require('child_process');
+const util = require('util');
+const Ec = require('../epic');
+
+// 将 exec 转换为 Promise 版本
+const execAsync = util.promisify(exec);
+
+/**
+ * 检查当前目录是否为 Git 仓库
+ * @returns {Promise<boolean>} 是否为 Git 仓库
+ */
+const _isGitRepo = async () => {
+    try {
+        await execAsync('git rev-parse --git-dir');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+/**
+ * 初始化当前目录为 Git 仓库
+ */
+const _initGitRepo = async () => {
+    try {
+        Ec.waiting('正在初始化 Git 仓库');
+        const command = 'git init -b master';
+        await execAsync(command);
+        Ec.waiting('✅ 成功初始化 Git 仓库');
+    } catch (error) {
+        Ec.error(`❌ 初始化 Git 仓库失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 添加远程仓库作为 submodule
+ * @param {string} repoUrl 远程仓库地址
+ * @param {string} targetDir 目标目录（相对路径）
+ */
+const _addSubmodule = async (repoUrl, targetDir) => {
+    try {
+        Ec.waiting(`正在添加 Submodule ${repoUrl} 到 ${targetDir}`);
+        // 使用相对路径添加 submodule
+        const command = `git submodule add ${repoUrl} ${targetDir}`;
+
+        // 使用 spawn 实现实时输出
+        const {spawn} = require('child_process');
+        const gitProcess = spawn('git', ['submodule', 'add', repoUrl, targetDir]);
+
+        // 实时输出 stdout
+        gitProcess.stdout.on('data', (data) => {
+            Ec.waiting(`Submodule 添加输出: ${data.toString().trim()}`);
+        });
+
+        // 实时输出 stderr
+        gitProcess.stderr.on('data', (data) => {
+            Ec.waiting(`Submodule 添加进度: ${data.toString().trim()}`);
+        });
+
+        // 等待进程完成
+        await new Promise((resolve, reject) => {
+            gitProcess.on('close', (code) => {
+                if (code === 0) {
+                    Ec.waiting(`✅ 成功添加 Submodule 到 ${targetDir}`);
+                    resolve();
+                } else {
+                    Ec.error(`❌ git submodule add 命令退出码: ${code}`);
+                    reject(new Error(`git submodule add 命令退出码: ${code}`));
+                }
+            });
+
+            gitProcess.on('error', (error) => {
+                Ec.error(`❌ 添加 Submodule 失败: ${error.message}`);
+                reject(error);
+            });
+        });
+    } catch (error) {
+        Ec.error(`❌ 添加 Submodule 失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 初始化并更新 submodule
+ */
+const _initAndUpdateSubmodules = async () => {
+    try {
+        Ec.waiting('正在初始化并更新所有 Submodule');
+        const command = 'git submodule update --init --recursive';
+
+        // 使用 spawn 实现实时输出
+        const {spawn} = require('child_process');
+        const gitProcess = spawn('git', ['submodule', 'update', '--init', '--recursive']);
+
+        // 实时输出 stdout
+        gitProcess.stdout.on('data', (data) => {
+            Ec.waiting(`Submodule 初始化输出: ${data.toString().trim()}`);
+        });
+
+        // 实时输出 stderr
+        gitProcess.stderr.on('data', (data) => {
+            Ec.waiting(`Submodule 初始化进度: ${data.toString().trim()}`);
+        });
+
+        // 等待进程完成
+        await new Promise((resolve, reject) => {
+            gitProcess.on('close', (code) => {
+                if (code === 0) {
+                    Ec.waiting('✅ 成功初始化并更新所有 Submodule');
+                    resolve();
+                } else {
+                    Ec.error(`❌ git submodule update 命令退出码: ${code}`);
+                    reject(new Error(`git submodule update 命令退出码: ${code}`));
+                }
+            });
+
+            gitProcess.on('error', (error) => {
+                Ec.error(`❌ 初始化并更新 Submodule 失败: ${error.message}`);
+                reject(error);
+            });
+        });
+    } catch (error) {
+        Ec.error(`❌ 初始化并更新 Submodule 失败: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * 创建目录（如果不存在）
+ * @param {string} dirPath 目录路径
+ */
+const _createDirIfNotExists = async (dirPath) => {
+    if (!fs.existsSync(dirPath)) {
+        await fs.promises.mkdir(dirPath, {recursive: true});
+    }
+};
+
+/**
+ * 获取下一个可用的 develop 目录编号
+ * @param {string} sourceDir source 目录路径
+ * @returns {number} 下一个可用的编号
+ */
+const _getNextDevelopNumber = (sourceDir) => {
+    if (!fs.existsSync(sourceDir)) {
+        return 1;
+    }
+
+    const files = fs.readdirSync(sourceDir);
+    const developDirs = files.filter(file =>
+        fs.statSync(path.join(sourceDir, file)).isDirectory() &&
+        file.startsWith('develop-')
+    );
+
+    if (developDirs.length === 0) {
+        return 1;
+    }
+
+    // 提取编号并找出最大值
+    const numbers = developDirs.map(dir => {
+        const match = dir.match(/^develop-(\d+)$/);
+        return match ? parseInt(match[1], 10) : 0;
+    });
+
+    return Math.max(...numbers) + 1;
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    // 获取参数
+    const repoUrl = parsed.address || parsed.a;
+    const instanceCount = parsed.i || parsed.instance || 10; // 默认值为10
+    
+    // 验证参数
+    if (!repoUrl) {
+        Ec.error("❌ 请提供远程仓库地址 (-a, --address)");
+        process.exit(1);
+    }
+    
+    // 验证 instanceCount 范围（只能是2位数）
+    if (instanceCount < 1 || instanceCount > 99) {
+        Ec.error("❌ 实例数量必须在 1-99 之间");
+        process.exit(1);
+    }
+    
+    Ec.waiting(`准备添加 Submodule ${repoUrl}，创建 ${instanceCount} 个实例副本...`);
+    
+    try {
+        // 检查当前目录是否为 Git 仓库，如果不是则初始化
+        const isGitRepo = await _isGitRepo();
+        if (!isGitRepo) {
+            await _initGitRepo();
+        }
+        
+        // 确保 source 目录存在
+        const sourceDir = path.resolve(process.cwd(), 'source');
+        await _createDirIfNotExists(sourceDir);
+        
+        // 获取起始编号
+        let startNumber = _getNextDevelopNumber(sourceDir);
+        
+        // 添加指定数量的 submodule 实例
+        for (let i = 0; i < instanceCount; i++) {
+            const developNumber = startNumber + i;
+            // 格式化为两位数
+            const formattedNumber = developNumber.toString().padStart(2, '0');
+            // 使用相对路径
+            const targetDir = path.join('source', `develop-${formattedNumber}`);
+            
+            // 如果目录已存在，跳过
+            const fullPath = path.join(process.cwd(), targetDir);
+            if (fs.existsSync(fullPath)) {
+                Ec.waiting(`⚠️  目录 ${targetDir} 已存在，跳过`);
+                continue;
+            }
+            
+            // 添加 submodule
+            await _addSubmodule(repoUrl, targetDir);
+        }
+        
+        // 初始化并更新所有 submodule
+        await _initAndUpdateSubmodules();
+        
+        Ec.info('✅ 所有 Submodule 添加完成！');
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};