momo-ai 1.0.1 → 1.0.3

package/README.md

@@ -1,30 +1,28 @@
-# Rachel Momo SDD - Spec Driven Development 工具
+# Momo SDD - Spec Driven Development 工具
 
-[![Downloads](https://img.shields.io/npm/dm/momo-ai.svg)](https://www.npmjs.com/package/momo-ai)
-
-![npm version](https://img.shields.io/npm/v/momo-ai.svg)
+![npm version](https://img.shields.io/npm/v/momo-ai.svg) | [![Downloads](https://img.shields.io/npm/dm/momo-ai.svg)](https://www.npmjs.com/package/momo-ai)
+> For Rachel Momo
 
 ## 1. 介绍
 
 当前工具会在操作系统中安装 `momo` 命令，使用它进行 `SDD - Spec Driven Development` 开发：
 
 1. 参考：`OpenSpec / Spec-Kit / Kiro`
-2. 工具：`TRAE` 工具集成（推荐使用国际版）/ `Cursor` / `Lingma`
-3. 中文规范支持，命令运行之后将 `prompt` 提示词拷贝到剪切板
+2. 工具支持：
+    - `Trea`（推荐使用，可支持多Agent模式）
+    - `Cursor`（稍贵，可支持多Agent模式）
+    - `Lingma`
+    - `Kiro`
+3. 中文规范，命令运行之后将 `prompt` 提示词拷贝到剪切板，直接复制到工具中即可使用，提示词生成之后会存储在 `.working` 目录下。
 4. 多个 Agent 协同，实现 Team 团队模式的 AI 开发，无模型限制（推荐使用同一个模型进行任务协同开发）
 
 和 `OpenSpec / Spec-Kit / Kiro` 原生工具不同，当前工具以 AI Agent 开发为核心，提供从 Plan -> Deployment
-完整生命周期的整体开发流程，属于上层项目实施的开发工具——暴力、简单、易懂。由于 IDE（ `TRAE / Cursor`
-）中可直接选择使用的模型，本工具不提供任何模型选择，模型本身取决于你所使用的工具本身，命令行只是一个辅助，核心开发模式为：
-`AI 开发 + 人工审核`，本工具的宗旨就是 `prompt` 的模板化。
-
-> 多个异构Agent！中文优先！
+完整生命周期的整体开发流程，是 SDD 的一种落地手段——暴力、简单、易懂。由于辅助工具可选择模型，所以本工具不提供模型选择，模型本身取决于你所使用的工具本身，命令行只是一个辅助，核心开发模式为：
+`AI 开发 + 人工审核`，本工具的核心是 `prompt` 的模板化。
 
-## 2. 使用
+> 除开 `momo` 命令后续会提供和模型直接交互的 `lain` 命令，近似 `iFlow / openspec` 的功能。
 
-- 执行 `momo repo` 的过程中会依赖一个已经初始化好的项目 `Git` 地址，且当前项目本身依赖一个 `Git`（因为项目是以
-  `submodule` 的方式添加到环境中的）。
-- 移除相关命令如 `submodule` 只支持 Linux/Mac 的脚本，这个用独立脚本防止更改丢失。
+## 2. 工具使用
 
 ### 2.1. 安装
 
@@ -34,9 +32,16 @@ npm install -g momo-ai
 momo help
 ```
 
-### 2.2. 控制台：定模型
+### 2.2. 操作步骤
 
-> 控制台开发中（Lain 模式）
+1. 使用 `momo init` 初始化协同工程项目（运行之前可使用 `momo env` 检查环境）。
+2. 使用 `momo repo` 添加项目代码库以及工程实例（有多少个 `Agent` 工作就添加多少工程实例），添加完成后可使用 `momo open`
+   直接打开工程。
+3. 更新 `project.md / project-model.md / requirement.md` 的细节文档（可用AI帮助拆分和书写）
+4. 使用 `momo add -n 需求名称` 添加细节需求（可用AI帮助拆分和书写：`momo plan -n 需求名称`）
+5. 使用 `momo tasks` 列出所有任务，并且使用 `momo run` 运行任务得到任务提示词
+
+> 带 (CV) 标记的命令运行成功后可直接“Ctrl + V”粘贴到 TRAE / Lingma / Cursor / Kiro 中执行。
 
 ### 2.3. 命令：不定模型
 
@@ -87,28 +92,24 @@ momo actor -a "角色名称"             # 添加新角色 -> 交互式命令，
 
 # momo run                          ( 生成提示词 -> 剪切板，自动计算空闲的 source-01 ）
 momo run -a {actor} -t {task}       # 将任务分配给角色，检查执行目录看哪些任务正在执行
+momo run                            # 从菜单中选择任务
 momo unlock                         # 解锁任务 -> 任务状态 = 待办
 ```
 
-## 3. 操作步骤
+### 2.4. 控制台：定模型
 
-1. 使用 `momo init` 初始化协同工程项目（运行之前可使用 `momo env` 检查环境）。
-2. 使用 `momo repo` 添加项目代码库以及工程实例（有多少个 `Agent` 工作就添加多少工程实例），添加完成后可使用 `momo open`
-   直接打开工程。
-3. 更新 `project.md / project-model.md / requirement.md` 的细节文档（可用AI帮助拆分和书写）
-3. 使用 `momo add -n 需求名称` 添加细节需求（可用AI帮助拆分和书写：`momo plan -n 需求名称`）
-4. 使用 `momo tasks` 列出所有任务，并且使用 `momo run` 运行任务得到任务提示词
+> 控制台开发中（Lain 模式）
 
-## 4. 参考链接
+## 3. 参考链接
 
-### 4.1. 旧版
+### 3.1. 旧版
 
 - （后端）Zero Ecotope：<https://www.zerows.io>
 - （前端）Zero UI：<https://www.vertxui.cn>
 - （工具）Zero AI：<https://www.vertxai.cn>
 - （标准）Zero Schema：<https://www.vertx-cloud.cn>
 
-### 4.2. 新增
+### 3.2. 新增
 
 - Maven 统一版本管理：<https://gitee.com/silentbalanceyh/rachel-momo>
 - Rapid快速开发框架：<https://gitee.com/silentbalanceyh/r2mo-rapid>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "momo-ai",
-    "version": "1.0.1",
+    "version": "1.0.3",
     "description": "Rachel Momo ( OpenSpec )",
     "main": "src/momo.js",
     "bin": {
@@ -44,7 +44,6 @@
         "lodash": "^4.17.21",
         "mkdirp": "^3.0.1",
         "mockjs": "^1.1.0",
-        "momo-ai": "^1.0.0",
         "random-js": "^2.1.0",
         "superagent": "^8.0.9",
         "taffydb": "^2.7.3",

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

@@ -1,7 +1,7 @@
 # 任务执行需求
 
 <!-- BEGIN -->
-在 source/<%= ROOT %> 目录下完成任务 <%= TASK %> 的开发工作（任务详情：specification/changes/<%= REQ %>/tasks/<%= TASK %>.md）。
+在 source/<%= ROOT %> 目录下完成任务 <%= TASK %> 的开发工作（任务详情：specification/changes/<%= REQ %>/tasks/<%= TASK %>.md），任务完成后将并且将 specification/changes/<%= REQ %>/tasks/<%= TASK %>.md 文件更名为 <%= TASK %>.done，并且更新 并且将 specification/changes/<%= REQ %>/tasks.md 中的总任务清单。
 
 任务完成后，请记得删除以下两个锁文件：
 1. 任务锁文件: specification/changes/<%= REQ %>/tasks/<%= TASK %>.lock

package/src/commander/run.json

@@ -1,6 +1,6 @@
 {
     "executor": "executeRun",
-    "description": "执行指定的任务！",
+    "description": "（CV）执行指定的任务！",
     "command": "run",
     "options": [
         {

package/src/executor/executeHelp.js

@@ -4,7 +4,12 @@ module.exports = (options) => {
     const metadata = Ec.parseMetadata();
     metadata.forEach(runner => {
         Ec.waiting(`命令：` + `momo ${runner.command} [-options]`.green);
-        Ec.waiting(`说明：${runner.description}`.yellow);
+        // 检查描述中是否包含"CV"，如果包含则在(CV)和说明之间添加红色高亮emoji
+        let description = runner.description;
+        if (description.includes("（CV）")) {
+            description = description.replace("（CV）", "（CV）📋️ ");
+        }
+        Ec.waiting(`说明`.yellow + `：${description}`);
         const options = runner.options || [];
         options.forEach(option => {
             if (option.hasOwnProperty('default')) {

package/src/executor/executeInit.js

@@ -26,7 +26,8 @@ const _ioDirectory = async (baseDir) => {
         "integration/windsurf/",
         "integration/github/",
         "integration/claude-code/",
-        "integration/chatgpt/"
+        "integration/chatgpt/",
+        ".working/"
     ];
 
     // 创建所有目录

package/src/executor/executeOpen.js

@@ -32,7 +32,15 @@ module.exports = async (options) => {
         // 如果只有一个工具可用，直接使用它
         if (availableTools.length === 1) {
             const tool = availableTools[0];
-            Ec.waiting(`🔍 检测到可用工具: ${tool.name}`);
+            let toolDisplayName = tool.name;
+            if (tool.name === 'Trae' || tool.name === 'Cursor') {
+                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
+            }
+            if (tool.name === 'Trae') {
+                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName.green}`);
+            } else {
+                Ec.waiting(`🔍 检测到可用工具: ${toolDisplayName}`);
+            }
             await _openWithTool(tool.command);
             Ec.askClose();
             process.exit(0);
@@ -40,9 +48,17 @@ module.exports = async (options) => {
         
         // 显示交互式选择菜单
         Ec.waiting('🔍 检测到多个可用的AI工具，请选择要使用的工具:');
-        const choices = availableTools.map((tool, index) => 
-            `${index + 1}. ${tool.name}`
-        );
+        const choices = availableTools.map((tool, index) => {
+            let toolDisplayName = tool.name;
+            if (tool.name === 'Trae' || tool.name === 'Cursor') {
+                toolDisplayName = `${tool.name}（${'Multi-Agent'.cyan}）`;
+            }
+            if (tool.name === 'Trae') {
+                return `${index + 1}. ${toolDisplayName} ${'推荐'.green}`;
+            } else {
+                return `${index + 1}. ${toolDisplayName}`;
+            }
+        });
         
         // 添加退出选项
         choices.push(`${choices.length + 1}. 退出`);
@@ -69,7 +85,11 @@ module.exports = async (options) => {
         
         // 执行选择的工具
         const selectedTool = availableTools[selectedIndex];
-        Ec.waiting(`🚀 正在使用 ${selectedTool.name} 打开项目...`);
+        let toolDisplayName = selectedTool.name;
+        if (selectedTool.name === 'Trae' || selectedTool.name === 'Cursor') {
+            toolDisplayName = `${selectedTool.name}（${'Multi-Agent'.cyan}）`;
+        }
+        Ec.waiting(`🚀 正在使用 ${toolDisplayName} 打开项目...`);
         await _openWithTool(selectedTool.command);
         Ec.askClose();
         process.exit(0);

package/src/executor/executePlan.js

@@ -68,8 +68,9 @@ const _isRequirementExists = (changesDir, requirementName) => {
 /**
  * 将内容复制到剪贴板（去除换行符）
  * @param {string} content 要复制的内容
+ * @param {string} requirementName 需求名称
  */
-const _copyToClipboard = async (content) => {
+const _copyToClipboard = async (content, requirementName) => {
     try {
         // 去除换行符，将内容合并为一行后再复制到剪贴板
         const contentWithoutNewlines = content.replace(/\r?\n|\r/g, ' ');
@@ -77,6 +78,20 @@ const _copyToClipboard = async (content) => {
         proc.stdin.write(contentWithoutNewlines);
         proc.stdin.end();
         Ec.waiting('✅ 计划提示词已复制到剪贴板');
+        
+        // 保存内容到 .working 目录
+        const workingDir = path.resolve(process.cwd(), '.working');
+        const fileName = `REQ-${requirementName}.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}`);
         // 在非 macOS 系统上可能没有 pbcopy，提供备选方案
@@ -123,7 +138,7 @@ module.exports = async (options) => {
         const renderedContent = _renderTemplate(templateContent, { NAME: requirementName });
         
         // 将提示词复制到剪贴板
-        await _copyToClipboard(renderedContent);
+        await _copyToClipboard(renderedContent, requirementName);
         
         Ec.info(`✅ 成功生成需求 "${requirementName}" 的计划提示词`);
         process.exit(0);

package/src/executor/executeRun.js

@@ -2,7 +2,7 @@ const Ec = require('../epic');
 const fs = require('fs');
 const path = require('path');
 const util = require('util');
-const { spawn } = require('child_process');
+const {spawn} = require('child_process');
 const fsAsync = require('fs').promises;
 
 /**
@@ -16,7 +16,7 @@ const _readTemplate = async (templatePath) => {
         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;
@@ -25,12 +25,12 @@ const _readTemplate = async (templatePath) => {
                 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}`);
@@ -58,13 +58,15 @@ const _renderTemplate = (template, data) => {
 /**
  * 将内容复制到剪贴板
  * @param {string} content 要复制的内容
+ * @param {string} requirementName 需求名称
+ * @param {string} taskName 任务名称
  */
-const _copyToClipboard = async (content) => {
+const _copyToClipboard = async (content, requirementName, taskName) => {
     try {
-        const proc = spawn('pbcopy', { stdio: 'pipe' });
+        const proc = spawn('pbcopy', {stdio: 'pipe'});
         proc.stdin.write(content);
         proc.stdin.end();
-        
+
         // 等待复制操作完成
         await new Promise((resolve, reject) => {
             proc.on('close', (code) => {
@@ -76,8 +78,22 @@ const _copyToClipboard = async (content) => {
             });
             proc.on('error', reject);
         });
-        
+
         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}`);
         // 备选方案：显示内容
@@ -94,25 +110,25 @@ const _copyToClipboard = async (content) => {
 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 => 
+    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({
@@ -124,10 +140,57 @@ const _findTaskInstances = (taskName) => {
             }
         }
     });
-    
+
     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} 可用工作空间列表
@@ -135,16 +198,16 @@ const _findTaskInstances = (taskName) => {
 const _getAvailableWorkspaces = () => {
     const sourceDir = path.resolve(process.cwd(), 'source');
     const workspaces = [];
-    
+
     if (!fs.existsSync(sourceDir)) {
         return workspaces;
     }
-    
+
     // 获取所有目录
-    const dirs = fs.readdirSync(sourceDir).filter(file => 
+    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`);
@@ -155,7 +218,7 @@ const _getAvailableWorkspaces = () => {
             });
         }
     });
-    
+
     return workspaces;
 };
 
@@ -165,11 +228,11 @@ const _getAvailableWorkspaces = () => {
  */
 const _selectWorkspace = () => {
     const workspaces = _getAvailableWorkspaces();
-    
+
     if (workspaces.length === 0) {
         return null;
     }
-    
+
     // 随机选择一个工作空间
     const randomIndex = Math.floor(Math.random() * workspaces.length);
     return workspaces[randomIndex];
@@ -185,12 +248,12 @@ const _selectWorkspace = () => {
 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.mkdirSync(taskLockDir, {recursive: true});
     }
-    
+
     // 创建锁文件
     fs.writeFileSync(taskLockPath, `Locked by: ${actorName}\nLocked at: ${new Date().toISOString()}\n`);
     return taskLockPath;
@@ -206,110 +269,269 @@ const _createTaskLock = (taskName, requirementName, actorName) => {
 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;
-    
-    // 检查必要参数
-    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('❌ 无效的选择');
+
+        // 如果没有提供任务名称，则让用户选择任务
+        if (!taskName || taskName === 'unset') {
+            Ec.waiting("🔍 未指定任务，正在枚举所有可用任务...");
+
+            // 枚举所有任务
+            const allTasks = _enumerateAllTasks();
+
+            if (allTasks.length === 0) {
+                Ec.error("❌ 未找到任何任务");
                 Ec.askClose();
                 process.exit(1);
             }
-            
-            selectedTask = taskInstances[selectedIndex];
+
+            // 循环直到用户选择一个非进行中的任务
+            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 {
-            selectedTask = taskInstances[0];
+            // 查找所有匹配的任务实例
+            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(taskName, requirementName, actorName);
+            taskLockPath = _createTaskLock(selectedTask.name, requirementName, actorName);
         }
-        
+
         // 创建工作空间锁文件
         if (selectedWorkspace) {
-            workspaceLockPath = _createWorkspaceLock(selectedWorkspace.name, taskName, actorName);
+            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: taskName,
+                const renderedContent = _renderTemplate(templateContent, {
+                    TASK: selectedTask.name,
                     REQ: requirementName,
                     ROOT: selectedWorkspace ? selectedWorkspace.path : 'source/<WORKSPACE_PATH>'
                 });
-                
+
                 // 将提示词复制到剪贴板
-                await _copyToClipboard(renderedContent);
-                Ec.info(`✅ 任务 ${taskName} 准备完成，请查看剪切板中的提示词`);
+                await _copyToClipboard(renderedContent, requirementName, selectedTask.name);
+                Ec.info(`✅ 任务 ${selectedTask.name} 准备完成，请查看剪切板中的提示词`);
             } catch (error) {
-                Ec.info(`✅ 任务 ${taskName} 查找完成`);
+                Ec.info(`✅ 任务 ${selectedTask.name} 查找完成`);
             }
         } else {
-            Ec.info(`✅ 任务 ${taskName} 查找完成`);
+            Ec.info(`✅ 任务 ${selectedTask.name} 查找完成`);
         }
-        
+
         Ec.askClose();
         process.exit(0);
         

package/src/executor/executeTasks.js

@@ -61,7 +61,6 @@ const _renderTemplate = (template, data) => {
  */
 const _copyToClipboard = async (content) => {
     try {
-        Ec.waiting("📋 正在将内容复制到剪切板...");
         const proc = spawn('pbcopy', { stdio: 'pipe' });
         proc.stdin.write(content);
         proc.stdin.end();
@@ -88,37 +87,55 @@ const _copyToClipboard = async (content) => {
 };
 
 /**
- * 处理剪切板任务
- * @param {string} taskName 任务名称
- * @param {Array} taskInstances 任务实例列表
+ * 从 Markdown 文件中提取第一个标题
+ * @param {string} filePath 文件路径
+ * @returns {string} 第一个标题内容
  */
-const _handleClipboardTask = async (taskName, taskInstances) => {
-    // 读取模板文件并填充参数，然后拷贝到剪切板
-    const templatePath = path.resolve(__dirname, '../_template/PROMPT/tasks.md.ejs');
-    Ec.waiting(`📄 读取模板文件: ${templatePath}`);
-    
-    if (fs.existsSync(templatePath)) {
-        try {
-            // 读取并处理提示词模板
-            const templateContent = await _readTemplate(templatePath);
-            Ec.waiting("🔧 渲染模板参数");
-            
-            const renderedContent = _renderTemplate(templateContent, { 
-                REQ: taskInstances[0].requirement,
-                TASK: taskName
-            });
-            
-            Ec.waiting("📋 准备复制到剪切板");
-            Ec.waiting(`📋 剪切板内容预览: ${renderedContent.substring(0, 50)}${renderedContent.length > 50 ? '...' : ''}`);
-            
-            // 将提示词复制到剪贴板
-            await _copyToClipboard(renderedContent);
-        } catch (error) {
-            Ec.waiting(`⚠️  处理模板时出错: ${error.message}`);
+const _extractTitleFromMarkdown = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return path.basename(filePath, '.md');
         }
-    } else {
-        Ec.waiting(`⚠️  未找到模板文件: ${templatePath}`);
+        
+        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} 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 '未开始';
 };
 
 module.exports = async (options) => {
@@ -148,12 +165,8 @@ module.exports = async (options) => {
             process.exit(0);
         }
         
-        Ec.waiting(`📁 找到 ${requirements.length} 个需求目录`);
-        
         // 如果指定了任务名称，只检查该任务的重复信息
         if (taskName) {
-            Ec.waiting(`🔍 检查任务 ${taskName} 的重复信息...`);
-            
             const taskInstances = [];
             
             // 查找指定任务
@@ -222,11 +235,31 @@ module.exports = async (options) => {
                 taskFiles.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));
+                    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: taskPath,
-                        requirement: requirement
+                        requirement: requirement,
+                        status: coloredStatus
                     });
                 });
             }
@@ -241,10 +274,11 @@ module.exports = async (options) => {
             process.exit(0);
         }
         
-        // 列出所有任务（包含路径）
+        // 列出所有任务（包含路径和状态，状态在前）
         Ec.waiting(`📊 共找到 ${tasks.length} 个任务:`);
         tasks.forEach((task, index) => {
-            Ec.waiting(`${index + 1}. ${task.name}, ${task.path}`);
+            const coloredName = task.name.cyan;
+            Ec.waiting(`${index + 1}. [${task.status}] ${task.title} (${coloredName}), ${task.path}`);
         });
         
         // 执行剪切板任务（使用第一个任务）
@@ -257,4 +291,33 @@ module.exports = async (options) => {
         Ec.askClose();
         process.exit(1);
     }
+};
+
+/**
+ * 处理剪切板任务
+ * @param {string} taskName 任务名称
+ * @param {Array} taskInstances 任务实例列表
+ */
+const _handleClipboardTask = async (taskName, taskInstances) => {
+    // 读取模板文件并填充参数，然后拷贝到剪切板
+    const templatePath = path.resolve(__dirname, '../_template/PROMPT/tasks.md.ejs');
+    
+    if (fs.existsSync(templatePath)) {
+        try {
+            // 读取并处理提示词模板
+            const templateContent = await _readTemplate(templatePath);
+            
+            const renderedContent = _renderTemplate(templateContent, { 
+                REQ: taskInstances[0].requirement,
+                TASK: taskName
+            });
+            
+            // 将提示词复制到剪贴板
+            await _copyToClipboard(renderedContent);
+        } catch (error) {
+            Ec.waiting(`⚠️  处理模板时出错: ${error.message}`);
+        }
+    } else {
+        Ec.waiting(`⚠️  未找到模板文件: ${templatePath}`);
+    }
 };