momo-ai 1.0.20 → 1.0.22

package/src/executor/executeRun.js

@@ -1,644 +0,0 @@
-const Ec = require('../epic');
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-const { outCopy } = require('../epic/momo.fn.out');
-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 要复制的内容
- * @param {string} requirementName 需求名称
- * @param {string} taskName 任务名称
- */
-const _copyToClipboard = async (content, requirementName, taskName) => {
-    try {
-        // 使用统一的剪贴板函数
-        await outCopy(content);
-        Ec.waiting('📄 任务执行提示词已拷贝到剪切板');
-        
-        // 保存内容到 .working 目录
-        const workingDir = path.resolve(process.cwd(), '.working');
-        const fileName = `REQ-${requirementName}-${taskName}.txt`;
-        const filePath = path.join(workingDir, fileName);
-        
-        // 确保 .working 目录存在
-        if (!fs.existsSync(workingDir)) {
-            await fsAsync.mkdir(workingDir, { recursive: true });
-        }
-        
-        // 写入文件
-        await fsAsync.writeFile(filePath, content);
-        Ec.waiting(`📄 任务执行提示词已保存到文件: ${filePath}`);
-    } catch (error) {
-        Ec.waiting(`⚠️  无法拷贝到剪切板: ${error.message}`);
-        // 备选方案：显示内容
-        Ec.waiting('提示词内容:');
-        console.log(content);
-        if (process.platform === 'win32') {
-            Ec.waiting('💡 Windows 用户提示: 请确保您在具有足够权限的命令行中运行此命令');
-        }
-    }
-};
-
-/**
- * 查找所有匹配的任务实例
- * @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()) {
-            // 检查 .md 文件
-            const taskFile = `${taskName}.md`;
-            const taskPath = path.resolve(tasksDir, taskFile);
-
-            // 检查任务文件是否存在
-            if (fs.existsSync(taskPath)) {
-                // 提取任务标题
-                const title = _extractTitleFromMarkdown(taskPath);
-                taskInstances.push({
-                    name: taskName,
-                    path: taskPath,
-                    requirement: requirement,
-                    relativePath: path.relative(process.cwd(), taskPath),
-                    title: title
-                });
-            }
-            
-            // 如果 .md 文件不存在，检查 .done 文件
-            const doneFile = `${taskName}.done`;
-            const donePath = path.resolve(tasksDir, doneFile);
-            
-            if (!fs.existsSync(taskPath) && fs.existsSync(donePath)) {
-                // 提取任务标题（从 .done 文件中）
-                const title = _extractTitleFromMarkdown(donePath);
-                taskInstances.push({
-                    name: taskName,
-                    path: donePath,
-                    requirement: requirement,
-                    relativePath: path.relative(process.cwd(), donePath),
-                    title: title
-                });
-            }
-        }
-    });
-
-    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');
-    }
-};
-
-/**
- * 保存任务分派记录
- * @param {string} taskName 任务名称
- * @param {string} workspaceName 工作空间名称
- * @param {string} actorName Actor名称
- * @param {string} requirementName 需求名称
- */
-const _saveAssignmentRecord = async (taskName, workspaceName, actorName, requirementName) => {
-    try {
-        // 确保 .activities 目录存在
-        const activitiesDir = path.resolve(process.cwd(), '.activities');
-        if (!fs.existsSync(activitiesDir)) {
-            await fsAsync.mkdir(activitiesDir, { recursive: true });
-        }
-
-        // 创建文件名：{任务编号}-develop-xx-时间戳.txt
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, -5);
-        // 只使用工作空间名称，而不是完整路径
-        const workspaceDirName = path.basename(workspaceName);
-        const fileName = `${taskName}-${workspaceDirName}-${timestamp}.txt`;
-        const filePath = path.join(activitiesDir, fileName);
-
-        // 写入分派记录
-        const recordContent = `Task Assignment Record
-=====================
-
-Task Name: ${taskName}
-Workspace: ${workspaceDirName}
-Actor: ${actorName}
-Requirement: ${requirementName}
-Assigned At: ${new Date().toISOString()}
-
-This task has been assigned to workspace ${workspaceDirName} for actor ${actorName}.
-`;
-        
-        await fsAsync.writeFile(filePath, recordContent);
-        Ec.waiting(`[Momo AI] 任务分派记录已保存: ${filePath}`);
-    } catch (error) {
-        Ec.waiting(`⚠️  无法保存任务分派记录: ${error.message}`);
-    }
-};
-
-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})`);
-                });
-                
-                // 添加退出选项
-                Ec.waiting(`${allTasks.length + 1}. 退出`);
-
-                // 获取用户选择
-                const answer = await Ec.ask('请输入选项编号: ');
-                const selectedIndex = parseInt(answer) - 1;
-
-                // 验证选择
-                if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex > allTasks.length) {
-                    Ec.error('❌ 无效的选择');
-                    continue;
-                }
-                
-                // 检查是否选择退出
-                if (selectedIndex === allTasks.length) {
-                    Ec.info("已退出任务选择");
-                    Ec.askClose();
-                    process.exit(0);
-                }
-
-                // 检查选中的任务是否正在进行中
-                const tasksDir = path.resolve(process.cwd(), 'specification', 'changes', allTasks[selectedIndex].requirement, 'tasks');
-                const status = _checkTaskStatus(allTasks[selectedIndex].name, tasksDir);
-                
-                if (status === '进行中') {
-                    Ec.error('❌ 不能选择正在进行中的任务，请重新选择');
-                    continue;
-                }
-                
-                // 检查选中的任务是否已完成
-                if (status === '已完成') {
-                    Ec.info(`✅ 任务 ${allTasks[selectedIndex].name} 已经完成，不用分派`);
-                    Ec.askClose();
-                    process.exit(0);
-                }
-
-                // 直接使用用户选择的任务，跳过重复检查
-                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;
-                    }
-                    
-                    // 检查选中的任务是否已完成
-                    if (status === '已完成') {
-                        Ec.info(`✅ 任务 ${taskInstances[selectedIndex].name} 已经完成，不用分派`);
-                        Ec.askClose();
-                        process.exit(0);
-                    }
-
-                    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);
-                }
-                
-                // 检查任务是否已完成
-                if (status === '已完成') {
-                    Ec.info(`✅ 任务 ${taskName} 已经完成，不用分派`);
-                    Ec.askClose();
-                    process.exit(0);
-                }
-                
-                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);
-        }
-
-        // 保存任务分派记录
-        if (selectedWorkspace) {
-            await _saveAssignmentRecord(selectedTask.name, selectedWorkspace.name, actorName, requirementName);
-        }
-
-        // 读取模板文件并填充参数，然后拷贝到剪贴板
-        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>'
-                });
-
-                // 打印额外信息
-                Ec.waiting(`执行任务: ${selectedTask.name} - ${selectedTask.title || '未知任务'}`);
-                Ec.waiting(`使用工作空间: ${selectedWorkspace.path}`);
-                Ec.waiting('提示词内容:');
-                Ec.waiting('--------------------------------------------------');
-                
-                // 按行打印提示词内容，保持原有格式
-                const lines = renderedContent.split('\n');
-                lines.forEach(line => {
-                    Ec.waiting(line);
-                });
-                
-                Ec.waiting('--------------------------------------------------');
-
-                // 将提示词复制到剪贴板
-                await _copyToClipboard(renderedContent, requirementName, selectedTask.name);
-                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);
-    }
-};