momo-ai 1.0.0 → 1.0.2

package/src/executor/executeRun.js

@@ -0,0 +1,527 @@
+const Ec = require('../epic');
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const {spawn} = require('child_process');
+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} content 要复制的内容
+ */
+const _copyToClipboard = async (content) => {
+    try {
+        const proc = spawn('pbcopy', {stdio: 'pipe'});
+        proc.stdin.write(content);
+        proc.stdin.end();
+
+        // 等待复制操作完成
+        await new Promise((resolve, reject) => {
+            proc.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`pbcopy 进程退出码: ${code}`));
+                }
+            });
+            proc.on('error', reject);
+        });
+
+        Ec.waiting('📄 任务执行提示词已拷贝到剪切板');
+    } catch (error) {
+        Ec.waiting(`⚠️  无法拷贝到剪切板: ${error.message}`);
+        // 备选方案：显示内容
+        Ec.waiting('提示词内容:');
+        console.log(content);
+    }
+};
+
+/**
+ * 查找所有匹配的任务实例
+ * @param {string} taskName 任务名称
+ * @returns {Array} 任务实例列表
+ */
+const _findTaskInstances = (taskName) => {
+    const changesDir = path.resolve(process.cwd(), 'specification', 'changes');
+    const taskInstances = [];
+
+    if (!fs.existsSync(changesDir)) {
+        return taskInstances;
+    }
+
+    // 获取所有需求目录
+    const requirements = fs.readdirSync(changesDir).filter(file =>
+        fs.statSync(path.join(changesDir, file)).isDirectory()
+    );
+
+    // 查找所有匹配的任务文件
+    requirements.forEach(requirement => {
+        const tasksDir = path.resolve(changesDir, requirement, 'tasks');
+
+        // 检查 tasks 目录是否存在
+        if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+            const taskFile = `${taskName}.md`;
+            const taskPath = path.resolve(tasksDir, taskFile);
+
+            // 检查任务文件是否存在
+            if (fs.existsSync(taskPath)) {
+                taskInstances.push({
+                    name: taskName,
+                    path: taskPath,
+                    requirement: requirement,
+                    relativePath: path.relative(process.cwd(), taskPath)
+                });
+            }
+        }
+    });
+
+    return taskInstances;
+};
+
+/**
+ * 枚举所有可用的任务
+ * @returns {Array} 任务列表
+ */
+const _enumerateAllTasks = () => {
+    const changesDir = path.resolve(process.cwd(), 'specification', 'changes');
+    const tasks = [];
+    
+    if (!fs.existsSync(changesDir)) {
+        return tasks;
+    }
+    
+    // 获取所有需求目录
+    const requirements = fs.readdirSync(changesDir).filter(file => 
+        fs.statSync(path.join(changesDir, file)).isDirectory()
+    );
+    
+    // 查找所有任务文件
+    requirements.forEach(requirement => {
+        const tasksDir = path.resolve(changesDir, requirement, 'tasks');
+        
+        // 检查 tasks 目录是否存在
+        if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+            const taskFiles = fs.readdirSync(tasksDir).filter(file => 
+                file.endsWith('.md')
+            );
+            
+            taskFiles.forEach(taskFile => {
+                const taskName = path.basename(taskFile, '.md');
+                const taskPath = path.resolve(tasksDir, taskFile);
+                const title = _extractTitleFromMarkdown(taskPath);
+                
+                tasks.push({
+                    name: taskName,
+                    path: taskPath,
+                    requirement: requirement,
+                    relativePath: path.relative(process.cwd(), taskPath),
+                    display: `${requirement}/${taskName}`,
+                    title: title
+                });
+            });
+        }
+    });
+    
+    return tasks;
+};
+
+/**
+ * 获取所有可用的工作空间（排除已被锁定的）
+ * @returns {Array} 可用工作空间列表
+ */
+const _getAvailableWorkspaces = () => {
+    const sourceDir = path.resolve(process.cwd(), 'source');
+    const workspaces = [];
+
+    if (!fs.existsSync(sourceDir)) {
+        return workspaces;
+    }
+
+    // 获取所有目录
+    const dirs = fs.readdirSync(sourceDir).filter(file =>
+        fs.statSync(path.join(sourceDir, file)).isDirectory()
+    );
+
+    // 检查哪些工作空间可用（没有对应的.lock文件）
+    dirs.forEach(dir => {
+        const lockFilePath = path.resolve(sourceDir, `${dir}.lock`);
+        if (!fs.existsSync(lockFilePath)) {
+            workspaces.push({
+                name: dir,
+                path: path.join('source', dir)
+            });
+        }
+    });
+
+    return workspaces;
+};
+
+/**
+ * 自动选择一个可用的工作空间
+ * @returns {Object|null} 选中的工作空间对象或null
+ */
+const _selectWorkspace = () => {
+    const workspaces = _getAvailableWorkspaces();
+
+    if (workspaces.length === 0) {
+        return null;
+    }
+
+    // 随机选择一个工作空间
+    const randomIndex = Math.floor(Math.random() * workspaces.length);
+    return workspaces[randomIndex];
+};
+
+/**
+ * 创建任务锁文件
+ * @param {string} taskName 任务名称
+ * @param {string} requirementName 需求名称
+ * @param {string} actorName Actor名称
+ * @returns {string} 锁文件路径
+ */
+const _createTaskLock = (taskName, requirementName, actorName) => {
+    const taskLockDir = path.resolve(process.cwd(), 'specification', 'changes', requirementName, 'tasks');
+    const taskLockPath = path.resolve(taskLockDir, `${taskName}.lock`);
+
+    // 确保目录存在
+    if (!fs.existsSync(taskLockDir)) {
+        fs.mkdirSync(taskLockDir, {recursive: true});
+    }
+
+    // 创建锁文件
+    fs.writeFileSync(taskLockPath, `Locked by: ${actorName}\nLocked at: ${new Date().toISOString()}\n`);
+    return taskLockPath;
+};
+
+/**
+ * 创建工作空间锁文件
+ * @param {string} workspaceName 工作空间名称
+ * @param {string} taskName 任务名称
+ * @param {string} actorName Actor名称
+ * @returns {string} 锁文件路径
+ */
+const _createWorkspaceLock = (workspaceName, taskName, actorName) => {
+    const sourceDir = path.resolve(process.cwd(), 'source');
+    const workspaceLockPath = path.resolve(sourceDir, `${workspaceName}.lock`);
+
+    // 创建锁文件
+    fs.writeFileSync(workspaceLockPath, `Task: ${taskName}\nLocked by: ${actorName}\nLocked at: ${new Date().toISOString()}\n`);
+    return workspaceLockPath;
+};
+
+/**
+ * 检查任务状态
+ * @param {string} taskName 任务名称
+ * @param {string} tasksDir 任务目录
+ * @returns {string} 任务状态
+ */
+const _checkTaskStatus = (taskName, tasksDir) => {
+    // 检查.lock文件（进行中）
+    const lockFile = path.join(tasksDir, `${taskName}.lock`);
+    if (fs.existsSync(lockFile)) {
+        return '进行中';
+    }
+
+    // 检查.done文件（已完成）
+    const doneFile = path.join(tasksDir, `${taskName}.done`);
+    if (fs.existsSync(doneFile)) {
+        return '已完成';
+    }
+
+    // 默认状态（未开始）
+    return '未开始';
+};
+
+/**
+ * 从 Markdown 文件中提取第一个标题
+ * @param {string} filePath 文件路径
+ * @returns {string} 第一个标题内容
+ */
+const _extractTitleFromMarkdown = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return path.basename(filePath, '.md');
+        }
+        
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        for (const line of lines) {
+            // 匹配 # 开头的标题行
+            const titleMatch = line.match(/^#\s+(.+)$/);
+            if (titleMatch) {
+                return titleMatch[1].trim();
+            }
+        }
+        
+        // 如果没有找到标题，使用文件名（不含扩展名）作为任务名称
+        return path.basename(filePath, '.md');
+    } catch (error) {
+        return path.basename(filePath, '.md');
+    }
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+
+    const actorName = parsed.actor;
+    const taskName = parsed.task;
+
+    try {
+        let selectedTask;
+
+        // 如果没有提供任务名称，则让用户选择任务
+        if (!taskName || taskName === 'unset') {
+            Ec.waiting("🔍 未指定任务，正在枚举所有可用任务...");
+
+            // 枚举所有任务
+            const allTasks = _enumerateAllTasks();
+
+            if (allTasks.length === 0) {
+                Ec.error("❌ 未找到任何任务");
+                Ec.askClose();
+                process.exit(1);
+            }
+
+            // 循环直到用户选择一个非进行中的任务
+            while (true) {
+                Ec.waiting(`🔍 找到 ${allTasks.length} 个任务，请选择要执行的任务:`);
+
+                allTasks.forEach((task, index) => {
+                    // 获取任务状态
+                    const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', task.requirement, 'tasks');
+                    const status = _checkTaskStatus(task.name, tasksDir);
+                    
+                    // 为状态添加颜色代码
+                    let coloredStatus;
+                    switch (status) {
+                        case '进行中':
+                            coloredStatus = status.blue;
+                            break;
+                        case '已完成':
+                            coloredStatus = status.green;
+                            break;
+                        case '未开始':
+                            coloredStatus = status.red;
+                            break;
+                        default:
+                            coloredStatus = status;
+                    }
+                    
+                    const coloredName = task.name.cyan;
+                    Ec.waiting(`${index + 1}. [${coloredStatus}] ${task.display} (${coloredName})`);
+                });
+
+                // 获取用户选择
+                const answer = await Ec.ask('请输入选项编号: ');
+                const selectedIndex = parseInt(answer) - 1;
+
+                // 验证选择
+                if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= allTasks.length) {
+                    Ec.error('❌ 无效的选择');
+                    continue;
+                }
+
+                // 检查选中的任务是否正在进行中
+                const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', allTasks[selectedIndex].requirement, 'tasks');
+                const status = _checkTaskStatus(allTasks[selectedIndex].name, tasksDir);
+                
+                if (status === '进行中') {
+                    Ec.error('❌ 不能选择正在进行中的任务，请重新选择');
+                    continue;
+                }
+
+                // 直接使用用户选择的任务，跳过重复检查
+                selectedTask = allTasks[selectedIndex];
+                Ec.waiting(`✅ 选择任务: ${selectedTask.display}`);
+                break;
+            }
+        } else {
+            // 查找所有匹配的任务实例
+            const taskInstances = _findTaskInstances(taskName);
+
+            if (taskInstances.length === 0) {
+                Ec.error(`❌ 未找到任务 ${taskName}`);
+                Ec.askClose();
+                process.exit(1);
+            }
+
+            // 如果有多个任务实例，让用户选择
+            if (taskInstances.length > 1) {
+                // 循环直到用户选择一个非进行中的任务
+                while (true) {
+                    Ec.waiting(`🔍 发现 ${taskInstances.length} 个重复任务，请选择要执行的任务:`);
+
+                    taskInstances.forEach((task, index) => {
+                        // 获取任务状态
+                        const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', task.requirement, 'tasks');
+                        const status = _checkTaskStatus(task.name, tasksDir);
+                        
+                        // 为状态添加颜色代码
+                        let coloredStatus;
+                        switch (status) {
+                            case '进行中':
+                                coloredStatus = status.blue;
+                                break;
+                            case '已完成':
+                                coloredStatus = status.green;
+                                break;
+                            case '未开始':
+                                coloredStatus = status.red;
+                                break;
+                            default:
+                                coloredStatus = status;
+                        }
+                        
+                        const coloredName = task.name.cyan;
+                        Ec.waiting(`${index + 1}. [${coloredStatus}] ${task.relativePath} (${coloredName})`);
+                    });
+
+                    // 获取用户选择
+                    const answer = await Ec.ask('请输入选项编号: ');
+                    const selectedIndex = parseInt(answer) - 1;
+
+                    // 验证选择
+                    if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= taskInstances.length) {
+                        Ec.error('❌ 无效的选择');
+                        continue;
+                    }
+
+                    // 检查选中的任务是否正在进行中
+                    const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', taskInstances[selectedIndex].requirement, 'tasks');
+                    const status = _checkTaskStatus(taskInstances[selectedIndex].name, tasksDir);
+                    
+                    if (status === '进行中') {
+                        Ec.error('❌ 不能选择正在进行中的任务，请重新选择');
+                        continue;
+                    }
+
+                    selectedTask = taskInstances[selectedIndex];
+                    break;
+                }
+            } else {
+                // 检查唯一任务是否正在进行中
+                const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', taskInstances[0].requirement, 'tasks');
+                const status = _checkTaskStatus(taskInstances[0].name, tasksDir);
+                
+                if (status === '进行中') {
+                    Ec.error(`❌ 任务 ${taskName} 正在进行中，无法重复执行`);
+                    Ec.askClose();
+                    process.exit(1);
+                }
+                
+                selectedTask = taskInstances[0];
+            }
+
+            Ec.waiting(`✅ 找到任务: ${selectedTask.relativePath}`);
+        }
+
+        // 记录需求名称
+        const requirementName = selectedTask.requirement;
+
+        // 自动选择工作空间
+        const selectedWorkspace = _selectWorkspace();
+
+        if (!selectedWorkspace) {
+            Ec.error("❌ 所有工作空间都已被占用，请稍后再试");
+            Ec.askClose();
+            process.exit(1);
+        }
+
+        // 创建锁文件
+        let taskLockPath = null;
+        let workspaceLockPath = null;
+
+        // 创建任务锁文件
+        if (requirementName) {
+            taskLockPath = _createTaskLock(selectedTask.name, requirementName, actorName);
+        }
+
+        // 创建工作空间锁文件
+        if (selectedWorkspace) {
+            workspaceLockPath = _createWorkspaceLock(selectedWorkspace.name, selectedTask.name, actorName);
+        }
+
+        // 读取模板文件并填充参数，然后拷贝到剪贴板
+        const templatePath = path.resolve(__dirname, '../_template/PROMPT/run.md.ejs');
+
+        if (fs.existsSync(templatePath)) {
+            try {
+                // 读取并处理提示词模板
+                const templateContent = await _readTemplate(templatePath);
+                const renderedContent = _renderTemplate(templateContent, {
+                    TASK: selectedTask.name,
+                    REQ: requirementName,
+                    ROOT: selectedWorkspace ? selectedWorkspace.path : 'source/<WORKSPACE_PATH>'
+                });
+
+                // 将提示词复制到剪贴板
+                await _copyToClipboard(renderedContent);
+                Ec.info(`✅ 任务 ${selectedTask.name} 准备完成，请查看剪切板中的提示词`);
+            } catch (error) {
+                Ec.info(`✅ 任务 ${selectedTask.name} 查找完成`);
+            }
+        } else {
+            Ec.info(`✅ 任务 ${selectedTask.name} 查找完成`);
+        }
+
+        Ec.askClose();
+        process.exit(0);
+        
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        Ec.askClose();
+        process.exit(1);
+    }
+};

