momo-ai 1.0.0 → 1.0.1

package/src/executor/executeRun.js

@@ -0,0 +1,321 @@
+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 _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;
+};
+
+module.exports = async (options) => {
+    // 参数提取
+    const parsed = Ec.parseArgument(options);
+    
+    const actorName = parsed.actor;
+    const taskName = parsed.task;
+    
+    // 检查必要参数
+    if (!taskName) {
+        Ec.error("❌ 缺少必要参数 -t/--task，请提供任务名称");
+        Ec.askClose();
+        process.exit(1);
+    }
+    
+    try {
+        // 查找所有匹配的任务实例
+        const taskInstances = _findTaskInstances(taskName);
+        
+        if (taskInstances.length === 0) {
+            Ec.error(`❌ 未找到任务 ${taskName}`);
+            Ec.askClose();
+            process.exit(1);
+        }
+        
+        let selectedTask;
+        // 如果有多个任务实例，让用户选择
+        if (taskInstances.length > 1) {
+            Ec.waiting(`🔍 发现 ${taskInstances.length} 个重复任务，请选择要执行的任务:`);
+            
+            taskInstances.forEach((task, index) => {
+                Ec.waiting(`${index + 1}. ${task.relativePath}`);
+            });
+            
+            // 获取用户选择
+            const answer = await Ec.ask('请输入选项编号: ');
+            const selectedIndex = parseInt(answer) - 1;
+            
+            // 验证选择
+            if (isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= taskInstances.length) {
+                Ec.error('❌ 无效的选择');
+                Ec.askClose();
+                process.exit(1);
+            }
+            
+            selectedTask = taskInstances[selectedIndex];
+        } else {
+            selectedTask = taskInstances[0];
+        }
+        
+        // 记录需求名称
+        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(taskName, requirementName, actorName);
+        }
+        
+        // 创建工作空间锁文件
+        if (selectedWorkspace) {
+            workspaceLockPath = _createWorkspaceLock(selectedWorkspace.name, taskName, 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: taskName,
+                    REQ: requirementName,
+                    ROOT: selectedWorkspace ? selectedWorkspace.path : 'source/<WORKSPACE_PATH>'
+                });
+                
+                // 将提示词复制到剪贴板
+                await _copyToClipboard(renderedContent);
+                Ec.info(`✅ 任务 ${taskName} 准备完成，请查看剪切板中的提示词`);
+            } catch (error) {
+                Ec.info(`✅ 任务 ${taskName} 查找完成`);
+            }
+        } else {
+            Ec.info(`✅ 任务 ${taskName} 查找完成`);
+        }
+        
+        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);
+    }
+};