momo-ai 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "momo-ai",
-    "version": "1.0.15",
+    "version": "1.0.17",
     "description": "Rachel Momo ( OpenSpec )",
     "main": "src/momo.js",
     "bin": {

package/src/_template/PROMPT/run.md.ejs

@@ -6,4 +6,5 @@
 任务完成后，请记得删除以下两个锁文件：
 1. 任务锁文件: specification/changes/<%= REQ %>/tasks/<%= TASK %>.lock
 2. 任务空间锁文件: source/<%= ROOT %>.lock
+3. 任务完成之后你需要十分智能地检查 git 仓库状态并且提交一份代码到 git 远程仓库，注意提交之前保证自己手中代码是最新的，若有冲突要解决冲突后合并提交。
 <!-- END -->

package/src/executor/executePush.js

@@ -21,6 +21,44 @@ const _isGitRepo = async (dirPath) => {
     }
 };
 
+/**
+ * 检查是否有未合并的文件
+ * @param {string} dirPath 目录路径
+ * @returns {Promise<boolean>} 是否有未合并的文件
+ */
+const _hasUnmergedFiles = async (dirPath) => {
+    try {
+        const { stdout } = await execAsync('git diff --name-only --diff-filter=U', { cwd: dirPath });
+        return stdout.trim() !== '';
+    } catch (error) {
+        return false;
+    }
+};
+
+/**
+ * 执行 git merge 命令合并更改
+ * @param {string} dirPath 目录路径
+ */
+const _mergeChanges = async (dirPath) => {
+    try {
+        Ec.waiting(`正在合并更改: ${dirPath}`);
+        const { stdout, stderr } = await execAsync('git merge --no-edit', { cwd: dirPath });
+        
+        if (stdout) {
+            Ec.waiting(`输出: ${stdout.trim()}`);
+        }
+        if (stderr) {
+            Ec.waiting(`进度: ${stderr.trim()}`);
+        }
+        
+        Ec.waiting(`✅ 成功合并更改: ${dirPath}`);
+        return true;
+    } catch (error) {
+        Ec.error(`❌ 合并更改失败 ${dirPath}: ${error.message}`);
+        return false;
+    }
+};
+
 /**
  * 从远程拉取最新代码
  * @param {string} dirPath 目录路径
@@ -40,8 +78,33 @@ const _pullRepo = async (dirPath) => {
         Ec.waiting(`✅ 成功拉取代码: ${dirPath}`);
         return true;
     } catch (error) {
-        Ec.error(`❌ 拉取代码失败 ${dirPath}: ${error.message}`);
-        return false;
+        // 检查是否是分支分歧错误
+        if (error.message.includes('Need to specify how to reconcile divergent branches')) {
+            try {
+                Ec.waiting(`检测到分支分歧错误，正在配置 pull.rebase=false: ${dirPath}`);
+                await execAsync('git config pull.rebase false', { cwd: dirPath });
+                Ec.waiting(`已设置 pull.rebase=false，重新尝试拉取代码: ${dirPath}`);
+                
+                // 重新执行 pull 操作
+                const { stdout, stderr } = await execAsync('git pull', { cwd: dirPath });
+                
+                if (stdout) {
+                    Ec.waiting(`输出: ${stdout.trim()}`);
+                }
+                if (stderr) {
+                    Ec.waiting(`进度: ${stderr.trim()}`);
+                }
+                
+                Ec.waiting(`✅ 成功拉取代码: ${dirPath}`);
+                return true;
+            } catch (retryError) {
+                Ec.error(`❌ 重新拉取代码失败 ${dirPath}: ${retryError.message}`);
+                return false;
+            }
+        } else {
+            Ec.error(`❌ 拉取代码失败 ${dirPath}: ${error.message}`);
+            return false;
+        }
     }
 };
 

package/src/executor/executeRun.js

@@ -115,6 +115,7 @@ const _findTaskInstances = (taskName) => {
 
         // 检查 tasks 目录是否存在
         if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+            // 检查 .md 文件
             const taskFile = `${taskName}.md`;
             const taskPath = path.resolve(tasksDir, taskFile);
 
@@ -127,6 +128,19 @@ const _findTaskInstances = (taskName) => {
                     relativePath: path.relative(process.cwd(), taskPath)
                 });
             }
+            
+            // 如果 .md 文件不存在，检查 .done 文件
+            const doneFile = `${taskName}.done`;
+            const donePath = path.resolve(tasksDir, doneFile);
+            
+            if (!fs.existsSync(taskPath) && fs.existsSync(donePath)) {
+                taskInstances.push({
+                    name: taskName,
+                    path: donePath,
+                    requirement: requirement,
+                    relativePath: path.relative(process.cwd(), donePath)
+                });
+            }
         }
     });
 
@@ -316,6 +330,46 @@ const _extractTitleFromMarkdown = (filePath) => {
     }
 };
 
+/**
+ * 保存任务分派记录
+ * @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 fileName = `${taskName}-${workspaceName}-${timestamp}.txt`;
+        const filePath = path.join(activitiesDir, fileName);
+
+        // 写入分派记录
+        const recordContent = `Task Assignment Record
+=====================
+
+Task Name: ${taskName}
+Workspace: ${workspaceName}
+Actor: ${actorName}
+Requirement: ${requirementName}
+Assigned At: ${new Date().toISOString()}
+
+This task has been assigned to workspace ${workspaceName} 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);
@@ -386,6 +440,13 @@ module.exports = async (options) => {
                     Ec.error('❌ 不能选择正在进行中的任务，请重新选择');
                     continue;
                 }
+                
+                // 检查选中的任务是否已完成
+                if (status === '已完成') {
+                    Ec.info(`✅ 任务 ${allTasks[selectedIndex].name} 已经完成，不用分派`);
+                    Ec.askClose();
+                    process.exit(0);
+                }
 
                 // 直接使用用户选择的任务，跳过重复检查
                 selectedTask = allTasks[selectedIndex];
@@ -451,6 +512,13 @@ module.exports = async (options) => {
                         Ec.error('❌ 不能选择正在进行中的任务，请重新选择');
                         continue;
                     }
+                    
+                    // 检查选中的任务是否已完成
+                    if (status === '已完成') {
+                        Ec.info(`✅ 任务 ${taskInstances[selectedIndex].name} 已经完成，不用分派`);
+                        Ec.askClose();
+                        process.exit(0);
+                    }
 
                     selectedTask = taskInstances[selectedIndex];
                     break;
@@ -466,6 +534,13 @@ module.exports = async (options) => {
                     process.exit(1);
                 }
                 
+                // 检查任务是否已完成
+                if (status === '已完成') {
+                    Ec.info(`✅ 任务 ${taskName} 已经完成，不用分派`);
+                    Ec.askClose();
+                    process.exit(0);
+                }
+                
                 selectedTask = taskInstances[0];
             }
 
@@ -498,6 +573,11 @@ module.exports = async (options) => {
             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');
 

package/src/executor/executeTasks.js

@@ -164,6 +164,7 @@ module.exports = async (options) => {
                 
                 // 检查 tasks 目录是否存在
                 if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+                    // 检查 .md 文件
                     const taskFile = `${taskName}.md`;
                     const taskPath = path.resolve(tasksDir, taskFile);
                     
@@ -176,6 +177,19 @@ module.exports = async (options) => {
                             requirement: requirement
                         });
                     }
+                    
+                    // 检查 .done 文件（如果 .md 文件不存在）
+                    const doneFile = `${taskName}.done`;
+                    const donePath = path.resolve(tasksDir, doneFile);
+                    
+                    if (!fs.existsSync(taskPath) && fs.existsSync(donePath)) {
+                        const relativePath = path.relative(process.cwd(), donePath);
+                        taskInstances.push({
+                            name: taskName,
+                            path: relativePath,
+                            requirement: requirement
+                        });
+                    }
                 }
             });
             
@@ -217,11 +231,17 @@ module.exports = async (options) => {
             // 检查 tasks 目录是否存在
             if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
                 // 获取所有 .md 文件
-                const taskFiles = fs.readdirSync(tasksDir).filter(file => 
+                const mdFiles = fs.readdirSync(tasksDir).filter(file => 
                     file.endsWith('.md')
                 );
                 
-                taskFiles.forEach(taskFile => {
+                // 获取所有 .done 文件
+                const doneFiles = fs.readdirSync(tasksDir).filter(file => 
+                    file.endsWith('.done')
+                );
+                
+                // 处理 .md 文件
+                mdFiles.forEach(taskFile => {
                     const name = path.basename(taskFile, '.md');
                     const taskPath = path.relative(process.cwd(), path.resolve(tasksDir, taskFile));
                     const title = _extractTitleFromMarkdown(path.resolve(tasksDir, taskFile));
@@ -251,9 +271,58 @@ module.exports = async (options) => {
                         status: coloredStatus
                     });
                 });
+                
+                // 处理 .done 文件（但没有对应的 .md 文件）
+                doneFiles.forEach(doneFile => {
+                    const name = path.basename(doneFile, '.done');
+                    // 检查是否已经有对应的 .md 文件在任务列表中
+                    const hasMdFile = mdFiles.some(mdFile => 
+                        path.basename(mdFile, '.md') === name
+                    );
+                    
+                    // 如果没有对应的 .md 文件，则添加到任务列表
+                    if (!hasMdFile) {
+                        const donePath = path.relative(process.cwd(), path.resolve(tasksDir, doneFile));
+                        // 尝试从 .done 文件中提取标题，如果失败则使用文件名
+                        let title = _extractTitleFromMarkdown(path.resolve(tasksDir, `${name}.md`));
+                        // 如果从 .md 文件提取失败，则尝试从 .done 文件提取
+                        if (title === name) {
+                            title = _extractTitleFromMarkdown(path.resolve(tasksDir, doneFile));
+                        }
+                        // 使用标准的状态检查函数
+                        const status = _checkTaskStatus(name, tasksDir);
+                        // 为状态添加颜色代码
+                        let coloredStatus;
+                        switch (status) {
+                            case '进行中':
+                                coloredStatus = status.blue;
+                                break;
+                            case '已完成':
+                                coloredStatus = status.green;
+                                break;
+                            case '未开始':
+                                coloredStatus = status.red;
+                                break;
+                            default:
+                                coloredStatus = status;
+                        }
+                        
+                        tasks.push({
+                            name: name,
+                            title: title,
+                            path: donePath,
+                            requirement: requirement,
+                            status: coloredStatus
+                        });
+                    }
+                });
+
             }
         });
         
+        // 按任务名称排序
+        tasks.sort((a, b) => a.name.localeCompare(b.name));
+        
         if (tasks.length === 0) {
             Ec.waiting("🔍 未找到任何任务");
             // 即使未找到任务也执行剪切板任务（使用默认值）
@@ -269,7 +338,8 @@ module.exports = async (options) => {
             const paddedIndex = String(index + 1).padStart(3, '0');
             const coloredName = task.name.cyan;
             const coloredPath = task.path.yellow;  // 使用黄色高亮路径
-            Ec.waiting(`${paddedIndex}. ${coloredName} | ${task.title} / ${coloredPath}`);
+            
+            Ec.waiting(`${paddedIndex}. ${coloredName} [${task.status}] | ${task.title} / ${coloredPath}`);
         });
         
         // 执行剪切板任务（使用第一个任务）