package/src/executor/executeShow.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+const Ec = require('../epic');
+
+/**
+ * 解析 Markdown 文件内容，提取标题结构
+ * @param {string} content 文件内容
+ * @returns {Array} 标题结构数组
+ */
+const _parseMarkdownStructure = (content) => {
+    const lines = content.split('\n');
+    const structure = [];
+    const stack = [];
+    
+    lines.forEach(line => {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const title = headingMatch[2].trim();
+            
+            // 调整栈以匹配当前层级
+            while (stack.length >= level) {
+                stack.pop();
+            }
+            
+            const item = { level, title, children: [] };
+            
+            if (stack.length > 0) {
+                stack[stack.length - 1].children.push(item);
+            } else {
+                structure.push(item);
+            }
+            
+            stack.push(item);
+        }
+    });
+    
+    return structure;
+};
+
+/**
+ * 打印树型结构
+ * @param {Array} items 结构项数组
+ * @param {number} indent 缩进级别
+ */
+const _printTree = (items, indent = 0) => {
+    items.forEach(item => {
+        const prefix = '  '.repeat(indent);
+        Ec.waiting(`${prefix}├─ ${item.title}`);
+        
+        if (item.children && item.children.length > 0) {
+            _printTree(item.children, indent + 1);
+        }
+    });
+};
+
+/**
+ * 提取任务清单
+ * @param {string} tasksFile 任务文件路径
+ * @returns {Array} 任务列表
+ */
+const _extractTaskList = (tasksFile) => {
+    const tasks = [];
+    
+    try {
+        if (!fs.existsSync(tasksFile)) {
+            return tasks;
+        }
+        
+        const content = fs.readFileSync(tasksFile, 'utf8');
+        const lines = content.split('\n');
+        
+        // 使用与 executeList.js 相同的逻辑来匹配任务
+        for (const line of lines) {
+            // 匹配任务格式，例如: - [ ] [任务1简要描述](tasks/M01-T001-01.md)
+            if (line.trim().startsWith('- [') && line.includes('] [') && line.includes('](') && line.includes('tasks/')) {
+                // 提取任务描述部分，使用更兼容的正则表达式
+                const titleMatch = line.match(/] $$(.*?)$$$(tasks\/)/);
+                if (titleMatch) {
+                    // 获取标题和链接
+                    const fullMatch = line.match(/] $$(.*?)$$$(tasks\/[^)]+)$/);
+                    if (fullMatch) {
+                        tasks.push({
+                            title: fullMatch[1],
+                            link: fullMatch[2]
+                        });
+                    }
+                } else {
+                    // 备用方案：简单提取方括号中的内容
+                    const simpleMatch = line.match(/\[([^\]]+)\]/g);
+                    if (simpleMatch && simpleMatch.length >= 2) {
+                        tasks.push({
+                            title: simpleMatch[1].substring(1, simpleMatch[1].length - 1),
+                            link: ''
+                        });
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        // 忽略错误，返回空任务列表
+    }
+    
+    return tasks;
+};
+
+module.exports = (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    const requirementName = parsed.name || parsed.n;
+    
+    // 验证参数
+    if (!requirementName) {
+        Ec.error("❌ 请提供需求名称 (-n, --name)");
+        process.exit(1);
+    }
+    
+    try {
+        // 构建路径
+        const projectDir = process.cwd();
+        const changesDir = path.join(projectDir, 'specification', 'changes');
+        const requirementDir = path.join(changesDir, requirementName);
+        
+        // 检查需求目录是否存在
+        if (!fs.existsSync(requirementDir)) {
+            Ec.error(`❌ 需求 "${requirementName}" 不存在`);
+            process.exit(1);
+        }
+        
+        // 读取 proposal.md 文件
+        const proposalFile = path.join(requirementDir, 'proposal.md');
+        if (!fs.existsSync(proposalFile)) {
+            Ec.error(`❌ 需求 "${requirementName}" 中未找到 proposal.md 文件`);
+            process.exit(1);
+        }
+        
+        const content = fs.readFileSync(proposalFile, 'utf8');
+        
+        // 解析并显示结构
+        Ec.waiting(`需求名称: ${requirementName}`);
+        Ec.waiting('文档结构:');
+        const structure = _parseMarkdownStructure(content);
+        _printTree(structure);
+        
+        // 提取并显示任务清单
+        const tasksFile = path.join(requirementDir, 'tasks.md');
+        const tasks = _extractTaskList(tasksFile);
+        
+        Ec.waiting(`\n任务清单 (共${tasks.length}个任务):`);
+        if (tasks.length > 0) {
+            tasks.forEach((task, index) => {
+                Ec.waiting(`  ${index + 1}. ${task.title}`);
+            });
+        } else {
+            Ec.waiting('  无');
+        }
+        
+        Ec.info('✅ 需求详情显示完成');
+        process.exit(0);
+    } catch (error) {
+        Ec.error(`❌ 执行过程中发生错误: ${error.message}`);
+        process.exit(1);
+    }
+};