momo-ai 1.0.15 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "momo-ai",
-    "version": "1.0.15",
+    "version": "1.0.18",
     "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/commander/repo.json

@@ -9,8 +9,8 @@
             "description": "当前项目的远程 Git 仓库地址！"
         },
         {
-            "name": "i",
-            "alias": "instance",
+            "name": "instance",
+            "alias": "i",
             "description": "需要 Clone 的远程仓库的实例副本数量！",
             "default": 10
         }

package/src/executor/executeConsole.js

@@ -4,65 +4,92 @@
 
 const readline = require('readline');
 const colors = require('colors');
-const Ec = require('../epic');
+const path = require('path');
+const fs = require('fs');
+const terminalCommands = require('../terminal');
+
+// 设置颜色主题
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'red',
+    info: 'green',
+    data: 'blue',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'magenta',
+    error: 'red'
+});
 
 // 显示欢迎界面和菜单
 const showMenu = () => {
     // 清屏
     process.stdout.write('\x1Bc');
-    
+
     // 显示标准头部信息
-    Ec.executeHeader("Rachel Momo / SDD");
-    
+    showHeader();
+
     // 使用96个字符宽度
     const width = 96;
     const headerBorder = '='.repeat(width).blue;
     const footerBorder = '-'.repeat(width).blue;
-    
+
     console.log('');
     console.log(headerBorder);
     const title = 'Momo AI / Lain Console';
     const padding = ' '.repeat(Math.floor((width - title.length) / 2) - 1);
     console.log(`${padding}${title}`.bold.brightCyan);
     console.log(headerBorder);
-    
+
     console.log('');
     console.log('欢迎使用 Momo AI / Lain 控制台！'.green);
     console.log('这是一个交互式命令行界面。'.yellow);
     console.log('');
-    
+
     console.log('可用命令：'.bold);
     console.log('  help     - 显示帮助信息'.white);
-    console.log('  exit     - 退出控制台'.white);
+    console.log('  llm      - 查看大模型配置信息'.white);
     console.log('  quit     - 退出控制台'.white);
     console.log('');
-    
+
     console.log('请在提示符后输入命令。'.gray);
     console.log(footerBorder);
 };
 
+// 显示标准头部信息
+const showHeader = () => {
+    const appInfo = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
+
+    console.log(`[Momo AI]`.green.bold + ` ----------------- Rachel Momo / AI工具项  ------------------`.rainbow);
+    console.log(`[Momo AI]`.green.bold + ' 应用名称: '.bold + 'Rachel Momo / SDD');
+    console.log(`[Momo AI]`.green.bold + ' 工具主页: '.bold + appInfo.homepage.blue);
+    console.log(`[Momo AI]`.green.bold + ` 工具版本: ` + `${appInfo.version}`.red + '  ' + `( Node >= 22.x )`.yellow);
+    console.log(`[Momo AI]`.green.bold);
+    console.log(`[Momo AI]`.green.bold + ` ----------------- AI 系统启动…… ----------------------------`.rainbow);
+};
+
 // 处理用户输入
-const handleInput = (input) => {
+const handleInput = (input, commands) => {
     const command = input.trim().toLowerCase();
-    
+
+    // 创建命令上下文
+    const context = {
+        commands: commands
+    };
+
     switch (command) {
         case '':
             // 空命令，不处理
             break;
         case 'help':
-            console.log('');
-            console.log('帮助信息：'.bold.brightYellow);
-            console.log('  help     - 显示此帮助信息'.white);
-            console.log('  exit     - 退出控制台'.white);
-            console.log('  quit     - 退出控制台'.white);
-            console.log('');
+            commands.help(context);
+            break;
+        case 'llm':
+            commands.llm(context);
             break;
-        case 'exit':
         case 'quit':
-            console.log('');
-            console.log('感谢使用 Momo AI / Lain 控制台，再见！'.brightGreen);
-            console.log('');
-            process.exit(0);
+            commands.quit(context);
             break;
         default:
             console.log('');
@@ -97,7 +124,7 @@ const executeConsole = async () => {
     
     rl.on('line', (line) => {
         const input = line.trim();
-        handleInput(input);
+        handleInput(input, terminalCommands);
         rl.prompt();
     }).on('close', () => {
         console.log('\n' + '感谢使用 Momo AI / Lain 控制台，再见！'.brightGreen + '\n');

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/executeRepo.js

@@ -176,8 +176,8 @@ module.exports = async (options) => {
     const parsed = Ec.parseArgument(options);
     
     // 获取参数
-    const repoUrl = parsed.address || parsed.a;
-    const instanceCount = parsed.i || parsed.instance || 10; // 默认值为10
+    const repoUrl = parsed.address;
+    const instanceCount = parsed.instance;
     
     // 验证参数
     if (!repoUrl) {

package/src/executor/executeRun.js

@@ -115,16 +115,36 @@ const _findTaskInstances = (taskName) => {
 
         // 检查 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)
+                    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
                 });
             }
         }
@@ -316,6 +336,48 @@ 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 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);
@@ -367,16 +429,26 @@ module.exports = async (options) => {
                     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) {
+                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');
@@ -386,6 +458,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 +530,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 +552,13 @@ module.exports = async (options) => {
                     process.exit(1);
                 }
                 
+                // 检查任务是否已完成
+                if (status === '已完成') {
+                    Ec.info(`✅ 任务 ${taskName} 已经完成，不用分派`);
+                    Ec.askClose();
+                    process.exit(0);
+                }
+                
                 selectedTask = taskInstances[0];
             }
 
@@ -498,6 +591,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');
 
@@ -512,15 +610,15 @@ module.exports = async (options) => {
                 });
 
                 // 打印额外信息
-                Ec.waiting(`[Momo AI] 执行任务: ${selectedTask.name} - ${selectedTask.title}`);
-                Ec.waiting(`[Momo AI] 使用工作空间: ${selectedWorkspace.path}`);
-                Ec.waiting('[Momo AI] 提示词内容:');
+                Ec.waiting(`执行任务: ${selectedTask.name} - ${selectedTask.title || '未知任务'}`);
+                Ec.waiting(`使用工作空间: ${selectedWorkspace.path}`);
+                Ec.waiting('提示词内容:');
                 Ec.waiting('--------------------------------------------------');
                 
                 // 按行打印提示词内容，保持原有格式
                 const lines = renderedContent.split('\n');
                 lines.forEach(line => {
-                    Ec.waiting(`[Momo AI] ${line}`);
+                    Ec.waiting(line);
                 });
                 
                 Ec.waiting('--------------------------------------------------');

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}`);
         });
         
         // 执行剪切板任务（使用第一个任务）